cooking with gas

Author: wisebaldone

build.gradle

@@ -48,19 +48,15 @@ dependencies {
     implementation 'com.github.therapi:therapi-runtime-javadoc:0.15.0'
     implementation 'com.github.therapi:therapi-runtime-javadoc-scribe:0.15.0'
     implementation 'info.picocli:picocli:4.7.7'
-    implementation 'io.reactivex.rxjava3:rxjava:3.1.12'
     implementation 'com.google.code.gson:gson:2.13.2'
     implementation 'com.google.guava:guava:33.5.0-jre'
-    implementation 'org.apache.logging.log4j:log4j-api:2.13.1'
-    implementation 'org.apache.logging.log4j:log4j-core:2.13.1'
     implementation 'com.google.dagger:dagger:2.57.2'
     implementation 'com.github.bsommerfeld.jshepherd:core:3.3.2'
     implementation 'com.github.bsommerfeld.jshepherd:yaml:3.3.2'
     implementation 'com.google.flogger:flogger:0.9'
     implementation 'com.google.flogger:flogger-system-backend:0.9'
     implementation 'org.pitest:pitest:1.20.6'
     implementation 'org.pitest:pitest-entry:1.20.6'
-    implementation 'org.pitest:pitest-html-report:1.20.6'
 
     // Annotations
     annotationProcessor 'com.google.dagger:dagger-compiler:2.57.2'

src/chalkbox/commands/Grade.java

@@ -0,0 +1,80 @@
+package chalkbox.commands;
+
+import chalkbox.config.Config;
+import chalkbox.source.Solution;
+import chalkbox.source.Submission;
+import chalkbox.stages.Result;
+import chalkbox.stages.Stage;
+import chalkbox.stages.StageException;
+import chalkbox.stages.StageResult;
+import chalkbox.stages.ai.Ai;
+import chalkbox.stages.header.Header;
+import com.google.common.flogger.FluentLogger;
+import de.bsommerfeld.jshepherd.core.ConfigurationLoader;
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Mixin;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+@Command(name = "grade",
+        description = "Runs a sequence of stages and generates a Gradescope submission result")
+public class Grade implements Runnable {
+    private static final FluentLogger logger = FluentLogger.forEnclosingClass();
+
+    @CommandLine.Option(names = { "--stages" }, required = true, description = "Comma seperated stages to run")
+    public String stages;
+
+    @Mixin Shared shared = new Shared();
+
+    @Override
+    public void run() {
+        Path configFile = Paths.get(shared.configFile);
+        var config = ConfigurationLoader.load(configFile, Config::new);
+
+        logger.atInfo().log("Running the following stages: " + String.join(" ,", stages));
+
+        //todo(mh): Config this
+        var solution = new Solution("./test/resources/csse2002/solutions/correct",
+                "./test/resources/csse2002/lib/junit-4.12.jar");
+        var submission = new Submission(shared.submissionPath, "./test/resources/csse2002/lib/junit-4.12.jar");
+
+        // for each stage in the config
+        var stages = this.stages.split(",");
+        for (var name : stages) {
+            var stage = getStage(name, config);
+            if (stage == null) {
+                logger.atWarning().log("Unable to find stage for " + name);
+                continue;
+            }
+            StageResult result = null;
+            try {
+                switch (stage.getType()) {
+                    case SUBMISSION_ONLY -> result = stage.run(submission);
+                    case SUBMISSION_AND_SOLUTION -> result = stage.run(submission, solution);
+                }
+            } catch (StageException e) {
+                result = StageResult.fromOverview(new Result(stage.getName()));
+            }
+
+            logger.atInfo().log(stage.getName());
+            if (result == null) {
+                continue;
+            }
+            logger.atInfo().log(result.overview().getOutput());
+        }
+    }
+
+    private Stage getStage(String name, Config config) {
+        return switch (name) {
+            case "header" -> new Header();
+            case "ai" -> new Ai();
+            case "codestyle" -> config.toCodestyle();
+            case "conformance" -> config.toConformance();
+            case "functionality" -> config.toFunctionality();
+            case "mutation" -> config.toMutation();
+            default -> null;
+        };
+    }
+}

src/chalkbox/commands/Run.java

@@ -5,7 +5,7 @@
 
 @Command(name = "run",
         description = "Run one of the supported commands: CheckStyle, Conformance, Functionality, Mutation",
-        subcommands = { Conformance.class, CodeStyle.class, Functionality.class, Mutation.class, CommandLine.HelpCommand.class })
+        subcommands = { Grade.class, Conformance.class, CodeStyle.class, Functionality.class, Mutation.class, CommandLine.HelpCommand.class })
 public class Run implements Runnable {
 
     @Override

src/chalkbox/source/Source.java

@@ -11,6 +11,7 @@
 import java.io.IOException;
 import java.io.StringWriter;
 import java.net.*;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;

src/chalkbox/source/SourceNotCompiled.java

@@ -1,9 +1,22 @@
 package chalkbox.source;
 
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
 public class Submission extends Source {
 
     public Submission(String baseDirectory, String classPath) {
         super("submission", baseDirectory, classPath);
     }
 
+    public String getAiDeclaration() {
+        try {
+            return Files.readString(Path.of(getBasePath() + "/ai/" + "README.txt"), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            return "";
+        }
+    }
+
 }

src/chalkbox/source/Submission.java

@@ -6,6 +6,10 @@
 import java.util.List;
 
 public interface Stage {
+    String getName();
+
+    Type getType();
+
     StageResult run(Submission submission) throws StageException;
 
     StageResult run(Submission submission, Solution solution) throws StageException;

src/chalkbox/stages/Stage.java

@@ -0,0 +1,7 @@
+package chalkbox.stages;
+
+public enum Type {
+    SUBMISSION_ONLY,
+    SUBMISSION_AND_SOLUTION,
+    SUBMISSION_AND_MULTIPLE_SOLUTIONS
+}

src/chalkbox/stages/Type.java

@@ -0,0 +1,57 @@
+package chalkbox.stages.ai;
+
+import chalkbox.source.Solution;
+import chalkbox.source.Submission;
+import chalkbox.stages.*;
+
+import java.util.List;
+
+public class Ai implements Stage {
+    @Override
+    public String getName() {
+        return "Ai Declaration";
+    }
+
+    @Override
+    public Type getType() {
+        return Type.SUBMISSION_ONLY;
+    }
+
+    @Override
+    public StageResult run(Submission submission) throws StageException {
+        var result = new Result("Info")
+                        .setStatus(Status.PASSED)
+                        .setVisibility(Visibility.VISIBLE)
+                        .setOutputFormat("HTML");
+
+        var declaration = submission.getAiDeclaration();
+        if (declaration.isEmpty()) {
+            result.appendOutput("<p>You have not declared if you have or have not used Ai</p>");
+            result.setStatus(Status.FAILED);
+        } else {
+            if (declaration.contains("No generative AI tools were utilised")) {
+                result.appendOutput("<p><span style=\"color: blue; font-size: 20px;\">&#x1F6C8;</span> You have declared that you did not use Ai in your submission</p>\n");
+            } else {
+                result.appendOutput("<p><span style=\"color: blue; font-size: 20px;\">&#x1F6C8;</span> You have declared that you <b>did<b> use Ai in your submission</p>\n");
+            }
+            result.appendOutput(String.format("""
+                        <h2>Ai Declaration</h2>
+                        <code>
+                        %s
+                        </code>
+                        """, declaration));
+        }
+
+        return StageResult.fromOverview(result);
+    }
+
+    @Override
+    public StageResult run(Submission submission, Solution solution) throws StageException {
+        return null;
+    }
+
+    @Override
+    public StageResult run(Submission submission, List<Solution> solutions) throws StageException {
+        return null;
+    }
+}

src/chalkbox/stages/ai/Ai.java

@@ -3,13 +3,9 @@
 import chalkbox.api.common.Execution;
 import chalkbox.api.common.ProcessExecution;
 import chalkbox.source.Solution;
-import chalkbox.stages.Result;
-import chalkbox.stages.Stage;
-import chalkbox.stages.StageException;
+import chalkbox.stages.*;
 import chalkbox.source.Submission;
-import chalkbox.stages.StageResult;
 import com.google.common.flogger.FluentLogger;
-import org.apache.logging.log4j.util.Strings;
 
 import java.io.IOException;
 import java.net.URI;
@@ -43,6 +39,16 @@ public CodeStyle(int weighting, float penaltyPerInfraction, List<String> exclude
         this.excludedFiles = excludedFiles;
     }
 
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Type getType() {
+        return Type.SUBMISSION_ONLY;
+    }
+
     public CodeStyle overrideCheckstyleConfig(String filePath) {
         this.customCheckstyleConfig = filePath;
         return this;
@@ -82,7 +88,7 @@ public StageResult run(Submission submission) throws StageException {
         processArgs.add(customCheckstyleConfig.isEmpty() ? checkstyleConfig : customCheckstyleConfig);
         processArgs.addAll(generateExcludedArgs(excludedFiles));
         processArgs.add(submission.getSrcFolder());
-        logger.atInfo().log("Running CheckStyle %s", Strings.join(processArgs, ' '));
+        logger.atInfo().log("Running CheckStyle %s", String.join(" ", processArgs));
 
         // todo(mh): Change this to # * timeunit.Seconds or likewise
         ProcessExecution process = null;