Lasagna analyzer

src/main/java/analyzer/AnalyzerRoot.java

@@ -3,6 +3,7 @@
 import analyzer.comments.FeedbackRequest;
 import analyzer.exercises.GlobalAnalyzer;
 import analyzer.exercises.hamming.HammingAnalyzer;
+import analyzer.exercises.lasagna.LasagnaAnalyzer;
 import analyzer.exercises.leap.LeapAnalyzer;
 import analyzer.exercises.twofer.TwoferAnalyzer;
 import com.github.javaparser.ast.CompilationUnit;
@@ -19,24 +20,25 @@ public static Analysis analyze(String slug, List<CompilationUnit> compilationUni
             analyzer.analyze(compilationUnits, analysis);
         }
 
-        if (!analysis.getComments().isEmpty()) {
+        if (analysis.getComments().stream().anyMatch(x -> x.getType() != CommentType.CELEBRATORY)) {
             analysis.addComment(new FeedbackRequest());
         }
-        
+
         return analysis;
     }
 
     private static List<Analyzer> createAnalyzers(String slug) {
         var analyzers = new ArrayList<Analyzer>();
 
+        analyzers.add(new GlobalAnalyzer());
+
         switch (slug) {
             case "hamming" -> analyzers.add(new HammingAnalyzer());
+            case "lasagna" -> analyzers.add(new LasagnaAnalyzer());
             case "leap" -> analyzers.add(new LeapAnalyzer());
             case "two-fer" -> analyzers.add(new TwoferAnalyzer());
         }
 
-        analyzers.add(new GlobalAnalyzer());
-
         return List.copyOf(analyzers);
     }
 }

src/main/java/analyzer/comments/ExemplarSolution.java

@@ -0,0 +1,32 @@
+package analyzer.comments;
+
+import analyzer.Comment;
+import analyzer.CommentType;
+
+import java.util.Map;
+
+/**
+ * @see <a href="https://github.com/exercism/website-copy/blob/main/analyzer-comments/java/general/exemplar.md">Markdown Template</a>
+ */
+public class ExemplarSolution extends Comment {
+    private final String exerciseName;
+
+    public ExemplarSolution(String exerciseName) {
+        this.exerciseName = exerciseName;
+    }
+
+    @Override
+    public String getKey() {
+        return "java.general.exemplar";
+    }
+
+    @Override
+    public Map<String, String> getParameters() {
+        return Map.of("exerciseName", this.exerciseName);
+    }
+
+    @Override
+    public CommentType getType() {
+        return CommentType.CELEBRATORY;
+    }
+}

src/main/java/analyzer/comments/RemoveTodoComments.java

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

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

