Adding analyzer for log-levels concept exercise

src/main/java/analyzer/AnalyzerRoot.java

@@ -6,6 +6,7 @@
 import analyzer.exercises.hamming.HammingAnalyzer;
 import analyzer.exercises.lasagna.LasagnaAnalyzer;
 import analyzer.exercises.leap.LeapAnalyzer;
+import analyzer.exercises.loglevels.LogLevelsAnalyzer;
 import analyzer.exercises.needforspeed.NeedForSpeedAnalyzer;
 import analyzer.exercises.twofer.TwoferAnalyzer;
 
@@ -51,6 +52,7 @@ private static List<Analyzer> createAnalyzers(String slug) {
             case "hamming" -> analyzers.add(new HammingAnalyzer());
             case "lasagna" -> analyzers.add(new LasagnaAnalyzer());
             case "leap" -> analyzers.add(new LeapAnalyzer());
+            case "log-levels" -> analyzers.add(new LogLevelsAnalyzer());
             case "need-for-speed" -> analyzers.add(new NeedForSpeedAnalyzer());
             case "two-fer" -> analyzers.add(new TwoferAnalyzer());
         }

src/main/java/analyzer/comments/PreferStringConcatenation.java

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

src/main/java/analyzer/exercises/lasagna/ReuseCode.java → src/main/java/analyzer/comments/ReuseCode.java

@@ -1,24 +1,24 @@
-package analyzer.exercises.lasagna;
+package analyzer.comments;
 
 import analyzer.Comment;
 
 import java.util.Map;
 
 /**
- * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/lasagna/reuse_code.md">Markdown Template</a>
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/general/reuse_code.md">Markdown Template</a>
  */
-class ReuseCode extends Comment {
+public class ReuseCode extends Comment {
     private final String callingMethod;
     private final String methodToCall;
 
-    ReuseCode(String callingMethod, String methodToCall) {
+    public ReuseCode(String callingMethod, String methodToCall) {
         this.callingMethod = callingMethod;
         this.methodToCall = methodToCall;
     }
 
     @Override
     public String getKey() {
-        return "java.lasagna.reuse_code";
+        return "java.general.reuse_code";
     }
 
     @Override

src/main/java/analyzer/exercises/lasagna/LasagnaAnalyzer.java

@@ -5,6 +5,8 @@
 import analyzer.Solution;
 import analyzer.comments.ExemplarSolution;
 import analyzer.comments.RemoveTodoComments;
+import analyzer.comments.ReuseCode;
+
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.body.MethodDeclaration;
 import com.github.javaparser.ast.comments.LineComment;

src/main/java/analyzer/exercises/loglevels/LogLevelsAnalyzer.java

@@ -0,0 +1,86 @@
+package analyzer.exercises.loglevels;
+
+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.visitor.VoidVisitorAdapter;
+
+import analyzer.Analyzer;
+import analyzer.OutputCollector;
+import analyzer.Solution;
+import analyzer.comments.AvoidHardCodedTestCases;
+import analyzer.comments.ExemplarSolution;
+import analyzer.comments.PreferStringConcatenation;
+import analyzer.comments.ReuseCode;
+
+import java.util.List;
+
+/**
+ * The {@link LogLevelsAnalyzer} is the analyzer implementation for the {@code log-levels} 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/concept/log-levels">The log-levels exercise on the Java track</a>
+ */
+public class LogLevelsAnalyzer extends VoidVisitorAdapter<OutputCollector> implements Analyzer {
+    private static final String EXERCISE_NAME = "Log Levels";
+    private static final String REFORMAT = "reformat";
+    private static final String MESSAGE = "message";
+    private static final String LOG_LEVEL = "logLevel";
+    private static final String SUBSTRING = "substring";
+    private static final String FORMAT = "format";
+
+    @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(MethodDeclaration node, OutputCollector output) {
+        if (containsHarcodedString(node)) {
+            output.addComment(new AvoidHardCodedTestCases());
+            return;
+        }
+
+        if (!node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, SUBSTRING)) {
+            output.addComment(new UseSubstringMethod());
+            return;
+        }
+
+        if (node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, MESSAGE)) {
+            output.addComment(new ReuseCode(REFORMAT, MESSAGE));
+        }
+
+        if (node.getNameAsString().equals(REFORMAT) && doesNotCallMethod(node, LOG_LEVEL)) {
+            output.addComment(new ReuseCode(REFORMAT, LOG_LEVEL));
+        }
+
+        if (node.getNameAsString().equals(REFORMAT) && callsMethod(node, FORMAT)) {
+            output.addComment(new PreferStringConcatenation());
+        }
+
+        super.visit(node, output);
+    }
+
+    private static boolean containsHarcodedString(MethodDeclaration node) {
+        List<StringLiteralExpr> hardcodedStrings = node.findAll(StringLiteralExpr.class,
+                x -> x.getValue().contains("ERROR") || x.getValue().contains("WARNING")
+                        || x.getValue().contains("INFO"));
+
+        return hardcodedStrings.size() > 1;
+    }
+
+    private static boolean doesNotCallMethod(MethodDeclaration node, String otherMethodName) {
+        return node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty();
+    }
+
+    private static boolean callsMethod(MethodDeclaration node, String otherMethodName) {
+        return !node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty();
+    }
+}

src/main/java/analyzer/exercises/loglevels/UseSubstringMethod.java

@@ -0,0 +1,19 @@
+package analyzer.exercises.loglevels;
+
+import analyzer.Comment;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/log-levels/use_substring_method.md">Markdown Template</a>
+ */
+class UseSubstringMethod extends Comment {
+
+    @Override
+    public String getKey() {
+        return "java.log-levels.use_substring_method";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.ACTIONABLE;
+    }
+}

src/test/java/analyzer/AnalyzerIntegrationTest.java

@@ -113,7 +113,7 @@ public void annalynsinfiltration(String scenario) throws IOException {
 
         Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario));
     }
