Conditionally use non-const enums based on annotation (#248) (#249)

* Conditionally use non-const enums based on annotation (#248)

* some cleanup

* converted TsEnumModel.isNonConstEnum to final

* backwards-compatibility

Author: danielkaneider

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

@@ -48,6 +48,7 @@ public class Settings {
     public DateMapping mapDate; // default is DateMapping.asDate
     public EnumMapping mapEnum; // default is EnumMapping.asUnion
     public boolean nonConstEnums = false;
+    public List<Class<? extends Annotation>> nonConstEnumAnnotations = new ArrayList<>();
     public ClassMapping mapClasses; // default is ClassMapping.asInterfaces
     public List<String> mapClassesAsClassesPatterns;
     private Predicate<String> mapClassesAsClassesFilter = null;
@@ -102,7 +103,7 @@ public TypeScriptGeneratorURLClassLoader(String name, URL[] urls, ClassLoader pa
         public String toString() {
             return "TsGenURLClassLoader{" + name + ", parent: " + getParent() + "}";
         }
-        
+
     }
 
     public static URLClassLoader createClassLoader(String name, URL[] urls, ClassLoader parent) {
@@ -140,6 +141,13 @@ public void loadExtensions(ClassLoader classLoader, List<String> extensions, Lis
         }
     }
 
+    public static List<Class<? extends Annotation>> loadAnnotations(ClassLoader classLoader, List<String> stringAnnotations) {
+        if (stringAnnotations != null) {
+            return new ArrayList<>(loadClasses(classLoader, stringAnnotations, Annotation.class));
+        }
+        return new ArrayList<>(0);
+    }
+
     public void loadIncludePropertyAnnotations(ClassLoader classLoader, List<String> includePropertyAnnotations) {
         if (includePropertyAnnotations != null) {
             this.includePropertyAnnotations = loadClasses(classLoader, includePropertyAnnotations, Annotation.class);
@@ -232,7 +240,7 @@ public void validate() {
                 defaultStringEnumsOverriddenByExtension = true;
             }
         }
-        if (nonConstEnums && outputFileType != TypeScriptFileType.implementationFile) {
+        if ((nonConstEnums || !nonConstEnumAnnotations.isEmpty()) && outputFileType != TypeScriptFileType.implementationFile) {
             throw new RuntimeException("Non-const enums can only be used in implementation files but 'outputFileType' parameter is not set to 'implementationFile'.");
         }
         if (mapClasses == ClassMapping.asClasses && outputFileType != TypeScriptFileType.implementationFile) {

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

@@ -176,7 +176,7 @@ private <T> TsBeanModel processBean(SymbolTable symbolTable, Model model, Map<Ty
                 extendsList.add(parentType);
         }
         }
-        
+
         final List<TsType> interfaces = new ArrayList<>();
         for (Type aInterface : bean.getInterfaces()) {
             final TsType interfaceType = typeFromJava(symbolTable, aInterface);
@@ -189,7 +189,7 @@ private <T> TsBeanModel processBean(SymbolTable symbolTable, Model model, Map<Ty
         } else {
             extendsList.addAll(interfaces);
         }
-        
+
         final List<TsPropertyModel> properties = processProperties(symbolTable, model, bean, "", "");
 
         if (bean.getDiscriminantProperty() != null && !containsProperty(properties, bean.getDiscriminantProperty())) {
@@ -297,7 +297,21 @@ private TsPropertyModel processProperty(SymbolTable symbolTable, BeanModel bean,
 
     private TsEnumModel processEnum(SymbolTable symbolTable, EnumModel enumModel) {
         final Symbol beanIdentifier = symbolTable.getSymbol(enumModel.getOrigin());
-        return TsEnumModel.fromEnumModel(beanIdentifier, enumModel);
+        TsEnumModel tsEnumModel = TsEnumModel.fromEnumModel(beanIdentifier, enumModel, isEnumNonConst(enumModel));
+        return tsEnumModel;
+    }
+
+    private boolean isEnumNonConst(EnumModel enumModel) {
+        boolean isNonConst = settings.nonConstEnums;
+        if (!isNonConst) {
+            for (Class<? extends Annotation> nonConstAnnotation : settings.nonConstEnumAnnotations) {
+                if (enumModel.getOrigin().isAnnotationPresent(nonConstAnnotation)) {
+                    isNonConst = true;
+                    break;
+                }
+            }
+        }
+        return isNonConst;
     }
 
     private TsType typeFromJava(SymbolTable symbolTable, Type javaType) {
@@ -342,13 +356,13 @@ private TsModel addImplementedProperties(SymbolTable symbolTable, TsModel tsMode
         for (TsBeanModel bean : tsModel.getBeans()) {
             if (bean.isClass()) {
                 final List<TsPropertyModel> resultProperties = new ArrayList<>(bean.getProperties());
-                
+
                 final Set<String> classPropertyNames = new LinkedHashSet<>();
                 for (TsPropertyModel property : bean.getProperties()) {
                     classPropertyNames.add(property.getName());
                 }
                 classPropertyNames.addAll(getInheritedProperties(symbolTable, tsModel, bean.getExtendsList()).keySet());
-                
+
                 final List<TsPropertyModel> implementedProperties = getImplementedProperties(symbolTable, tsModel, bean.getImplementsList());
                 Collections.reverse(implementedProperties);
                 for (TsPropertyModel implementedProperty : implementedProperties) {
@@ -357,7 +371,7 @@ private TsModel addImplementedProperties(SymbolTable symbolTable, TsModel tsMode
                         classPropertyNames.add(implementedProperty.getName());
                     }
                 }
-                
+
                 beans.add(bean.withProperties(resultProperties));
             } else {
                 beans.add(bean);
@@ -622,7 +636,7 @@ public TsType transform(TsType.Context context, TsType type) {
                     }
                 }
                 return type;
-                
+
             }
         });
         return model.withTypeAliases(new ArrayList<>(typeAliases));

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/emitter/Emitter.java

@@ -365,7 +365,7 @@ private void emitLiteralEnum(TsEnumModel enumModel, boolean exportKeyword, boole
         writeNewLine();
         emitComments(enumModel.getComments());
         final String declareText = declareKeyword ? "declare " : "";
-        final String constText = settings.nonConstEnums ? "" : "const ";
+        final String constText = enumModel.isNonConstEnum() ? "" : "const ";
         writeIndentedLine(exportKeyword, declareText + constText + "enum " + enumModel.getName().getSimpleName() + " {");
         indent++;
         for (EnumMemberModel member : enumModel.getMembers()) {

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/emitter/TsEnumModel.java

@@ -12,15 +12,22 @@ public class TsEnumModel extends TsDeclarationModel {
 
     private final EnumKind kind;
     private final List<EnumMemberModel> members;
+    private final boolean isNonConstEnum;
 
+    @Deprecated
     public TsEnumModel(Class<?> origin, Symbol name, EnumKind kind, List<EnumMemberModel> members, List<String> comments) {
+        this(origin, name, kind, members, comments, false);
+    }
+
+    public TsEnumModel(Class<?> origin, Symbol name, EnumKind kind, List<EnumMemberModel> members, List<String> comments, boolean isNonConstEnum) {
         super(origin, null, name, comments);
         this.kind = kind;
         this.members = members;
+        this.isNonConstEnum = isNonConstEnum;
     }
 
-    public static TsEnumModel fromEnumModel(Symbol name, EnumModel enumModel) {
-        return new TsEnumModel(enumModel.getOrigin(), name, enumModel.getKind(), enumModel.getMembers(), enumModel.getComments());
+    public static TsEnumModel fromEnumModel(Symbol name, EnumModel enumModel, boolean isNonConstEnum) {
+        return new TsEnumModel(enumModel.getOrigin(), name, enumModel.getKind(), enumModel.getMembers(), enumModel.getComments(), isNonConstEnum);
     }
 
     public EnumKind getKind() {
@@ -31,8 +38,13 @@ public List<EnumMemberModel> getMembers() {
         return members;
     }
 
+    public boolean isNonConstEnum() {
+        return isNonConstEnum;
+    }
+
     public TsEnumModel withMembers(List<EnumMemberModel> members) {
-        return new TsEnumModel(origin, name, kind, members, comments);
+        TsEnumModel model = new TsEnumModel(origin, name, kind, members, comments, isNonConstEnum);
+        return model;
     }
 
 }

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/ext/ClassEnumExtension.java

@@ -59,7 +59,8 @@ public TsModel transformModel(SymbolTable symbolTable, TsModel model) {
                             tsBeanModel.getName(),
                             EnumKind.StringBased,
                             members,
-                            null
+                            null,
+                            false
                     );
                     stringEnums.add(temp);
                 }

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

@@ -8,6 +8,10 @@
 import cz.habarta.typescript.generator.parser.Model;
 import cz.habarta.typescript.generator.parser.ModelParser;
 import java.io.File;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.util.Arrays;
 import org.junit.Assert;
 import org.junit.Test;
@@ -54,6 +58,20 @@ public void testNonConstEnum() {
                 output.trim());
     }
 
+    @Test
+    public void testNonConstAnnotationEnum() {
+        final Settings settings = TestUtils.settings();
+        settings.outputFileType = TypeScriptFileType.implementationFile;
+        settings.nonConstEnumAnnotations.add(SomeNonConstAnnotation.class);
+        final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(SomeCode.class));
+        Assert.assertEquals(
+                "enum SomeCode {\n" +
+                "    VALUE0 = 10,\n" +
+                "    VALUE1 = 11,\n" +
+                "}",
+                output.trim());
+    }
+
     @Test
     public void testJavadoc() {
         final Settings settings = TestUtils.settings();
@@ -68,6 +86,7 @@ public void testJavadoc() {
      * Documentation for SomeCode enum.
      */
     @JsonFormat(shape = JsonFormat.Shape.NUMBER_INT)
+    @SomeNonConstAnnotation
     public static enum SomeCode {
 
         /**
@@ -91,4 +110,9 @@ public Integer getJsonValue() {
         }
     }
 
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.TYPE})
+    public @interface SomeNonConstAnnotation {
+    }
+
 }

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

@@ -45,6 +45,7 @@ public class GenerateTask extends DefaultTask {
     public DateMapping mapDate;
     public EnumMapping mapEnum;
     public boolean nonConstEnums;
+    public List<String> nonConstEnumAnnotations;
     public ClassMapping mapClasses;
     public List<String> mapClassesAsClassesPatterns;
     public boolean disableTaggedUnions;
@@ -133,6 +134,7 @@ public void generate() throws Exception {
         settings.mapDate = mapDate;
         settings.mapEnum = mapEnum;
         settings.nonConstEnums = nonConstEnums;
+        settings.nonConstEnumAnnotations = Settings.loadAnnotations(classLoader, nonConstEnumAnnotations);
         settings.mapClasses = mapClasses;
         settings.mapClassesAsClassesPatterns = mapClassesAsClassesPatterns;
         settings.disableTaggedUnions = disableTaggedUnions;

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

@@ -293,6 +293,15 @@ public class GenerateMojo extends AbstractMojo {
     @Parameter
     private boolean nonConstEnums;
 
+    /**
+     * If this list is not empty, then generated enums will not have <code>const</code> keyword,
+     * if the enum contains one of the annotations defined in this list.
+     * See {@link #nonConstEnums}
+     *
+     */
+    @Parameter
+    private List<String> nonConstEnumAnnotations;
+
     /**
      * Specifies whether Java classes will be mapped to TypeScript classes or interfaces.
      * Java interfaces are always mapped as TypeScript interfaces.
@@ -596,6 +605,7 @@ public void execute() {
             settings.mapDate = mapDate;
             settings.mapEnum = mapEnum;
             settings.nonConstEnums = nonConstEnums;
+            settings.nonConstEnumAnnotations = Settings.loadAnnotations(classLoader, nonConstEnumAnnotations);
             settings.mapClasses = mapClasses;
             settings.mapClassesAsClassesPatterns = mapClassesAsClassesPatterns;
             settings.disableTaggedUnions = disableTaggedUnions;