refactor(generator): scope overrides

4 files changed, 200 insertions, 63 deletions

diff --git a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
index 6c1d105d..b33fce23 100644
--- a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
+++ b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
@@ -11,16 +11,10 @@ import com.google.inject.Inject;
 import org.eclipse.emf.ecore.resource.Resource;
 import tools.refinery.generator.ModelGeneratorFactory;
 import tools.refinery.generator.ProblemLoader;
-import tools.refinery.language.model.problem.Problem;
-import tools.refinery.language.model.problem.Relation;
-import tools.refinery.language.model.problem.ScopeDeclaration;
 
-import java.io.ByteArrayOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 
@@ -32,15 +26,15 @@ public class GenerateCommand {
         @Inject
         private ModelGeneratorFactory generatorFactory;
 
-        private String problemPath;
+        private String inputPath;
         private String outputPath = "-";
         private List<String> scopes = new ArrayList<>();
         private List<String> overrideScopes = new ArrayList<>();
         private long randomSeed = 1;
 
-        @Parameter(description = "Input path", required = true)
-        public void setProblemPath(String problemPath) {
-                this.problemPath = problemPath;
+        @Parameter(description = "input path", required = true)
+        public void setInputPath(String inputPath) {
+                this.inputPath = inputPath;
         }
 
         @Parameter(names = {"-output", "-o"}, description = "Output path")
@@ -64,14 +58,15 @@ public class GenerateCommand {
         }
 
         public void run() throws IOException {
-                var problem = addScopeConstraints(loader.loadFile(problemPath));
+                var problem = isStandardStream(inputPath) ? loader.loadStream(System.in) : loader.loadFile(inputPath);
+                problem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
                 var generator = generatorFactory.createGenerator(problem);
                 generator.setRandomSeed(randomSeed);
                 generator.generate();
                 var solution = generator.serializeSolution();
                 var solutionResource = solution.eResource();
                 var saveOptions = Map.of();
-                if (outputPath == null || outputPath.equals("-")) {
+                if (isStandardStream(outputPath)) {
                         printSolution(solutionResource, saveOptions);
                 } else {
                         try (var outputStream = new FileOutputStream(outputPath)) {
@@ -80,57 +75,8 @@ public class GenerateCommand {
                 }
         }
 
-        private Problem addScopeConstraints(Problem problem) throws IOException {
-                var allScopes = new ArrayList<>(scopes);
-                allScopes.addAll(overrideScopes);
-                if (allScopes.isEmpty()) {
-                        return problem;
-                }
-                int originalStatementCount = problem.getStatements().size();
-                var builder = new StringBuilder();
-                var problemResource = problem.eResource();
-                try (var outputStream = new ByteArrayOutputStream()) {
-                        problemResource.save(outputStream, Map.of());
-                        builder.append(outputStream.toString(StandardCharsets.UTF_8));
-                }
-                builder.append('\n');
-                for (var scope : allScopes) {
-                        builder.append("scope ").append(scope).append(".\n");
-                }
-                var modifiedProblem = loader.loadString(builder.toString(), problemResource.getURI());
-                var modifiedStatements = modifiedProblem.getStatements();
-                int modifiedStatementCount = modifiedStatements.size();
-                if (modifiedStatementCount != originalStatementCount + allScopes.size()) {
-                        throw new IllegalStateException("Failed to parse scope constraints");
-                }
-                // Override scopes remove any scope constraint from the original problem with the same target type.
-                var overriddenScopes = new HashSet<Relation>();
-                for (int i = modifiedStatementCount - overrideScopes.size(); i < modifiedStatementCount; i++) {
-                        var statement = modifiedStatements.get(i);
-                        if (!(statement instanceof ScopeDeclaration scopeDeclaration)) {
-                                throw new IllegalStateException("Invalid scope constraint: " + statement);
-                        }
-                        for (var typeScope : scopeDeclaration.getTypeScopes()) {
-                                overriddenScopes.add(typeScope.getTargetType());
-                        }
-                }
-                int statementIndex = 0;
-                var iterator = modifiedStatements.iterator();
-                // Scope overrides only affect type scopes from the original problem and leave type scopes added on the
-                // command line intact.
-                while (statementIndex < originalStatementCount && iterator.hasNext()) {
-                        var statement = iterator.next();
-                        if (statement instanceof ScopeDeclaration scopeDeclaration) {
-                                var typeScopes = scopeDeclaration.getTypeScopes();
-                                typeScopes.removeIf(typeScope -> overriddenScopes.contains(typeScope.getTargetType()));
-                                // Scope declarations with no type scopes are invalid, so we have to remove them.
-                                if (typeScopes.isEmpty()) {
-                                        iterator.remove();
-                                }
-                        }
-                        statementIndex++;
-                }
-                return modifiedProblem;
+        private boolean isStandardStream(String path) {
+                return path == null || path.equals("-");
         }
 
         // We deliberately write to the standard output if no output path is specified.
diff --git a/subprojects/generator/build.gradle.kts b/subprojects/generator/build.gradle.kts
index d87ce6de..f78fee4d 100644
--- a/subprojects/generator/build.gradle.kts
+++ b/subprojects/generator/build.gradle.kts
@@ -12,4 +12,5 @@ dependencies {
         api(project(":refinery-language-semantics"))
         api(libs.eclipseCollections.api)
         implementation(project(":refinery-store-query-interpreter"))
+        testImplementation(testFixtures(project(":refinery-language")))
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
index abfbe7e6..20ea8132 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ProblemLoader.java
@@ -17,11 +17,18 @@ import org.eclipse.xtext.util.LazyStringInputStream;
 import org.eclipse.xtext.validation.CheckMode;
 import org.eclipse.xtext.validation.IResourceValidator;
 import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.model.problem.ScopeDeclaration;
 import tools.refinery.store.util.CancellationToken;
 
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
 import java.util.Map;
 
 public class ProblemLoader {
@@ -104,4 +111,58 @@ public class ProblemLoader {
                 }
                 return problem;
         }
+
+        public Problem loadScopeConstraints(Problem problem, List<String> extraScopes,
+                                                                                List<String> overrideScopes) throws IOException {
+                var allScopes = new ArrayList<>(extraScopes);
+                allScopes.addAll(overrideScopes);
+                if (allScopes.isEmpty()) {
+                        return problem;
+                }
+                int originalStatementCount = problem.getStatements().size();
+                var builder = new StringBuilder();
+                var problemResource = problem.eResource();
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        problemResource.save(outputStream, Map.of());
+                        builder.append(outputStream.toString(StandardCharsets.UTF_8));
+                }
+                builder.append('\n');
+                for (var scope : allScopes) {
+                        builder.append("scope ").append(scope).append(".\n");
+                }
+                var modifiedProblem = loadString(builder.toString(), problemResource.getURI());
+                var modifiedStatements = modifiedProblem.getStatements();
+                int modifiedStatementCount = modifiedStatements.size();
+                if (modifiedStatementCount != originalStatementCount + allScopes.size()) {
+                        throw new IllegalArgumentException("Failed to parse scope constraints");
+                }
+                // Override scopes remove any scope constraint from the original problem with the same target type.
+                var overriddenScopes = new HashSet<Relation>();
+                for (int i = modifiedStatementCount - overrideScopes.size(); i < modifiedStatementCount; i++) {
+                        var statement = modifiedStatements.get(i);
+                        if (!(statement instanceof ScopeDeclaration scopeDeclaration)) {
+                                throw new IllegalStateException("Invalid scope constraint: " + statement);
+                        }
+                        for (var typeScope : scopeDeclaration.getTypeScopes()) {
+                                overriddenScopes.add(typeScope.getTargetType());
+                        }
+                }
+                int statementIndex = 0;
+                var iterator = modifiedStatements.iterator();
+                // Scope overrides only affect type scopes from the original problem and leave type scopes added on the
+                // command line intact.
+                while (statementIndex < originalStatementCount && iterator.hasNext()) {
+                        var statement = iterator.next();
+                        if (statement instanceof ScopeDeclaration scopeDeclaration) {
+                                var typeScopes = scopeDeclaration.getTypeScopes();
+                                typeScopes.removeIf(typeScope -> overriddenScopes.contains(typeScope.getTargetType()));
+                                // Scope declarations with no type scopes are invalid, so we have to remove them.
+                                if (typeScopes.isEmpty()) {
+                                        iterator.remove();
+                                }
+                        }
+                        statementIndex++;
+                }
+                return modifiedProblem;
+        }
 }
diff --git a/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java b/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java
new file mode 100644
index 00000000..0c0db105
--- /dev/null
+++ b/subprojects/generator/src/test/java/tools/refinery/generator/ProblemLoaderTest.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.generator;
+
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemInjectorProvider.class)
+class ProblemLoaderTest {
+        private static final String PREFIX = """
+                        class Foo.
+                        class Bar.
+                        """;
+
+        @Inject
+        private ProblemLoader loader;
+
+        @ParameterizedTest
+        @MethodSource
+        void loadScopeConstraintsTest(String originalScopes, List<String> scopes, List<String> overrideScopes,
+                                                                  String expectedScopes) throws IOException {
+                var problem = loader.loadString(PREFIX + originalScopes);
+                var modifiedProblem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
+                String serializedProblem;
+                try (var outputStream = new ByteArrayOutputStream()) {
+                        modifiedProblem.eResource().save(outputStream, Map.of());
+                        serializedProblem = outputStream.toString(StandardCharsets.UTF_8);
+                }
+                assertThat(serializedProblem, is(PREFIX + expectedScopes));
+        }
+
+        static Stream<Arguments> loadScopeConstraintsTest() {
+                return Stream.of(Arguments.of("",
+                                List.of(),
+                                List.of(),
+                                ""), Arguments.of("",
+                                List.of("node=5..10"),
+                                List.of(), """
+
+                                                scope node=5..10.
+                                                """), Arguments.of("",
+                                List.of("Foo=2", "Bar=3"),
+                                List.of(), """
+
+                                                scope Foo=2.
+                                                scope Bar=3.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of("node=5..10"),
+                                List.of(), """
+                                                scope Foo = 1, Bar = 1.
+
+                                                scope node=5..10.
+                                                """), Arguments.of("""
+                                                scope Foo = 0..10, Bar = 1.
+                                                """,
+                                List.of("Foo = 5"),
+                                List.of(), """
+                                                scope Foo = 0..10, Bar = 1.
+
+                                                scope Foo = 5.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("node=5..10"), """
+                                                scope Foo = 1, Bar = 1.
+
+                                                scope node=5..10.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Foo=3..4"), """
+                                                scope Bar = 1.
+
+                                                scope Foo=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of("Foo=2"),
+                                List.of("Foo=3..4"), """
+                                                scope Bar = 1.
+
+                                                scope Foo=2.
+                                                scope Foo=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1.
+                                                scope Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Bar=3..4"), """
+                                                scope Foo = 1.
+
+
+                                                scope Bar=3..4.
+                                                """), Arguments.of("""
+                                                scope Foo = 1, Bar = 1.
+                                                """,
+                                List.of(),
+                                List.of("Foo=3..4", "Bar=4..5"), """
+
+                                                scope Foo=3..4.
+                                                scope Bar=4..5.
+                                                """));
+        }
+}