Use imports instead of FQN #97

src/main/java/org/assertj/assertions/generator/BaseAssertionGenerator.java

@@ -22,9 +22,12 @@
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -319,14 +322,49 @@ private String generateAssertionsEntryPointClassContent(final Set<ClassDescripti
         ? determineBestEntryPointsAssertionsClassPackage(classDescriptionSet)
         : entryPointClassPackage;
     entryPointAssertionsClassContent = replace(entryPointAssertionsClassContent, PACKAGE, classPackage);
-
+    Set<String> imports;
+    if (entryPointAssertionsClassContent.contains(IMPORTS)) {
+      imports = extractImports(classDescriptionSet);
+      entryPointAssertionsClassContent = replace(entryPointAssertionsClassContent, IMPORTS, listNeededImports(imports));
+    } else {
+      imports = new HashSet<>();
+    }
     String allEntryPointsAssertionContent = generateAssertionEntryPointMethodsFor(classDescriptionSet,
-                                                                                  entryPointAssertionMethodTemplate);
+                                                                                  entryPointAssertionMethodTemplate,
+                                                                                  imports);
     entryPointAssertionsClassContent = replace(entryPointAssertionsClassContent, ALL_ASSERTIONS_ENTRY_POINTS,
                                                allEntryPointsAssertionContent);
     return entryPointAssertionsClassContent;
   }
 
