private void generateDeprecatedAnnotation(String replacement, DataObjectModel model, CodeWriter writer) { writer.println("@Deprecated("); writer.println(" message = \"This function will be removed in a future version\","); writer.print(" replaceWith = ReplaceWith(\"" + replacement + "("); String parameters = model.getPropertyMap() .values() .stream() .filter(filterProperties()) .map(PropertyInfo::getName) .collect(Collectors.joining(", ")); writer.print(parameters); writer.println(")\")\n)"); }
private void render(DataObjectModel model, PrintWriter html) { html.append("[[").append(model.getType().getSimpleName()).append("]]\n"); html.append("== ").append(model.getType().getSimpleName()).append("\n"); html.append("\n"); Doc doc = model.getDoc(); if (doc != null) { html.append("++++\n"); html.append("|===\n"); html.append("^|Name | Type ^| Description\n"); model.getPropertyMap().values().forEach(property -> { String propertytype = getDataType(property.getType()); if (propertytype != null) {
@Override public String filename(DataObjectModel model) { return enabled && model.isConcrete() ? generated + model.getModule().translateQualifiedName(model.getFqn(), "kotlin").replace(".", "/") + ".kt" : null; }
@Override public String filename(DataObjectModel model) { if (model.isClass() && model.getGenerateConverter()) { return model.getFqn() + "Converter.java"; } return null; }
@Override public Map<String, Object> getVars() { Map<String, Object> vars = Model.super.getVars(); vars.put("type", type); vars.put("doc", doc); vars.put("generateConverter", generateConverter); vars.put("inheritConverter", inheritConverter); vars.put("publicConverter", publicConverter); vars.put("concrete", concrete); vars.put("isClass", isClass); vars.put("properties", propertyMap.values()); vars.put("importedTypes", importedTypes); vars.put("superTypes", superTypes); vars.put("superType", superType); vars.put("abstractSuperTypes", abstractSuperTypes); vars.put("jsonifiable", jsonifiable); vars.put("hasEmptyConstructor", hasEmptyConstructor()); vars.put("deprecated", deprecated); vars.put("deprecatedDesc", getDeprecatedDesc()); return vars; }
@Test public void testConcreteInheritsConcrete() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteExtendsConcrete.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(0, model.getPropertyMap().size()); assertEquals(Collections.singleton((ClassTypeInfo) TypeReflectionFactory.create(Concrete.class)), model.getSuperTypes()); assertEquals(TypeReflectionFactory.create(Concrete.class), model.getSuperType()); assertEquals(Collections.<ClassTypeInfo>emptySet(), model.getAbstractSuperTypes()); }
@Test public void testConcreteOverridesFromAbstractDataObject() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteOverridesFromAbstractDataObject.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(3, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("inheritedProperty"), "inheritedProperty", "setInheritedProperty", null, null, TypeReflectionFactory.create(String.class), false, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("overriddenProperty"), "overriddenProperty", "setOverriddenProperty", null, null, TypeReflectionFactory.create(String.class), false, PropertyKind.VALUE, true); assertProperty(model.getPropertyMap().get("abstractProperty"), "abstractProperty", "setAbstractProperty", null, null, TypeReflectionFactory.create(String.class), true, PropertyKind.VALUE, true); }
@Test public void testConcreteOverridesFromNonDataObject() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ConcreteOverridesFromNonDataObject.class); assertNotNull(model); assertTrue(model.isConcrete()); assertEquals(1, model.getPropertyMap().size()); assertProperty(model.getPropertyMap().get("nonDataObjectProperty"), "nonDataObjectProperty", "setNonDataObjectProperty", null, null, TypeReflectionFactory.create(String.class), true, PropertyKind.VALUE, true); assertEquals(Collections.<ClassTypeInfo>emptySet(), model.getSuperTypes()); }
private void generateImport(DataObjectModel model, CodeWriter writer) { writer.println("import " + model.getType().getRaw().getName()); Set<String> genImports = new TreeSet<>(); for (PropertyInfo p : model.getPropertyMap().values()) { ClassKind propertyKind = p.getType().getKind(); if ((propertyKind == ClassKind.ENUM || propertyKind == ClassKind.DATA_OBJECT) && !p.getType().equals(model.getType())) { genImports.add(p.getType().getName()); } } for (String i : genImports) { writer.println("import " + i); } }
private void generateFunction(String functionName, DataObjectModel model, CodeWriter writer) { boolean isKotlin = model.getAnnotations().stream().anyMatch(ann -> ann.getName().equals("kotlin.Metadata")); ClassTypeInfo type = model.getType(); writer.println("fun " + functionName + "("); String paramsInfo = model.getPropertyMap() .values() .stream() writer.print(paramsInfo); writer.print("): "); writer.print(model.getType().getSimpleName()); writer.print(" = "); writer.print(model.getType().getName()); writer.print("("); if (!model.hasEmptyConstructor()) { writer.print("io.vertx.core.json.JsonObject()"); writer.println(); writer.indent(); model.getPropertyMap().values() .stream() .filter(filterProperties())
for (ClassTypeInfo referencedType : filterImports(model.getPropertyMap())) { if (!isImported(referencedType, session)) { if (referencedType.getKind() == ClassKind.ENUM) { if (referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from './enums';\n", referencedType.getSimpleName()); imports = true; if (!referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from '%s/options';\n", referencedType.getSimpleName(), getNPMScope(referencedType.getRaw().getModule())); imports = true; if (referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from './index';\n", referencedType.getSimpleName()); imports = true; writer.printf("export %sclass %s {\n", model.isConcrete() ? "" : "abstract ", model.getType().getRaw().getSimpleName()); writer.print(" constructor();\n"); writer.printf(" constructor(obj: %s);\n", model.getType().getRaw().getSimpleName()); for (Map.Entry<String, PropertyInfo> entry : model.getPropertyMap().entrySet()) { writer.print(" */\n"); writer.printf(" %s(%s: %s): %s;\n", property.getSetterMethod(), cleanReserved(entry.getKey()), genType(property.getType()), model.getType().getRaw().getSimpleName()); writer.printf(" %s(%s: %s): %s;\n", property.getAdderMethod(), cleanReserved(entry.getKey()), genType(property.getType()), model.getType().getRaw().getSimpleName());
@Test public void testDataObjectWithAnnotations() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(DataObjectWithAnnotatedField.class); assertNotNull(model); assertTrue(model.isClass()); assertTrue(model.getGenerateConverter()); assertTrue(model.isPublicConverter()); PropertyInfo idModel = model.getPropertyMap().get("id"); assertEquals(1, idModel.getAnnotations().size()); assertNotNull(idModel.getAnnotation(SomeAnnotation.class.getName()).getName()); PropertyInfo fieldWithMethodAnnotationModel = model.getPropertyMap().get("fieldWithMethodAnnotation"); assertEquals(2, fieldWithMethodAnnotationModel.getAnnotations().size()); assertNotNull(fieldWithMethodAnnotationModel.getAnnotation(SomeAnnotation.class.getName()).getName()); assertNotNull(fieldWithMethodAnnotationModel.getAnnotation(SomeMethodAnnotation.class.getName()).getName()); }
@Override public String render(DataObjectModel model, int index, int size, Map<String, Object> session) { StringWriter sw = new StringWriter(); PrintWriter writer = new PrintWriter(sw); if (index == 0) { Util.generateLicense(writer); writer.printf("/// <reference types=\"%s/options\" />\n", getNPMScope(model.getType().getRaw().getModule())); } writer.printf("export const %s = Java.type('%s');\n", model.getType().getRaw().getSimpleName(), model.getType().getName()); return sw.toString(); } }
@Override public String render(DataObjectModel model, int index, int size, Map<String, Object> session) { StringWriter buffer = new StringWriter(); PrintWriter writer = new PrintWriter(buffer); String visibility= model.isPublicConverter() ? "public" : ""; String simpleName = model.getType().getSimpleName(); boolean inheritConverter = model.getInheritConverter(); writer.print("package " + model.getType().getPackageName() + ";\n"); writer.print("\n"); writer.print("import io.vertx.core.json.JsonObject;\n"); writer.print("import io.vertx.core.json.JsonArray;\n"); writer.print("import java.time.Instant;\n"); writer.print("import java.time.format.DateTimeFormatter;\n"); writer.print("\n"); writer.print("/**\n"); writer.print(" * Converter for {@link " + model.getType() + "}.\n"); writer.print(" * NOTE: This class has been automatically generated from the {@link " + model.getType() + "} original class using Vert.x codegen.\n"); writer.print(" */\n"); writer.print(visibility + " class " + simpleName + "Converter {\n"); writer.print("\n"); generateFromson(visibility, inheritConverter, model, writer); writer.print("\n"); generateToJson(visibility, inheritConverter, model, writer); writer.print("}\n"); return buffer.toString(); }
@Test public void testDataObjectDeprecated() throws Exception { DataObjectModel model = generator.generateDataObject(DeprecatedDataObject.class); assertTrue(model.isDeprecated()); assertEquals(model.getVars().get("deprecated"), true); assertNotNull(model.getDeprecatedDesc()); assertEquals(model.getDeprecatedDesc().getValue(), "deprecated info"); for (PropertyInfo property : model.getPropertyMap().values()) { assertTrue(property.isDeprecated()); assertNotNull(property.getDeprecatedDesc()); assertEquals(property.getDeprecatedDesc().getValue(), "property deprecated info"); } }
@Test public void testModuleScopedDataObjectModel() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ModuleScopedDataObject.class); assertEquals(ModuleScopedDataObject.class.getName(), model.getFqn()); assertEquals("io.vertx.test.codegen.testmodule.modulescoped", model.getModule().getPackageName()); assertEquals("simple", model.getModule().getName()); }
@Test public void testEmptyDataObject() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(EmptyDataObject.class); assertNotNull(model); assertTrue(model.isClass()); assertFalse(model.getGenerateConverter()); assertFalse(model.getInheritConverter()); assertTrue(model.isPublicConverter()); try { EmptyDataObject.class.getConstructor(); fail(); } catch (NoSuchMethodException ignore) { } try { EmptyDataObject.class.getConstructor(EmptyDataObject.class); fail(); } catch (NoSuchMethodException ignore) { } }
@Test public void testDataObjectNotDeprecated() throws Exception { DataObjectModel model = generator.generateDataObject(DataObjectWithProperty.class); assertFalse(model.isDeprecated()); assertEquals(model.getVars().get("deprecated"), false); for (PropertyInfo property : model.getPropertyMap().values()) { assertFalse(property.isDeprecated()); } }
@Test public void testNoConverterDataObject() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(NoConverterDataObject.class); assertFalse(model.getGenerateConverter()); assertTrue(model.isPublicConverter()); }
deprecatedDesc = new Text(Helper.normalizeWhitespaces(tag.getValue())).map(Token.tagMapper(elementUtils, typeUtils, modelElt)) ); if (getModule() == null) { throw new GenException(modelElt, "Data object must have an ancestor package annotated with @ModuleGen"); case CONSTRUCTOR: ExecutableElement constrElt = (ExecutableElement) enclosedElt; processConstructor(constrElt); break; case METHOD: { processMethods(methodsElt);