General

• Home
• Downloads
• GitHub Project
• Javadoc

Running

• Ant Task
• Command-Line [Docker]
• Run as a Test
• Other Tools/Frameworks

Using

• Creating a RuleSet
• Creating a Rule
• Configuring Rules
• Config for Grails, Spock, etc.
• Starter RuleSet (All)

Report Types

• HTML Report [SAMPLE]
• Sortable HTML [SAMPLE]
• XML Report [SAMPLE]
• JSON Report [SAMPLE]
• Text/IDE/Compact Reports
• GitLab Code Quality Report
• Baseline Report

Rules

• Rule Index [By Name]
• Basic Rules
• Braces Rules
• Comments Rules
• Concurrency Rules
• Convention Rules
• Design Rules
• DRY Rules
• Enhanced Rules
• Exceptions Rules
• Formatting Rules
• Generic Rules
• Grails Rules
• Groovyism Rules
• Import Rules
• JDBC Rules
• JUnit Rules
• Logging Rules
• Naming Rules
• Size/Complexity Rules
• Security Rules
• Serialization Rules
• Unnecessary Rules
• Unused Rules

Developing

• Developer Guide

Size and Complexity Rules (“rulesets/size.xml”)

AbcMetric Rule

Calculates theABC size metric for methods/classes and checks against configured threshold values.

ThemaxMethodAbcScore property holds the threshold value for the ABC score for each method.If this value is non-zero, a method with an ABC score greater than this value is considered a violation.The value does not have to be an integer (e.g., 1.7 is allowed).

ThemaxClassAverageMethodAbcScore property holds the threshold value for the average ABCscore for each class. If this value is non-zero, a class with an average ABC score value greaterthan this value is considered a violation. The value does not have to be an integer.

ThemaxClassAbcScore property holds the threshold value for the total ABCscore value for each class. If this value is non-zero, a class with a total ABC scoregreater than this value is considered a violation. The value does not have to be an integer.

This rule treats “closure fields” as methods. If a class field is initialized to a Closure (ClosureExpression),then that Closure is analyzed and checked just like a method.

ABC Size Metric Calculation Rules

TheABC score is calculated as follows:TheABC metric measures size by counting the number of Assignments (A), Branches (B) andConditions (C) and assigns a single numerical score calculated as:

TheABC Metric calculation rules for Groovy:

