Code Metrics Overview

Comprehensive analysis of your codebase quality and maintainability - these metrics only show the average values per file so outliers might be hidden

Lines of Code

Total codebase size

{{total_code_metrics.loc}} lines {{#IF has_total_code_metrics_trend}} {{total_code_metrics_trend.loc_delta}} {{/IF}}
0
Small
0
Medium
0
Large
0
Very Large

Total size of your codebase. Larger codebases require more maintenance effort and are harder to understand.

Avg. Cyclomatic Complexity

Avg. Function Cyclomatic Complexity per file

{{total_code_metrics.avgCcPerFunction}} avg per function per file {{#IF has_total_code_metrics_trend}} {{total_code_metrics_trend.avgCcPerFunction_delta}} {{/IF}}
0
Simple
0
Moderate
0
Complex
0
Very Complex

Lower complexity (1-4) is better. Values above 10 indicate functions that are hard to test and maintain.

Avg. Cognitive Complexity

Avg. Function Cognitive Complexity per file

{{total_code_metrics.avg_cog_complexity_per_function}} avg per function {{#IF has_total_code_metrics_trend}} {{total_code_metrics_trend.avg_cog_complexity_per_function_delta}} {{/IF}}
0
Simple
0
Moderate
0
Complex
0
Very Complex

Lower complexity (1-4) is better. Values above 10 indicate functions that are hard to test and maintain.

Maintainability

Maintainability Index per file

{{total_code_metrics.maintainabilityIndex}} / 100 {{#IF has_total_code_metrics_trend}} {{total_code_metrics_trend.maintainabilityIndex_delta}} {{/IF}}
0
Excellent
0
Good
0
Fair
0
Poor

Higher is better. Values above 80 indicate highly maintainable code, below 60 suggests refactoring needed.

Avg. Method Size

Average lines per method

{{total_code_metrics.avgLocPerFunction}} lines {{#IF has_total_code_metrics_trend}} {{total_code_metrics_trend.avgLocPerFunction_delta}} {{/IF}}
0
Concise
0
Optimal
0
Large
0
Too Large

Shorter methods (10-20 lines) are easier to understand and test. Methods over 50 lines should be refactored.

Avg. LCOM4

Average LCOM4 per class

{{total_code_metrics.avgLcom4}} avg per class {{#IF has_total_code_metrics_trend}} {{/IF}}
0
Useless (0)
0
Concise (1)
0
Complex (>1)

A value of 1 indicates a cohesive class. >2 indicates a problem. The class should be split into smaller classes. A value of 0 happens when there are no methods in a class. This is also a "bad" class.

Lines of Code

Total size of functions

{{total_code_metrics_functions.loc}} lines {{#IF has_total_code_metrics_functions_trend}} {{total_code_metrics_functions_trend.loc_delta}} {{/IF}}
{{total_code_metrics_functions_segmentation.loc.good}}
Small
{{total_code_metrics_functions_segmentation.loc.ok}}
Medium
{{total_code_metrics_functions_segmentation.loc.warning}}
Large
{{total_code_metrics_functions_segmentation.loc.critical}}
Very Large

Total size of your functions. Larger functions require more maintenance effort and are harder to understand.

Cyclomatic Complexity

Cyclomatic Complexity per function

{{total_code_metrics_functions.avgCcPerFunction}} avg per function {{#IF has_total_code_metrics_functions_trend}} {{total_code_metrics_functions_trend.avgCcPerFunction_delta}} {{/IF}}
{{total_code_metrics_functions_segmentation.complexity.good}}
Simple
{{total_code_metrics_functions_segmentation.complexity.ok}}
Moderate
{{total_code_metrics_functions_segmentation.complexity.warning}}
Complex
{{total_code_metrics_functions_segmentation.complexity.critical}}
Very Complex

Lower complexity (1-4) is better. Values above 10 indicate functions that are hard to test and maintain.

Cognitive Complexity

Cognitive Complexity per function

{{total_code_metrics_functions.avg_cog_complexity_per_function}} avg per function {{#IF has_total_code_metrics_functions_trend}} {{total_code_metrics_functions_trend.avg_cog_complexity_per_function_delta}} {{/IF}}
{{total_code_metrics_functions_segmentation.cognitiveComplexity.good}}
Simple
{{total_code_metrics_functions_segmentation.cognitiveComplexity.ok}}
Moderate
{{total_code_metrics_functions_segmentation.cognitiveComplexity.warning}}
Complex
{{total_code_metrics_functions_segmentation.cognitiveComplexity.critical}}
Very Complex

Lower complexity (1-4) is better. Values above 10 indicate functions that are hard to test and maintain.

Maintainability

Maintainability Index per function

{{total_code_metrics_functions.maintainabilityIndex}} / 100 {{#IF has_total_code_metrics_functions_trend}} {{total_code_metrics_functions_trend.maintainabilityIndex_delta}} {{/IF}}
{{total_code_metrics_functions_segmentation.maintainability.good}}
Excellent
{{total_code_metrics_functions_segmentation.maintainability.ok}}
Good
{{total_code_metrics_functions_segmentation.maintainability.warning}}
Fair
{{total_code_metrics_functions_segmentation.maintainability.critical}}
Poor

Higher is better. Values above 80 indicate highly maintainable code, below 60 suggests refactoring needed.

Avg. LCOM4

Average LCOM4 per class

{{total_code_metrics_functions.avgLcom4}} avg per class {{#IF has_total_code_metrics_functions_trend}} {{total_code_metrics_functions_trend.avg_lcom4_per_class_delta}} {{/IF}}
{{total_code_metrics_functions_segmentation.lcom4.warning}}
Useless (0)
{{total_code_metrics_functions_segmentation.lcom4.good}}
Concise (1)
{{total_code_metrics_functions_segmentation.lcom4.critical}}
Complex (>1)

A value of 1 indicates a cohesive class. >2 indicates a problem. The class should be split into smaller classes. A value of 0 happens when there are no methods in a class. This is also a "bad" class.

Git Activity

Commit frequency over time

License Types

Distribution by license