Isolated updates

bin/build.gradle

@@ -27,6 +27,7 @@ mainClassName = 'io.github.alechenninger.monarch.Main'
 dependencies {
   compile 'org.yaml:snakeyaml:1.16'
   compile 'net.sourceforge.argparse4j:argparse4j:0.7.0'
+  compile 'com.google.guava:guava:19.0'
   compile project(':monarch-lib')
   testCompile 'org.codehaus.groovy:groovy:2.4.5'
   testCompile 'junit:junit:4.12'

bin/src/io/github/alechenninger/monarch/Main.java

@@ -26,10 +26,10 @@
 import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.Yaml;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
-import java.nio.charset.Charset;
 import java.nio.file.FileSystem;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
@@ -42,8 +42,6 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
@@ -60,8 +58,6 @@ public class Main {
 
   private final MonarchArgParser parser;
 
-  private static final Charset UTF_8 = Charset.forName("UTF-8");
-
   public Main(Monarch monarch, Yaml yaml, String defaultConfigPath, FileSystem fileSystem,
       MonarchParsers parsers, OutputStream consoleOut) {
     this.monarch = monarch;
@@ -140,15 +136,15 @@ public int run(String... args) {
             .orElseThrow(missingOptionException("data directory"));
         Hierarchy hierarchy = options.hierarchy()
             .orElseThrow(missingOptionException("hierarchy"));
-        SourceSpec target = options.target()
+        SourceSpec targetSpec = options.target()
             .orElseThrow(missingOptionException("target"));
 
-        Map<String, Map<String, Object>> currentData =
+        Map<String, SourceData> currentData =
             parsers.parseDataSourcesInHierarchy(dataDir, hierarchy);
-        Source source = hierarchy.sourceFor(target).orElseThrow(
-            () -> new IllegalArgumentException("Target source not found in hierarchy: " + target));
+        Source target = hierarchy.sourceFor(targetSpec).orElseThrow(
+            () -> new IllegalArgumentException("Target source not found in hierarchy: " + targetSpec));
 
-        applyChanges(outputDir, options.changes(), options.mergeKeys(), currentData, source);
+        applyChanges(outputDir, options.changes(), options.mergeKeys(), currentData, target);
       } catch (Exception e) {
         printError(e);
         consoleOut.println();
@@ -161,34 +157,48 @@ public int run(String... args) {
   }
 
   private void applyChanges(Path outputDir, Iterable<Change> changes, Set<String> mergeKeys,
-      Map<String, Map<String, Object>> currentData, Source source) throws IOException {
+      Map<String, SourceData> currentSources, Source target) throws IOException {
     if (!changes.iterator().hasNext()) {
       consoleOut.println("No changes provided; formatting target.");
     }
 
-    List<String> affectedSources = source.descendants().stream()
+    List<String> affectedSources = target.descendants().stream()
         .map(Source::path)
         .collect(Collectors.toList());
+    // TODO: Consider currentSources of type Sources or something like that with getter for this
+    Map<String, Map<String, Object>> currentData = currentSources.entrySet().stream()
+        .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().data()));
 
     Map<String, Map<String, Object>> result = monarch.generateSources(
-        source, changes, currentData, mergeKeys);
+        target, changes, currentData, mergeKeys);
 
     for (Map.Entry<String, Map<String, Object>> pathToData : result.entrySet()) {
       String path = pathToData.getKey();
 
+      // We only output a source if it is target or under.
       if (!affectedSources.contains(path)) {
         continue;
       }
 
-      Path sourcePath = outputDir.resolve(path);
-      ensureParentDirectories(sourcePath);
+      Path outPath = outputDir.resolve(path);
+      Map<String, Object> outData = pathToData.getValue();
+      SourceData sourceData = currentSources.containsKey(path)
+          ? currentSources.get(path)
+          : parsers.forPath(outPath).newSourceData();
 
-      SortedMap<String, Object> sorted = new TreeMap<>(pathToData.getValue());
+      if (sourceData.isEmpty() && outData.isEmpty()) {
+        continue;
+      }
 
-      if (sorted.isEmpty()) {
-        Files.write(sourcePath, new byte[]{});
-      } else {
-        yaml.dump(sorted, Files.newBufferedWriter(sourcePath, UTF_8));
+      try {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        sourceData.writeNew(outData, out);
+        ensureParentDirectories(outPath);
+        Files.write(outPath, out.toByteArray());
+      } catch (Exception e) {
+        // TODO: Proper logger
+        new MonarchException("Failed to write updated data source at " + path + " to " + outPath, e)
+            .printStackTrace(consoleOut);
       }
     }
   }

bin/src/io/github/alechenninger/monarch/MonarchFileParseException.java

@@ -24,7 +24,7 @@ public class MonarchFileParseException extends MonarchException {
   private final Path path;
 
   public MonarchFileParseException(String whatWasBeingParsed, Path path, Exception cause) {
-    super("Failed to parse '" + whatWasBeingParsed + "' at: " + path , cause);
+    super("Failed to parse " + whatWasBeingParsed + " at: " + path , cause);
     this.path = path;
   }
 

bin/src/io/github/alechenninger/monarch/MonarchParser.java

@@ -18,7 +18,9 @@
 
 package io.github.alechenninger.monarch;
 
+import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
 
@@ -33,4 +35,6 @@ public interface MonarchParser {
   Hierarchy parseHierarchy(InputStream hierarchyInput);
   List<Change> parseChanges(InputStream changesInput);
   Map<String, Object> parseMap(InputStream inputStream);
+  SourceData newSourceData();
+  SourceData parseData(InputStream inputStream) throws IOException;
 }

bin/src/io/github/alechenninger/monarch/MonarchParsers.java

@@ -121,10 +121,10 @@ default List<Change> parseChanges(String pathOrParseable, FileSystem fileSystem)
     }
   }
 
-  default Map<String, Object> parseData(String pathOrParseable, FileSystem fileSystem) {
+  default Map<String, Object> parseMap(String pathOrParseable, FileSystem fileSystem) {
     try {
       Path path = fileSystem.getPath(pathOrParseable);
-      return parseData(path);
+      return parseMap(path);
     } catch (InvalidPathException | MonarchFileParseException e) {
       byte[] parseable = pathOrParseable.getBytes(Charset.forName("UTF-8"));
       ByteArrayInputStream parseableStream = new ByteArrayInputStream(parseable);
@@ -133,29 +133,64 @@ default Map<String, Object> parseData(String pathOrParseable, FileSystem fileSys
         return yaml().parseMap(parseableStream);
       } catch (Exception parseException) {
         e.addSuppressed(parseException);
-        throw new MonarchException("Failed to parse data", e);
+        throw new MonarchException("Failed to parse map", e);
       }
     }
   }
 
-  default Map<String, Object> parseData(Path path) {
+  default Map<String, Object> parseMap(Path path) {
     try {
       return forPath(path).parseMap(Files.newInputStream(path));
-    } catch (NoSuchFileException ignored) {
+    } catch (NoSuchFileException e) {
       return Collections.emptyMap();
+    } catch (Exception e) {
+      throw new MonarchFileParseException("map", path, e);
+    }
+  }
+
+  /**
+   * If {@code pathOrParseable} is a valid file path but the file does not exist, an empty
+   * {@link SourceData} will be returned.
+   */
+  default SourceData parseData(String pathOrParseable, FileSystem fileSystem) {
+    try {
+      Path path = fileSystem.getPath(pathOrParseable);
+      return parseData(path);
+    } catch (InvalidPathException | MonarchFileParseException e) {
+      byte[] parseable = pathOrParseable.getBytes(Charset.forName("UTF-8"));
+      ByteArrayInputStream parseableStream = new ByteArrayInputStream(parseable);
+
+      try {
+        return yaml().parseData(parseableStream);
+      } catch (Exception parseException) {
+        e.addSuppressed(parseException);
+        throw new MonarchException("Failed to parse data", e);
+      }
+    }
+  }
+
+  /**
+   * If {@code path} does not exist, an empty {@link SourceData} will be returned.
+   */
+  default SourceData parseData(Path path) {
+    try {
+      return forPath(path).parseData(Files.newInputStream(path));
+    } catch (NoSuchFileException e) {
+      return forPath(path).newSourceData();
     } catch (Exception e) {
       throw new MonarchFileParseException("data", path, e);
     }
   }
 
-  default Map<String, Map<String, Object>> parseDataSourcesInHierarchy(Path dataDir, Hierarchy hierarchy) {
-    Map<String, Map<String, Object>> data = new HashMap<>();
+  default Map<String, SourceData> parseDataSourcesInHierarchy(Path dataDir, Hierarchy hierarchy) {
+    Map<String, SourceData> data = new HashMap<>();
 
     hierarchy.descendants().stream()
+        // TODO .parallel() but yaml is not threadsafe
         .map(Source::path)
         .forEach(source -> {
           Path sourcePath = dataDir.resolve(source);
-          Map<String, Object> sourceData = parseData(sourcePath);
+          SourceData sourceData = parseData(sourcePath);
           data.put(source, sourceData);
         });
 

bin/src/io/github/alechenninger/monarch/SerializableConfig.java

@@ -18,8 +18,6 @@
 
 package io.github.alechenninger.monarch;
 
-import java.util.List;
-import java.util.Map;
 import java.util.Set;
 
 /**

bin/src/io/github/alechenninger/monarch/SourceData.java

@@ -0,0 +1,46 @@
+/*
+ * monarch - A tool for managing hierarchical data.
+ * Copyright (C) 2016 Alec Henninger
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.alechenninger.monarch;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Map;
+
+public interface SourceData {
+
+  Map<String, Object> data();
+
+  default boolean isEmpty() {
+    return data().isEmpty();
+  }
+
+  default boolean isNotEmpty() {
+    return !isEmpty();
+  }
+
+  /**
+   * Outputs {@code newData} to {@code out} in the same data format as the source.
+   *
+   * <p>Some implementations may use the original source to influence the output, such as by
+   * maintaining comments, formatting, or style, etc.
+   *
+   * <p>Closes {@code out} when done.
+   */
+  void writeNew(Map<String, Object> newData, OutputStream out) throws IOException;
+}