@@ -0,0 +1,58 @@
+package analyzer.exercises.lasagna;
+
+import analyzer.Analysis;
+import analyzer.Analyzer;
+import analyzer.comments.ExemplarSolution;
+import analyzer.comments.RemoveTodoComments;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.comments.LineComment;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
+
+import java.util.List;
+
+public class LasagnaAnalyzer extends VoidVisitorAdapter<Analysis> implements Analyzer {
+    private static final String EXERCISE_NAME = "Lasagna";
+    private static final String EXPECTED_MINUTES_IN_OVEN = "expectedMinutesInOven";
+    private static final String REMAINING_MINUTES_IN_OVEN = "remainingMinutesInOven";
+    private static final String PREPARATION_TIME_IN_MINUTES = "preparationTimeInMinutes";
+    private static final String TOTAL_TIME_IN_MINUTES = "totalTimeInMinutes";
+
+    @Override
+    public void analyze(List<CompilationUnit> compilationUnits, Analysis analysis) {
+        for (CompilationUnit compilationUnit : compilationUnits) {
+            compilationUnit.accept(this, analysis);
+        }
+
+        if (analysis.getComments().isEmpty()) {
+            analysis.addComment(new ExemplarSolution(EXERCISE_NAME));
+        }
+    }
+
+    @Override
+    public void visit(MethodDeclaration node, Analysis analysis) {
+        if (node.getNameAsString().equals(REMAINING_MINUTES_IN_OVEN)
+                && doesNotCallMethod(node, EXPECTED_MINUTES_IN_OVEN)) {
+            analysis.addComment(new ReuseCode(REMAINING_MINUTES_IN_OVEN, EXPECTED_MINUTES_IN_OVEN));
+        }
+
+        if (node.getNameAsString().equals(TOTAL_TIME_IN_MINUTES)
+                && doesNotCallMethod(node, PREPARATION_TIME_IN_MINUTES)) {
+            analysis.addComment(new ReuseCode(TOTAL_TIME_IN_MINUTES, PREPARATION_TIME_IN_MINUTES));
+        }
+
+        super.visit(node, analysis);
+    }
+
+    private static boolean doesNotCallMethod(MethodDeclaration node, String otherMethodName) {
+        return node.findAll(MethodCallExpr.class, x -> x.getNameAsString().contains(otherMethodName)).isEmpty();
+    }
+
+    @Override
+    public void visit(LineComment node, Analysis analysis) {
+        if (node.getContent().contains("TODO")) {
+            analysis.addComment(new RemoveTodoComments());
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+package analyzer.exercises.lasagna;
+
+import analyzer.Comment;
+import analyzer.CommentType;
+
+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>
+ */
+class ReuseCode extends Comment {
+    private final String callingMethod;
+    private final String methodToCall;
+
+    ReuseCode(String callingMethod, String methodToCall) {
+        this.callingMethod = callingMethod;
+        this.methodToCall = methodToCall;
+    }
+
+    @Override
+    public String getKey() {
+        return "java.lasagna.reuse_code";
+    }
+
+    @Override
+    public Map<String, String> getParameters() {
+        return Map.of(
+                "callingMethod", this.callingMethod,
+                "methodToCall", this.methodToCall
+        );
+    }
+
+    @Override
+    public CommentType getType() {
+        return CommentType.ACTIONABLE;
+    }
+}

src/test/java/analyzer/AnalyzerTest.java

@@ -3,10 +3,15 @@
 import com.github.javaparser.StaticJavaParser;
 import com.github.javaparser.ast.CompilationUnit;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.List;
 
-public abstract class AnalyzerTest {
-    protected abstract Analyzer getAnalyzer();
+public class AnalyzerTest<T extends Analyzer> {
+    private final Class<T> analyzerClass;
+
+    public AnalyzerTest(Class<T> analyzerClass) {
+        this.analyzerClass = analyzerClass;
+    }
 
     protected Analysis analyzeResourceFile(String resourceFileName) {
         var resource = getClass().getResourceAsStream(resourceFileName);
@@ -22,4 +27,12 @@ private Analysis analyze(CompilationUnit compilationUnit) {
         getAnalyzer().analyze(List.of(compilationUnit), analysis);
         return analysis;
     }
+
+    private T getAnalyzer() {
+        try {
+            return this.analyzerClass.getConstructor().newInstance();
+        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
+            throw new AssertionError("Unable to create instance of " + this.analyzerClass.getName(), ex);
+        }
+    }
 }

src/test/java/analyzer/exercises/GlobalAnalyzerTest.java

@@ -1,6 +1,5 @@
 package analyzer.exercises;
 
-import analyzer.Analyzer;
 import analyzer.AnalyzerTest;
 import analyzer.comments.AvoidPrintStatements;
 import analyzer.comments.DoNotUseMainMethod;
@@ -11,10 +10,9 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class GlobalAnalyzerTest extends AnalyzerTest {
-    @Override
-    protected Analyzer getAnalyzer() {
-        return new GlobalAnalyzer();
+public class GlobalAnalyzerTest extends AnalyzerTest<GlobalAnalyzer> {
+    public GlobalAnalyzerTest() {
+        super(GlobalAnalyzer.class);
     }
 
     @MethodSource

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

@@ -1,8 +1,7 @@
 package analyzer.exercises.hamming;
 
-import analyzer.Analyzer;
-import analyzer.Comment;
 import analyzer.AnalyzerTest;
+import analyzer.Comment;
 import analyzer.comments.ConstructorTooLong;
 import analyzer.comments.MethodTooLong;
 import analyzer.comments.UseProperClassName;
@@ -15,10 +14,9 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class HammingAnalyzerTest extends AnalyzerTest {
-    @Override
-    protected Analyzer getAnalyzer() {
-        return new HammingAnalyzer();
+public class HammingAnalyzerTest extends AnalyzerTest<HammingAnalyzer> {
+    public HammingAnalyzerTest() {
+        super(HammingAnalyzer.class);
     }
 
     private static Stream<Arguments> testCases() {

src/test/java/analyzer/exercises/lasagna/LasagnaAnalyzerTest.java

@@ -0,0 +1,44 @@
+package analyzer.exercises.lasagna;
+
+import analyzer.AnalyzerTest;
+import analyzer.Comment;
+import analyzer.comments.ExemplarSolution;
+import analyzer.comments.RemoveTodoComments;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class LasagnaAnalyzerTest extends AnalyzerTest<LasagnaAnalyzer> {
+    public LasagnaAnalyzerTest() {
+        super(LasagnaAnalyzer.class);
+    }
+
+    private static Stream<Arguments> testCases() {
+        return Stream.of(
+                Arguments.of("ExemplarSolution.java", List.of(new ExemplarSolution("Lasagna"))),
+                Arguments.of("ExemplarSolutionWithTodoComments.java", List.of(new RemoveTodoComments())),
+                Arguments.of("NoReuseOfExpectedMinutesInOven.java",
+                        List.of(new ReuseCode("remainingMinutesInOven", "expectedMinutesInOven"))),
+                Arguments.of("NoReuseOfPreparationTimeInMinutes.java",
+                        List.of(new ReuseCode("totalTimeInMinutes", "preparationTimeInMinutes"))),
+                Arguments.of("NoReuseOfBothMethods.java",
+                        List.of(
+                                new ReuseCode("remainingMinutesInOven", "expectedMinutesInOven"),
+                                new ReuseCode("totalTimeInMinutes", "preparationTimeInMinutes")
+                        )
+                )
+        );
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("testCases")
+    public void testCommentsOnSolution(String filename, List<Comment> expectedComments) {
+        var analysis = analyzeResourceFile("/analyzer/exercises/lasagna/" + filename);
+        assertThat(analysis.getComments()).containsExactlyInAnyOrder(expectedComments.toArray(Comment[]::new));
+    }
+}

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

@@ -1,8 +1,7 @@
 package analyzer.exercises.twofer;
 
-import analyzer.Analyzer;
-import analyzer.Comment;
 import analyzer.AnalyzerTest;
+import analyzer.Comment;
 import analyzer.comments.AvoidHardCodedTestCases;
 import analyzer.comments.UseProperClassName;
 import analyzer.comments.UseProperMethodName;
@@ -14,11 +13,10 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-public class TwoferAnalyzerTest extends AnalyzerTest {
+public class TwoferAnalyzerTest extends AnalyzerTest<TwoferAnalyzer> {
 
-    @Override
-    protected Analyzer getAnalyzer() {
-        return new TwoferAnalyzer();
+    public TwoferAnalyzerTest() {
+        super(TwoferAnalyzer.class);
     }
 
     private static Stream<Arguments> testCases() {

src/test/resources/analyzer/exercises/lasagna/ExemplarSolution.java

@@ -0,0 +1,17 @@
+public class Lasagna {
+    public int expectedMinutesInOven() {
+        return 40;
+    }
+
+    public int remainingMinutesInOven(int actualMinutesInOven) {
+        return expectedMinutesInOven() - actualMinutesInOven;
+    }
+
+    public int preparationTimeInMinutes(int numberOfLayers) {
+        return numberOfLayers * 2;
+    }
+
+    public int totalTimeInMinutes(int numberOfLayers, int actualMinutesInOven) {
+        return preparationTimeInMinutes(numberOfLayers) + actualMinutesInOven;
+    }
+}

src/test/resources/analyzer/exercises/lasagna/ExemplarSolutionWithTodoComments.java

@@ -0,0 +1,21 @@
+public class Lasagna {
+    // TODO: define the 'expectedMinutesInOven()' method
+    public int expectedMinutesInOven() {
+        return 40;
+    }
+
+    // TODO: define the 'remainingMinutesInOven()' method
+    public int remainingMinutesInOven(int actualMinutesInOven) {
+        return expectedMinutesInOven() - actualMinutesInOven;
+    }
+
+    // TODO: define the 'preparationTimeInMinutes()' method
+    public int preparationTimeInMinutes(int numberOfLayers) {
+        return numberOfLayers * 2;
+    }
+
+    // TODO: define the 'totalTimeInMinutes()' method
+    public int totalTimeInMinutes(int numberOfLayers, int actualMinutesInOven) {
+        return preparationTimeInMinutes(numberOfLayers) + actualMinutesInOven;
+    }
+}

src/test/resources/analyzer/exercises/lasagna/NoReuseOfBothMethods.java

@@ -0,0 +1,17 @@
+public class Lasagna {
+    public int expectedMinutesInOven() {
+        return 40;
+    }
+
+    public int remainingMinutesInOven(int actualMinutesInOven) {
+        return 40 - actualMinutesInOven;
+    }
+
+    public int preparationTimeInMinutes(int numberOfLayers) {
+        return numberOfLayers * 2;
+    }
+
+    public int totalTimeInMinutes(int numberOfLayers, int actualMinutesInOven) {
+        return 2 * numberOfLayers + actualMinutesInOven;
+    }
+}