Merge from cayhorstmann/codecheck2

.gitignore

@@ -2,8 +2,10 @@
 **/*.class
 **/*.zip
 **/*.jar
-development.conf
+**/*.bloop
+conf/development.conf
 conf/production.conf
+conf/staging.conf
 production.env
 antbuild
 project/project
@@ -17,11 +19,13 @@ target
 .cache-main
 .bsp
 .metals
+.vscode
 application-log*
 gcloud
 deploy
 checkall
 testdiff
 /bin
 checker/docker/build
+comrun/build
 todo.txt

README.md

@@ -1,4 +1,4 @@
-CodeCheck^®^
+CodeCheck<sup>®</sup>
 ============
 
 * [Description](https://codecheck.io)

app/com/horstmann/codecheck/Annotations.java

@@ -5,17 +5,20 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.regex.Pattern;
 
 public class Annotations {
-    public static final Set<String> VALID_ANNOTATIONS = Set.of(
-            "HIDE", "SHOW", "EDIT", "SOLUTION", "CALL", "SUB", "ID", "SAMPLE", "ARGS", 
+    public static final Set<String> VALID_ANNOTATIONS = new LinkedHashSet<>(List.of(
+            "CALL HIDDEN", "IN HIDDEN", "HIDDEN", "HIDE", "SHOW", "EDIT", "SOLUTION", "CALL", "SUB", "ID", "SAMPLE", "ARGS", 
             "IN", "OUT", "TIMEOUT", "TOLERANCE", "IGNORECASE", "IGNORESPACE", "MAXOUTPUTLEN",
-            "REQUIRED", "FORBIDDEN", "SCORING", "INTERLEAVE", "TILE", "FIXED", "OR", "PSEUDO");    
+            "REQUIRED", "FORBIDDEN", "SCORING", "INTERLEAVE", "TILE", "FIXED", "OR", "PSEUDO"));  
+    // TODO SAMPLE, SCORING legacy
     public static final Set<String> NON_BLANK_BEFORE_OK = Set.of("SUB", "PSEUDO"); 
 
     public static class Annotation {
@@ -27,35 +30,48 @@ public static class Annotation {
         public String next = "";
     }
 
+    /**
+        @param line the line of code to parse
+        @param start the starting comment delimiter
+        @param end the ending comment delimiter
+        @return the parsed annotation, or an empty annotation if none found
+     */
     public static Annotation parse(String line, String start, String end) {
         Annotation ann = new Annotation();
         int i = line.indexOf(start);
         if (i < 0) return ann;
         String before = line.substring(0, i); 
         i += start.length();
-        String line1 = line.stripTrailing();
-        if (!line1.endsWith(end)) return ann;
-        int j = line1.length() - end.length(); 
-        int k = i;
-        while (k < j && Character.isAlphabetic(line.charAt(k))) k++;
-        if (k < j && !Character.isWhitespace(line.charAt(k))) return ann;
-        String key = line.substring(i, k);
-        if (!VALID_ANNOTATIONS.contains(key)) return ann;
+        String line1 = line.substring(i).stripTrailing();
+        if (end.length() > 0) {
+            if (!line1.endsWith(end)) return ann;
+            line1 = line1.substring(0, line1.length() - end.length()).stripTrailing();
+        }
+        boolean found = false;
+        Iterator<String> iter = VALID_ANNOTATIONS.iterator();
+        String key = "";
+        while (!found && iter.hasNext()) {
+            key = iter.next();
+            if (line1.startsWith(key)) found = true;
+        }
+        if (!found) return ann;
+        if (key.length() < line1.length() && !Character.isWhitespace(line1.charAt(key.length()))) return ann;
         // Only a few annotations can have non-blank before
         if (!before.isBlank() && !NON_BLANK_BEFORE_OK.contains(key)) return ann;
         ann.isValid = true;
         ann.before = before;
         ann.key = key;
-        ann.args = line.substring(k, j).strip();
+        ann.args = line1.substring(key.length()).strip();
         return ann;
     }               
-
 
     private Language language;
     private List<Annotation> annotations = new ArrayList<>();
     private Set<String> keys = new HashSet<>();
     private Set<Path> solutions = new TreeSet<>();
     private Set<Path> hidden = new TreeSet<>();
+    private Set<Path> hiddenCallFiles = new TreeSet<>();
+    private Set<Path> hiddenTestFiles = new TreeSet<>();
 
     public Annotations(Language language) {
         this.language = language;
@@ -88,6 +104,12 @@ private void read(Path p, byte[] contents) {
                     solutions.add(p);
                 if (a.key.equals("HIDE")) 
                     hidden.add(p);
+                if (a.key.equals("CALL HIDDEN"))
+                    hiddenCallFiles.add(p); 
+                if (a.key.equals("HIDDEN")) {
+                    hiddenTestFiles.add(p); 
+                    hidden.add(p);
+                }
                 a.path = p;
                 annotations.add(a);
             }
@@ -102,7 +124,15 @@ public Set<Path> getHidden() {
         return Collections.unmodifiableSet(hidden);
     }
 
-    public String findUniqueKey(String key) {
+    public Set<Path> getHiddenCallFiles() {
+        return Collections.unmodifiableSet(hiddenCallFiles);
+    }
+
+    public Set<Path> getHiddenTestFiles() {
+        return Collections.unmodifiableSet(hiddenTestFiles);
+    }
+
+    public String findUnique(String key) {
         Annotation match = null;
         for (Annotation a : annotations) {
             if (a.key.equals(key)) {
@@ -123,7 +153,7 @@ else if (!match.args.equals(a.args)) {
         return match == null ? null : match.args;
     }
 
-    public List<String> findKeys(String key) {
+    public List<String> findAll(String key) {
         List<String> result = new ArrayList<>();
         for (Annotation a : annotations) 
             if (a.key.equals(key)) 
@@ -152,27 +182,24 @@ public double findUniqueDoubleKey(String key, double defaultValue) {
 
 
     public boolean checkConditions(Map<Path, String> submissionFiles, Report report) {
+        String[] delims = language.pseudoCommentDelimiters();
         for (Annotation a : annotations) {
             boolean forbidden = a.key.equals("FORBIDDEN");
             if (a.key.equals("REQUIRED") || forbidden) {
+                String nextLine = a.next;
+                String message = null;
+                if (nextLine.startsWith(delims[0]) && nextLine.endsWith(delims[1]))
+                    message = nextLine.substring(delims[0].length(), nextLine.length() - delims[1].length()).trim();
                 StringBuilder contents = new StringBuilder();
                 for (String line : Util.lines(submissionFiles.get(a.path))) {
-                    // TODO: Removing comments like this is language specific
-                    contents.append(line.replaceAll("//.*$", ""));
+                	String commentPattern = Pattern.quote(delims[0]) + ".*" + Pattern.quote(delims[1]);
+                    contents.append(line.replaceAll(commentPattern, ""));
                     contents.append(" ");
                 }
                 boolean found = Pattern.compile(a.args).matcher(contents).find();
-                if (found == forbidden) { // found && forbidden || !found && required
-                    String nextLine = a.next;
-                    String[] delims = language.pseudoCommentDelimiters();
-                    String message;
-                    if (nextLine.startsWith(delims[0]) && nextLine.endsWith(delims[1]))
-                        message = nextLine.substring(delims[0].length(), nextLine.length() - delims[1].length()).trim();
-                    else 
-                        message = (forbidden ? "Found " : "Did not find ") + a.args;
-                    report.error(a.path + ": " + message);
-                    return false;
-                }
+                boolean passed = found != forbidden; // found and required or not found and forbidden  
+            	report.condition(passed, forbidden, a.path, a.args, message);
+                if (!passed) return false;
             }
         }
         return true;
@@ -182,6 +209,10 @@ public boolean has(String key) {
         return keys.contains(key);
     }
 
+    /*
+     * TODO: It would be more robust if substitutions could only be
+     * in non-editable lines. 
+     */
     public Substitution findSubstitution() {
         Substitution sub = new Substitution(language);
         for (Annotation a : annotations) {
@@ -191,6 +222,7 @@ public Substitution findSubstitution() {
         return sub;
     }
 
+    // TODO: SAMPLE legacy?
     /**
      * Checks if a path is a sample
      * @param p the path without student/solution directory
@@ -205,9 +237,17 @@ public boolean isSample(Path p) {
 
     public Calls findCalls() {
         Calls calls = new Calls(language);
-        for (Annotation a : annotations) {
-            if (a.key.equals("CALL"))
-                calls.addCall(a.path, a.args, a.next);
+        int callNum = 0; 
+        for (int a=0; a<annotations.size(); a++) {
+            if (annotations.get(a).key.equals("CALL")) {
+                 calls.addCall(annotations.get(a).path, annotations.get(a).args, annotations.get(a).next);
+                 callNum += 1; 
+            }
+            else if (annotations.get(a).key.equals("CALL HIDDEN")) {
+                calls.addCall(annotations.get(a).path, annotations.get(a).args, annotations.get(a).next);
+                calls.getCall(callNum).setHidden(true);
+                callNum += 1; 
+            }
         }
         return calls;
     }

app/com/horstmann/codecheck/AsExpected.java

@@ -14,10 +14,10 @@ public class AsExpected {
     public AsExpected(Comparison comp) {
         this.comp = comp;
     }
-    
-        // Scoring doesn't work when outerr contains an exception report because we don't know how many
-        // test cases have not occurred. 
-        // Need to count the number of expected cases in the file 
+
+    // Scoring doesn't work when outerr contains an exception report because we don't know how many
+    // test cases have not occurred. 
+    // Need to count the number of expected cases in the file 
 
     public static int expectedTests(String contents) { // TODO: Shouldn't this be in Language?
         Pattern expecteds = Pattern.compile("Expected: "); // TODO: What if this is commented out? 
@@ -66,7 +66,7 @@ public void eval(String value, Report report, Score score, String tester) {
                 report.output(value);
                 report.error("Missing \"Expected: ...\"\n");
             } else {
-                report.output(lines, matches, mismatches);
+            	report.output(lines, matches, mismatches);
             }
             // If the program run ends in an exception, it can happen that the number of
             // actual vs. expected values is less than it should be. In that case,

app/com/horstmann/codecheck/BashLanguage.java

@@ -0,0 +1,54 @@
+package com.horstmann.codecheck;
+
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class BashLanguage implements Language {
+
+    @Override
+    public String getExtension() {
+        return "sh";
+    }
+
+    @Override
+    public boolean isMain(Path filename, String contents) {
+    	return moduleOf(filename).matches("main|tester[0-9]*"); 
+    }
+
+    @Override
+    public String[] pseudoCommentDelimiters() {
+        return new String[] { "##", "" };
+    }
+
+    private static Pattern VARIABLE_PATTERN = Pattern.compile("^\\s*(?<name>[A-Za-z][A-Za-z0-9_]*)=(?<rhs>.*)$");
+    @Override public Pattern variableDeclPattern() { return VARIABLE_PATTERN; }
+
+    private static Pattern FUNCTION_PATTERN = Pattern.compile("^\\s*function\\s+(?<name>[A-Za-z][A-Za-z0-9_]*).*");
+    @Override
+    public String functionName(String declaration) { 
+    	Matcher matcher = FUNCTION_PATTERN.matcher(declaration);
+    	if (matcher.matches()) return matcher.group("name");
+    	else return null;
+    }
+
+    @Override
+    public Map<Path, String> writeTester(Path file, String contents, List<Calls.Call> calls, ResourceLoader resourceLoader) {
+
+        String moduleName = moduleOf(file);
+        String result = contents + "\n";
+        result += "case $1 in\n";
+        for (int k = 0; k < calls.size(); k++) {
+            Calls.Call call = calls.get(k);
+            result += "  " + (k + 1) + ")\n    " + call.name + " " + call.args + "\n    ;;\n";
+        }
+        result += "esac\n";
+
+        Map<Path, String> paths = new HashMap<>();
+        paths.put(pathOf(moduleName + "CodeCheck"), result);
+        return paths;
+    }
+}

app/com/horstmann/codecheck/CLanguage.java

@@ -22,7 +22,7 @@ public boolean isSource(Path p) {
     private static Pattern MAIN_PATTERN = Pattern.compile("\\s*((int|void)\\s+)?main\\s*\\([^)]*\\)\\s*(\\{\\s*)?");
     @Override public Pattern mainPattern() { return MAIN_PATTERN; }
 
-    private static Pattern VARIABLE_PATTERN = Pattern.compile(".*\\S\\s+(?<name>[A-Za-z][A-Za-z0-9]*)(\\s*[*\\[\\]]+)?\\s*=\\s*(?<rhs>[^;]+);.*");
+    private static Pattern VARIABLE_PATTERN = Pattern.compile(".*\\S\\s+(?<name>[A-Za-z][A-Za-z0-9_]*)(\\s*[*\\[\\]]+)?\\s*=\\s*(?<rhs>[^;]+);.*");
     @Override public Pattern variableDeclPattern() { return VARIABLE_PATTERN; }
 
     private static Pattern ERROR_PATTERN = Pattern.compile(".+/(?<file>[^/]+\\.cpp):(?<line>[0-9]+):(?<col>[0-9]+): error: (?<msg>.+)");

app/com/horstmann/codecheck/CSharpLanguage.java

@@ -7,12 +7,8 @@ public class CSharpLanguage implements Language {
     public String getExtension() {
         return "cs";
     }
-
-    private static String patternString = ".*\\S\\s+(\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)\\s*=\\s*(?<rhs>[^;]+);.*";
-    private static Pattern pattern = Pattern.compile(patternString);
-
-    @Override
-    public Pattern variableDeclPattern() {
-        return pattern;
-    }
+
+    private static Pattern VARIABLE_DECL_PATTERN = Pattern.compile(
+        	".*\\S\\s+(\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)\\s*=\\s*(?<rhs>[^;]+);");
+    @Override public Pattern variableDeclPattern() { return VARIABLE_DECL_PATTERN; }
 }

app/com/horstmann/codecheck/CallMethod.java

@@ -174,7 +174,7 @@ public void run(Path dir, Report report, Score score) throws Exception {
         } finally {
             loader.close();
         }
-        report.runTable(null, new String[] { "Arguments" }, args, actual, expected, outcomes);
+        report.runTable(null, new String[] { "Arguments" }, args, actual, expected, outcomes, null, null);
     }
 
     private boolean compare(Object a, Object b) {