Rework substitution maps to allow reusing them across compiles.

I need to be able to compile multiple CSS bundles using a rename map,
then recompile just a few based on hash checking.

There are two problems with using CssCompiler.execute(renameFile, ...).
1. CssCompiler writes out the rename map using only the entries actually
   encountered by keeping a side table of mappings, not getting the
   entire mapping from the SubstitutionMap.
2. MinimalSubstitutionMap and others have no standard way to reconstitute
   a substitution map from a string->string relation.

This addresses both problems.

I added read() methods to OutputRenamingMapFormat.

I added an Initializable interface to SubstitutionMap that allows
reconstituting a renamer from a rename map, and reworked
RecordingSubstitutionMap and friends to implement Initializable.

Along the way, I cleared up an ambiguity in how SplittingSubstitutionMap
& RecodingSubstitutionMap interpreted renamings that caused problems
when a prefixing substitution map effectively prefixed only the first
renaming in a chain.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=131714015

src/com/google/common/css/MinimalSubstitutionMap.java

@@ -20,7 +20,6 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Maps;
-
 import java.util.Arrays;
 import java.util.Map;
 import java.util.Set;
@@ -31,7 +30,7 @@
  *
  * @author bolinfest@google.com (Michael Bolin)
  */
-public class MinimalSubstitutionMap implements SubstitutionMap {
+public class MinimalSubstitutionMap implements SubstitutionMap.Initializable {
 
  /** Possible first chars in a CSS class name */
  private static final char[] START_CHARS = {
@@ -91,7 +90,7 @@ public class MinimalSubstitutionMap implements SubstitutionMap {
  /**
  * A set of CSS class names that may not be output from this substitution map.
  */
- private final Set<String> outputValueBlacklist;
+ private ImmutableSet<String> outputValueBlacklist;
 
  public MinimalSubstitutionMap() {
  this(ImmutableSet.<String>of());
@@ -156,6 +155,14 @@ public String get(String key) {
  return value;
  }
 
+ @Override
+ public void initializeWithMappings(Map<? extends String, ? extends String> m) {
+ Preconditions.checkState(renamedCssClasses.isEmpty());
+ this.outputValueBlacklist =
+ ImmutableSet.<String>builder().addAll(outputValueBlacklist).addAll(m.values()).build();
+ this.renamedCssClasses.putAll(m);
+ }
+
  /**
  * Converts a 32-bit integer to a unique short string whose first character
  * is in {@link #START_CHARS} and whose subsequent characters, if any, are

src/com/google/common/css/OutputRenamingMapFormat.java

@@ -16,14 +16,25 @@
 
 package com.google.common.css;
 
+
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+import com.google.common.escape.CharEscaperBuilder;
+import com.google.common.escape.Escaper;
+import com.google.common.io.CharStreams;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-
+import com.google.gson.JsonParser;
+import java.io.BufferedReader;
+import java.io.IOException;
 import java.io.PrintWriter;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.Writer;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Properties;
@@ -52,36 +63,14 @@ public enum OutputRenamingMapFormat {
  CLOSURE_COMPILED_BY_WHOLE("goog.setCssNameMapping(%s, 'BY_WHOLE');\n"),
 
  /**
- * Before writing the mapping as CLOSURE_COMPILED, split the css name maps
- * by hyphens and write out each piece individually. see
- * {@code CLOSURE_COMPILED}
+ * Before writing the mapping as CLOSURE_COMPILED, split the css name maps by hyphens and write
+ * out each piece individually. see {@code CLOSURE_COMPILED}
  */
- CLOSURE_COMPILED_SPLIT_HYPHENS {
+ CLOSURE_COMPILED_SPLIT_HYPHENS("goog.setCssNameMapping(%s);\n") {
  @Override
- public void writeRenamingMap(Map<String, String> renamingMap,
- PrintWriter renamingMapWriter) {
- Map<String, String> newSplitRenamingMap = Maps.newHashMap();
- for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
- Iterator<String> parts =
- HYPHEN_SPLITTER.split(entry.getKey()).iterator();
- Iterator<String> partsNew =
- HYPHEN_SPLITTER.split(entry.getValue()).iterator();
- while (parts.hasNext() && partsNew.hasNext()) {
- newSplitRenamingMap.put(parts.next(), partsNew.next());
- }
- if (parts.hasNext()) {
- throw new AssertionError("Not all parts of the original class "
- + "name were output. Class: " + entry.getKey() + " Next Part:"
- + parts.next());
- }
- if (partsNew.hasNext()) {
- throw new AssertionError("Not all parts of the renamed class were "
- + "output. Class: " + entry.getKey() + " Renamed Class: "
- + entry.getValue() + " Next Part:" + partsNew.next());
- }
- }
- OutputRenamingMapFormat.CLOSURE_COMPILED.writeRenamingMap(
- newSplitRenamingMap, renamingMapWriter);
+ public void writeRenamingMap(Map<String, String> renamingMap, Writer renamingMapWriter)
+ throws IOException {
+ super.writeRenamingMap(splitEntriesOnHyphens(renamingMap), renamingMapWriter);
  }
  },
 
@@ -103,17 +92,22 @@ public void writeRenamingMap(Map<String, String> renamingMap,
  */
  PROPERTIES {
  @Override
- public void writeRenamingMap(Map<String, String> renamingMap,
- PrintWriter renamingMapWriter) {
+ public void writeRenamingMap(Map<String, String> renamingMap, Writer renamingMapWriter)
+ throws IOException {
+ writeOnePerLine('=', renamingMap, renamingMapWriter);
  // We write the properties directly rather than using
  // Properties#store() because it is impossible to suppress the timestamp
  // comment: http://goo.gl/6hsrN. As noted on the Stack Overflow thread,
  // the timestamp results in unnecessary diffs between runs. Further, those
  // who are using a language other than Java to parse this file should not
  // have to worry about adding support for comments.
- for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
- renamingMapWriter.format("%s=%s\n", entry.getKey(), entry.getValue());
- }
+ }
+
+ @Override
+ void readMapInto(
+ BufferedReader in, ImmutableMap.Builder<? super String, ? super String> builder)
+ throws IOException {
+ readOnePerLine('=', in, builder);
  }
  },
 
@@ -123,16 +117,18 @@ public void writeRenamingMap(Map<String, String> renamingMap,
  */
  JSCOMP_VARIABLE_MAP {
  @Override
- public void writeRenamingMap(Map<String, String> renamingMap,
- PrintWriter renamingMapWriter) {
- for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
- renamingMapWriter.format("%s:%s\n", entry.getKey(), entry.getValue());
- }
+ public void writeRenamingMap(Map<String, String> renamingMap, Writer renamingMapWriter)
+ throws IOException {
+ writeOnePerLine(':', renamingMap, renamingMapWriter);
  }
- };
 
- // Splitter used for CLOSURE_COMPILED_SPLIT_HYPHENS format.
- private static final Splitter HYPHEN_SPLITTER = Splitter.on("-");
+ @Override
+ void readMapInto(
+ BufferedReader in, ImmutableMap.Builder<? super String, ? super String> builder)
+ throws IOException {
+ readOnePerLine(':', in, builder);
+ }
+ };
 
  private final String formatString;
 
@@ -146,11 +142,13 @@ private OutputRenamingMapFormat() {
  }
 
  /**
+ * Writes the renaming map.
+ *
  * @see com.google.common.css.compiler.commandline.DefaultCommandLineCompiler
  * #writeRenamingMap(Map, PrintWriter)
  */
- public void writeRenamingMap(Map<String, String> renamingMap,
- PrintWriter renamingMapWriter) {
+ public void writeRenamingMap(Map<String, String> renamingMap, Writer renamingMapWriter)
+ throws IOException {
  // Build up the renaming map as a JsonObject.
  JsonObject properties = new JsonObject();
  for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
@@ -162,4 +160,170 @@ public void writeRenamingMap(Map<String, String> renamingMap,
  renamingMapWriter.write(String.format(formatString,
  gson.toJson(properties)));
  }
+
+ /**
+ * Like {@writeRenamingMap(java.util.Map, java.io.Writer)} but does not throw when writes fail.
+ */
+ public final void writeRenamingMap(
+ Map<String, String> renamingMap, PrintWriter renamingMapWriter) {
+ try {
+ writeRenamingMap(renamingMap, (Writer) renamingMapWriter);
+ } catch (IOException ex) {
+ throw (AssertionError) new AssertionError("IOException from PrintWriter").initCause(ex);
+ }
+ }
+
+ /**
+ * Reads the output of {@link #writeRenamingMap} so a renaming map can be reused from one compile
+ * to another.
+ */
+ public ImmutableMap<String, String> readRenamingMap(Reader in) throws IOException {
+ String subsitutionMarker = "%s";
+ int formatStringSubstitutionIndex = formatString.indexOf(subsitutionMarker);
+ Preconditions.checkState(formatStringSubstitutionIndex >= 0, formatString);
+
+ String formatPrefix = formatString.substring(0, formatStringSubstitutionIndex);
+ String formatSuffix =
+ formatString.substring(formatStringSubstitutionIndex + subsitutionMarker.length());
+
+ // GSON's JSONParser does not stop reading bytes when it sees a bracket that
+ // closes the value.
+ // We read the whole input in, then strip prefixes and suffixes and then parse
+ // the rest.
+ String content = CharStreams.toString(in);
+
+ content = content.trim();
+ formatPrefix = formatPrefix.trim();
+ formatSuffix = formatSuffix.trim();
+
+ if (!content.startsWith(formatPrefix)
+ || !content.endsWith(formatSuffix)
+ || content.length() < formatPrefix.length() + formatSuffix.length()) {
+ throw new IOException("Input does not match format " + formatString + " : " + content);
+ }
+
+ content = content.substring(formatPrefix.length(), content.length() - formatSuffix.length());
+
+ ImmutableMap.Builder<String, String> b = ImmutableMap.builder();
+ BufferedReader br = new BufferedReader(new StringReader(content));
+ readMapInto(br, b);
+ requireEndOfInput(br);
+
+ return b.build();
+ }
+
+ /**
+ * Reads the mapping portion of the formatted output.
+ *
+ * <p>This default implementation works for formats that substitute a JSON mapping from rewritten
+ * names to originals into their format string, and may be overridden by formats that do something
+ * different.
+ */
+ void readMapInto(BufferedReader in, ImmutableMap.Builder<? super String, ? super String> builder)
+ throws IOException {
+ JsonElement json = new JsonParser().parse(in);
+ for (Map.Entry<String, JsonElement> e : json.getAsJsonObject().entrySet()) {
+ builder.put(e.getKey(), e.getValue().getAsString());
+ }
+ }
+
+ /**
+ * Raises an IOException if there are any non-space characters on in, and consumes the remaining
+ * characters on in.
+ */
+ private static void requireEndOfInput(BufferedReader in) throws IOException {
+ for (int ch; (ch = in.read()) >= 0; ) {
+ if (!Character.isSpace((char) ch)) {
+ throw new IOException("Expected end of input, not '" + escape((char) ch) + "'");
+ }
+ }
+ }
+
+ private static final Escaper ESCAPER =
+ new CharEscaperBuilder()
+ .addEscape('\t', "\\t")
+ .addEscape('\n', "\\n")
+ .addEscape('\r', "\\r")
+ .addEscape('\\', "\\\\")
+ .addEscape('\'', "\\'")
+ .toEscaper();
+
+ private static String escape(char ch) {
+ return ESCAPER.escape(new String(new char[] {ch}));
+ }
+
+ /** Splitter used for CLOSURE_COMPILED_SPLIT_HYPHENS format. */
+ private static final Splitter HYPHEN_SPLITTER = Splitter.on("-");
+
+ /**
+ * <code>{ "foo-bar": "f-b" }</code> => <code>{ "foo": "f", "bar": "b" }</code>.
+ *
+ * @see SplittingSubstitutionMap
+ */
+ private static Map<String, String> splitEntriesOnHyphens(Map<String, String> renamingMap) {
+ Map<String, String> newSplitRenamingMap = Maps.newLinkedHashMap();
+ for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
+ Iterator<String> keyParts = HYPHEN_SPLITTER.split(entry.getKey()).iterator();
+ Iterator<String> valueParts = HYPHEN_SPLITTER.split(entry.getValue()).iterator();
+ while (keyParts.hasNext() && valueParts.hasNext()) {
+ String keyPart = keyParts.next();
+ String valuePart = valueParts.next();
+ String oldValuePart = newSplitRenamingMap.put(keyPart, valuePart);
+ // Splitting by part to make a simple map shouldn't involve mapping two old names
+ // to the same new name. It's ok the other way around, but the part relation should
+ // be a partial function.
+ Preconditions.checkState(oldValuePart == null || oldValuePart.equals(valuePart));
+ }
+ if (keyParts.hasNext()) {
+ throw new AssertionError(
+ "Not all parts of the original class "
+ + "name were output. Class: "
+ + entry.getKey()
+ + " Next Part:"
+ + keyParts.next());
+ }
+ if (valueParts.hasNext()) {
+ throw new AssertionError(
+ "Not all parts of the renamed class were "
+ + "output. Class: "
+ + entry.getKey()
+ + " Renamed Class: "
+ + entry.getValue()
+ + " Next Part:"
+ + valueParts.next());
+ }
+ }
+ return newSplitRenamingMap;
+ }
+
+ private static void writeOnePerLine(
+ char separator, Map<String, String> renamingMap, Writer renamingMapWriter)
+ throws IOException {
+ for (Map.Entry<String, String> entry : renamingMap.entrySet()) {
+ String key = entry.getKey();
+ String value = entry.getValue();
+ Preconditions.checkState(key.indexOf(separator) < 0);
+ Preconditions.checkState(key.indexOf('\n') < 0);
+ Preconditions.checkState(value.indexOf('\n') < 0);
+
+ renamingMapWriter.write(key);
+ renamingMapWriter.write(separator);
+ renamingMapWriter.write(value);
+ renamingMapWriter.write('\n');
+ }
+ }
+
+ private static void readOnePerLine(
+ char separator,
+ BufferedReader in,
+ ImmutableMap.Builder<? super String, ? super String> builder)
+ throws IOException {
+ for (String line; (line = in.readLine()) != null; ) {
+ int eq = line.indexOf(separator);
+ if (eq < 0 && !line.isEmpty()) {
+ throw new IOException("Line is missing a '" + separator + "': " + line);
+ }
+ builder.put(line.substring(0, eq), line.substring(eq + 1));
+ }
+ }
 }