Add Java analyzer for Annalyns Infiltration

src/main/java/analyzer/AnalyzerRoot.java

@@ -2,6 +2,7 @@
 
 import analyzer.comments.FeedbackRequest;
 import analyzer.exercises.GlobalAnalyzer;
+import analyzer.exercises.annalynsinfiltration.AnnalynsInfiltrationAnalyzer;
 import analyzer.exercises.hamming.HammingAnalyzer;
 import analyzer.exercises.lasagna.LasagnaAnalyzer;
 import analyzer.exercises.leap.LeapAnalyzer;
@@ -45,6 +46,7 @@ private static List<Analyzer> createAnalyzers(String slug) {
         analyzers.add(new GlobalAnalyzer());
 
         switch (slug) {
+            case "annalyns-infiltration" -> analyzers.add(new AnnalynsInfiltrationAnalyzer());
             case "hamming" -> analyzers.add(new HammingAnalyzer());
             case "lasagna" -> analyzers.add(new LasagnaAnalyzer());
             case "leap" -> analyzers.add(new LeapAnalyzer());

src/main/java/analyzer/exercises/annalynsinfiltration/AnnalynsInfiltrationAnalyzer.java

@@ -0,0 +1,67 @@
+package analyzer.exercises.annalynsinfiltration;
+
+import analyzer.Analyzer;
+import analyzer.OutputCollector;
+import analyzer.Solution;
+import analyzer.comments.ExemplarSolution;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.expr.BinaryExpr;
+import com.github.javaparser.ast.expr.BooleanLiteralExpr;
+import com.github.javaparser.ast.expr.EnclosedExpr;
+import com.github.javaparser.ast.stmt.IfStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
+
+/**
+ * The {@link AnnalynsInfiltrationAnalyzer} is the analyzer implementation for the {@code annalyns-infiltration} practice exercise.
+ * It extends from the {@link VoidVisitorAdapter} and uses the visitor pattern to traverse each compilation unit.
+ *
+ * @see <a href="https://github.com/exercism/java/tree/main/exercises/practice/annalyns-infiltration">The Annalyns Infiltration exercise on the Java track</a>
+ */
+public class AnnalynsInfiltrationAnalyzer extends VoidVisitorAdapter<OutputCollector> implements Analyzer {
+    private static final String EXERCISE_NAME = "Annalyn's Infiltration";
+
+    @Override
+    public void analyze(Solution solution, OutputCollector output) {
+        for (CompilationUnit compilationUnit : solution.getCompilationUnits()) {
+            compilationUnit.accept(this, output);
+        }
+
+        if (output.getComments().isEmpty()) {
+            output.addComment(new ExemplarSolution(EXERCISE_NAME));
+        }
+    }
+
+    @Override
+    public void visit(IfStmt node, OutputCollector output) {
+        output.addComment(new AvoidIfStatements());
+        super.visit(node, output);
+    }
+
+    @Override
+    public void visit(ReturnStmt node, OutputCollector output) {
+        if (node.getExpression().isPresent() && node.getExpression().get() instanceof BooleanLiteralExpr) {
+            output.addComment(new AvoidBooleanLiteralReturns());
+        }
+        super.visit(node, output);
+    }
+
+    @Override
+    public void visit(BinaryExpr node, OutputCollector output) {
+        if (node.getOperator().equals(BinaryExpr.Operator.OR)) {
+            for (Node childNode : node.getChildNodes()) {
+                if (childNode instanceof EnclosedExpr
+                        && ((EnclosedExpr) childNode).getInner() instanceof BinaryExpr
+                        && ((BinaryExpr) ((EnclosedExpr) childNode).getInner()).getOperator().equals(BinaryExpr.Operator.AND)) {
+                    output.addComment(new RedundantParentheses());
+                }
+            }
+        }
+        if (node.getOperator().equals(BinaryExpr.Operator.EQUALS)
+                && (node.getLeft() instanceof BooleanLiteralExpr || node.getRight() instanceof BooleanLiteralExpr)) {
+            output.addComment(new AvoidComparisonWithLiteral());
+        }
+        super.visit(node, output);
+    }
+}

src/main/java/analyzer/exercises/annalynsinfiltration/AvoidBooleanLiteralReturns.java

@@ -0,0 +1,18 @@
+package analyzer.exercises.annalynsinfiltration;
+
+import analyzer.Comment;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/annalyns-infiltration/avoid_boolean_literal_returns.md">Markdown Template</a>
+ */
+public class AvoidBooleanLiteralReturns extends Comment {
+    @Override
+    public String getKey() {
+        return "java.annalyns-infiltration.avoid_boolean_literal_returns";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.ESSENTIAL;
+    }
+}

src/main/java/analyzer/exercises/annalynsinfiltration/AvoidComparisonWithLiteral.java

@@ -0,0 +1,18 @@
+package analyzer.exercises.annalynsinfiltration;
+
+import analyzer.Comment;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/annalyns-infiltration/avoid_comparison_with_literal.md">Markdown Template</a>
+ */
+public class AvoidComparisonWithLiteral extends Comment {
+    @Override
+    public String getKey() {
+        return "java.annalyns-infiltration.avoid_comparison_with_literal";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.ESSENTIAL;
+    }
+}

src/main/java/analyzer/exercises/annalynsinfiltration/AvoidIfStatements.java

@@ -0,0 +1,18 @@
+package analyzer.exercises.annalynsinfiltration;
+
+import analyzer.Comment;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/annalyns-infiltration/avoid_if_statements.md">Markdown Template</a>
+ */
+public class AvoidIfStatements extends Comment {
+    @Override
+    public String getKey() {
+        return "java.annalyns-infiltration.avoid_if_statements";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.ESSENTIAL;
+    }
+}

src/main/java/analyzer/exercises/annalynsinfiltration/RedundantParentheses.java

@@ -0,0 +1,18 @@
+package analyzer.exercises.annalynsinfiltration;
+
+import analyzer.Comment;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/annalyns-infiltration/some_parentheses_are_redundant.md">Markdown Template</a>
+ */
+public class RedundantParentheses extends Comment {
+    @Override
+    public String getKey() {
+        return "java.annalyns-infiltration.some_parentheses_are_redundant";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.INFORMATIVE;
+    }
+}

src/test/java/analyzer/AnalyzerIntegrationTest.java

@@ -97,4 +97,20 @@ public void twofer(String scenario) throws IOException {
 
         Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario));
     }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "Optimal",