• Add one to theassignment count for each occurrence of an assignment operator, excluding constantdeclarations: = *= /= %= += **= **= &= |= ^= `=
• Add one to theassignment count for each occurrence of an increment or decrement operator(prefix or postfix): ++ –
• Add one to thebranch count for each function call or class method call.
• Add one to thebranch count for each occurrence of the new operator.
• Add one to thecondition count for each use of a conditional operator: == != <= >= < > <=> =~ ==~
• Add one to thecondition count for each use of the following keywords: else case default try catch ?
• Add one to thecondition count for each unary conditional expression.

Notes

• See theABC Metric specification
• See theBlog post describing guidelines for interpreting an ABC score
• This(Spanish) blog post about theeXcentia Sonar ABC Metric Plugin (for Java) includes a table of risk classifications for ABC scores for both methods and classes.
• See theGMetrics ABC metric.This includes a discussion of guidelines for interpretingABC scores.
• This rule requires the GMetrics jar on the classpath. SeeGMetrics.

ClassSize Rule

Checks if the size of a class exceeds the number of lines specified by themaxLines property.

CrapMetric Rule

Calculates theC.R.A.P. (Change Risk Anti-Patterns)metric score for methods/classes and checks against configured threshold values.

TheCRAP metric score is based on thecyclomatic complexity and test coverage for individual methods.A method with aCRAP value greater than themaxMethodCrapScore property causes a violation. Likewise,a class that has an (average method)CRAP value greater than themaxClassAverageMethodCrapScoreproperty causes a violation.

NOTE: This rule requires theGMetrics[3] jar, version 0.5 (or later), on the classpath, as well asaCobertura[4]-[6] XML coverage file. If either of these prerequisites is not available, this rulelogs a warning messages and exits (i.e., does nothing).

ThemaxMethodCrapScore property holds the threshold value for the CRAP value for each method. If thisvalue is non-zero, a method with a cyclomatic complexity value greater than this value is considered a violation.

ThemaxClassAverageMethodCrapScore property holds the threshold value for the average CRAP valuefor each class. If this value is non-zero, a class with an average cyclomatic complexityvalue greater than this value is considered a violation.

NOTE: This rule does NOT treatclosure fields as methods (unlike some of the other size/complexity rules).

CRAP Formula

Given a Groovy method m, C.R.A.P. for m is calculated as follows:

  C.R.A.P.(m) = comp(m)^2 * (1 - cov(m)/100)^3 + comp(m)

Wherecomp(m) is thecyclomatic complexity of method m, andcov(m) is the test code coverage providedby automated tests.

References

• [1] The original 2007blog post that defined theCRAP metric.

• [2] A 2011blog post from Alberto Savoia (the co-creator of theCRAP metric with Bob Evans), describing the formula, the motivation, and theCRAP4J tool for calculatingCRAP score for Java code.

• [3] TheGMetrics CRAP Metric.

• [4]Cobertura –Cobertura is a free Java tool that calculates the percentage of code accessed by tests. It can be used to identify which parts of your Java program are lacking test coverage.

• [5]Cobertura Ant Task Reference

• [6]Cobertura Maven Plugin

CyclomaticComplexity Rule

Calculates theCyclomatic Complexity for methods/classes and checks against configured threshold values.

ThemaxMethodComplexity property holds the threshold value for the cyclomatic complexityvalue for each method. If this value is non-zero, a method with a cyclomatic complexity value greater thanthis value is considered a violation.

ThemaxClassAverageMethodComplexity property holds the threshold value for the average cyclomaticcomplexity value for each class. If this value is non-zero, a class with an average cyclomatic complexityvalue greater than this value is considered a violation.

This rule treats “closure fields” as methods. If a class field is initialized to a Closure (ClosureExpression),then that Closure is analyzed and checked just like a method.

Cyclomatic Complexity Metric Calculation Rules

Thecyclomatic complexity value is calculated as follows:

Start with a initial (default) value of one (1).Add one (1) for each occurrence of each of the following:

 * `if` statement * `while` statement * `for` statement * `case` statement * `catch` statement * `&&` and `||` boolean operations * `?:` ternary operator and `?:` *Elvis* operator. * `?.` null-check operator

Notes

• See theCyclomatic Complexity Wikipedia entry
• See theoriginal paper describing Cyclomatic Complexity
• See theGMetrics Cyclomatic Complexity metric.This includes a discussion of guidelines for interpretingcyclomatic complexity values.
• This rule requires the GMetrics jar on the classpath. SeeGMetrics.

MethodCount Rule

Since CodeNarc 0.11

Checks if the number of methods within a class exceeds the number of lines specified by themaxMethod property.

A class with too many methods is probably a good suspect for refactoring, in order to reduce itscomplexity and find a way to have more fine grained objects.

MethodSize Rule

Checks if the size of a method exceeds the number of lines specified by themaxLines property.

Known Limitations:

• Annotations on a method are included in the size (line count) for that method.

NestedBlockDepth Rule

Checks for blocks or closures nested more deeply than a configured maximum number.Blocks includeif,for,while,switch,try,catch,finally andsynchronized blocks/statements, as well as closures.

Methods calls, constructor calls, and property access through Builder objects are ignore. For instance, this codedoes not cause a violation:

    myBuilder.root {        foo {            bar {                baz {                    quix {                        qux {                            quaxz {                            }                        }                    }                }            }        }    }

ParameterCount Rule

Since CodeNarc 0.23

Checks if the number of parameters in method/constructor exceeds the number of parameters specified by the maxParameters property.

Example of violations:

    void someMethod(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) { // violation    }    @Override    void someMethod(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7) { // no violation if ignoreOverriddenMethods == true    }    class SampleClass {        SampleClass(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7) { // violation        }    }