change logic of building processed content (for tracking special cases)

immutables · Jan 30, 2015 · 4f74845 · 4f74845
1 parent 6bb536f
commit 4f74845
Show file tree

Hide file tree

Showing 2 changed files with 96 additions and 23 deletions.
diff --git a/generator/src/org/immutables/generator/PostprocessingMachine.java b/generator/src/org/immutables/generator/PostprocessingMachine.java
@@ -4,9 +4,10 @@
 import com.google.common.base.Joiner;
 import com.google.common.base.Optional;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
-import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeMap;
 import java.util.TreeSet;
 
 final class PostprocessingMachine {
@@ -18,11 +19,6 @@ private PostprocessingMachine() {
   static CharSequence rewrite(CharSequence content) {
     String currentPackage = "";
     ImportsBuilder importsBuilder = new ImportsBuilder();
-    ArrayList<String> parts = Lists.newArrayList();
-    // reserve position for package
-    parts.add("");
-    // reserve position for imports
-    parts.add("");
 
     State state = State.UNDEFINED;
     int packageFrom = -1;
@@ -68,24 +64,46 @@ static CharSequence rewrite(CharSequence content) {
         if (!commentMachine.isInComment()) {
           fullyQualifiedNameMachine.nextChar(c, i);
           if (fullyQualifiedNameMachine.isFinished()) {
-            importsBuilder.addImport(
+
+            importsBuilder.addImportCandidate(
+                content.subSequence(fullyQualifiedNameMachine.packageTo, fullyQualifiedNameMachine.importTo).toString(),
                 content.subSequence(fullyQualifiedNameMachine.importFrom, fullyQualifiedNameMachine.importTo)
-                    .toString());
+                    .toString(),
-            parts.add(content.subSequence(nextPartFrom, fullyQualifiedNameMachine.importFrom).toString());
+                fullyQualifiedNameMachine.importFrom,
-            nextPartFrom = fullyQualifiedNameMachine.packageTo;
+                fullyQualifiedNameMachine.importTo,
+                fullyQualifiedNameMachine.packageTo);
           }
         }
         break;
       }
     }
-    // last part
-    parts.add(content.subSequence(nextPartFrom, content.length()).toString());
 
+    importsBuilder.preBuild();
+
+    StringBuilder stringBuilder = new StringBuilder(content.length() << 1);
+
+    for (ImportCandidate importCandidate : importsBuilder.importCandidates.values()) {
+      if (importCandidate.importTo != -1) {
+        importsBuilder.addImport(importCandidate.preparedImport);
+      }
+      stringBuilder.append(content.subSequence(nextPartFrom, importCandidate.importFrom));
+      nextPartFrom = importCandidate.packageTo;
+    }
+
+    String imports = importsBuilder.build();
+
+    stringBuilder
+        // last part
+        .append(content.subSequence(nextPartFrom, content.length()))
+            // imports
+        .insert(0, imports);
+
+    // package
     if (!currentPackage.isEmpty()) {
-      parts.set(0, "package " + currentPackage + ";\n");
+      stringBuilder.insert(0, ";\n").insert(0, currentPackage).insert(0, "package ");
     }
-    parts.set(1, importsBuilder.build());
+
-    return JOINER.join(parts);
+    return stringBuilder.toString();
   }
 
   enum State {
@@ -159,19 +177,32 @@ static final class ImportsBuilder {
 
     private TreeSet<String> imports = Sets.newTreeSet();
     private Optional<String> currentPackage = Optional.absent();
+    private TreeMap<String, ImportCandidate> importCandidates = Maps.newTreeMap();
+    private HashSet<String> exceptions = Sets.newHashSet();
 
-    void addImport(String importedPackage) {
+    void addImportCandidate(String name, String fullyQualifiedName, int importFrom, int importTo, int packageTo) {
-      String normalized = normalize(importedPackage);
+      String normalized = normalize(fullyQualifiedName);
 
       if (normalized.startsWith(JAVA_LANG)) {
+        importCandidates.put(name, new ImportCandidate(importFrom, -1, packageTo, normalized));
         return;
       }
 
       if (currentPackage.isPresent() && normalized.startsWith(currentPackage.get())) {
+        importCandidates.put(name, new ImportCandidate(importFrom, -1, packageTo, normalized));
         return;
       }
 
-      imports.add(normalized);
+      importCandidates.put(name, new ImportCandidate(importFrom, importTo, packageTo, normalized));
+    }
+
+    // TODO use it
+    void addException(String name) {
+      exceptions.add(name);
+    }
+
+    void addImport(String importedPackage) {
+      imports.add(normalize(importedPackage));
     }
 
     void setCurrentPackage(String currentPackage) {
@@ -182,6 +213,12 @@ private String normalize(String s) {
       return s.replace(" ", "").replace("\n", "").replace("\t", "").replace("\r", "");
     }
 
+    void preBuild() {
+      for (String exception : exceptions) {
+        importCandidates.remove(exception);
+      }
+    }
+
     String build() {
       return JOINER.join(Iterables.transform(imports, ToImportStatement.FUNCTION));
     }
@@ -344,6 +381,20 @@ enum CommentState {
     BLOCK_COMMENT_OUT_CANDIDATE
   }
 
+  private static final class ImportCandidate {
+    final int importFrom;
+    final int importTo;
+    final int packageTo;
+    String preparedImport;
+
+    private ImportCandidate(int importFrom, int importTo, int packageTo, String preparedImport) {
+      this.importFrom = importFrom;
+      this.importTo = importTo;
+      this.packageTo = packageTo;
+      this.preparedImport = preparedImport;
+    }
+  }
+
   private static boolean isSpaceChar(char c) {
     return Character.isSpaceChar(c) || c == '\n' || c == '\t' || c == '\r';
   }
@@ -363,7 +414,4 @@ private static boolean isLowerCaseAlphabetic(char c) {
   private static boolean isUpperCaseAlphabetic(char c) {
     return c >= 'A' && c <= 'Z';
   }
-
-  public static void main(String[] args) {
-  }
 }
diff --git a/generator/test/org/immutables/generator/PostprocessingMachineTest.java b/generator/test/org/immutables/generator/PostprocessingMachineTest.java
@@ -79,7 +79,7 @@ public void javaLangImports() {
   }
 
   @Test
-  public void importsNoPlaceholders() {
+  public void simpleImport() {
     CharSequence rewrited = PostprocessingMachine.rewrite(
         "class My extends java.util.Set {}");
 
@@ -98,6 +98,19 @@ public void importsNoPlaceholders() {
             "class My extends Set {}"));
   }
 
+  @Test
+  @Ignore
+  public void staticImport() {
+    CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join(
+        "import static org.immutables.check.Checkers.*;",
+        "class My extends java.util.Set {}"));
+
+    check(rewrited).hasToString(LINES.join(
+            "import java.util.Set;",
+            "import static org.immutables.check.Checkers.*;",
+            "class My extends Set {}"));
+  }
+
   @Test
   @Ignore
   public void conflictResolution() {
@@ -106,5 +119,17 @@ public void conflictResolution() {
 
     check(rewrited).hasToString(
         "class Set extends java.util.Set {}");
+
+    rewrited = PostprocessingMachine.rewrite(LINES.join(
+        "import my.Set;",
+        "class X {",
+        "  my.Set same(Set set);",
+        "}"));
+
+    check(rewrited).hasToString(LINES.join(
+            "import my.Set;",
+            "class X {",
+            "  Set same(Set set);",
+            "}"));
   }
 }