@Override public Map<String, Object> getVars() { Map<String, Object> vars = Model.super.getVars(); vars.put("importedTypes", getImportedTypes()); vars.put("concrete", isConcrete()); vars.put("type", getType()); vars.put("ifacePackageName", getIfacePackageName()); vars.put("ifaceSimpleName", getIfaceSimpleName()); vars.put("ifaceFQCN", getIfaceFQCN()); vars.put("ifaceComment", getIfaceComment()); vars.put("doc", doc); vars.put("methods", getMethods()); vars.put("constants", getConstants()); vars.put("referencedTypes", getReferencedTypes()); vars.put("superTypes", getSuperTypes()); vars.put("concreteSuperType", getConcreteSuperType()); vars.put("abstractSuperTypes", getAbstractSuperTypes()); vars.put("handlerType", getHandlerType()); vars.put("methodsByName", getMethodMap()); vars.put("classAnnotations", getAnnotations()); vars.put("annotationsByMethodName", getMethodAnnotations()); vars.put("referencedDataObjectTypes", getReferencedDataObjectTypes()); vars.put("referencedEnumTypes", getReferencedEnumTypes()); vars.put("typeParams", getTypeParams()); vars.put("instanceMethods", getInstanceMethods()); vars.put("staticMethods", getStaticMethods()); vars.put("deprecated", isDeprecated()); vars.put("deprecatedDesc", getDeprecatedDesc()); return vars;
ClassTypeInfo type = model.getType(); for (ApiTypeInfo referencedType : model.getReferencedTypes()) { if (!isImported(referencedType, session)) { if (!referencedType.getRaw().getModuleName().equals(type.getModuleName())) { for (ClassTypeInfo dataObjectType : model.getReferencedDataObjectTypes()) { if (!isImported(dataObjectType, session)) { if (dataObjectType.getRaw().getModuleName().equals(type.getModuleName())) { for (EnumTypeInfo enumType : model.getReferencedEnumTypes()) { if (!isImported(enumType, session)) { if (enumType.getRaw().getModuleName().equals(type.getModuleName())) { model.getAbstractSuperTypes().forEach(ti -> superTypes.add(genType(ti))); if (model.getHandlerType() != null) { if (model.isConcrete()) { superTypes.add("Handler<" + genType(model.getHandlerType()) + ">"); writer.printf("export %s %s%s", model.isConcrete() ? "abstract class" : "interface", type.getSimpleName(), genGeneric(type.getParams())); if (model.isConcrete()) { if (model.getConcreteSuperType() != null) { writer.printf(" extends %s", genType(model.getConcreteSuperType())); if (model.getHandlerType() != null) { writer.printf(" extends Handler<%s>", genType(model.getHandlerType())); if (!superTypes.isEmpty()) {
@Override public String filename(ClassModel model) { return enabled && model.getMethods().stream().anyMatch(this::generateFilter) ? generated + model.getModule().translateQualifiedName(model.getFqn(), "kotlin").replace(".", "/") + ".kt" : null; }
@Test public void testValidDataObjectReturn() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidDataObjectReturn.class); assertEquals(MethodWithValidDataObjectReturn.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithValidDataObjectReturn.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(3, model.getMethods().size()); checkMethod(model.getMethods().get(0), "methodWithDataObjectReturn", 0, PlainDataObjectWithToJson.class.getName(), MethodKind.OTHER); checkMethod(model.getMethods().get(1), "methodWithAbstractDataObjectReturn", 0, AbstractDataObjectWithToJson.class.getName(), MethodKind.OTHER); checkMethod(model.getMethods().get(2), "methodWithInterfaceDataObjectReturn", 0, InterfaceDataObjectWithToJson.class.getName(), MethodKind.OTHER); }
private void generateClassBody(ClassModel model, String constructor, PrintWriter writer) { ClassTypeInfo type = model.getType(); String simpleName = type.getSimpleName(); if (model.isConcrete()) { writer.print(" public static final io.vertx.lang.rx.TypeArg<"); writer.print(simpleName); writer.print(Helper.getNonGenericType(model.getIfaceFQCN())); List<TypeParamInfo.Class> typeParams = model.getTypeParams(); if (typeParams.size() > 0) { writer.print(typeParams.stream().map(TypeParamInfo.Class::getName).collect(Collectors.joining(",", "<", ">"))); writer.print(constructor); writer.print("("); writer.print(Helper.getNonGenericType(model.getIfaceFQCN())); writer.println(" delegate) {"); if (model.isConcrete() && model.getConcreteSuperType() != null) { writer.println(" super(delegate);"); writer.print(constructor); writer.print("("); writer.print(Helper.getNonGenericType(model.getIfaceFQCN())); writer.print(" delegate"); for (TypeParamInfo.Class typeParam : typeParams) { if (model.isConcrete() && model.getConcreteSuperType() != null) { writer.println(" super(delegate);"); for (MethodInfo method : model.getMethods()) {
private void generateClass(ClassModel model, PrintWriter writer) { ClassTypeInfo type = model.getType(); if (model.isConcrete()) { writer.print("class"); } else { writer.print(Helper.getSimpleName(model.getIfaceFQCN())); if (model.isConcrete() && model.getConcreteSuperType() != null) { writer.print(" extends "); writer.print(genTypeName(model.getConcreteSuperType())); List<TypeInfo> abstractSuperTypes = model.getAbstractSuperTypes(); if (abstractSuperTypes.size() > 0) { writer.print(" "); if (model.isConcrete()) { writer.print("implements"); } else { TypeInfo handlerType = model.getHandlerType(); if (handlerType != null) { if (abstractSuperTypes.isEmpty()) { writer.print(" "); if (model.isConcrete()) { writer.print("implements "); } else { if (model.isConcrete()) { if ("io.vertx.core.buffer.Buffer".equals(type.getName())) {
@Test public void testInstanceMethods() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithInstanceMethods.class); assertEquals(InterfaceWithInstanceMethods.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithInstanceMethods.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(2, model.getReferencedTypes().size()); assertTrue(model.getReferencedTypes().contains(VertxGenClass1Info)); assertTrue(model.getReferencedTypes().contains(VertxGenClass2Info)); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(2, model.getMethods().size()); Consumer<List<MethodInfo>> checker = (methods) -> { checkMethod(methods.get(0), "foo", 1, VertxGenClass1.class, MethodKind.OTHER); checkMethod(methods.get(1), "bar", 1, VertxGenClass2.class, MethodKind.OTHER); }; checker.accept(model.getMethods()); checker.accept(model.getInstanceMethods()); assertEquals(Collections.<MethodInfo>emptyList(), model.getStaticMethods()); }
@Test public void testSupertypes() throws Exception { ClassModel gen = new GeneratorHelper().generateClass(InterfaceWithSupertypes.class, VertxGenClass1.class, VertxGenInterface.class); assertEquals(InterfaceWithSupertypes.class.getName(), gen.getIfaceFQCN()); assertEquals(InterfaceWithSupertypes.class.getSimpleName(), gen.getIfaceSimpleName()); assertEquals(2, gen.getReferencedTypes().size()); assertTrue(gen.getReferencedTypes().contains(VertxGenClass1Info)); assertTrue(gen.getReferencedTypes().contains(VertxGenInterfaceInfo)); assertEquals(2, gen.getSuperTypes().size()); assertTrue(gen.getSuperTypes().contains(VertxGenClass1Info)); assertTrue(gen.getSuperTypes().contains(VertxGenInterfaceInfo)); assertEquals(VertxGenClass1Info, gen.getConcreteSuperType()); assertEquals(1, gen.getAbstractSuperTypes().size()); assertTrue(gen.getAbstractSuperTypes().contains(VertxGenInterfaceInfo)); List<MethodInfo> methods = gen.getMethods(); assertEquals(2, methods.size()); Collections.sort(methods); checkMethod(methods.get(0), "bar", 1, "void", MethodKind.OTHER); checkMethod(methods.get(1), "quux", 1, "void", MethodKind.OTHER); }
@Override public String render(ClassModel 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\" />\n", getNPMScope(model.getType().getRaw().getModule())); if (model.getType().getRaw().getModuleName().equals("vertx")) { writer.print("export const AsyncResult = Java.type('io.vertx.core.AsyncResult');\n"); } } writer.printf("export const %s = Java.type('%s');\n", model.getType().getRaw().getSimpleName(), model.getType().getName()); return sw.toString(); } }
@Test public void testModuleScopedApiModel() throws Exception { ClassModel model = new GeneratorHelper().generateClass(ModuleScopedApi.class); assertEquals(ModuleScopedApi.class.getName(), model.getIfaceFQCN()); assertEquals("io.vertx.test.codegen.testmodule.modulescoped", model.getModule().getPackageName()); assertEquals("simple", model.getModule().getName()); ApiTypeInfo type = (ApiTypeInfo) model.getType(); assertEquals("io.vertx.test.groovy.codegen.testmodule.modulescoped.ModuleScopedApi", type.translateName("groovy")); assertEquals("io.vertx.test.ceylon.simple.ModuleScopedApi", type.translateName(TypeNameTranslator.composite("ceylon"))); }
@Override public String render(ClassModel model, int index, int size, Map<String, Object> session) { ClassTypeInfo type = model.getType(); String simpleName = type.getSimpleName(); String ifaceName = Helper.decapitaliseFirstLetter(simpleName); for (TypeParamInfo.Class param : model.getTypeParams()) { writer.format(", j_arg_%s", param.getIndex()); for (TypeParamInfo.Class param : model.getTypeParams()) { writer.format(" var j_%s = typeof j_arg_%s !== 'undefined' ? j_arg_%s : utils.unknown_jtype;", param.getName(), param.getIndex(), param.getIndex()); for (TypeInfo superType : model.getSuperTypes()) { writer.print(superType.getRaw().getSimpleName()); writer.print(".call(this, j_val"); model.getMethods().forEach(method -> { writer.format("var __super_%s = this.%s;\n", method.getName(), method.getName()); }); model.getMethods() .stream() .filter(method -> !method.isStaticMethod()) model.getMethods() .stream() .filter(MethodInfo::isStaticMethod) for (ConstantInfo constant : model.getConstants()) { genConstant(model, constant, writer);
@Test public void testMethodHandlerAsyncResultParam() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithHandlerAsyncResultParam.class); checkMethod(model.getMethods().get(0), "foo_1", 1, "void", MethodKind.FUTURE); checkMethod(model.getMethods().get(1), "foo_2", 2, "void", MethodKind.FUTURE); checkMethod(model.getMethods().get(2), "foo_3", 2, "void", MethodKind.FUTURE); checkMethod(model.getMethods().get(3), "foo_4", 1, MethodWithHandlerAsyncResultParam.class, MethodKind.FUTURE, MethodCheck.FLUENT); checkMethod(model.getMethods().get(4), "foo_5", 2, MethodWithHandlerAsyncResultParam.class, MethodKind.FUTURE, MethodCheck.FLUENT); checkMethod(model.getMethods().get(5), "foo_6", 2, MethodWithHandlerAsyncResultParam.class, MethodKind.FUTURE, MethodCheck.FLUENT); checkMethod(model.getMethods().get(6), "foo_7", 1, String.class.getName(), MethodKind.OTHER); checkMethod(model.getMethods().get(7), "foo_8", 2, "void", MethodKind.OTHER); }
@Test public void testOverloadCheckIgnoreAnyJavaTypeMethod() throws Exception { ClassModel model = new GeneratorHelper().generateClass(OverloadCheckIgnoreEnhancedMethod.class); assertEquals(1, model.getMethodMap().get("meth").size()); assertEquals(1, model.getMethods().size()); assertEquals(1, model.getAnyJavaTypeMethods().size()); }
StringWriter buffer = new StringWriter(); CodeWriter writer = new CodeWriter(buffer); ClassTypeInfo type = model.getType(); Stream<MethodInfo> methodStream = Stream.concat( model.getMethods().stream(), model.getAnyJavaTypeMethods().stream() ); Map<Boolean, List<MethodInfo>> methodGroupMap = methodStream
private void genRequire(ClassModel model, PrintWriter writer) { ClassTypeInfo type = model.getType(); writer.println("var utils = require('vertx-js/util/utils');"); for (ClassTypeInfo referencedType : model.getReferencedTypes()) { writer.format("var %s = require('%s');\n", referencedType.getSimpleName(), getModuleName(referencedType)); } writer.println(); //The top level vars for the module writer.println("var io = Packages.io;"); writer.println("var JsonObject = io.vertx.core.json.JsonObject;"); writer.format("var J%s = Java.type('%s');\n", type.getSimpleName(), type.getName()); for (ClassTypeInfo dataObjectType : model.getReferencedDataObjectTypes()) { writer.format("var %s = Java.type('%s');\n", dataObjectType.getSimpleName(), dataObjectType.getName()); } } }
@Test public void testInterfaceExtendingHandlerStringSubtype() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceExtendingHandlerStringSubtype.class); TypeInfo handlerSuperType = model.getHandlerType(); assertEquals(TypeReflectionFactory.create(String.class), handlerSuperType); ApiTypeInfo apiType = (ApiTypeInfo) model.getType(); assertTrue(apiType.isHandler()); assertEquals(TypeReflectionFactory.create(String.class), apiType.getHandlerArg()); assertFalse(apiType.isReadStream()); assertFalse(apiType.isWriteStream()); assertEquals(1, model.getMethodMap().size()); assertEquals(1, model.getMethodMap().get("handle").size()); checkMethod(model.getMethodMap().get("handle").get(0), "handle", 1, "void", MethodKind.OTHER); }
@Test public void testInterfaceComments() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithComments.class); assertEquals(InterfaceWithComments.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithComments.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); String firstSentence = " Interface comment line 1\n" + " Interface comment line 2\n" + " Interface comment line 3"; assertEquals(firstSentence, model.getDoc().getFirstSentence().getValue()); }
@Test public void testConstants() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithConstants.class); assertEquals(1, model.getReferencedTypes().size()); assertEquals(VertxGenClass1.class.getName(), model.getReferencedTypes().iterator().next().getName()); assertEquals(1, model.getReferencedDataObjectTypes().size()); assertEquals(TestDataObject.class.getName(), model.getReferencedDataObjectTypes().iterator().next().getName()); assertEquals(1, model.getReferencedEnumTypes().size()); assertEquals(TestEnum.class.getName(), model.getReferencedEnumTypes().iterator().next().getName()); List<ConstantInfo> constants = model.getConstants(); assertEquals(66, constants.size());
@Test public void testParameterizedVariableSuperType() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithParameterizedVariableSupertype.class); assertEquals(InterfaceWithParameterizedVariableSupertype.class.getName() + "<T>", model.getIfaceFQCN()); assertEquals(InterfaceWithParameterizedVariableSupertype.class.getSimpleName(), model.getIfaceSimpleName()); assertEquals(1, model.getReferencedTypes().size()); assertTrue(model.getReferencedTypes().contains(GenericInterfaceInfo)); assertEquals(1, model.getSuperTypes().size()); assertTrue(model.getSuperTypes().contains(TypeReflectionFactory.create(InterfaceWithParameterizedVariableSupertype.class.getGenericInterfaces()[0]))); List<TypeInfo> superTypeArgs = model.getSuperTypeArguments(); assertEquals(1, superTypeArgs.size()); TypeVariableInfo superTypeArg = (TypeVariableInfo) superTypeArgs.get(0); assertEquals("T", superTypeArg.getName()); assertTrue(superTypeArg.isClassParam()); }