+  private static String listNeededImports(Collection<String> imports) {
+    StringBuilder builder = new StringBuilder();
+    for (String anImport : imports) {
+      builder.append(format(IMPORT_LINE, anImport, LINE_SEPARATOR));
+    }
+    return builder.toString();
+  }
+
+  private static Set<String> extractImports(Set<ClassDescription> classDescriptionSet) {
+    Set<String> imports = new TreeSet<>();
+    Map<String, String> importedQualifiedName = new HashMap<>(classDescriptionSet.size() * 2);
+    for (ClassDescription description : new TreeSet<>(classDescriptionSet)) {
+      String outerClassName = description.getOuterClassName();
+      if (!importedQualifiedName.containsKey(outerClassName)) {
+        String toImport = description.getPackageName() + "." + outerClassName;
+        imports.add(toImport);
+        importedQualifiedName.put(outerClassName, toImport);
+      }
+
+      if (!importedQualifiedName.containsKey(simpleAssertClassName(description))) {
+        String toImport = fullyQualifiedAssertClassName(description);
+        imports.add(toImport);
+        importedQualifiedName.put(simpleAssertClassName(description), toImport);
+      }
+    }
+    return imports;
+  }
+
   /**
    * create the assertions entry point file, located in its package directory starting from targetBaseDirectory.
    * <p>
@@ -352,7 +390,8 @@ private File createAssertionsFileFor(final Set<ClassDescription> classDescriptio
   }
 
   private String generateAssertionEntryPointMethodsFor(final Set<ClassDescription> classDescriptionSet,
-                                                       Template assertionEntryPointMethodTemplate) {
+                                                       Template assertionEntryPointMethodTemplate,
+                                                       Set<String> imports) {
     // sort ClassDescription according to their class name.
     SortedSet<ClassDescription> sortedClassDescriptionSet = new TreeSet<ClassDescription>(classDescriptionSet);
     // generate for each classDescription the entry point method, e.g. assertThat(MyClass) or then(MyClass)
@@ -362,12 +401,20 @@ private String generateAssertionEntryPointMethodsFor(final Set<ClassDescription>
       String assertionEntryPointMethodContent = assertionEntryPointMethodTemplate.getContent();
       // resolve class assert (ex: PlayerAssert)
       // in case of inner classes like Movie.PublicCategory, class assert will be MoviePublicCategoryAssert
+      String customAssertionClass = fullyQualifiedAssertClassName(classDescription);
+      if (imports.contains(customAssertionClass)) {
+        customAssertionClass = simpleAssertClassName(classDescription);
+      }
       assertionEntryPointMethodContent = replace(assertionEntryPointMethodContent, CUSTOM_ASSERTION_CLASS,
-                                                 fullyQualifiedAssertClassName(classDescription));
+                                                 customAssertionClass);
       // resolve class (ex: Player)
       // in case of inner classes like Movie.PublicCategory use class name with outer class i.e. Movie.PublicCategory.
+      String classToAssert = classDescription.getFullyQualifiedClassName();
+      if (imports.contains(classDescription.getPackageName() + "." + classDescription.getOuterClassName())) {
+        classToAssert = classDescription.getClassNameWithOuterClass();
+      }
       assertionEntryPointMethodContent = replace(assertionEntryPointMethodContent, CLASS_TO_ASSERT,
-                                                 classDescription.getFullyQualifiedClassName());
+                                                 classToAssert);
       allAssertThatsContentBuilder.append(lineSeparator).append(assertionEntryPointMethodContent);
     }
     return allAssertThatsContentBuilder.toString();
@@ -405,7 +452,11 @@ private static String abstractAssertClassNameOf(TypeName type) {
   }
 
   private static String fullyQualifiedAssertClassName(ClassDescription classDescription) {
-    return classDescription.getPackageName() + "." + classDescription.getClassNameWithOuterClassNotSeparatedByDots()
+    return classDescription.getPackageName() + "." + simpleAssertClassName(classDescription);
+  }
+
+  private static String simpleAssertClassName(ClassDescription classDescription) {
+    return classDescription.getClassNameWithOuterClassNotSeparatedByDots()
            + ASSERT_CLASS_SUFFIX;
   }
 

src/main/java/org/assertj/assertions/generator/description/ClassDescription.java

@@ -60,7 +60,11 @@ public String getClassNameWithOuterClass() {
   public String getClassNameWithOuterClassNotSeparatedByDots() {
     return classTypeName.getSimpleNameWithOuterClassNotSeparatedByDots();
   }
-
+
+  public String getOuterClassName() {
+    return classTypeName.getOuterClassName();
+  }
+
   public String getPackageName() {
     return classTypeName.getPackageName();
   }

src/main/java/org/assertj/assertions/generator/description/TypeName.java

@@ -47,6 +47,7 @@ public class TypeName implements Comparable<TypeName> {
   private String typeSimpleNameWithOuterClass;
   private String typeSimpleNameWithOuterClassNotSeparatedByDots;
   private String packageName;
+  private String outerClassName;
 
   public TypeName(String typeSimpleName, String packageName) {
     if (typeSimpleName == null) throw new IllegalArgumentException("type simple name should not be null");
@@ -82,6 +83,7 @@ public TypeName(Class<?> clazz) {
     this.typeSimpleNameWithOuterClass = ClassUtil.getSimpleNameWithOuterClass(clazz);
     this.typeSimpleNameWithOuterClassNotSeparatedByDots = ClassUtil.getSimpleNameWithOuterClassNotSeparatedByDots(clazz);
     this.packageName = clazz.getPackage() == null ? NO_PACKAGE : clazz.getPackage().getName();
+    this.outerClassName = ClassUtil.getSimpleNameOuterClass(clazz);
   }
 
   public String getSimpleName() {
@@ -104,6 +106,10 @@ private void setPackageName(String packageName) {
     this.packageName = packageName == null ? NO_PACKAGE : packageName;
   }
 
+  public String getOuterClassName() {
+    return outerClassName;
+  }
+
   public boolean isPrimitive() {
     return contains(PRIMITIVE_TYPES, typeSimpleName) && isEmpty(packageName);
   }

src/main/java/org/assertj/assertions/generator/util/ClassUtil.java

@@ -475,6 +475,24 @@ public static String getSimpleNameWithOuterClass(Class<?> clazz) {
     return nestedClassName;
   }
 
+  /**
+   * Gets the simple name of the outer class, if the class is not nested then this is the same as
+   * {@link Class#getSimpleName()}.
+   *
+   * @param clazz
+   * @return see description
+   */
+  public static String getSimpleNameOuterClass(Class<?> clazz) {
+    if (isNotNestedClass(clazz)) {
+      return clazz.getSimpleName();
+    }
+    String outerClassName = null;
+    outerClassName = clazz.getName();
+    outerClassName = outerClassName.substring(clazz.getPackage().getName().length() + 1);
+    outerClassName = outerClassName.substring(0, outerClassName.indexOf('$'));
+    return outerClassName;
+  }
+
   /**
    * Gets the simple name of the class but, unlike {@link Class#getSimpleName()}, it includes the name of the outer
    * class when <code>clazz</code> is an inner class, both class names are concatenated.

src/main/resources/templates/auto_closeable_bdd_soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * A version of {@link BDDSoftAssertions} that uses try-with-resources statement to automatically call
  * {@link BDDSoftAssertions#assertAll()} so that you don't forget to.

src/main/resources/templates/auto_closeable_soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * A version of {@link SoftAssertions} that uses try-with-resources statement to automatically call
  * {@link SoftAssertions#assertAll()} so that you don't forget to.

src/main/resources/templates/bdd_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Entry point for BDD assertions of different data types.
  */

src/main/resources/templates/bdd_soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Entry point for BDD soft assertions of different data types.
  */

