custom type naming (closes #57)

Author: vojtechhabarta

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/Settings.java

@@ -27,6 +27,7 @@ public class Settings {
     public String removeTypeNameSuffix = null;
     public String addTypeNamePrefix = null;
     public String addTypeNameSuffix = null;
+    public Map<String, String> customTypeNaming = new LinkedHashMap<>();
     public DateMapping mapDate = DateMapping.asDate;
     public TypeProcessor customTypeProcessor = null;
     public boolean sortDeclarations = false;
@@ -56,6 +57,20 @@ public void loadOptionalAnnotations(ClassLoader classLoader, List<String> option
         }
     }
 
+    public static Map<String, String> convertToMap(List<String> mappings) {
+        final Map<String, String> result = new LinkedHashMap<>();
+        if (mappings != null) {
+            for (String mapping : mappings) {
+                final String[] values = mapping.split(":", 2);
+                if (values.length < 2) {
+                    throw new RuntimeException("Invalid mapping format: " + mapping);
+                }
+                result.put(values[0].trim(), values[1].trim());
+            }
+        }
+        return result;
+    }
+
     public void validate() {
         if (outputKind == null) {
             throw new RuntimeException("Required 'outputKind' parameter is not configured. " + seeLink());

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/compiler/SymbolTable.java

@@ -39,18 +39,43 @@ public Symbol getSyntheticSymbol(String name) {
     }
 
     public void resolveSymbolNames(Settings settings) {
-//        TODO check for conflicts
+        final Map<String, List<Class<?>>> names = new LinkedHashMap<>();
         for (Map.Entry<Class<?>, Symbol> entry : symbols.entrySet()) {
             final Class<?> cls = entry.getKey();
             final Symbol symbol = entry.getValue();
-            symbol.name = getMappedName(cls);
+            final String name = getMappedName(cls);
+            symbol.name = name;
+            if (!names.containsKey(name)) {
+                names.put(name, new ArrayList<Class<?>>());
+            }
+            names.get(name).add(cls);
+        }
+        reportConflicts(names);
+    }
+
+    private static void reportConflicts(Map<String, List<Class<?>>> names) {
+        boolean conflict = false;
+        for (Map.Entry<String, List<Class<?>>> entry : names.entrySet()) {
+            final String name = entry.getKey();
+            final List<Class<?>> classes = entry.getValue();
+            if (classes.size() > 1) {
+                System.out.println(String.format("Multiple classes are mapped to '%s' name. Conflicting classes: %s", name, classes));
+                conflict = true;
+            }
+        }
+        if (conflict) {
+            throw new NameConflictException("Multiple classes are mapped to the same name. You can use 'customTypeNaming' setting to resolve conflicts or exclude conflicting class if it was added accidentally.");
         }
     }
 
     private String getMappedName(Class<?> cls) {
         if (cls == null) {
             return null;
         }
+        final String customName = settings.customTypeNaming.get(cls.getName());
+        if (customName != null) {
+            return customName;
+        }
         String name = cls.getSimpleName();
         if (settings.removeTypeNamePrefix != null && name.startsWith(settings.removeTypeNamePrefix)) {
             name = name.substring(settings.removeTypeNamePrefix.length(), name.length());
@@ -67,4 +92,26 @@ private String getMappedName(Class<?> cls) {
         return name;
     }
 
+
+    public static class NameConflictException extends RuntimeException {
+        
+        private static final long serialVersionUID = 1L;
+
+        public NameConflictException() {
+        }
+
+        public NameConflictException(String message) {
+            super(message);
+        }
+
+        public NameConflictException(String message, Throwable cause) {
+            super(message, cause);
+        }
+
+        public NameConflictException(Throwable cause) {
+            super(cause);
+        }
+
+    }
+
 }

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/NamingTest.java

@@ -0,0 +1,41 @@
+
+package cz.habarta.typescript.generator;
+
+import cz.habarta.typescript.generator.compiler.SymbolTable;
+import java.util.LinkedHashMap;
+import org.junit.Assert;
+import org.junit.Test;
+
+
+public class NamingTest {
+
+    @Test(expected = SymbolTable.NameConflictException.class)
+    public void testConflictReport() {
+        final Settings settings = TestUtils.settings();
+        new TypeScriptGenerator(settings).generateTypeScript(Input.from(A.ConflictingClass.class, B.ConflictingClass.class));
+    }
+
+    @Test
+    public void testConflictResolved() {
+        final Settings settings = TestUtils.settings();
+        settings.customTypeNaming = new LinkedHashMap<>();
+        settings.customTypeNaming.put("cz.habarta.typescript.generator.NamingTest$A$ConflictingClass", "A$ConflictingClass");
+        settings.customTypeNaming.put("cz.habarta.typescript.generator.NamingTest$B$ConflictingClass", "B$ConflictingClass");
+        final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(A.ConflictingClass.class, B.ConflictingClass.class));
+        Assert.assertTrue(output.contains("A$ConflictingClass"));
+        Assert.assertTrue(output.contains("B$ConflictingClass"));
+    }
+
+    private static class A {
+        private static class ConflictingClass {
+            public String conflictingProperty;
+        }
+    }
+
+    private static class B {
+        private static class ConflictingClass {
+            public String conflictingProperty;
+        }
+    }
+
+}

typescript-generator-gradle-plugin/src/main/java/cz/habarta/typescript/generator/gradle/GenerateTask.java

@@ -27,6 +27,7 @@ public class GenerateTask extends DefaultTask {
     public String removeTypeNameSuffix;
     public String addTypeNamePrefix;
     public String addTypeNameSuffix;
+    public List<String> customTypeNaming;
     public DateMapping mapDate;
     public String customTypeProcessor;
     public boolean sortDeclarations;
@@ -75,6 +76,7 @@ public void generate() throws Exception {
         settings.removeTypeNameSuffix = removeTypeNameSuffix;
         settings.addTypeNamePrefix = addTypeNamePrefix;
         settings.addTypeNameSuffix = addTypeNameSuffix;
+        settings.customTypeNaming = Settings.convertToMap(customTypeNaming);
         settings.mapDate = mapDate;
         settings.loadCustomTypeProcessor(classLoader, customTypeProcessor);
         settings.sortDeclarations = sortDeclarations;

typescript-generator-maven-plugin/src/main/java/cz/habarta/typescript/generator/maven/GenerateMojo.java

@@ -129,6 +129,14 @@ public class GenerateMojo extends AbstractMojo {
     @Parameter
     private String addTypeNameSuffix;
 
+    /**
+     * Specifies custom TypeScript name for Java classes.
+     * Multiple mappings can be specified, each using this format: "javaClassName:typescriptName".
+     * This takes precedence over other naming settings.
+     */
+    @Parameter
+    private List<String> customTypeNaming;
+
     /**
      * Specifies how {@link java.util.Date} will be mapped.
      * Supported values are 'asDate', 'asNumber, 'asString'.
@@ -229,6 +237,7 @@ public void execute() {
             settings.removeTypeNameSuffix = removeTypeNameSuffix;
             settings.addTypeNamePrefix = addTypeNamePrefix;
             settings.addTypeNameSuffix = addTypeNameSuffix;
+            settings.customTypeNaming = Settings.convertToMap(customTypeNaming);
             settings.mapDate = mapDate;
             settings.loadCustomTypeProcessor(classLoader, customTypeProcessor);
             settings.sortDeclarations = sortDeclarations;