+            "ComparingBooleanWithLiteral",
+            "ReturningBooleanLiteral",
+            "UsingIfStatement",
+            "UsingRedundantParenthesis",
+    })
+    public void annalynsinfiltration(String scenario) throws IOException {
+        var path = Path.of("annalynsinfiltration", scenario + ".java");
+        var solution = new SolutionFromFiles("annalyns-infiltration", SCENARIOS.resolve(path));
+        var output = AnalyzerRoot.analyze(solution);
+
+        Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario));
+    }
 }

src/test/resources/analyzer/AnalyzerIntegrationTest.annalynsinfiltration.ComparingBooleanWithLiteral.approved.txt

@@ -0,0 +1,14 @@
+{
+  "comments": [
+    {
+      "comment": "java.annalyns-infiltration.avoid_comparison_with_literal",
+      "params": {},
+      "type": "essential"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.annalynsinfiltration.Optimal.approved.txt

@@ -0,0 +1,11 @@
+{
+  "comments": [
+    {
+      "comment": "java.general.exemplar",
+      "params": {
+        "exerciseName": "Annalyn\u0027s Infiltration"
+      },
+      "type": "celebratory"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.annalynsinfiltration.ReturningBooleanLiteral.approved.txt

@@ -0,0 +1,19 @@
+{
+  "comments": [
+    {
+      "comment": "java.annalyns-infiltration.avoid_if_statements",
+      "params": {},
+      "type": "essential"
+    },
+    {
+      "comment": "java.annalyns-infiltration.avoid_boolean_literal_returns",
+      "params": {},
+      "type": "essential"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.annalynsinfiltration.UsingIfStatement.approved.txt

@@ -0,0 +1,19 @@
+{
+  "comments": [
+    {
+      "comment": "java.annalyns-infiltration.avoid_if_statements",
+      "params": {},
+      "type": "essential"
+    },
+    {
+      "comment": "java.annalyns-infiltration.avoid_boolean_literal_returns",
+      "params": {},
+      "type": "essential"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.annalynsinfiltration.UsingRedundantParenthesis.approved.txt

@@ -0,0 +1,14 @@
+{
+  "comments": [
+    {
+      "comment": "java.annalyns-infiltration.some_parentheses_are_redundant",
+      "params": {},
+      "type": "informative"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/scenarios/annalynsinfiltration/ComparingBooleanWithLiteral.java

@@ -0,0 +1,17 @@
+class AnnalynsInfiltration {
+    public static boolean canFastAttack(boolean knightIsAwake) {
+        return !knightIsAwake;
+    }
+
+    public static boolean canSpy(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake) {
+        return knightIsAwake || archerIsAwake || prisonerIsAwake;
+    }
+
+    public static boolean canSignalPrisoner(boolean archerIsAwake, boolean prisonerIsAwake) {
+        return prisonerIsAwake == true && archerIsAwake == false;
+    }
+
+    public static boolean canFreePrisoner(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake, boolean petDogIsPresent) {
+        return !archerIsAwake && (petDogIsPresent || prisonerIsAwake && !knightIsAwake);
+    }
+}

src/test/resources/scenarios/annalynsinfiltration/Optimal.java

@@ -0,0 +1,17 @@
+class AnnalynsInfiltration {
+    public static boolean canFastAttack(boolean knightIsAwake) {
+        return !knightIsAwake;
+    }
+
+    public static boolean canSpy(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake) {
+        return knightIsAwake || archerIsAwake || prisonerIsAwake;
+    }
+
+    public static boolean canSignalPrisoner(boolean archerIsAwake, boolean prisonerIsAwake) {
+        return prisonerIsAwake && !archerIsAwake;
+    }
+
+    public static boolean canFreePrisoner(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake, boolean petDogIsPresent) {
+        return !archerIsAwake && (petDogIsPresent || prisonerIsAwake && !knightIsAwake);
+    }
+}

src/test/resources/scenarios/annalynsinfiltration/ReturningBooleanLiteral.java

@@ -0,0 +1,20 @@
+class AnnalynsInfiltration {
+    public static boolean canFastAttack(boolean knightIsAwake) {
+        return !knightIsAwake;
+    }
+
+    public static boolean canSpy(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake) {
+        if(knightIsAwake) return true;
+        if(archerIsAwake) return true;
+        if(prisonerIsAwake) return true;
+        return false;
+    }
+
+    public static boolean canSignalPrisoner(boolean archerIsAwake, boolean prisonerIsAwake) {
+        return prisonerIsAwake && !archerIsAwake;
+    }
+
+    public static boolean canFreePrisoner(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake, boolean petDogIsPresent) {
+        return !archerIsAwake && (petDogIsPresent || prisonerIsAwake && !knightIsAwake);
+    }
+}

src/test/resources/scenarios/annalynsinfiltration/UsingIfStatement.java

@@ -0,0 +1,20 @@
+class AnnalynsInfiltration {
+    public static boolean canFastAttack(boolean knightIsAwake) {
+        return !knightIsAwake;
+    }
+
+    public static boolean canSpy(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake) {
+        return knightIsAwake || archerIsAwake || prisonerIsAwake;
+    }
+
+    public static boolean canSignalPrisoner(boolean archerIsAwake, boolean prisonerIsAwake) {
+        return prisonerIsAwake && !archerIsAwake;
+    }
+
+    public static boolean canFreePrisoner(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake, boolean petDogIsPresent) {
+        if(!archerIsAwake){
+            return petDogIsPresent || prisonerIsAwake && !knightIsAwake;
+        }
+        return false;
+    }
+}

src/test/resources/scenarios/annalynsinfiltration/UsingRedundantParenthesis.java

@@ -0,0 +1,17 @@
+class AnnalynsInfiltration {
+    public static boolean canFastAttack(boolean knightIsAwake) {
+        return !knightIsAwake;
+    }
+
+    public static boolean canSpy(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake) {
+        return knightIsAwake || archerIsAwake || prisonerIsAwake;
+    }
+
+    public static boolean canSignalPrisoner(boolean archerIsAwake, boolean prisonerIsAwake) {
+        return prisonerIsAwake && !archerIsAwake;
+    }
+
+    public static boolean canFreePrisoner(boolean knightIsAwake, boolean archerIsAwake, boolean prisonerIsAwake, boolean petDogIsPresent) {
+        return !archerIsAwake && (petDogIsPresent || (prisonerIsAwake && !knightIsAwake));
+    }
+}

tests/annalyns-infiltration/comparing-boolean-with-literal/.meta/config.json

@@ -0,0 +1,23 @@
+{
+  "authors": [
+    "mikedamay"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/AnnalynsInfiltration.java"
+    ],
+    "test": [
+      "src/test/java/AnnalynsInfiltrationTest.java"
+    ],
+    "exemplar": [
+      ".meta/src/reference/java/AnnalynsInfiltration.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "forked_from": [
+    "csharp/annalyns-infiltration"
+  ],
+  "blurb": "Learn about booleans while helping Annalyn rescue her friend."
+}