Use JSON to configure CLI

5 files changed, 61 insertions, 69 deletions

diff --git a/src/main/java/org/zwobble/couscous/CouscousCompiler.java b/src/main/java/org/zwobble/couscous/CouscousCompiler.java
index 4822d97..714ac66 100644
--- a/src/main/java/org/zwobble/couscous/CouscousCompiler.java
+++ b/src/main/java/org/zwobble/couscous/CouscousCompiler.java
@@ -7,6 +7,8 @@ import java.io.IOException;
 import java.nio.file.Path;
 import java.util.List;
 
+import static org.zwobble.couscous.util.ExtraLists.list;
+
 public class CouscousCompiler {
     private final JavaFrontend frontend;
     private final Backend backend;
@@ -17,7 +19,7 @@ public class CouscousCompiler {
     }
 
     public void compileDirectory(List<Path> sourcePaths, Path path) throws IOException {
-        List<TypeNode> classes = frontend.readSourceDirectory(sourcePaths, path);
+        List<TypeNode> classes = frontend.readSourceDirectory(sourcePaths, list(path));
         backend.compile(classes);
     }
 
diff --git a/src/main/java/org/zwobble/couscous/cli/CouscousCli.java b/src/main/java/org/zwobble/couscous/cli/CouscousCli.java
index 8a9b6da..f363384 100644
--- a/src/main/java/org/zwobble/couscous/cli/CouscousCli.java
+++ b/src/main/java/org/zwobble/couscous/cli/CouscousCli.java
@@ -1,5 +1,8 @@
 package org.zwobble.couscous.cli;
 
+import com.eclipsesource.json.Json;
+import com.eclipsesource.json.JsonObject;
+import com.eclipsesource.json.JsonValue;
 import org.apache.commons.cli.*;
 import org.zwobble.couscous.Backend;
 import org.zwobble.couscous.ast.TypeNode;
@@ -7,6 +10,7 @@ import org.zwobble.couscous.backends.csharp.CsharpBackend;
 import org.zwobble.couscous.backends.python.PythonBackend;
 import org.zwobble.couscous.frontends.java.JavaFrontend;
 
+import java.io.FileReader;
 import java.io.IOException;
 import java.nio.file.FileSystems;
 import java.nio.file.Path;
@@ -16,37 +20,32 @@ import static java.util.Arrays.asList;
 import static org.zwobble.couscous.util.ExtraLists.*;
 
 public class CouscousCli {
+    public static final String FILES = "files";
     public static final String SOURCEPATH = "sourcepath";
     public static final String BACKEND = "backend";
     public static final String OUTPUT = "output";
 
     public static void main(String[] rawArguments) throws Exception {
-        CommandLine arguments = parseArguments(rawArguments);
+        JsonObject configuration = Json.parse(new FileReader("couscous.json")).asObject();
+        String backendName = configuration.get(BACKEND).asString();
+        String outputDirectory = configuration.get(OUTPUT).asString();
+        List<String> sourcePaths = eagerMap(
+            configuration.get(SOURCEPATH).asArray().values(),
+            JsonValue::asString);
+        List<String> files = eagerMap(
+            configuration.get(FILES).asArray().values(),
+            JsonValue::asString);
 
-        JavaFrontend frontend = new JavaFrontend();
-        List<TypeNode> classNodes = eagerFlatMap(
-            arguments.getArgList(),
-            path -> {
-                try {
-                    return frontend.readSourceDirectory(
-                        eagerMap(sourcePath(arguments), sourcePath -> path(sourcePath)),
-                        path(path));
-                } catch (IOException exception) {
-                    throw new RuntimeException(exception);
-                }
-            });
-
-        Backend backend = backend(
-            arguments.getOptionValue(BACKEND),
-            arguments.getOptionValue(OUTPUT));
-        backend.compile(classNodes);
-    }
+        Backend backend = backend(backendName, outputDirectory);
 
-    private static List<String> sourcePath(CommandLine arguments) {
-        if (arguments.hasOption(SOURCEPATH)) {
-            return asList(arguments.getOptionValues(SOURCEPATH));
-        } else {
-            return list();
+        JavaFrontend frontend = new JavaFrontend();
+        try {
+            List<TypeNode> classNodes = frontend.readSourceDirectory(
+                paths(sourcePaths),
+                paths(files));
+            backend.compile(classNodes);
+        } catch (IOException exception) {
+            throw new RuntimeException(exception);
         }
     }
 
@@ -61,31 +60,11 @@ public class CouscousCli {
         }
     }
 
-    private static Path path(String output) {
-        return FileSystems.getDefault().getPath(output);
+    private static List<Path> paths(List<String> paths) {
+        return eagerMap(paths, path -> path(path));
     }
 
-    private static CommandLine parseArguments(String[] rawArguments) throws ParseException {
-        Options options = new Options();
-        options.addOption(requiredOption(BACKEND));
-        options.addOption(requiredOption(OUTPUT));
-        options.addOption(multipleOption(SOURCEPATH));
-
-        return new DefaultParser().parse(options, rawArguments);
-    }
-
-    private static Option requiredOption(String name) {
-        return Option.builder()
-            .longOpt(name)
-            .required()
-            .hasArg()
-            .build();
-    }
-
-    private static Option multipleOption(String name) {
-        return Option.builder()
-            .longOpt(name)
-            .hasArgs()
-            .build();
+    private static Path path(String output) {
+        return FileSystems.getDefault().getPath(output);
     }
 }
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
index 9925068..b633093 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaFrontend.java
@@ -1,34 +1,40 @@
 package org.zwobble.couscous.frontends.java;
 
 import com.google.common.collect.Multimaps;
-import org.zwobble.couscous.ast.*;
+import org.zwobble.couscous.ast.Node;
+import org.zwobble.couscous.ast.TypeNode;
+import org.zwobble.couscous.ast.VariableDeclaration;
+import org.zwobble.couscous.ast.VariableNode;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 import static org.zwobble.couscous.ast.structure.NodeStructure.descendantNodesAndSelf;
 import static org.zwobble.couscous.util.Casts.tryCast;
+import static org.zwobble.couscous.util.ExtraIterables.iterable;
 import static org.zwobble.couscous.util.ExtraLists.eagerFlatMap;
-import static org.zwobble.couscous.util.ExtraLists.flatMap;
-import static org.zwobble.couscous.util.ExtraLists.list;
 import static org.zwobble.couscous.util.ExtraStreams.toStream;
 
 public class JavaFrontend {
-    public List<TypeNode> readSourceDirectory(List<Path> sourcePaths, Path directoryPath) throws IOException {
-        List<TypeNode> classNodes = flatMap(
-            findJavaFiles(directoryPath),
-            javaFile -> JavaReader.readClassesFromFiles(sourcePaths, list(javaFile)));
+    public List<TypeNode> readSourceDirectory(List<Path> sourcePaths, List<Path> sourceFiles) throws IOException {
+        List<Path> expandedSourceFiles = eagerFlatMap(sourceFiles, this::findJavaFiles);
+        List<TypeNode> classNodes = JavaReader.readClassesFromFiles(sourcePaths, expandedSourceFiles);
         ensureDeclarationsAreUnique(classNodes);
         return classNodes;
     }
 
-    private Stream<Path> findJavaFiles(Path directoryPath) throws IOException {
-        return Files.walk(directoryPath)
-            .filter(path -> path.toFile().isFile() && path.toString().endsWith(".java"));
+    private Iterable<Path> findJavaFiles(Path directoryPath) {
+        return iterable(() -> {
+            try {
+                return Files.walk(directoryPath)
+                    .filter(path -> path.toFile().isFile() && path.toString().endsWith(".java"));
+            } catch (IOException exception) {
+                throw new RuntimeException(exception);
+            }
+        });
     }
 
     private void ensureDeclarationsAreUnique(List<TypeNode> classNodes) {
diff --git a/src/main/java/org/zwobble/couscous/frontends/java/JavaParser.java b/src/main/java/org/zwobble/couscous/frontends/java/JavaParser.java
index e1addd3..e97d853 100644
--- a/src/main/java/org/zwobble/couscous/frontends/java/JavaParser.java
+++ b/src/main/java/org/zwobble/couscous/frontends/java/JavaParser.java
@@ -25,6 +25,9 @@ public class JavaParser {
     
     public JavaParser() {
         parser = ASTParser.newParser(AST.JLS8);
+    }
+    
+    public CompilationUnit parseCompilationUnit(List<Path> sourcePaths, Path sourcePath) throws IOException {
         parser.setBindingsRecovery(false);
         parser.setKind(ASTParser.K_COMPILATION_UNIT);
         @SuppressWarnings("unchecked")
@@ -34,9 +37,6 @@ public class JavaParser {
         options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_8);
         parser.setCompilerOptions(options);
         parser.setResolveBindings(true);
-    }
-    
-    public CompilationUnit parseCompilationUnit(List<Path> sourcePaths, Path sourcePath) throws IOException {
         parser.setUnitName(sourcePath.toString());
 
         String[] sourcePathArguments = Iterables.toArray(
diff --git a/src/main/java/org/zwobble/couscous/util/ExtraIterables.java b/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
index cd9b3df..a77869d 100644
--- a/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
+++ b/src/main/java/org/zwobble/couscous/util/ExtraIterables.java
@@ -5,6 +5,7 @@ import com.google.common.collect.Iterables;
 import java.util.Iterator;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
@@ -105,15 +106,19 @@ public class ExtraIterables {
     }
 
     public static <T, R> Iterable<R> lazyFlatMap(Iterable<T> iterable, Function<T, Iterable<R>> function) {
-        return new Iterable<R>() {
-            @Override
-            public Iterator<R> iterator() {
-                return stream(iterable).flatMap(element -> stream(function.apply(element))).iterator();
-            }
-        };
+        return iterable(() -> stream(iterable).flatMap(element -> stream(function.apply(element))));
     }
 
     public static <T> Stream<T> stream(Iterable<T> iterable) {
         return StreamSupport.stream(iterable.spliterator(), false);
     }
+
+    public static <T, E> Iterable<T> iterable(Supplier<Stream<T>> stream) {
+        return new Iterable<T>() {
+            @Override
+            public Iterator<T> iterator() {
+                return stream.get().iterator();
+            }
+        };
+    }
 }