Custom type names specified using JavaScript function (#113)

customTypeNamingFunction

* customTypeNamingFunction - fix for Java 7

* customTypeNamingFunction - fix for Java 7

Author: vojtechhabarta

pom.xml

@@ -77,6 +77,7 @@
                 <version>2.18.1</version>
                 <configuration>
                     <argLine>-Dfile.encoding=UTF-8</argLine>
+                    <trimStackTrace>false</trimStackTrace>
                 </configuration>
             </plugin>
             <plugin>

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

@@ -32,6 +32,7 @@ public class Settings {
     public String addTypeNamePrefix = null;
     public String addTypeNameSuffix = null;
     public Map<String, String> customTypeNaming = new LinkedHashMap<>();
+    public String customTypeNamingFunction = null;
     public List<String> referencedFiles = new ArrayList<>();
     public List<String> importDeclarations = new ArrayList<>();
     public Map<String, String> customTypeMappings = new LinkedHashMap<>();

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

@@ -4,6 +4,10 @@
 import cz.habarta.typescript.generator.Settings;
 import cz.habarta.typescript.generator.util.Pair;
 import java.util.*;
+import javax.script.Invocable;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
 
 
 /**
@@ -14,6 +18,7 @@ public class SymbolTable {
     private final Settings settings;
     private final LinkedHashMap<Pair<Class<?>, String>, Symbol> symbols = new LinkedHashMap<>();
     private final LinkedHashMap<String, Symbol> syntheticSymbols = new LinkedHashMap<>();
+    private CustomTypeNamingFunction customTypeNamingFunction;
 
     public SymbolTable(Settings settings) {
         this.settings = settings;
@@ -80,18 +85,29 @@ private static void reportConflicts(Map<String, List<Class<?>>> names) {
             }
         }
         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.");
+            throw new NameConflictException("Multiple classes are mapped to the same name. You can use 'customTypeNaming' or 'customTypeNamingFunction' settings to resolve conflicts or exclude conflicting class if it was added accidentally.");
         }
     }
 
-    private String getMappedName(Class<?> cls) {
+    public String getMappedName(Class<?> cls) {
         if (cls == null) {
             return null;
         }
         final String customName = settings.customTypeNaming.get(cls.getName());
         if (customName != null) {
             return customName;
         }
+        if (settings.customTypeNamingFunction != null) {
+            try {
+                final CustomTypeNamingFunction function = getCustomTypeNamingFunction();
+                final Object getNameResult = function.getName(cls.getName(), cls.getSimpleName());
+                if (getNameResult != null && !isUndefined(getNameResult)) {
+                    return (String) getNameResult;
+                }
+            } catch (ScriptException e) {
+                throw new RuntimeException("Evaluating 'customTypeNamingFunction' failed.", e);
+            }
+        }
         String name = cls.getSimpleName();
         if (settings.removeTypeNamePrefix != null && name.startsWith(settings.removeTypeNamePrefix)) {
             name = name.substring(settings.removeTypeNamePrefix.length(), name.length());
@@ -108,6 +124,30 @@ private String getMappedName(Class<?> cls) {
         return name;
     }
 
+    private static boolean isUndefined(Object variable) {
+        // Java 8
+//        return ScriptObjectMirror.isUndefined(variable);
+
+        // Hack for Java 7, it should match both:
+        // org.mozilla.javascript.Undefined (Java 7)
+        // jdk.nashorn.internal.runtime.Undefined (Java 8)
+        return variable != null && variable.getClass().getSimpleName().equals("Undefined");
+    }
+
+    private CustomTypeNamingFunction getCustomTypeNamingFunction() throws ScriptException {
+        if (customTypeNamingFunction == null) {
+            final ScriptEngineManager manager = new ScriptEngineManager();
+            final ScriptEngine engine = manager.getEngineByName("javascript");
+            engine.eval("var getName = " + settings.customTypeNamingFunction);
+            final Invocable invocable = (Invocable) engine;
+            customTypeNamingFunction = invocable.getInterface(CustomTypeNamingFunction.class);
+        }
+        return customTypeNamingFunction;
+    }
+
+    public static interface CustomTypeNamingFunction {
+        public Object getName(String className, String classSimpleName);
+    }
 
     public static class NameConflictException extends RuntimeException {
 

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/parser/Jackson2Parser.java

@@ -38,7 +38,7 @@ public Jackson2Parser(Settings settings, TypeProcessor typeProcessor, boolean us
         super(settings, typeProcessor);
         if (!settings.disableJackson2ModuleDiscovery) {
             objectMapper.registerModules(ObjectMapper.findModules(settings.classLoader));
-            }
+        }
         if (useJaxbAnnotations) {
             AnnotationIntrospector introspector = new JaxbAnnotationIntrospector(objectMapper.getTypeFactory());
             objectMapper.setAnnotationIntrospector(introspector);

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

@@ -38,4 +38,22 @@ private static class ConflictingClass {
         }
     }
 
+    @Test
+    public void testTypeNamingFunction() {
+        final Settings settings = TestUtils.settings();
+        settings.customTypeNamingFunction = "function(name, simpleName) { if (name.indexOf('cz.') === 0) return 'Test' + simpleName; }";
+        final SymbolTable symbolTable = new SymbolTable(settings);
+        final String name = symbolTable.getMappedName(A.class);
+        Assert.assertEquals("TestA", name);
+    }
+
+    @Test
+    public void testTypeNamingFunctionReturnsUndefined() {
+        final Settings settings = TestUtils.settings();
+        settings.customTypeNamingFunction = "function() {}";
+        final SymbolTable symbolTable = new SymbolTable(settings);
+        final String name = symbolTable.getMappedName(A.class);
+        Assert.assertEquals("A", name);
+    }
+
 }

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

@@ -32,6 +32,7 @@ public class GenerateTask extends DefaultTask {
     public String addTypeNamePrefix;
     public String addTypeNameSuffix;
     public List<String> customTypeNaming;
+    public String customTypeNamingFunction;
     public List<String> referencedFiles;
     public List<String> importDeclarations;
     public List<String> customTypeMappings;
@@ -90,6 +91,7 @@ public void generate() throws Exception {
         settings.addTypeNamePrefix = addTypeNamePrefix;
         settings.addTypeNameSuffix = addTypeNameSuffix;
         settings.customTypeNaming = Settings.convertToMap(customTypeNaming);
+        settings.customTypeNamingFunction = customTypeNamingFunction;
         settings.referencedFiles = referencedFiles;
         settings.importDeclarations = importDeclarations;
         settings.customTypeMappings = Settings.convertToMap(customTypeMappings);

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

@@ -160,13 +160,22 @@ public class GenerateMojo extends AbstractMojo {
     private String addTypeNameSuffix;
 
     /**
-     * Specifies custom TypeScript name for Java classes.
+     * Specifies custom TypeScript names 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 JavaScript function for getting custom TypeScript names for Java classes.
+     * Function can return undefined if default name should be used.
+     * Function signature: <code>function getName(className: string, classSimpleName: string): string | null | undefined;</code>
+     * Example function: <code>function(name, simpleName) { if (name.startsWith('cz.')) return 'Test' + simpleName; }</code>
+     */
+    @Parameter
+    private String customTypeNamingFunction;
+
     /**
      * List of files which will be referenced using triple-slash directive: /// &lt;reference path="file" />.
      * This can be used with "customTypeMappings" to provide needed TypeScript types.
@@ -331,6 +340,7 @@ public void execute() {
             settings.addTypeNamePrefix = addTypeNamePrefix;
             settings.addTypeNameSuffix = addTypeNameSuffix;
             settings.customTypeNaming = Settings.convertToMap(customTypeNaming);
+            settings.customTypeNamingFunction = customTypeNamingFunction;
             settings.referencedFiles = referencedFiles;
             settings.importDeclarations = importDeclarations;
             settings.customTypeMappings = Settings.convertToMap(customTypeMappings);