{ "$schema": "https://json.schemastore.org/sarif-2.1.0.json", "version": "2.1.0", "runs": [ { "tool": { "driver": { "name": "CodeNarc", "version": "3.7.0", "informationUri": "https://codenarc.org", "rules": [ { "id": "AbcMetric", "name": "AbcMetricRule", "shortDescription": { "text": "Checks the ABC size metric for methods/classes. A method (or \"closure field\") with an ABC score greater than the maxMethodAbcScore property (60) causes a violation. Likewise, a class that has an (average method) ABC score greater than the maxClassAverageMethodAbcScore property (60) causes a violation." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#abcmetric-rule", "properties": { "priority": 2 } }, { "id": "AddEmptyString", "name": "AddEmptyStringRule", "shortDescription": { "text": "Finds empty string literals which are being added. This is an inefficient way to convert any type to a String." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#addemptystring-rule", "properties": { "priority": 2 } }, { "id": "AssertWithinFinallyBlock", "name": "AssertWithinFinallyBlockRule", "shortDescription": { "text": "Checks for assert statements within a finally block. An assert can throw an exception, hiding the original exception, if there is one." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#assertwithinfinallyblock-rule", "properties": { "priority": 2 } }, { "id": "AssignCollectionSort", "name": "AssignCollectionSortRule", "shortDescription": { "text": "The Collections.sort() method mutates the list and returns the list as a value. If you are assigning the result of sort() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#assigncollectionsort-rule", "properties": { "priority": 2 } }, { "id": "AssignCollectionUnique", "name": "AssignCollectionUniqueRule", "shortDescription": { "text": "The Collections.unique() method mutates the list and returns the list as a value. If you are assigning the result of unique() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#assigncollectionunique-rule", "properties": { "priority": 2 } }, { "id": "AssignmentInConditional", "name": "AssignmentInConditionalRule", "shortDescription": { "text": "An assignment operator (=) was used in a conditional test. This is usually a typo, and the comparison operator (==) was intended." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#assignmentinconditional-rule", "properties": { "priority": 2 } }, { "id": "BigDecimalInstantiation", "name": "BigDecimalInstantiationRule", "shortDescription": { "text": "Checks for calls to the BigDecimal constructors that take a double parameter, which may result in an unexpected BigDecimal value." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#bigdecimalinstantiation-rule", "properties": { "priority": 2 } }, { "id": "BitwiseOperatorInConditional", "name": "BitwiseOperatorInConditionalRule", "shortDescription": { "text": "Checks for bitwise operations in conditionals, if you need to do a bitwise operation then it is best practice to extract a temp variable." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#bitwiseoperatorinconditional-rule", "properties": { "priority": 2 } }, { "id": "BooleanGetBoolean", "name": "BooleanGetBooleanRule", "shortDescription": { "text": "This rule catches usages of java.lang.Boolean.getBoolean(String) which reads a boolean from the System properties. It is often mistakenly used to attempt to read user input or parse a String into a boolean. It is a poor piece of API to use; replace it with System.properties['prop']." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#booleangetboolean-rule", "properties": { "priority": 2 } }, { "id": "BrokenNullCheck", "name": "BrokenNullCheckRule", "shortDescription": { "text": "Looks for faulty checks for null that can cause a NullPointerException." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#brokennullcheck-rule", "properties": { "priority": 2 } }, { "id": "BrokenOddnessCheck", "name": "BrokenOddnessCheckRule", "shortDescription": { "text": "The code uses x % 2 == 1 to check to see if a value is odd, but this won't work for negative numbers (e.g., (-5) % 2 == -1). If this code is intending to check for oddness, consider using x & 1 == 1, or x % 2 != 0." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#brokenoddnesscheck-rule", "properties": { "priority": 2 } }, { "id": "ClassForName", "name": "ClassForNameRule", "shortDescription": { "text": "Using Class.forName(...) is a common way to add dynamic behavior to a system. However, using this method can cause resource leaks because the classes can be pinned in memory for long periods of time." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#classforname-rule", "properties": { "priority": 2 } }, { "id": "ClassSize", "name": "ClassSizeRule", "shortDescription": { "text": "Checks if the size of a class exceeds the number of lines specified by the maxLines property (1000)." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#classsize-rule", "properties": { "priority": 3 } }, { "id": "ClosureAsLastMethodParameter", "name": "ClosureAsLastMethodParameterRule", "shortDescription": { "text": "If a method is called and the last parameter is an inline closure then it can be declared outside of the method call brackets." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#closureaslastmethodparameter-rule", "properties": { "priority": 3 } }, { "id": "CollectAllIsDeprecated", "name": "CollectAllIsDeprecatedRule", "shortDescription": { "text": "collectAll{} is deprecated since Groovy 1.8.1. Use collectNested instead{}." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#collectallisdeprecated-rule", "properties": { "priority": 2 } }, { "id": "ComparisonOfTwoConstants", "name": "ComparisonOfTwoConstantsRule", "shortDescription": { "text": "Checks for expressions where a comparison operator or equals() or compareTo() is used to compare two constants to each other or two literals that contain only constant values, e.g.: 23 == 67, Boolean.FALSE != false, 0.17 <= 0.99, \"abc\" > \"ddd\", [a:1] <=> [a:2], [1,2].equals([3,4]) or [a:false, b:true].compareTo(['a':34.5, b:Boolean.TRUE], where x is a variable." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#comparisonoftwoconstants-rule", "properties": { "priority": 2 } }, { "id": "ComparisonWithSelf", "name": "ComparisonWithSelfRule", "shortDescription": { "text": "Checks for expressions where a comparison operator or equals() or compareTo() is used to compare a variable to itself, e.g.: x == x, x != x, x <=> x, x < x, x >= x, x.equals(x) or x.compareTo(x), where x is a variable." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#comparisonwithself-rule", "properties": { "priority": 2 } }, { "id": "ConfusingMultipleReturns", "name": "ConfusingMultipleReturnsRule", "shortDescription": { "text": "Multiple return values can be used to set several variables at once. To use multiple return values, the left hand side of the assignment must be enclosed in parenthesis. If not, then you are not using multiple return values, you're only assigning the last element." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#confusingmultiplereturns-rule", "properties": { "priority": 2 } }, { "id": "ConsecutiveLiteralAppends", "name": "ConsecutiveLiteralAppendsRule", "shortDescription": { "text": "Violations occur when method calls to append(Object) are chained together with literals as parameters. The chained calls can be joined into one invocation." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#consecutiveliteralappends-rule", "properties": { "priority": 2 } }, { "id": "ConsecutiveStringConcatenation", "name": "ConsecutiveStringConcatenationRule", "shortDescription": { "text": "Catches concatenation of two string literals on the same line. These can safely by joined." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#consecutivestringconcatenation-rule", "properties": { "priority": 3 } }, { "id": "ConstantAssertExpression", "name": "ConstantAssertExpressionRule", "shortDescription": { "text": "Checks for assert statements where the assert boolean condition expression is a constant or literal value." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#constantassertexpression-rule", "properties": { "priority": 3 } }, { "id": "ConstantIfExpression", "name": "ConstantIfExpressionRule", "shortDescription": { "text": "Checks for if statements with a constant value for the if expression, such as true, false, null, or a literal constant value." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#constantifexpression-rule", "properties": { "priority": 2 } }, { "id": "ConstantTernaryExpression", "name": "ConstantTernaryExpressionRule", "shortDescription": { "text": "Checks for ternary expressions with a constant value for the boolean expression, such as true, false, null, or a literal constant value." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#constantternaryexpression-rule", "properties": { "priority": 2 } }, { "id": "CrapMetric", "name": "CrapMetricRule", "shortDescription": { "text": "Checks the CRAP (Change Risk Anti-Patterns) score for methods/classes. The CRAP metric score is based on the cyclomatic complexity and test coverage for individual methods. A method with a CRAP value greater than the maxMethodCrapScore property (30) causes a violation. Likewise, a class that has an (average method) CRAP value greater than the maxClassAverageMethodCrapScore property (30) causes a violation." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#crapmetric-rule", "properties": { "priority": 2 } }, { "id": "CyclomaticComplexity", "name": "CyclomaticComplexityRule", "shortDescription": { "text": "Checks the cyclomatic complexity for methods/classes.A method (or \"closure field\") with a cyclomatic complexity value greater than the maxMethodComplexity property (20) causes a violation. Likewise, a class that has an (average method) cyclomatic complexityvalue greater than the maxClassAverageMethodComplexity property (20) causes a violation." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#cyclomaticcomplexity-rule", "properties": { "priority": 2 } }, { "id": "DeadCode", "name": "DeadCodeRule", "shortDescription": { "text": "Dead code appears after a return statement or an exception is thrown. If code appears after one of these statements then it will never be executed and can be safely deleted." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#deadcode-rule", "properties": { "priority": 2 } }, { "id": "DoubleNegative", "name": "DoubleNegativeRule", "shortDescription": { "text": "There is no point in using a double negative, it is always positive. For instance !!x can always be simplified to x. And !(!x) can as well." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#doublenegative-rule", "properties": { "priority": 2 } }, { "id": "DuplicateCaseStatement", "name": "DuplicateCaseStatementRule", "shortDescription": { "text": "Check for duplicate case statements in a switch block, such as two equal integers or strings." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#duplicatecasestatement-rule", "properties": { "priority": 2 } }, { "id": "DuplicateImport", "name": "DuplicateImportRule", "shortDescription": { "text": "Duplicate import statements are unnecessary." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#duplicateimport-rule", "properties": { "priority": 3 } }, { "id": "DuplicateMapKey", "name": "DuplicateMapKeyRule", "shortDescription": { "text": "A map literal is created with duplicated key. The map entry will be overwritten." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#duplicatemapkey-rule", "properties": { "priority": 2 } }, { "id": "DuplicateSetValue", "name": "DuplicateSetValueRule", "shortDescription": { "text": "A Set literal is created with duplicate constant value. A set cannot contain two elements with the same value." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#duplicatesetvalue-rule", "properties": { "priority": 2 } }, { "id": "EmptyCatchBlock", "name": "EmptyCatchBlockRule", "shortDescription": { "text": "In most cases, exceptions should not be caught and ignored (swallowed)." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptycatchblock-rule", "properties": { "priority": 2 } }, { "id": "EmptyClass", "name": "EmptyClassRule", "shortDescription": { "text": "Reports classes without methods, fields or properties. Why would you need a class like this?" }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyclass-rule", "properties": { "priority": 2 } }, { "id": "EmptyElseBlock", "name": "EmptyElseBlockRule", "shortDescription": { "text": "Empty else blocks are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyelseblock-rule", "properties": { "priority": 2 } }, { "id": "EmptyFinallyBlock", "name": "EmptyFinallyBlockRule", "shortDescription": { "text": "Empty finally blocks are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyfinallyblock-rule", "properties": { "priority": 2 } }, { "id": "EmptyForStatement", "name": "EmptyForStatementRule", "shortDescription": { "text": "Empty for statements are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyforstatement-rule", "properties": { "priority": 2 } }, { "id": "EmptyIfStatement", "name": "EmptyIfStatementRule", "shortDescription": { "text": "Empty if statements are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyifstatement-rule", "properties": { "priority": 2 } }, { "id": "EmptyInstanceInitializer", "name": "EmptyInstanceInitializerRule", "shortDescription": { "text": "An empty class instance initializer was found. It is safe to remove it." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyinstanceinitializer-rule", "properties": { "priority": 2 } }, { "id": "EmptyMethod", "name": "EmptyMethodRule", "shortDescription": { "text": "A method was found without an implementation. If the method is overriding or implementing a parent method, then mark it with the @Override annotation." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptymethod-rule", "properties": { "priority": 2 } }, { "id": "EmptyStaticInitializer", "name": "EmptyStaticInitializerRule", "shortDescription": { "text": "An empty static initializer was found. It is safe to remove it." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptystaticinitializer-rule", "properties": { "priority": 2 } }, { "id": "EmptySwitchStatement", "name": "EmptySwitchStatementRule", "shortDescription": { "text": "Empty switch statements are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptyswitchstatement-rule", "properties": { "priority": 2 } }, { "id": "EmptySynchronizedStatement", "name": "EmptySynchronizedStatementRule", "shortDescription": { "text": "Empty synchronized statements are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptysynchronizedstatement-rule", "properties": { "priority": 2 } }, { "id": "EmptyTryBlock", "name": "EmptyTryBlockRule", "shortDescription": { "text": "Empty try blocks are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptytryblock-rule", "properties": { "priority": 2 } }, { "id": "EmptyWhileStatement", "name": "EmptyWhileStatementRule", "shortDescription": { "text": "Empty while statements are confusing and serve no purpose." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#emptywhilestatement-rule", "properties": { "priority": 2 } }, { "id": "EqualsAndHashCode", "name": "EqualsAndHashCodeRule", "shortDescription": { "text": "If either the equals(Object) or the hashCode() methods are overridden within a class, then both must be overridden." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#equalsandhashcode-rule", "properties": { "priority": 2 } }, { "id": "EqualsOverloaded", "name": "EqualsOverloadedRule", "shortDescription": { "text": "The class has an equals method, but the parameter of the method is not of type Object. It is not overriding equals but instead overloading it." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#equalsoverloaded-rule", "properties": { "priority": 2 } }, { "id": "ExplicitArrayListInstantiation", "name": "ExplicitArrayListInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a ArrayList using the no-arg constructor. In Groovy, it is best to write \"new ArrayList()\" as \"[]\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitarraylistinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToAndMethod", "name": "ExplicitCallToAndMethodRule", "shortDescription": { "text": "This rule detects when the and(Object) method is called directly in code instead of using the & operator. A groovier way to express this: a.and(b) is this: a & b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoandmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToCompareToMethod", "name": "ExplicitCallToCompareToMethodRule", "shortDescription": { "text": "This rule detects when the compareTo(Object) method is called directly in code instead of using the <=>, >, >=, <, and <= operators. A groovier way to express this: a.compareTo(b) is this: a <=> b, or using the other operators." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltocomparetomethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToDivMethod", "name": "ExplicitCallToDivMethodRule", "shortDescription": { "text": "This rule detects when the div(Object) method is called directly in code instead of using the / operator. A groovier way to express this: a.div(b) is this: a / b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltodivmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToEqualsMethod", "name": "ExplicitCallToEqualsMethodRule", "shortDescription": { "text": "This rule detects when the equals(Object) method is called directly in code instead of using the == or != operator. A groovier way to express this: a.equals(b) is this: a == b and a groovier way to express : !a.equals(b) is : a != b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoequalsmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToGetAtMethod", "name": "ExplicitCallToGetAtMethodRule", "shortDescription": { "text": "This rule detects when the getAt(Object) method is called directly in code instead of using the [] index operator. A groovier way to express this: a.getAt(b) is this: a[b]" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltogetatmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToLeftShiftMethod", "name": "ExplicitCallToLeftShiftMethodRule", "shortDescription": { "text": "This rule detects when the leftShift(Object) method is called directly in code instead of using the << operator. A groovier way to express this: a.leftShift(b) is this: a << b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoleftshiftmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToMinusMethod", "name": "ExplicitCallToMinusMethodRule", "shortDescription": { "text": "This rule detects when the minus(Object) method is called directly in code instead of using the - operator. A groovier way to express this: a.minus(b) is this: a - b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltominusmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToModMethod", "name": "ExplicitCallToModMethodRule", "shortDescription": { "text": "This rule detects when the mod(Object) method is called directly in code instead of using the % operator. A groovier way to express this: a.mod(b) is this: a % b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltomodmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToMultiplyMethod", "name": "ExplicitCallToMultiplyMethodRule", "shortDescription": { "text": "This rule detects when the minus(Object) method is called directly in code instead of using the * operator. A groovier way to express this: a.multiply(b) is this: a * b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltomultiplymethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToOrMethod", "name": "ExplicitCallToOrMethodRule", "shortDescription": { "text": "This rule detects when the or(Object) method is called directly in code instead of using the | operator. A groovier way to express this: a.or(b) is this: a | b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoormethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToPlusMethod", "name": "ExplicitCallToPlusMethodRule", "shortDescription": { "text": "This rule detects when the plus(Object) method is called directly in code instead of using the + operator. A groovier way to express this: a.plus(b) is this: a + b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoplusmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToPowerMethod", "name": "ExplicitCallToPowerMethodRule", "shortDescription": { "text": "This rule detects when the power(Object) method is called directly in code instead of using the ** operator. A groovier way to express this: a.power(b) is this: a ** b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltopowermethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToPutAtMethod", "name": "ExplicitCallToPutAtMethodRule", "shortDescription": { "text": "Detects when the putAt(Object, Object) method is called directly in code instead of using the [] index operator. A groovier way to express this: map.putAt(k, v) is this: map[k] = v." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoputatmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToRightShiftMethod", "name": "ExplicitCallToRightShiftMethodRule", "shortDescription": { "text": "This rule detects when the rightShift(Object) method is called directly in code instead of using the >> operator. A groovier way to express this: a.rightShift(b) is this: a >> b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltorightshiftmethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitCallToXorMethod", "name": "ExplicitCallToXorMethodRule", "shortDescription": { "text": "This rule detects when the xor(Object) method is called directly in code instead of using the ^ operator. A groovier way to express this: a.xor(b) is this: a ^ b" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitcalltoxormethod-rule", "properties": { "priority": 2 } }, { "id": "ExplicitGarbageCollection", "name": "ExplicitGarbageCollectionRule", "shortDescription": { "text": "Calls to System.gc(), Runtime.getRuntime().gc(), and System.runFinalization() are not advised. Code should have the same behavior whether the garbage collection is disabled using the option -Xdisableexplicitgc or not. Moreover, \"modern\" jvms do a very good job handling garbage collections. If memory usage issues unrelated to memory leaks develop within an application, it should be dealt with JVM options rather than within the code itself." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#explicitgarbagecollection-rule", "properties": { "priority": 2 } }, { "id": "ExplicitHashMapInstantiation", "name": "ExplicitHashMapInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a HashMap using the no-arg constructor. In Groovy, it is best to write \"new HashMap()\" as \"[:]\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicithashmapinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitHashSetInstantiation", "name": "ExplicitHashSetInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a HashSet using the no-arg constructor. In Groovy, it is best to write \"new HashSet()\" as \"[] as Set\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicithashsetinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitLinkedHashMapInstantiation", "name": "ExplicitLinkedHashMapInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a LinkedHashMap using the no-arg constructor. In Groovy, it is best to write \"new LinkedHashMap()\" as \"[:]\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitlinkedhashmapinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitLinkedListInstantiation", "name": "ExplicitLinkedListInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a LinkedList using the no-arg constructor. In Groovy, it is best to write \"new LinkedList()\" as \"[] as Queue\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitlinkedlistinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitStackInstantiation", "name": "ExplicitStackInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a Stack using the no-arg constructor. In Groovy, it is best to write \"new Stack()\" as \"[] as Stack\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicitstackinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ExplicitTreeSetInstantiation", "name": "ExplicitTreeSetInstantiationRule", "shortDescription": { "text": "This rule checks for the explicit instantiation of a TreeSet using the no-arg constructor. In Groovy, it is best to write \"new TreeSet()\" as \"[] as SortedSet\", which creates the same object." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#explicittreesetinstantiation-rule", "properties": { "priority": 2 } }, { "id": "ForLoopShouldBeWhileLoop", "name": "ForLoopShouldBeWhileLoopRule", "shortDescription": { "text": "A for loop without an init and update statement can be simplified to a while loop." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#forloopshouldbewhileloop-rule", "properties": { "priority": 3 } }, { "id": "GStringAsMapKey", "name": "GStringAsMapKeyRule", "shortDescription": { "text": "A GString should not be used as a map key since its hashcode is not guaranteed to be stable. Consider calling key.toString()." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#gstringasmapkey-rule", "properties": { "priority": 2 } }, { "id": "GStringExpressionWithinString", "name": "GStringExpressionWithinStringRule", "shortDescription": { "text": "Check for regular (single quote) strings containing a GString-type expression (${...})." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#gstringexpressionwithinstring-rule", "properties": { "priority": 2 } }, { "id": "GetterMethodCouldBeProperty", "name": "GetterMethodCouldBePropertyRule", "shortDescription": { "text": "If a class defines a public method that follows the Java getter notation, and returns a constant, then it is cleaner to provide a Groovy property for the value rather than a Groovy method." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#gettermethodcouldbeproperty-rule", "properties": { "priority": 3 } }, { "id": "GroovyLangImmutable", "name": "GroovyLangImmutableRule", "shortDescription": { "text": "The groovy.lang.Immutable annotation has been deprecated and replaced by groovy.transform.Immutable. Do not use the Immutable in groovy.lang." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#groovylangimmutable-rule", "properties": { "priority": 2 } }, { "id": "HardCodedWindowsFileSeparator", "name": "HardCodedWindowsFileSeparatorRule", "shortDescription": { "text": "This rule finds usages of a Windows file separator within the constructor call of a File object. It is better to use the Unix file separator or use the File.separator constant." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#hardcodedwindowsfileseparator-rule", "properties": { "priority": 2 } }, { "id": "HardCodedWindowsRootDirectory", "name": "HardCodedWindowsRootDirectoryRule", "shortDescription": { "text": "This rule find cases where a File object is constructed with a windows-based path. This is not portable, and using the File.listRoots() method is a better alternative." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#hardcodedwindowsrootdirectory-rule", "properties": { "priority": 2 } }, { "id": "ImportFromSamePackage", "name": "ImportFromSamePackageRule", "shortDescription": { "text": "An import of a class that is within the same package is unnecessary." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#importfromsamepackage-rule", "properties": { "priority": 3 } }, { "id": "ImportFromSunPackages", "name": "ImportFromSunPackagesRule", "shortDescription": { "text": "Avoid importing anything from the 'sun.*' packages. These packages are not portable and are likely to change." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#importfromsunpackages-rule", "properties": { "priority": 2 } }, { "id": "IntegerGetInteger", "name": "IntegerGetIntegerRule", "shortDescription": { "text": "This rule catches usages of java.lang.Integer.getInteger(String, ...) which reads an Integer from the System properties. It is often mistakenly used to attempt to read user input or parse a String into an Integer. It is a poor piece of API to use; replace it with System.properties['prop']." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#integergetinteger-rule", "properties": { "priority": 2 } }, { "id": "MethodCount", "name": "MethodCountRule", "shortDescription": { "text": "A class with too many methods is probably a good suspect for refactoring, in order to reduce its complexity and find a way to have more fine grained objects. The maxMethods property (30) specifies the threshold." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#methodcount-rule", "properties": { "priority": 2 } }, { "id": "MethodSize", "name": "MethodSizeRule", "shortDescription": { "text": "Checks if the size of a method exceeds the number of lines specified by the maxLines property (100)." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#methodsize-rule", "properties": { "priority": 3 } }, { "id": "MisorderedStaticImports", "name": "MisorderedStaticImportsRule", "shortDescription": { "text": "Static imports should never be declared after nonstatic imports." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#misorderedstaticimports-rule", "properties": { "priority": 3 } }, { "id": "MultipleUnaryOperators", "name": "MultipleUnaryOperatorsRule", "shortDescription": { "text": "Checks for multiple consecutive unary operators. These are confusing, and are likely typos and bugs." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#multipleunaryoperators-rule", "properties": { "priority": 2 } }, { "id": "NestedBlockDepth", "name": "NestedBlockDepthRule", "shortDescription": { "text": "Checks for blocks or closures nested more than maxNestedBlockDepth (5) levels deep." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#nestedblockdepth-rule", "properties": { "priority": 2 } }, { "id": "NoWildcardImports", "name": "NoWildcardImportsRule", "shortDescription": { "text": "Wildcard imports, static or otherwise, should not be used." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#nowildcardimports-rule", "properties": { "priority": 3 } }, { "id": "ParameterAssignmentInFilterClosure", "name": "ParameterAssignmentInFilterClosureRule", "shortDescription": { "text": "An assignment operator was used on a parameter in a filtering closure. This is usually a typo, and the comparison operator (==) was intended." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#parameterassignmentinfilterclosure-rule", "properties": { "priority": 2 } }, { "id": "ParameterCount", "name": "ParameterCountRule", "shortDescription": { "text": "Checks if the number of parameters in method/constructor exceeds the number of parameters specified by the maxParameters property." }, "helpUri": "https://codenarc.org/codenarc-rules-size.html#parametercount-rule", "properties": { "priority": 2 } }, { "id": "RandomDoubleCoercedToZero", "name": "RandomDoubleCoercedToZeroRule", "shortDescription": { "text": "The Math.random() method returns a double result greater than or equal to 0.0 and less than 1.0. If you coerce this result into an Integer or int, then it is coerced to zero. Casting the result to int, or assigning it to an int field is probably a bug." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#randomdoublecoercedtozero-rule", "properties": { "priority": 2 } }, { "id": "RemoveAllOnSelf", "name": "RemoveAllOnSelfRule", "shortDescription": { "text": "Don't use removeAll to clear a collection. If you want to remove all elements from a collection c, use c.clear, not c.removeAll(c). Calling c.removeAll(c) to clear a collection is less clear, susceptible to errors from typos, less efficient and for some collections, might throw a ConcurrentModificationException." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#removeallonself-rule", "properties": { "priority": 2 } }, { "id": "ReturnFromFinallyBlock", "name": "ReturnFromFinallyBlockRule", "shortDescription": { "text": "Returning from a finally block is confusing and can hide the original exception." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#returnfromfinallyblock-rule", "properties": { "priority": 2 } }, { "id": "ThrowExceptionFromFinallyBlock", "name": "ThrowExceptionFromFinallyBlockRule", "shortDescription": { "text": "Throwing an exception from a finally block is confusing and can hide the original exception." }, "helpUri": "https://codenarc.org/codenarc-rules-basic.html#throwexceptionfromfinallyblock-rule", "properties": { "priority": 2 } }, { "id": "UnnecessaryBigDecimalInstantiation", "name": "UnnecessaryBigDecimalInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate BigDecimal objects. Instead just use the decimal literal or the 'G' identifier to force the type, such as 123.45 or 123.45G." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarybigdecimalinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryBigIntegerInstantiation", "name": "UnnecessaryBigIntegerInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate BigInteger objects. Instead just use the literal with the 'G' identifier to force the type, such as 8G or 42G." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarybigintegerinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryBooleanExpression", "name": "UnnecessaryBooleanExpressionRule", "shortDescription": { "text": "Checks for unnecessary boolean expressions, including ANDing (&&) or ORing (||) with true, false, null, or a Map/List/String/Number literal. Also checks for negation (!) of true, false, null, or a Map/List/String/Number literal." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarybooleanexpression-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryBooleanInstantiation", "name": "UnnecessaryBooleanInstantiationRule", "shortDescription": { "text": "Use Boolean.valueOf() for variable values or Boolean.TRUE and Boolean.FALSE for constant values instead of calling the Boolean() constructor directly or calling Boolean.valueOf(true) or Boolean.valueOf(false)." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarybooleaninstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryCallForLastElement", "name": "UnnecessaryCallForLastElementRule", "shortDescription": { "text": "This rule checks for excessively verbose methods of accessing the last element of an array or list. For instance, it is possible to access the last element of an array by performing array[array.length - 1], in Groovy it is simpler to either call array.last() or array[-1]. The same is true for lists. This violation is triggered whenever a get, getAt, or array-style access is used with an object size check." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycallforlastelement-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryCallToSubstring", "name": "UnnecessaryCallToSubstringRule", "shortDescription": { "text": "Calling String.substring(0) always returns the original string. This code is meaningless." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycalltosubstring-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryCast", "name": "UnnecessaryCastRule", "shortDescription": { "text": "Checks for unnecessary cast operations" }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycast-rule", "properties": { "priority": 2 } }, { "id": "UnnecessaryCatchBlock", "name": "UnnecessaryCatchBlockRule", "shortDescription": { "text": "Violations are triggered when a catch block does nothing but throw the original exception. In this scenario there is usually no need for a catch block, just let the exception be thrown from the original code. This condition frequently occurs when catching an exception for debugging purposes but then forgetting to take the catch statement out." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycatchblock-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryCollectCall", "name": "UnnecessaryCollectCallRule", "shortDescription": { "text": "Some method calls to Object.collect(Closure) can be replaced with the spread operator. For instance, list.collect { it.multiply(2) } can be replaced by list*.multiply(2). Warning: if a collection is null, collect will return an empty list, while *. will return null." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycollectcall-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryCollectionCall", "name": "UnnecessaryCollectionCallRule", "shortDescription": { "text": "Useless call to collections. This call doesn't make sense. For any collection c, calling c.containsAll(c) should always be true, and c.retainAll(c) should have no effect." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarycollectioncall-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryConstructor", "name": "UnnecessaryConstructorRule", "shortDescription": { "text": "This rule detects when a constructor is not necessary; i.e., when there's only one constructor, it's public, has an empty body, and takes no arguments." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryconstructor-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryDefInFieldDeclaration", "name": "UnnecessaryDefInFieldDeclarationRule", "shortDescription": { "text": "If a field has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance, 'static def constraints = {}' is redundant and can be simplified to 'static constraints = {}." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarydefinfielddeclaration-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryDefInMethodDeclaration", "name": "UnnecessaryDefInMethodDeclarationRule", "shortDescription": { "text": "If a method has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private method() {}' is redundant and can be simplified to 'private method() {}'." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarydefinmethoddeclaration-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryDefInVariableDeclaration", "name": "UnnecessaryDefInVariableDeclarationRule", "shortDescription": { "text": "If a variable has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private n = 2' is redundant and can be simplified to 'private n = 2'." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarydefinvariabledeclaration-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryDotClass", "name": "UnnecessaryDotClassRule", "shortDescription": { "text": "To make a reference to a class, it is unnecessary to specify the '.class' identifier. For instance String.class can be shortened to String." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarydotclass-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryDoubleInstantiation", "name": "UnnecessaryDoubleInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate Double objects. Instead just use the double literal or the 'D' identifier to force the type, such as 123.45d or 0.42d." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarydoubleinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryElseStatement", "name": "UnnecessaryElseStatementRule", "shortDescription": { "text": "When an if statement block ends with a return statement the else is unnecessary. The logic in the else branch can be run without being in a new scope." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryelsestatement-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryFinalOnPrivateMethod", "name": "UnnecessaryFinalOnPrivateMethodRule", "shortDescription": { "text": "A private method is marked final. Private methods cannot be overridden, so marking it final is unnecessary." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryfinalonprivatemethod-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryFloatInstantiation", "name": "UnnecessaryFloatInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate Float objects. Instead just use the float literal with the 'F' identifier to force the type, such as 123.45F or 0.42f." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryfloatinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryGString", "name": "UnnecessaryGStringRule", "shortDescription": { "text": "String objects should be created with single quotes, and GString objects created with double quotes. Creating normal String objects with double quotes is confusing to readers." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarygstring-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryGroovyImport", "name": "UnnecessaryGroovyImportRule", "shortDescription": { "text": "A Groovy file does not need to include an import for classes from java.lang, java.util, java.io, java.net, groovy.lang and groovy.util, as well as the classes java.math.BigDecimal and java.math.BigInteger." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#unnecessarygroovyimport-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryIfStatement", "name": "UnnecessaryIfStatementRule", "shortDescription": { "text": "Checks for if statements where the if and else blocks (or subsequent fall-through to a return), are merely returning true and false constants. These cases can be replaced by a simple return statement." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryifstatement-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryInstanceOfCheck", "name": "UnnecessaryInstanceOfCheckRule", "shortDescription": { "text": "This rule finds instanceof checks that cannot possibly evaluate to true. For instance, checking that (!variable instanceof String) will never be true because the result of a not expression is always a boolean." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryinstanceofcheck-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryInstantiationToGetClass", "name": "UnnecessaryInstantiationToGetClassRule", "shortDescription": { "text": "Avoid instantiating an object just to call getClass() on it; use the .class public member instead." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryinstantiationtogetclass-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryIntegerInstantiation", "name": "UnnecessaryIntegerInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate Integer objects. Instead just use the literal with the 'I' identifier to force the type, such as 8I or 42i." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryintegerinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryLongInstantiation", "name": "UnnecessaryLongInstantiationRule", "shortDescription": { "text": "It is unnecessary to instantiate Long objects. Instead just use the literal with the 'L' identifier to force the type, such as 8L or 42L." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarylonginstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryModOne", "name": "UnnecessaryModOneRule", "shortDescription": { "text": "Any expression mod 1 (exp % 1) is guaranteed to always return zero. This code is probably an error, and should be either (exp & 1) or (exp % 2)." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarymodone-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryNullCheck", "name": "UnnecessaryNullCheckRule", "shortDescription": { "text": "Groovy contains the safe dereference operator, which can be used in boolean conditional statements to safely replace explicit \"x == null\" tests." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarynullcheck-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryNullCheckBeforeInstanceOf", "name": "UnnecessaryNullCheckBeforeInstanceOfRule", "shortDescription": { "text": "There is no need to check for null before an instanceof; the instanceof keyword returns false when given a null argument." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarynullcheckbeforeinstanceof-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryObjectReferences", "name": "UnnecessaryObjectReferencesRule", "shortDescription": { "text": "Violations are triggered when an excessive set of consecutive statements all reference the same variable. This can be made more readable by using a with or identity block." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryobjectreferences-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryOverridingMethod", "name": "UnnecessaryOverridingMethodRule", "shortDescription": { "text": "The overriding method merely calls the same method defined in a superclass" }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryoverridingmethod-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryPackageReference", "name": "UnnecessaryPackageReferenceRule", "shortDescription": { "text": "Checks for explicit package reference for classes that Groovy imports by default, such as java.lang.String, java.util.Map and groovy.lang.Closure." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarypackagereference-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryParenthesesForMethodCallWithClosure", "name": "UnnecessaryParenthesesForMethodCallWithClosureRule", "shortDescription": { "text": "If a method is called and the only parameter to that method is an inline closure then the parentheses of the method call can be omitted." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryparenthesesformethodcallwithclosure-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryPublicModifier", "name": "UnnecessaryPublicModifierRule", "shortDescription": { "text": "The 'public' modifier is not required on methods or classes." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarypublicmodifier-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryReturnKeyword", "name": "UnnecessaryReturnKeywordRule", "shortDescription": { "text": "In Groovy, the return keyword is often optional. If a statement is the last line in a method or closure then you do not need to have the return keyword." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryreturnkeyword-rule", "properties": { "priority": 3 } }, { "id": "UnnecessarySafeNavigationOperator", "name": "UnnecessarySafeNavigationOperatorRule", "shortDescription": { "text": "Check for the safe navigation operator (?.) applied to constants and literals, which can never be null." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarysafenavigationoperator-rule", "properties": { "priority": 3 } }, { "id": "UnnecessarySelfAssignment", "name": "UnnecessarySelfAssignmentRule", "shortDescription": { "text": "Method contains a pointless self-assignment to a variable or property." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryselfassignment-rule", "properties": { "priority": 3 } }, { "id": "UnnecessarySemicolon", "name": "UnnecessarySemicolonRule", "shortDescription": { "text": "Semicolons as line terminators are not required in Groovy: remove them. Do not use a semicolon as a replacement for empty braces on for and while loops; this is a confusing practice." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarysemicolon-rule", "properties": { "priority": 3 } }, { "id": "UnnecessarySetter", "name": "UnnecessarySetterRule", "shortDescription": { "text": "Checks for explicit calls to setter methods which can, for the most part, be replaced by assignment to property. A setter is defined as a method call that matches set[A-Z] but not set[A-Z][A-Z] such as setURL(). Setters take one method argument." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarysetter-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryStringInstantiation", "name": "UnnecessaryStringInstantiationRule", "shortDescription": { "text": "Use a String literal (e.g., \"...\") instead of calling the corresponding String constructor (new String(\"..\")) directly." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarystringinstantiation-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryTernaryExpression", "name": "UnnecessaryTernaryExpressionRule", "shortDescription": { "text": "Checks for ternary expressions where the conditional expression always evaluates to a boolean and the true and false expressions are merely returning true and false constants. Also checks for ternary expressions where both expressions are the same constant or variable." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessaryternaryexpression-rule", "properties": { "priority": 3 } }, { "id": "UnnecessaryToString", "name": "UnnecessaryToStringRule", "shortDescription": { "text": "Checks for unnecessary calls to toString()." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarytostring-rule", "properties": { "priority": 2 } }, { "id": "UnnecessaryTransientModifier", "name": "UnnecessaryTransientModifierRule", "shortDescription": { "text": "The field is marked as transient, but the class isn't Serializable, so marking it as transient has no effect." }, "helpUri": "https://codenarc.org/codenarc-rules-unnecessary.html#unnecessarytransientmodifier-rule", "properties": { "priority": 3 } }, { "id": "UnusedImport", "name": "UnusedImportRule", "shortDescription": { "text": "Imports for a class that is never referenced within the source file is unnecessary." }, "helpUri": "https://codenarc.org/codenarc-rules-imports.html#unusedimport-rule", "properties": { "priority": 3 } }, { "id": "UseCollectMany", "name": "UseCollectManyRule", "shortDescription": { "text": "In many case collectMany() yields the same result as collect{}.flatten(). It is easier to understand and more clearly conveys the intent." }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#usecollectmany-rule", "properties": { "priority": 2 } }, { "id": "UseCollectNested", "name": "UseCollectNestedRule", "shortDescription": { "text": "Instead of nested collect{}-calls use collectNested{}" }, "helpUri": "https://codenarc.org/codenarc-rules-groovyism.html#usecollectnested-rule", "properties": { "priority": 2 } } ] } }, "results": [ { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractAstVisitorRuleTest.groovy" }, "region": { "startLine": 185, "snippet": { "text": "rule.doNotApplyToClassNames = 'Xxx' // doNotApply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractAstVisitorRuleTest.groovy" }, "region": { "startLine": 188, "snippet": { "text": "rule.applyToClassNames = 'Xxx' // apply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractAstVisitorRuleTest.groovy" }, "region": { "startLine": 189, "snippet": { "text": "rule.doNotApplyToClassNames = 'Xxx' // doNotApply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 137, "snippet": { "text": "rule.doNotApplyToFilesMatching = NO_MATCH // doNotApply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 140, "snippet": { "text": "rule.applyToFilesMatching = NO_MATCH // apply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 141, "snippet": { "text": "rule.doNotApplyToFilesMatching = NO_MATCH // doNotApply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 177, "snippet": { "text": "rule.applyToFileNames = 'org/codenarc/MyOtherTest.groovy'" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 225, "snippet": { "text": "rule.doNotApplyToFileNames = 'Xxx.groovy' // doNotApply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 228, "snippet": { "text": "rule.applyToFileNames = 'Xxx.groovy' // apply = NO" } } } } ] }, { "ruleId": "UnnecessaryObjectReferences", "level": "note", "message": { "text": "The code could be more concise by using a with() or identity() block" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "AbstractRuleTest.groovy" }, "region": { "startLine": 229, "snippet": { "text": "rule.doNotApplyToFileNames = 'Xxx.groovy' // doNotApply = NO" } } } } ] }, { "ruleId": "MisorderedStaticImports", "level": "note", "message": { "text": "Static imports should appear before normal imports" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "InlineViolationsParserTest.groovy" }, "region": { "startLine": 20, "snippet": { "text": "import static org.codenarc.rule.InlineViolationsParser.inlineViolation" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "InlineViolationsParserTest.groovy" }, "region": { "startLine": 199, "snippet": { "text": "return [lineNumber: lineNumber, sourceLineText: sourceLineText, messageText: messageText]" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/AbstractJavadocEmptyTagRuleTestCase.groovy" }, "region": { "startLine": 53, "snippet": { "text": "return rule.name" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/AbstractJavadocEmptyTagRuleTestCase.groovy" }, "region": { "startLine": 56, "snippet": { "text": "return \"The javadoc ${getTag()} tag is empty\"" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/AbstractJavadocMissingDescriptionRuleTestCase.groovy" }, "region": { "startLine": 51, "snippet": { "text": "return rule.name" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/AbstractJavadocMissingDescriptionRuleTestCase.groovy" }, "region": { "startLine": 54, "snippet": { "text": "return \"The description for the javadoc ${getTag()} tag is missing\"" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyAuthorTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@author'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyExceptionTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@exception'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyParamTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@param'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyReturnTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@return'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptySeeTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@see'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptySinceTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@since'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyThrowsTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@throws'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocEmptyVersionTagRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@version'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocMissingExceptionDescriptionRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@exception'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocMissingParamDescriptionRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@param'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "comments/JavadocMissingThrowsDescriptionRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "return '@throws'" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "convention/CompileStaticRuleTest.groovy" }, "region": { "startLine": 34, "snippet": { "text": "return new CompileStaticRule()" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "design/NestedForLoopRuleTest.groovy" }, "region": { "startLine": 106, "snippet": { "text": "return inlineViolation('Nested for loop')" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "design/OptionalCollectionReturnTypeRuleTest.groovy" }, "region": { "startLine": 128, "snippet": { "text": "return \"The method $methodName in class MyClass returns an Optional collection\"" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.design.PrivateFieldCouldBeFinalRuleTest has 34 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "design/PrivateFieldCouldBeFinalRuleTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "class PrivateFieldCouldBeFinalRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "enhanced/MissingOverrideAnnotationRuleTest.groovy" }, "region": { "startLine": 261, "snippet": { "text": "return \"Method '$methodName' is overriding a method in '$className' but is not annotated with @Override.\"" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n for(String name=${SomeClass.SOME_CONSTANT}; name==null;) // And what about {}\n {\n doStuff()\n }\n ' contains a GString-type expression: '${SomeClass.SOME_CONSTANT}; name==null;) // And what about {}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/BracesForForLoopRuleTest.groovy" }, "region": { "startLine": 101, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n if (someContainer.\"${SomeClass.SOME_CONSTANT}\" != null) // And what about {}\n {\n doStuff()\n }\n ' contains a GString-type expression: '${SomeClass.SOME_CONSTANT}\" != null) // And what about {}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/BracesForIfElseRuleTest.groovy" }, "region": { "startLine": 59, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.formatting.BracesForMethodRuleTest has 38 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/BracesForMethodRuleTest.groovy" }, "region": { "startLine": 28, "snippet": { "text": "class BracesForMethodRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n int size(String name = \"${SomeClass.SOME_CONSTANT}\")\n {\n return 99\n }\n }\n ' contains a GString-type expression: '${SomeClass.SOME_CONSTANT}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/BracesForMethodRuleTest.groovy" }, "region": { "startLine": 356, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/BracesForTryCatchFinallyRuleTest.groovy" }, "region": { "startLine": 181, "snippet": { "text": "return rule" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.formatting.ClassEndsWithBlankLineRuleTest has 33 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/ClassEndsWithBlankLineRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "class ClassEndsWithBlankLineRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.formatting.ClassStartsWithBlankLineRuleTest has 50 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/ClassStartsWithBlankLineRuleTest.groovy" }, "region": { "startLine": 28, "snippet": { "text": "class ClassStartsWithBlankLineRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "ClassSize", "level": "note", "message": { "text": "Class \"IndentationRuleTest\" is 1217 lines" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 26 } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.formatting.IndentationRuleTest has 60 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "class IndentationRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n |class MyClass {\n | private void execute() {\n | try {\n | executeWithArgs(args)\n | }\n | catch(Throwable t) {\n | println \"ERROR: ${t.message}\"\n | t.printStackTrace() // wrong column\n | }\n | finally {\n | closeResources()\n | }\n | }\n | private void executeOtherOne() {\n | try {\n | println 999 // wrong column \n | executeWithArgs(args)\n | } catch(Throwable t) {\n | t.printStackTrace()\n | } finally {\n | closeResources()\n | notifyUser() // wrong column\n | }\n | }\n |}\n ' contains a GString-type expression: '${t.message}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 609, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n |project.files(project.configurations.scaconfig.files.findAll { File it -> it.name.endsWith '.aar' }.collect { File it ->\n | MessageDigest sha1 = MessageDigest.getInstance('SHA1')\n | String inputFile = 'COMMAND=PREPARE_LIBRARY\\n' +\n | \"FILE_PATH=${it.absolutePath}\\n\"\n | String hash = new BigInteger(1, sha1.digest(inputFile.bytes)).toString(16)\n | cacheDir + hash + File.separator + 'output/jars/classes.jar'\n |}).asFileTree\n ' contains a GString-type expression: '${it.absolutePath}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 1018, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n |\"${if (true) 'content' else ''}\"\n ' contains a GString-type expression: '${if (true) 'content' else ''}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 1032, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n |package com.sample\n |\n |trait RegressionTest {\n |\n | String callStackPath = \"src/test/resources/callstacks/\"\n |\n | /**\n | * Checks the current callstack is the same as the reference callstack.\n | * The reference callstack can be updated into a txt file in the callStackPath\n | *\n | * Pattern: /<_subname>.txt\n | * @param subname optional subname, used in the reference callstack filename\n | */\n | void testNonRegression(String subname = '') {\n | String targetFileName = \"${callStackPath}${this.class.simpleName}\"\n | if (subname) {\n | targetFileName += \"_${subname}\"\n | }\n | RegressionTestHelper.testNonRegression(helper, targetFileName)\n | }\n |}\n ' contains a GString-type expression: '${callStackPath}${this.class.simpleName}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRuleTest.groovy" }, "region": { "startLine": 1040, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n |buildFileList()\n | .collect { File it ->\n | MessageDigest sha1 = MessageDigest.getInstance('SHA1')\n | String inputFile = 'COMMAND=PREPARE_LIBRARY\\n' +\n | \"FILE_PATH=${it.absolutePath}\\n\"\n | cacheDir + File.separator + inputFile + sha1\n | }\n | .each { name ->\n | println name\n | }\n |println \"done\"\n |\n |list2.collect { item ->\n | item.name\n |}.each { name -> println name }\n |\n |otherList.collect { item -> item.name }.each { name -> println name }\n |\n |if (expr instanceof ConstructorCallExpression || expr instanceof CastExpression) {\n | [Map, Iterable, List, Collection, ArrayList, Set, HashSet].findAll {\n | AstUtil.classNodeImplementsType(expr.type, it)\n | }.each {\n | callbackFunction()\n | }\n |}\n ' contains a GString-type expression: '${it.absolutePath}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/IndentationRule_MethodChainingTest.groovy" }, "region": { "startLine": 82, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private @Autowired DataSource dataSource\n private @Value('${name}') String name\n }\n ' contains a GString-type expression: '${name}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/MissingBlankLineBeforeAnnotatedFieldRuleTest.groovy" }, "region": { "startLine": 98, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = { }\n if (true) { }\n while(ready) { }\n try {\n } catch(Exception e) {\n } finally { }\n for(int i=0; i<10; i++) { }\n for(String name in names) { }\n for(String name: names) { }\n if (count > this.\"maxPriority${priority}Violations\") { }\n while (count > this.\"maxPriority${priority}Violations\") { }\n }\n MyClass() {\n this(classNames)\n } // ok\n static void reset() { violationCounts = [1:0, 2:0, 3:0] }\n void doStuff() { println 9 }\n }\n interface MyInterface { }\n enum MyEnum { OK, BAD }\n ' contains a GString-type expression: '${priority}Violations\") { }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterClosingBraceRuleTest.groovy" }, "region": { "startLine": 38, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def foo = 1\n \"I am a ${ -> foo }\"\n ' contains a GString-type expression: '${ -> foo }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterClosingBraceRuleTest.groovy" }, "region": { "startLine": 304, "snippet": { "text": "assertNoViolations('''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def foo = 1\n \"I am a ${ -> foo }0\"\n ' contains a GString-type expression: '${ -> foo }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterClosingBraceRuleTest.groovy" }, "region": { "startLine": 312, "snippet": { "text": "assertNoViolations('''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def template() {\n return {\n td(getResourceBundleString('htmlReport.summary.allPackages'), class:'allPackages')\n td {\n a(pathName, href:\"#${pathName}\")\n }\n }\n }\n }\n ' contains a GString-type expression: '${pathName}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterCommaRuleTest.groovy" }, "region": { "startLine": 53, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = { }\n if (true) { }\n while(ready) { }\n try {\n } catch(Exception e) {\n } finally { }\n for(int i=0; i<10; i++) { }\n for(String name in names) { }\n for(String name: names) { }\n if (count > this.\"maxPriority${priority}Violations\") { }\n while (count > this.\"maxPriority${priority}Violations\") { }\n }\n MyClass() {\n this(classNames)\n }\n MyClass(String s) { }\n MyClass(@Annotation('${prop}') String s) {\n }\n MyClass(Date date) { // comment\n this(classNames)\n }\n MyClass(Object object) { /* comment */ }\n }\n interface MyInterface { }\n enum MyEnum { OK, BAD }\n trait MyTrait { }\n ' contains a GString-type expression: '${priority}Violations\") { }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterOpeningBraceRuleTest.groovy" }, "region": { "startLine": 40, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = {}\n if (true) {}\n while(ready) {}\n try {\n } catch(Exception e) {\n } finally {}\n for(int i=0; i<10; i++) {}\n for(String name in names) {}\n for(String name: names) {}\n if (count > this.\"maxPriority${priority}Violations\") {}\n while (count > this.\"maxPriority${priority}Violations\") {}\n }\n void doStuff2() {}\n MyClass() {}\n MyClass(@Annotation('${prop}') String s) {}\n }\n interface MyInterface2 {}\n ' contains a GString-type expression: '${priority}Violations\") {}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterOpeningBraceRuleTest.groovy" }, "region": { "startLine": 102, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n MyClass() {int count }\n MyClass() {s = '{\"json\": true}' }\n MyClass(@Annotation('${prop}') String s) {println 123 }\n\n }\n ' contains a GString-type expression: '${prop}') String s) {println 123 }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterOpeningBraceRuleTest.groovy" }, "region": { "startLine": 196, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'MyClass(@Annotation('${prop}') String s) {println 123 }' contains a GString-type expression: '${prop}') String s) {println 123 }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterOpeningBraceRuleTest.groovy" }, "region": { "startLine": 207, "snippet": { "text": "[line:5, source:'MyClass(@Annotation(\\'${prop}\\') String s) {println 123 }', message:'The opening brace for the method in class MyClass'])" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n String s\n MyClass() { s = '{\"json\": true}' }\n MyClass(@Annotation('${prop}') String s) { println 123 }\n }\n ' contains a GString-type expression: '${prop}') String s) { println 123 }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAfterOpeningBraceRuleTest.groovy" }, "region": { "startLine": 325, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceAroundMapEntryColonRuleTest.groovy" }, "region": { "startLine": 167, "snippet": { "text": "return inlineViolation(\"The colon for the literal Map entry for key [$keyName] within class $className\" +" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = { }\n if (true) { }\n while(ready) { }\n try {\n } catch(Exception e) {\n } finally { }\n for(int i=0; i<10; i++) { }\n for(String name in names) { }\n for(String name: names) { }\n if (count > this.\"maxPriority${priority}Violations\") { }\n while (count > this.\"maxPriority${priority}Violations\") { }\n }\n MyClass() {\n this(classNames)\n }\n static void reset() { violationCounts = [1:0, 2:0, 3:0] }\n void doStuff() { println 9 }\n }\n interface MyInterface { }\n enum MyEnum { OK, BAD }\n ' contains a GString-type expression: '${priority}Violations\") { }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceBeforeClosingBraceRuleTest.groovy" }, "region": { "startLine": 39, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = {}\n if (true) {}\n while(ready) {}\n try {\n } catch(Exception e) {\n } finally {}\n for(int i=0; i<10; i++) {}\n for(String name in names) {}\n for(String name: names) {}\n if (count > this.\"maxPriority${priority}Violations\") {}\n while (count > this.\"maxPriority${priority}Violations\") {}\n }\n void doStuff2() {}\n }\n interface MyInterface2 {}\n ' contains a GString-type expression: '${priority}Violations\") {}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceBeforeClosingBraceRuleTest.groovy" }, "region": { "startLine": 80, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def myMethod() {\n def closure = { }\n if (true) { }\n while(ready) { }\n try {\n } catch(Exception e) {\n } finally { }\n for(int i=0; i<10; i++) { }\n for(String name in names) { }\n for(String name: names) { }\n if (count > this.\"maxPriority${priority}Violations\") { }\n while (count > this.\"maxPriority${priority}Violations\") { }\n }\n MyClass() {\n this(classNames)\n }\n }\n interface MyInterface { }\n enum MyEnum { OK, BAD }\n trait MyTrait { }\n ' contains a GString-type expression: '${priority}Violations\") { }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceBeforeOpeningBraceRuleTest.groovy" }, "region": { "startLine": 38, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def foo = 1\n \"I am a ${ -> foo }\"\n ' contains a GString-type expression: '${ -> foo }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "formatting/SpaceBeforeOpeningBraceRuleTest.groovy" }, "region": { "startLine": 277, "snippet": { "text": "assertNoViolations('''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n if (value.class == org.bad.BadClass) { }\n println \"isClosure=${value instanceof org.bad.OtherClass}\"\n def count = org.bad.Helper.getCount()\n ' contains a GString-type expression: '${value instanceof org.bad.OtherClass}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "generic/IllegalPackageReferenceRuleTest.groovy" }, "region": { "startLine": 64, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'println \"isClosure=${value instanceof org.bad.OtherClass}\"' contains a GString-type expression: '${value instanceof org.bad.OtherClass}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "generic/IllegalPackageReferenceRuleTest.groovy" }, "region": { "startLine": 72, "snippet": { "text": "[line:3, source:'println \"isClosure=${value instanceof org.bad.OtherClass}\"', message:'org.bad']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n @Value('${org.codenarc.test}')\n BigDecimal depositAmount\n }\n ' contains a GString-type expression: '${org.codenarc.test}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "generic/StatelessClassRuleTest.groovy" }, "region": { "startLine": 84, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class Person {\n String name\n Boolean isAdmin\n }\n def bindingMap = [name: 'John', isAdmin: true]\n def person = new Person()\n def p2 = new Person(\"It is currently ${ new Date() }\")\n def p3 = new Person(bindingMap)\n person.name = bindingMap['name']\n person.isAdmin = bindingMap.isAdmin\n person.properties = \"It is currently ${ new Date() }\"\n ' contains a GString-type expression: '${ new Date() }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "grails/GrailsMassAssignmentRuleTest.groovy" }, "region": { "startLine": 36, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def mySession = servletContext\n\n def edit = {\n println \"amount=${servletContext.amount}\"\n }\n }\n ' contains a GString-type expression: '${servletContext.amount}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "grails/GrailsServletContextReferenceRuleTest.groovy" }, "region": { "startLine": 78, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'println \"amount=${servletContext.amount}\"' contains a GString-type expression: '${servletContext.amount}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "grails/GrailsServletContextReferenceRuleTest.groovy" }, "region": { "startLine": 87, "snippet": { "text": "assertTwoViolations(SOURCE, 3, 'def mySession = servletContext', 6, 'println \"amount=${servletContext.amount}\"')" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n new Exception(\"${it.orElseThrow { new AssertionError() }}\")\n ' contains a GString-type expression: '${it.orElseThrow { new AssertionError() }}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/ClosureAsLastMethodParameterRuleTest.groovy" }, "region": { "startLine": 242, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n Map map = [\"${ someRef }\" : 'invalid' ]\n ' contains a GString-type expression: '${ someRef }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringAsMapKeyRuleTest.groovy" }, "region": { "startLine": 44, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '[\"${ someRef }\" :' contains a GString-type expression: '${ someRef }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringAsMapKeyRuleTest.groovy" }, "region": { "startLine": 48, "snippet": { "text": "2, '[\"${ someRef }\" :')" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class SomeClass {\n @SomeAnnotationOnField('${sample.property1}')\n String sampleProperty\n\n @SomeAnnotationOnMethod('${sample.property2}')\n void method() {\n }\n }\n ' contains a GString-type expression: '${sample.property1}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 49, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n @SomeAnnotationOnClass('${sample.property1}')\n class SomeClass {\n @SomeAnnotationOnField('${sample.property2}')\n String sampleProperty\n\n @SomeAnnotationOnMethod('${sample.property3}')\n void method() {\n }\n }\n ' contains a GString-type expression: '${sample.property1}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 64, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n @SomeAnnotationOnClass(attribute='${sample.property1}',\n nested=[@NestedAnnotation('${sample.property2}'),\n @NestedAnnotation('${sample.property3}')],\n someOtherAttribute='${sample.property4}')\n class SomeClass {\n }\n ' contains a GString-type expression: '${sample.property1}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 80, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n @SomeAnnotationOnClass(attribute=['${sample.property1}', '${sample.property2}'])\n class SomeClass {\n }\n ' contains a GString-type expression: '${sample.property1}', '${sample.property2}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 93, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def valueToBeReplaced = '123'\n def str1 = \"123\"\n def str2 = \"abc def ghi\"\n def str3 = \"abc ${count}\"\n def str4 = \"abc $count }\"\n def str5 = \"abc {123}\"\n def str6 = \"abc ${}\"\n def str7 = \"total: ${count * 25}\"\n def str8 = \"$valueToBeReplaced $valueNotToBeReplaced\"\n ' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 103, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def \"plugin does not apply idea plugin\"() {\n given:\n buildScript << \"\"\"\n task $testTaskName {\n doLast {\n println \"Has idea plugin: \\${project.plugins.hasPlugin(IdeaPlugin)}\"\n }\n }\n \"\"\"\n\n expect:\n runTask(testTaskName).output.contains('Has idea plugin: false')\n\n where:\n testTaskName = 'hasIdeaPlugin'\n }\n ' contains a GString-type expression: '${project.plugins.hasPlugin(IdeaPlugin)}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 119, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def str1 = 'total: ${count}'\n def str2 = 'average: ${total / count}'\n ' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 142, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def str1 = 'total: ${count}'' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 147, "snippet": { "text": "[line:2, source:\"def str1 = 'total: \\${count}'\", message:'\\'${count}\\'']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String ''${count}'' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 147, "snippet": { "text": "[line:2, source:\"def str1 = 'total: \\${count}'\", message:'\\'${count}\\'']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def str2 = 'average: ${total / count}'' contains a GString-type expression: '${total / count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 148, "snippet": { "text": "[line:3, source:\"def str2 = 'average: \\${total / count}'\", message:'\\'${total / count}\\''])" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String ''${total / count}'' contains a GString-type expression: '${total / count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 148, "snippet": { "text": "[line:3, source:\"def str2 = 'average: \\${total / count}'\", message:'\\'${total / count}\\''])" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class SomeClass {\n @SomeAnnotationOnMethod('${sample.property}')\n void method() {\n def str1 = 'total: ${count}'\n }\n }\n ' contains a GString-type expression: '${sample.property}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 153, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def str1 = 'total: ${count}'' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 161, "snippet": { "text": "assertSingleViolation(SOURCE, 5, \"def str1 = 'total: \\${count}'\", '\\'${count}\\'')" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String ''${count}'' contains a GString-type expression: '${count}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 161, "snippet": { "text": "assertSingleViolation(SOURCE, 5, \"def str1 = 'total: \\${count}'\", '\\'${count}\\'')" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class SomeClass {\n @SomeAnnotationOnField(someClass = SomeOtherClass, message = 'Some message ${sample.property1}')\n String sampleProperty\n }\n ' contains a GString-type expression: '${sample.property1}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "groovyism/GStringExpressionWithinStringRuleTest.groovy" }, "region": { "startLine": 166, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n import test.TestData1\n import test.TestData2\n import test.TestData3\n import test.TestData4\n import test.TestData5\n import test.TestData6\n import test.TestData7\n import test.TestData8\n import test.TestData9\n import test.TestData10\n import test.TestData11\n import test.TestData12\n import test.TestData13\n import test.TestData14\n import test.TestData15\n\n def GSTRING1 = \" ${TestData1.GOOD_XML}\"\n def GSTRING2 = \" $TestData2.XML\"\n def MAP1 = [(TestData3):123]\n def MAP2 = [abc:TestData4]\n def MAP3 = [abc:TestData5, ddd:123]\n def LIST = [TestData6,TestData7]\n def OPERATORS1 = 0+TestData8.VALUE-TestData9.VALUE\n def OPERATORS2 = 9*TestData10.VALUE/TestData11.VALUE\n def OPERATORS3 = 64&TestData12.VALUE|TestData13.VALUE^TestData14.VALUE\n def OPERATORS4 = !TestData15.VALUE\n ' contains a GString-type expression: '${TestData1.GOOD_XML}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "imports/UnusedImportRuleTest.groovy" }, "region": { "startLine": 215, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n import static Constants.CONSTANT1\n import static Constants.CONSTANT2\n import static Constants.CONSTANT3\n import static Constants.CONSTANT4\n import static Constants.CONSTANT5\n import static Constants.CONSTANT6\n \n void doSomething() {\n def stringA = \"$CONSTANT1$CONSTANT2\"\n def stringB = \"$CONSTANT3${CONSTANT4}\"\n def stringC = \"${CONSTANT5}$CONSTANT6\"\n } \n ' contains a GString-type expression: '${CONSTANT4}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "imports/UnusedImportRuleTest.groovy" }, "region": { "startLine": 264, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def x = 42\n def s = \"some string ${x}\"\n ' contains a GString-type expression: '${x}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/ClosureInGStringRuleTest.groovy" }, "region": { "startLine": 35, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n List l = [1,2,3]\n def s = \"some string ${l.collect { i -> i * i }.toString()}\"\n ' contains a GString-type expression: '${l.collect { i -> i * i }.toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/ClosureInGStringRuleTest.groovy" }, "region": { "startLine": 52, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def x = 42\n def s = \"some string ${-> x}\"\n def s = \"some string ${x} ${-> x}\"\n ' contains a GString-type expression: '${-> x}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/ClosureInGStringRuleTest.groovy" }, "region": { "startLine": 61, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def s = \"some string ${-> x}\"' contains a GString-type expression: '${-> x}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/ClosureInGStringRuleTest.groovy" }, "region": { "startLine": 67, "snippet": { "text": "[line: 3, source: 'def s = \"some string ${-> x}\"', message: 'GString contains a closure. Use variable interpolation instead']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def s = \"some string ${x} ${-> x}\"' contains a GString-type expression: '${x} ${-> x}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/ClosureInGStringRuleTest.groovy" }, "region": { "startLine": 68, "snippet": { "text": "[line: 4, source: 'def s = \"some string ${x} ${-> x}\"', message: 'GString contains a closure. Use variable interpolation instead'])" } } } } ] }, { "ruleId": "NoWildcardImports", "level": "note", "message": { "text": "Wildcard (star) import" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/JenkinsUtilTest.groovy" }, "region": { "startLine": 18, "snippet": { "text": "import org.codehaus.groovy.ast.*" } } } } ] }, { "ruleId": "MisorderedStaticImports", "level": "note", "message": { "text": "Static imports should appear before normal imports" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/JenkinsUtilTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "import static org.junit.jupiter.api.Assertions.*" } } } } ] }, { "ruleId": "NoWildcardImports", "level": "note", "message": { "text": "Wildcard (star) import" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "jenkins/JenkinsUtilTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "import static org.junit.jupiter.api.Assertions.*" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.naming.FieldNameRuleTest has 32 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "naming/FieldNameRuleTest.groovy" }, "region": { "startLine": 28, "snippet": { "text": "class FieldNameRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "MisorderedStaticImports", "level": "note", "message": { "text": "Static imports should appear before normal imports" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "size/GMetricsSourceCodeAdapterTest.groovy" }, "region": { "startLine": 22, "snippet": { "text": "import static org.codenarc.test.TestUtil.shouldFailWithMessageContaining" } } } } ] }, { "ruleId": "UnnecessaryReturnKeyword", "level": "note", "message": { "text": "The return keyword is not needed and can be removed" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "size/ParameterCountRuleTest.groovy" }, "region": { "startLine": 252, "snippet": { "text": "return inlineViolation(\"Number of parameters in ${name} exceeds maximum allowed (${rule.maxParameters}).\")" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def b = \"$Hello\" + 'World' // should be \"${Hello}World\"\n ' contains a GString-type expression: '${Hello}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/ConsecutiveStringConcatenationRuleTest.groovy" }, "region": { "startLine": 65, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def c = 'Hello' + \"$World\" // should be \"Hello${World}\"\n ' contains a GString-type expression: '${World}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/ConsecutiveStringConcatenationRuleTest.groovy" }, "region": { "startLine": 73, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def docFile = \"docs/codenarc-rules-${ruleSetName}.apt\"\n ' contains a GString-type expression: '${ruleSetName}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryGStringRuleTest.groovy" }, "region": { "startLine": 36, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n Mock {\n getSomeData()\n }\n Stub(1,2,3) {\n getData2()\n }\n \"${'Stub'}\"(MyClass) {\n getData3()\n }\n def closure = { getData4() }\n Mock({ getData5() }, 1234) // 2nd param is not a Closure\n Spy {\n getMoreData()\n }\n ' contains a GString-type expression: '${'Stub'}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryGetterRuleTest.groovy" }, "region": { "startLine": 180, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n if (value.class == java.math.BigDecimal) { }\n println \"isClosure=${value instanceof groovy.lang.Closure}\"\n def processors = java.lang.Runtime.availableProcessors()\n ' contains a GString-type expression: '${value instanceof groovy.lang.Closure}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryPackageReferenceRuleTest.groovy" }, "region": { "startLine": 66, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'println \"isClosure=${value instanceof groovy.lang.Closure}\"' contains a GString-type expression: '${value instanceof groovy.lang.Closure}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryPackageReferenceRuleTest.groovy" }, "region": { "startLine": 73, "snippet": { "text": "[line:3, source:'println \"isClosure=${value instanceof groovy.lang.Closure}\"', message:'groovy.lang']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n if (!file.setExecutable(true)) {\n throw new Exception(\"Cannot set ${file} as executable\")\n }\n def count = x.setCount(92)\n ' contains a GString-type expression: '${file}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessarySetterRuleTest.groovy" }, "region": { "startLine": 97, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n def name = \"Joe\" + new Date().toString()\n\n void run() {\n Object object = 1\n def string = 'some string' + object.toString()\n def withinGString = \"processing: ${'prefix' + object.toString()}\"\n\n def bigString = 'some string' + new Date() + object.toString() // not a violation; known limitation\n def other = 123 + object.toString().toInteger() // not a violation\n }\n }\n ' contains a GString-type expression: '${'prefix' + object.toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 67, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def withinGString = \"processing: ${'prefix' + object.toString()}\"' contains a GString-type expression: '${'prefix' + object.toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 84, "snippet": { "text": "[line:8, source:'def withinGString = \"processing: ${\\'prefix\\' + object.toString()}\"', message:'Calling toString() on [object] in class MyClass is unnecessary'])" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n def string = \"some string${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}\"\n def string2 = \"\"\"\n processing: ${123L.toString()}\n processing: ${new Date().toString()}\n \"\"\"\n ' contains a GString-type expression: '${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 89, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def string = \"some string${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}\"' contains a GString-type expression: '${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 97, "snippet": { "text": "[line:2, source:'def string = \"some string${123L.toString()} or ${123} or ${\\'ABC\\'} or ${new Date().toString()}\"', message:'Calling toString() on [123] in class None is unnecessary']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'def string = \"some string${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}\"' contains a GString-type expression: '${123L.toString()} or ${123} or ${'ABC'} or ${new Date().toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 98, "snippet": { "text": "[line:2, source:'def string = \"some string${123L.toString()} or ${123} or ${\\'ABC\\'} or ${new Date().toString()}\"', message:'Calling toString() on [new Date()] in class None is unnecessary']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'processing: ${123L.toString()}' contains a GString-type expression: '${123L.toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 99, "snippet": { "text": "[line:4, source:'processing: ${123L.toString()}', message:'Calling toString() on [123] in class None is unnecessary']," } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String 'processing: ${new Date().toString()}' contains a GString-type expression: '${new Date().toString()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unnecessary/UnnecessaryToStringRuleTest.groovy" }, "region": { "startLine": 100, "snippet": { "text": "[line:5, source:'processing: ${new Date().toString()}', message:'Calling toString() on [new Date()] in class None is unnecessary']" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.unused.AbstractUnusedPrivateFieldRuleTest has 32 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/AbstractUnusedPrivateFieldRuleTest.groovy" }, "region": { "startLine": 27, "snippet": { "text": "abstract class AbstractUnusedPrivateFieldRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private int count\n def other = this.\"${'count'}\"\n }\n ' contains a GString-type expression: '${'count'}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/AbstractUnusedPrivateFieldRuleTest.groovy" }, "region": { "startLine": 172, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private int count\n def varName = \"count\"\n def other = this.\"${varName}\" // can't see this\n }\n ' contains a GString-type expression: '${varName}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/AbstractUnusedPrivateFieldRuleTest.groovy" }, "region": { "startLine": 183, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n MyClass() { }\n MyClass(String id) { println id }\n\n String myMethod1(String id, int value) { doSomething(value); return id }\n void myMethod2(int value) { def x = value }\n def myMethod3(Date startDate) { return \"${startDate}\" }\n def myMethod4(Date startDate) {\n return new Object() {\n def x = startDate\n }\n }\n def myMethod5(Date startDate) {\n return new Object() {\n String toString() { return startDate }\n }\n }\n }\n ' contains a GString-type expression: '${startDate}\" }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedMethodParameterRuleTest.groovy" }, "region": { "startLine": 150, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private String myMethod1(String id, int value) { doSomething(value); return id }\n private void myMethod2(int value) { def x = value }\n private def myMethod3(Date startDate) { return \"${startDate}\" }\n private def myMethod4(Date startDate) {\n return new Object() {\n def x = startDate\n }\n }\n private def myMethod5(Date startDate) {\n return new Object() {\n String toString() { return startDate }\n }\n }\n }\n ' contains a GString-type expression: '${startDate}\" }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodParameterRuleTest.groovy" }, "region": { "startLine": 126, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.unused.UnusedPrivateMethodRuleTest has 37 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodRuleTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "class UnusedPrivateMethodRuleTest extends AbstractRuleTestCase {" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private int countStuff() { return 99 }\n int somePublicMethod() { }\n def abc = 'abc'\n private String getName() { 'abc' }\n private getPrice() { 0.0 }\n\n def doStuff() {\n def count = countStuff()\n def newName = this.getName()\n }\n\n def myClosure = { println \"price is ${getPrice()}\" }\n }\n ' contains a GString-type expression: '${getPrice()}\" }'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodRuleTest.groovy" }, "region": { "startLine": 354, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n static int getTotal() {\n println \"total=${MyClass.countStuff()}\"\n }\n private static int countStuff() { }\n }\n ' contains a GString-type expression: '${MyClass.countStuff()}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodRuleTest.groovy" }, "region": { "startLine": 423, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private int countStuff() { }\n def other = this.\"${countStuff}\"()\n }\n ' contains a GString-type expression: '${countStuff}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodRuleTest.groovy" }, "region": { "startLine": 436, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "GStringExpressionWithinString", "level": "warning", "message": { "text": "The String '\n class MyClass {\n private int countStuff() { }\n def varName = \"countStuff\"\n def other = this.\"${varName}\"() // can't see this\n }\n ' contains a GString-type expression: '${varName}'" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedPrivateMethodRuleTest.groovy" }, "region": { "startLine": 458, "snippet": { "text": "final SOURCE = '''" } } } } ] }, { "ruleId": "MethodCount", "level": "warning", "message": { "text": "Class org.codenarc.rule.unused.UnusedVariableRuleTest has 35 methods" }, "locations": [ { "physicalLocation": { "artifactLocation": { "uri": "unused/UnusedVariableRuleTest.groovy" }, "region": { "startLine": 26, "snippet": { "text": "class UnusedVariableRuleTest extends AbstractRuleTestCase {" } } } } ] } ] } ] }