Make Hamming check for method refs

This is to ensure that the Hamming analyzer considers the use of
method references when checking the solution.

Fixes #303.

Author: kahgoh

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

@@ -7,6 +7,7 @@
 import com.github.javaparser.ast.expr.CharLiteralExpr;
 import com.github.javaparser.ast.expr.LambdaExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.MethodReferenceExpr;
 import com.github.javaparser.ast.nodeTypes.NodeWithRange;
 import com.github.javaparser.ast.stmt.*;
 
@@ -75,9 +76,12 @@ private boolean isMethodCall(Statement statement) {
     }
 
     private Stream<String> getMethodCallNames(Statement statement) {
-        return statement.findAll(MethodCallExpr.class).stream()
-                .map(MethodCallExpr::getNameAsString)
-                .distinct();
+        Stream<String> methodCalled = statement.findAll(MethodCallExpr.class).stream()
+                .map(MethodCallExpr::getNameAsString);
+        Stream<String> methodRefs =  statement.findAll(MethodReferenceExpr.class).stream()
+                        .map(MethodReferenceExpr::getIdentifier);
+
+        return Stream.concat(methodCalled, methodRefs).distinct();
     }
 
     private Optional<MethodDeclaration> findGetHammingDistanceMethod() {

src/test/java/analyzer/AnalyzerIntegrationTest.java

@@ -38,6 +38,8 @@ void global(String scenario) throws IOException {
             "OptimalWithCalculationInGetHammingDistance",
             "OptimalWithValidationMethod",
             "UsesCharacterLiterals",
+            "UsesHelperMethodInLambda",
+            "UsesHelperMethodInMethodRef",
             "UsesStreamReduce",
     })
     void hamming(String scenario) throws IOException {

src/test/resources/analyzer/AnalyzerIntegrationTest.hamming.UsesHelperMethodInLambda.approved.txt

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

src/test/resources/analyzer/AnalyzerIntegrationTest.hamming.UsesHelperMethodInMethodRef.approved.txt

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

src/test/resources/scenarios/hamming/UsesHelperMethodInLambda.java

@@ -0,0 +1,19 @@
+import java.util.stream.IntStream;
+
+public class Hamming {
+    private final int distance;
+
+    public Hamming(String leftStrand, String rightStrand) {
+        if (leftStrand.length() != rightStrand.length()) {
+            throw new IllegalArgumentException("strands must be of equal length");
+        }
+
+        this.distance = (int) IntStream.range(0, leftStrand.length())
+                .filter(i -> leftStrand.charAt(i) != rightStrand.charAt(i))
+                .count();
+    }
+
+    public int getHammingDistance() {
+        return distance;
+    }
+}

src/test/resources/scenarios/hamming/UsesHelperMethodInMethodRef.java

@@ -0,0 +1,29 @@
+import java.util.Objects;
+import java.util.stream.IntStream;
+
+public class Hamming {
+    private final int length;
+    private final String leftStrand;
+    private final String rightStrand;
+
+    public Hamming(String leftStrand, String rightStrand) {
+        this.leftStrand = Objects.requireNonNull(leftStrand);
+        this.rightStrand = Objects.requireNonNull(rightStrand);
+
+        if (leftStrand.length() != rightStrand.length()) {
+            throw new IllegalArgumentException("strands must be of equal length");
+        }
+
+        this.length = leftStrand.length();
+    }
+
+    public int getHammingDistance() {
+        return IntStream.range(0, length)
+                .map(this::doesLetterMatch)
+                .sum();
+    }
+
+    private int doesLetterMatch(int i) {
+        return leftStrand.charAt(i) == rightStrand.charAt(i) ? 0 : 1;
+    }
+}