Updating Two Fer Analyzer to use our new analyzer convention (#137)

* Updating Two Fer Analyzer to use our new analyzer convention

* Deleting whitespace

* Updating usage of prefer string concatenation as now it is a general comment

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

@@ -1,33 +1,86 @@
 package analyzer.exercises.twofer;
 
 import analyzer.OutputCollector;
+
+import java.util.List;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.ast.stmt.IfStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
+
 import analyzer.Analyzer;
 import analyzer.Solution;
 import analyzer.comments.AvoidHardCodedTestCases;
+import analyzer.comments.PreferStringConcatenation;
 
 /**
  * The {@link TwoferAnalyzer} is the analyzer implementation for the {@code two-fer} practice exercise.
  *
  * @see <a href="https://github.com/exercism/java/tree/main/exercises/practice/two-fer">The two-fer exercise on the Java track</a>
  */
-public class TwoferAnalyzer implements Analyzer {
+public class TwoferAnalyzer extends VoidVisitorAdapter<OutputCollector> implements Analyzer {
 
     @Override
     public void analyze(Solution solution, OutputCollector output) {
-        TwoferWalker walker = new TwoferWalker();
-
-        solution.getCompilationUnits().forEach(cu -> cu.walk(walker));
+        for (CompilationUnit compilationUnit : solution.getCompilationUnits()) {
+            compilationUnit.accept(this, output);
+        }
+    }
 
-        if (walker.hasHardCodedTestCases) {
+    @Override
+    public void visit(MethodDeclaration node, OutputCollector output) {
+        if (hasHardCodedTestCases(node)) {
             output.addComment(new AvoidHardCodedTestCases());
-        } else if (walker.usesFormat) {
-            output.addComment(new AvoidStringFormat());
-        } else if (walker.returnCount > 1) {
+            return;
+        }
+
+        if (hasIfStatement(node)) {
+            output.addComment(new UseTernaryOperator());
+        }
+
+        if (hasMoreThanOneReturnStatement(node)) {
             output.addComment(new UseOneReturn());
-        } else {
-            if (walker.usesIfStatement) {
-                output.addComment(new UseTernaryOperator());
-            }
         }
+
+        if (callsFormatMethod(node)) {
+            output.addComment(new PreferStringConcatenation());
+        }
+    }
+
+    private static boolean hasHardCodedTestCases(MethodDeclaration node) {
+        List<StringLiteralExpr> hardcodedStrings = node.findAll(StringLiteralExpr.class,
+                x -> x.getValue().contains("Alice") || x.getValue().contains("Bob"));
+
+        return hardcodedStrings.size() > 1;
+    }
+
+    private static boolean hasMoreThanOneReturnStatement(MethodDeclaration node) {
+        long returnStmtCount = node.getBody()
+                .map(body -> body.getStatements().stream().filter(TwoferAnalyzer::isReturnStatement).count())
+                .orElse(0L);
+
+        return returnStmtCount > 1;
+    }
+
+    private static boolean callsFormatMethod(MethodDeclaration node) {
+        return !node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains("format")).isEmpty();
+    }
+
+    private static boolean hasIfStatement(MethodDeclaration node) {
+        return node.getBody().map(body -> body.getStatements().stream().anyMatch(TwoferAnalyzer::isIfStatement))
+                .orElse(false);
+    }
+
+    private static boolean isIfStatement(Statement statement) {
+        return !statement.findAll(IfStmt.class).isEmpty();
+    }
+
+    private static boolean isReturnStatement(Statement statement) {
+        return !statement.findAll(ReturnStmt.class).isEmpty();
     }
 }

src/test/resources/analyzer/AnalyzerIntegrationTest.twofer.UsesMultipleReturns.approved.txt

@@ -1,5 +1,10 @@
 {
   "comments": [
+    {
+      "comment": "java.two-fer.use_ternary_operator",
+      "params": {},
+      "type": "actionable"
+    },
     {
       "comment": "java.two-fer.use_one_return",
       "params": {},

src/test/resources/analyzer/AnalyzerIntegrationTest.twofer.UsesStringFormat.approved.txt

@@ -1,9 +1,9 @@
 {
   "comments": [
     {
-      "comment": "java.two-fer.avoid_string_format",
+      "comment": "java.general.prefer_string_concatenation",
       "params": {},
-      "type": "actionable"
+      "type": "informative"
     },
     {
       "comment": "java.general.feedback_request",

tests/two-fer/hardcoding-tests/expected_analysis.json

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

tests/two-fer/hardcoding-tests/src/main/java/TwoFer.java

@@ -0,0 +1,12 @@
+class Twofer {
+    public String twofer(String name) {
+        if (name == null) {
+            // fall through
+        } else if (name.equals("Alice")) {
+            return "One for Alice, one for me.";
+        } else if (name.equals("Bob")) {
+            return "One for Bob, one for me.";
+        }
+        return "One for you, one for me.";
+    }
+}

tests/two-fer/using-if-statement/.meta/config.json

@@ -0,0 +1,39 @@
+{
+  "authors": [
+    "Smarticles101"
+  ],
+  "contributors": [
+    "FridaTveit",
+    "ikhadykin",
+    "jmrunkle",
+    "jssander",
+    "kytrinyx",
+    "lemoncurry",
+    "msomji",
+    "muzimuzhi",
+    "rdavid1099",
+    "sjwarner-bp",
+    "SleeplessByte",
+    "sshine",
+    "stkent",
+    "uzilan",
+    "Valkryst",
+    "ymoskovits"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/Twofer.java"
+    ],
+    "test": [
+      "src/test/java/TwoferTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/Twofer.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "blurb": "Create a sentence of the form \"One for X, one for me.\".",
+  "source_url": "https://github.com/exercism/problem-specifications/issues/757"
+}

tests/two-fer/non-optimal-solution/expected_analysis.json → tests/two-fer/using-if-statement/expected_analysis.json

@@ -1,7 +1,7 @@
 {
   "comments": [
     {
-      "comment": "java.two-fer.avoid_string_format",
+      "comment": "java.two-fer.use_ternary_operator",
       "params": {},
       "type": "actionable"
     },

tests/two-fer/using-if-statement/expected_tags.json

@@ -0,0 +1,3 @@
+{
+  "tags": []
+}

tests/two-fer/using-if-statement/src/main/java/TwoFer.java

@@ -0,0 +1,7 @@
+class Twofer {
+    public String twofer(String rawName) {
+        String name = rawName;
+        if (name == null) name = "you";
+        return "One for " + name + ", one for me.";
+    }
+}

tests/two-fer/using-multiple-returns/.meta/config.json

@@ -0,0 +1,39 @@
+{
+  "authors": [
+    "Smarticles101"
+  ],
+  "contributors": [
+    "FridaTveit",
+    "ikhadykin",
+    "jmrunkle",
+    "jssander",
+    "kytrinyx",
+    "lemoncurry",
+    "msomji",
+    "muzimuzhi",
+    "rdavid1099",
+    "sjwarner-bp",
+    "SleeplessByte",
+    "sshine",
+    "stkent",
+    "uzilan",
+    "Valkryst",
+    "ymoskovits"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/Twofer.java"
+    ],
+    "test": [
+      "src/test/java/TwoferTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/Twofer.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "blurb": "Create a sentence of the form \"One for X, one for me.\".",
+  "source_url": "https://github.com/exercism/problem-specifications/issues/757"
+}

tests/two-fer/using-multiple-returns/expected_analysis.json

@@ -0,0 +1,19 @@
+{
+  "comments": [
+    {
+      "comment": "java.two-fer.use_ternary_operator",
+      "params": {},
+      "type": "actionable"
+    },
+    {
+      "comment": "java.two-fer.use_one_return",
+      "params": {},
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

tests/two-fer/using-multiple-returns/expected_tags.json

@@ -0,0 +1,3 @@
+{
+  "tags": []
+}

tests/two-fer/using-multiple-returns/src/main/java/TwoFer.java

@@ -0,0 +1,6 @@
+class Twofer {
+    public String twofer(String name) {
+        if (name == null) return "One for you, one for me.";
+        return "One for " + name + ", one for me.";
+    }
+}

tests/two-fer/using-string-format/.meta/config.json

@@ -0,0 +1,39 @@
+{
+  "authors": [
+    "Smarticles101"
+  ],
+  "contributors": [
+    "FridaTveit",
+    "ikhadykin",
+    "jmrunkle",
+    "jssander",
+    "kytrinyx",
+    "lemoncurry",
+    "msomji",
+    "muzimuzhi",
+    "rdavid1099",
+    "sjwarner-bp",
+    "SleeplessByte",
+    "sshine",
+    "stkent",
+    "uzilan",
+    "Valkryst",
+    "ymoskovits"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/Twofer.java"
+    ],
+    "test": [
+      "src/test/java/TwoferTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/Twofer.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "blurb": "Create a sentence of the form \"One for X, one for me.\".",
+  "source_url": "https://github.com/exercism/problem-specifications/issues/757"
+}