Remove redundant analyzer comments for hamming and two-fer (#122

)

* Gradlew.bat update

* Removing redundant analyzer comments for hamming exercise

* Removing redundant analyzer comments for two fer exercise

* Removing tests that there aren't used anymore

* Applying suggestions
Restoring MustUseStringCharAtOrCodePointAt analyzer functionality
Deleting unused usesConditional variable
Removing tests/hamming/.meta/src/reference/java/Hamming.java and tests/hamming/.meta/tests.toml

* Removing validateNotNull outdated check

src/main/java/analyzer/exercises/hamming/HammingAnalyzer.java

@@ -22,27 +22,6 @@ public void analyze(Solution solution, Analysis analysis) {
 
         solution.getCompilationUnits().forEach(cu -> cu.walk(ClassOrInterfaceDeclaration.class, walker));
 
-        if (!walker.hasConstructor()) {
-            analysis.addComment(new MustUseConstructor());
-            return;
-        }
-
-        if (!walker.constructorHasIfStatements() && !walker.constructorHasMethodCalls()) {
-            analysis.addComment(new MustUseConditionalLogicInConstructor());
-            return;
-        }
-
-        if (!walker.constructorThrowsIllegalArgument()) {
-            analysis.addComment(new MustThrowInConstructor());
-            return;
-        }
-
-        if (!walker.getHammingDistanceMethodMayCalculateDistance()
-                && !walker.constructorMayCalculateDistance()) {
-            analysis.addComment(new MustCalculateHammingDistance());
-            return;
-        }
-
         if (walker.usesCharacterLiterals()) {
             analysis.addComment(new AvoidCharacterLiterals());
             return;

src/main/java/analyzer/exercises/hamming/HammingWalker.java

@@ -21,8 +21,6 @@ class HammingWalker implements Consumer<ClassOrInterfaceDeclaration> {
     private ConstructorDeclaration constructor;
     private final Map<String, List<MethodDeclaration>> methods = new HashMap<>();
     private final Set<String> methodsCalledByConstructor = new HashSet<>();
-    private boolean constructorHasIfStatements;
-    private boolean constructorThrowsIllegalArgumentDirectly;
     private boolean constructorMayCalculateDistanceDirectly;
     private final Set<String> methodsCalledByGetHammingDistance = new HashSet<>();
     private boolean getHammingDistanceMayCalculateDistanceDirectly;
@@ -62,13 +60,6 @@ private void walkConstructor(ConstructorDeclaration foundConstructor) {
     }
 
     private void walkConstructorStatement(Statement statement) {
-        if (statement.isIfStmt()) {
-            constructorHasIfStatements = true;
-        }
-
-        if (isThrowNewIllegalArgument(statement)) {
-            constructorThrowsIllegalArgumentDirectly = true;
-        }
 
         if (statementMayCalculateHammingDistance(statement)) {
             constructorMayCalculateDistanceDirectly = true;
@@ -79,21 +70,6 @@ private void walkConstructorStatement(Statement statement) {
                         recursivelyAddMethodsCalled(methodName, methodsCalledByConstructor));
     }
 
-    private boolean isThrowNewIllegalArgument(Statement statement) {
-        return statement.findAll(ThrowStmt.class).stream()
-                .anyMatch(this::isCreatingIllegalArgumentException);
-    }
-
-    private boolean isCreatingIllegalArgumentException(ThrowStmt throwStmt) {
-        return throwStmt.getExpression().isObjectCreationExpr()
-                && throwStmt
-                .getExpression()
-                .asObjectCreationExpr()
-                .getType()
-                .getNameAsString()
-                .equals("IllegalArgumentException");
-    }
-
     private boolean isMethodCall(Statement statement) {
         return !statement.findAll(MethodCallExpr.class).isEmpty();
     }
@@ -160,44 +136,10 @@ private Stream<String> getMethodsCalledBy(BlockStmt body) {
                 .flatMap(this::getMethodCallNames);
     }
 
-    public boolean hasConstructor() {
-        return constructor != null;
-    }
-
-    public boolean constructorHasIfStatements() {
-        return constructorHasIfStatements;
-    }
-
     public boolean constructorHasMethodCalls() {
         return !methodsCalledByConstructor.isEmpty();
     }
 
-    public boolean constructorThrowsIllegalArgument() {
-        return constructorThrowsIllegalArgumentDirectly
-                || constructorThrowsIllegarArgumentIndirectly();
-    }
-
-    private boolean constructorThrowsIllegarArgumentIndirectly() {
-        return methodsCalledByConstructor.stream()
-                .anyMatch(this::methodThrowsIllegalArgumentException);
-    }
-
-    private boolean methodThrowsIllegalArgumentException(String methodName) {
-        return methods.getOrDefault(methodName, List.of()).stream()
-                .anyMatch(this::methodThrowsIllegalArgumentException);
-    }
-
-    private boolean methodThrowsIllegalArgumentException(MethodDeclaration method) {
-        return method.getBody()
-                .map(this::methodBodyThrowsIllegalArgumentException)
-                .orElse(false);
-    }
-
-    private boolean methodBodyThrowsIllegalArgumentException(BlockStmt body) {
-        return body.getStatements().stream()
-                .anyMatch(this::isThrowNewIllegalArgument);
-    }
-
     public boolean constructorMayCalculateDistance() {
         return constructorMayCalculateDistanceDirectly
                 || constructorCallsMethodThatMayCalculateDistance();

src/main/java/analyzer/exercises/twofer/TwoferAnalyzer.java

@@ -20,12 +20,6 @@ public void analyze(Solution solution, Analysis analysis) {
 
         if (walker.hasHardCodedTestCases) {
             analysis.addComment(new AvoidHardCodedTestCases());
-        } else if (walker.usesLambda) {
-            // could be used later for additional comments?
-        } else if (walker.usesLoops) {
-            // could be used later for additional comments?
-        } else if (!walker.hasMethodCall && !(walker.usesIfStatement || walker.usesConditional)) {
-            analysis.addComment(new UseConditionalLogic());
         } else if (walker.usesFormat) {
             analysis.addComment(new AvoidStringFormat());
         } else if (walker.returnCount > 1) {

src/main/java/analyzer/exercises/twofer/TwoferWalker.java

@@ -1,8 +1,6 @@
 package analyzer.exercises.twofer;
 
 import com.github.javaparser.ast.Node;
-import com.github.javaparser.ast.expr.ConditionalExpr;
-import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
 import com.github.javaparser.ast.expr.StringLiteralExpr;
 import com.github.javaparser.ast.stmt.*;
@@ -12,10 +10,7 @@
 class TwoferWalker implements Consumer<Node> {
     boolean hasHardCodedTestCases;
     boolean usesIfStatement;
-    boolean usesConditional;
     boolean hasMethodCall;
-    boolean usesLambda;
-    boolean usesLoops;
     boolean usesFormat;
     int returnCount;
 
@@ -27,18 +22,12 @@ public void accept(Node node) {
             this.returnCount++;
         } else if (node instanceof IfStmt) {
             this.usesIfStatement = true;
-        } else if (node instanceof ConditionalExpr) {
-            this.usesConditional = true;
         } else if (node instanceof MethodCallExpr && !this.hasMethodCall) {
             this.hasMethodCall = true;
 
             if (((MethodCallExpr) node).getName().toString().equals("format")) {
                 this.usesFormat = true;
             }
-        } else if (node instanceof LambdaExpr) {
-            this.usesLambda = true;
-        } else if (node instanceof WhileStmt || node instanceof ForStmt || node instanceof ForEachStmt) {
-            this.usesLoops = true;
         }
     }
 }

src/test/java/analyzer/exercises/hamming/HammingAnalyzerTest.java

@@ -17,10 +17,6 @@ public class HammingAnalyzerTest {
 
     private static Stream<Arguments> testCases() {
         return Stream.of(
-                Arguments.of("NoConstructor.java.txt", new Comment[]{new MustUseConstructor()}),
-                Arguments.of("NoConditionalInConstructor.java.txt", new Comment[]{new MustUseConditionalLogicInConstructor()}),
-                Arguments.of("DoesNotThrowInConstructor.java.txt", new Comment[]{new MustThrowInConstructor()}),
-                Arguments.of("NoCalculationOfHammingDistance.java.txt", new Comment[]{new MustCalculateHammingDistance()}),
                 Arguments.of("UsesCharacterLiterals.java.txt", new Comment[]{new AvoidCharacterLiterals()}),
                 Arguments.of("MustUseCharAtOrCodePointAt.java.txt", new Comment[]{new MustUseStringCharAtOrCodePointAt()}),
                 Arguments.of("NestedValidation.java.txt", new Comment[]{new CalculateDistanceInConstructor()}),

src/test/java/analyzer/exercises/twofer/TwoferAnalyzerTest.java

@@ -16,10 +16,7 @@ public class TwoferAnalyzerTest {
 
     private static Stream<Arguments> testCases() {
         return Stream.of(
-                Arguments.of("UsesLambda.java.txt", new Comment[0]),
-                Arguments.of("UsesLoop.java.txt", new Comment[0]),
                 Arguments.of("HardCodedTestCases.java.txt", new Comment[]{new AvoidHardCodedTestCases()}),
-                Arguments.of("NoConditionalLogic.java.txt", new Comment[]{new UseConditionalLogic()}),
                 Arguments.of("UsesStringFormat.java.txt", new Comment[]{new AvoidStringFormat()}),
                 Arguments.of("UsesMultipleReturns.java.txt", new Comment[]{new UseOneReturn()}),
                 Arguments.of("OptimalNoTernary.java.txt", new Comment[]{new UseTernaryOperator()}),