src/main/resources/templates/junit_bdd_soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Like {@link BDDSoftAssertions} but as a junit rule that takes care of calling
  * {@link SoftAssertions#assertAll() assertAll()} at the end of each test.

src/main/resources/templates/junit_soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Like {@link SoftAssertions} but as a junit rule that takes care of calling
  * {@link SoftAssertions#assertAll() assertAll()} at the end of each test.

src/main/resources/templates/soft_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Entry point for soft assertions of different data types.
  */

src/main/resources/templates/standard_assertions_entry_point_class_template.txt

@@ -1,5 +1,6 @@
 package ${package};
 
+${imports}
 /**
  * Entry point for assertions of different data types. Each method in this class is a static factory for the
  * type-specific assertion objects.

src/test/java/org/assertj/assertions/generator/NestedClassesTest.java

@@ -22,26 +22,31 @@
 public interface NestedClassesTest {
   @DataPoint
   public static final NestedClass SNC = new NestedClass(OuterClass.StaticNestedPerson.class,
-                                                        "OuterClass.StaticNestedPerson");
+                                                        "OuterClass.StaticNestedPerson", "OuterClass");
   @DataPoint
   public static final NestedClass SNC_SNC = new NestedClass(OuterClass.StaticNestedPerson.SNP_StaticNestedPerson.class,
-                                                            "OuterClass.StaticNestedPerson.SNP_StaticNestedPerson");
+                                                            "OuterClass.StaticNestedPerson.SNP_StaticNestedPerson",
+                                                            "OuterClass");
   @DataPoint
   public static final NestedClass SNC_IC = new NestedClass(OuterClass.StaticNestedPerson.SNP_InnerPerson.class,
-                                                           "OuterClass.StaticNestedPerson.SNP_InnerPerson");
+                                                           "OuterClass.StaticNestedPerson.SNP_InnerPerson",
+                                                           "OuterClass");
   @DataPoint
-  public static final NestedClass IC = new NestedClass(OuterClass.InnerPerson.class, "OuterClass.InnerPerson");
+  public static final NestedClass IC = new NestedClass(OuterClass.InnerPerson.class, "OuterClass.InnerPerson",
+                                                       "OuterClass");
   @DataPoint
   public static final NestedClass IC_IC = new NestedClass(OuterClass.InnerPerson.IP_InnerPerson.class,
-                                                          "OuterClass.InnerPerson.IP_InnerPerson");
+                                                          "OuterClass.InnerPerson.IP_InnerPerson", "OuterClass");
 
   public static class NestedClass {
     private final Class<?> nestedClass;
     private final String classNameWithOuterClass;
+    private final String outerClassName;
 
-    public NestedClass(Class<?> nestedClass, String classNameWithOuterClass) {
+    public NestedClass(Class<?> nestedClass, String classNameWithOuterClass, String outerClassName) {
       this.nestedClass = nestedClass;
       this.classNameWithOuterClass = classNameWithOuterClass;
+      this.outerClassName = outerClassName;
     }
 
     public String getClassNameWithOuterClass() {
@@ -55,5 +60,9 @@ public String getClassNameWithOuterClassNotSeparatedBytDots() {
     public Class<?> getNestedClass() {
       return nestedClass;
     }
+
+    public String getOuterClassName() {
+      return outerClassName;
+    }
   }
 }

src/test/java/org/assertj/assertions/generator/util/ClassUtilTest.java

@@ -17,6 +17,7 @@
 import static org.assertj.assertions.generator.util.ClassUtil.getClassesRelatedTo;
 import static org.assertj.assertions.generator.util.ClassUtil.getNegativePredicateFor;
 import static org.assertj.assertions.generator.util.ClassUtil.getPredicatePrefix;
+import static org.assertj.assertions.generator.util.ClassUtil.getSimpleNameOuterClass;
 import static org.assertj.assertions.generator.util.ClassUtil.getSimpleNameWithOuterClass;
 import static org.assertj.assertions.generator.util.ClassUtil.getSimpleNameWithOuterClassNotSeparatedByDots;
 import static org.assertj.assertions.generator.util.ClassUtil.getterMethodsOf;
@@ -211,6 +212,13 @@ public void should_return_inner_class_name_with_outer_class_name(NestedClass nes
     assertThat(actualName).isEqualTo(nestedClass.getClassNameWithOuterClass());
   }
 
+  @Theory
+  public void should_return_outer_class_name_for_nested_class(NestedClass nestedClass) {
+    String actualName = getSimpleNameOuterClass(nestedClass.getNestedClass());
+    assertThat(actualName).isEqualTo(nestedClass.getOuterClassName());
+  }
+
+
   @Theory
   public void should_return_inner_class_name_with_outer_class_name_not_separated_by_dots(NestedClass nestedClass) {
     String actualName = getSimpleNameWithOuterClassNotSeparatedByDots(nestedClass.getNestedClass());
@@ -228,6 +236,11 @@ public void testGetSimpleNameWithOuterClass_notNestedClass() throws Exception {
     assertThat(ClassUtil.getSimpleNameWithOuterClass(String.class)).isEqualTo("String");
   }
 
+  @Test
+  public void testGetSimpleNameOuterClass_notNestedClass() throws Exception {
+    assertThat(ClassUtil.getSimpleNameOuterClass(String.class)).isEqualTo("String");
+  }
+
   @Test
   public void getClass_on_parameterized_List_should_return_List_class() throws Exception {
     Method method = Generic.class.getMethod("getListOfInteger");