-      
+
     @ParameterizedTest
     @ValueSource(strings = {
             "ExemplarSolution",
@@ -126,7 +126,27 @@ void needforspeed(String scenario) throws IOException {
         var path = Path.of("need-for-speed", scenario + ".java");
         var solution = new SolutionFromFiles("need-for-speed", SCENARIOS.resolve(path));
         var output = AnalyzerRoot.analyze(solution);
-
+
+        Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "ExemplarSolution",
+            "HardCodingLogLevels",
+            "NoReuseLogLevel",
+            "NoReuseMessage",
+            "NoReuseOfBothMethods",
+            "NotUsingSubstringOnLogLevel",
+            "NotUsingSubstringOnMessage",
+            "NotUsingSubstringOnBothMethods",
+            "UsingStringFormat"
+    })
+    void loglevels(String scenario) throws IOException {
+        var path = Path.of("log-levels", scenario + ".java");
+        var solution = new SolutionFromFiles("log-levels", SCENARIOS.resolve(path));
+        var output = AnalyzerRoot.analyze(solution);
+
         Approvals.verify(serialize(output.analysis()), Approvals.NAMES.withParameters(scenario));
     }
 }

src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfBothMethods.approved.txt

@@ -1,15 +1,15 @@
 {
   "comments": [
     {
-      "comment": "java.lasagna.reuse_code",
+      "comment": "java.general.reuse_code",
       "params": {
         "callingMethod": "remainingMinutesInOven",
         "methodToCall": "expectedMinutesInOven"
       },
       "type": "actionable"
     },
     {
-      "comment": "java.lasagna.reuse_code",
+      "comment": "java.general.reuse_code",
       "params": {
         "callingMethod": "totalTimeInMinutes",
         "methodToCall": "preparationTimeInMinutes"

src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfExpectedMinutesInOven.approved.txt

@@ -1,7 +1,7 @@
 {
   "comments": [
     {
-      "comment": "java.lasagna.reuse_code",
+      "comment": "java.general.reuse_code",
       "params": {
         "callingMethod": "remainingMinutesInOven",
         "methodToCall": "expectedMinutesInOven"

src/test/resources/analyzer/AnalyzerIntegrationTest.lasagna.NoReuseOfPreparationTimeInMinutes.approved.txt

@@ -1,7 +1,7 @@
 {
   "comments": [
     {
-      "comment": "java.lasagna.reuse_code",
+      "comment": "java.general.reuse_code",
       "params": {
         "callingMethod": "totalTimeInMinutes",
         "methodToCall": "preparationTimeInMinutes"

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.ExemplarSolution.approved.txt

@@ -0,0 +1,11 @@
+{
+  "comments": [
+    {
+      "comment": "java.general.exemplar",
+      "params": {
+        "exerciseName": "Log Levels"
+      },
+      "type": "celebratory"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.HardCodingLogLevels.approved.txt

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

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseLogLevel.approved.txt

@@ -0,0 +1,17 @@
+{
+  "comments": [
+    {
+      "comment": "java.general.reuse_code",
+      "params": {
+        "callingMethod": "reformat",
+        "methodToCall": "logLevel"
+      },
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseMessage.approved.txt

@@ -0,0 +1,17 @@
+{
+  "comments": [
+    {
+      "comment": "java.general.reuse_code",
+      "params": {
+        "callingMethod": "reformat",
+        "methodToCall": "message"
+      },
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NoReuseOfBothMethods.approved.txt

@@ -0,0 +1,25 @@
+{
+  "comments": [
+    {
+      "comment": "java.general.reuse_code",
+      "params": {
+        "callingMethod": "reformat",
+        "methodToCall": "message"
+      },
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.reuse_code",
+      "params": {
+        "callingMethod": "reformat",
+        "methodToCall": "logLevel"
+      },
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnBothMethods.approved.txt

@@ -0,0 +1,14 @@
+{
+  "comments": [
+    {
+      "comment": "java.log-levels.use_substring_method",
+      "params": {},
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnLogLevel.approved.txt

@@ -0,0 +1,14 @@
+{
+  "comments": [
+    {
+      "comment": "java.log-levels.use_substring_method",
+      "params": {},
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}

src/test/resources/analyzer/AnalyzerIntegrationTest.loglevels.NotUsingSubstringOnMessage.approved.txt

@@ -0,0 +1,14 @@
+{
+  "comments": [
+    {
+      "comment": "java.log-levels.use_substring_method",
+      "params": {},
+      "type": "actionable"
+    },
+    {
+      "comment": "java.general.feedback_request",
+      "params": {},
+      "type": "informative"
+    }
+  ]
+}