@Override public Map<String, Object> getVars() { Map<String, Object> vars = Model.super.getVars(); vars.put("fqn", info.getPackageName()); vars.put("name", info.getName()); vars.put("module", getModule()); vars.put("annotations", getAnnotations()); return vars; }
/** * Translates the module package name for the specified {@code lang} parameter language. * * @param lang the language, for instance {@literal groovy} * @return the translated package name */ public String translatePackageName(String lang) { return translateQualifiedName(packageName, lang); }
static TypeNameTranslator hierarchical(String lang) { return (module, qualifiedName) -> { if (qualifiedName.startsWith(module.getGroupPackage())) { return module.getGroupPackage() + "." + lang + qualifiedName.substring(module.getGroupPackage().length(), qualifiedName.length()); } return qualifiedName; }; }
static TypeNameTranslator composite(String lang) { return (module, qualifiedName) -> { List<String> def = new ArrayList<>(Case.QUALIFIED.parse(module.getGroupPackage())); def.add(lang); List<String> abc = Case.KEBAB.parse(module.getName()); if (abc.get(0).equals("vertx")) { // Special case if (abc.size() == 1) { def.add("core"); } else { for (int i = 1;i < abc.size();i++) { def.add(abc.get(i)); } } } else { def.addAll(abc); } if (qualifiedName.startsWith(module.getPackageName())) { if (qualifiedName.equals(module.getPackageName())) { } else { String nameInPackage = qualifiedName.substring(module.getPackageName().length() + 1); def.addAll(Case.QUALIFIED.parse(nameInPackage)); } return Case.QUALIFIED.format(def); } return qualifiedName; }; }
@Test public void testModuleModel() throws Exception { ModuleModel model = new GeneratorHelper().generateModule(ModuleTest.class.getClassLoader(), "io.vertx.test.codegen.testmodule.modulescoped"); assertEquals("io.vertx.test.codegen.testmodule.modulescoped", model.getFqn()); assertEquals("simple", model.getName()); assertEquals("io.vertx.test.groovy.codegen.testmodule.modulescoped", model.translateFqn("groovy")); assertNotNull(model.getModule()); assertEquals("io.vertx.test.codegen.testmodule.modulescoped", model.getModule().getPackageName()); assertEquals("simple", model.getModule().getName()); assertEquals("io.vertx.test.groovy.codegen.testmodule.modulescoped", model.getModule().translatePackageName("groovy")); }
/** * @return the optional module name only present for {@link io.vertx.codegen.annotations.VertxGen} annotated types. */ public String getModuleName() { return module != null ? module.getName() : null; }
JsonObject entry = (JsonObject) el; if (entry.getString("group").equals(module.getGroupPackage())) { scope = entry.getString("scope", ""); if (scope.charAt(0) != '@') { if (module.getName().startsWith(entry.getString("prefix"))) { if (entry.getBoolean("stripPrefix")) { name = module.getName().substring(entry.getString("prefix").length()); } else { name = module.getName(); if (module.getName().equals(entry.getString("module"))) { name = entry.getString("name"); name = module.getName();
@Override public String getFqn() { return info.getPackageName(); }
public String translateFqn(String name) { return info.translatePackageName(name); }
/** * Resolve a module info for the specified {@code pkgElt} argument, returns null for undertermined. * * @param elementUtils the element utils * @param pkgElt the package element * @return the module info */ public static ModuleInfo resolve(Elements elementUtils, PackageElement pkgElt) { String pkgQN = pkgElt.getQualifiedName().toString(); while (true) { if (pkgElt != null) { ModuleGen annotation = pkgElt.getAnnotation(ModuleGen.class); if (annotation != null) { return new ModuleInfo(pkgElt.getQualifiedName().toString(), annotation.name(), annotation.groupPackage()); } } int pos = pkgQN.lastIndexOf('.'); if (pos == -1) { break; } else { pkgQN = pkgQN.substring(0, pos); Set<PackageElement> pkgElts = getPackageElement.apply(elementUtils, pkgQN); pkgElt = pkgElts.isEmpty() ? null : pkgElts.iterator().next(); } } return null; }
private Stream<Map.Entry<PackageElement, PackageModel>> getPackageModels() { return all.stream() .map(elementUtils::getPackageOf).distinct() .map(element -> new ModelEntry<>(element, () -> new PackageModel( element.getQualifiedName().toString(), ModuleInfo.resolve(elementUtils, element)) )); }
public String getName() { return info.getName(); }
ModuleGen annotation = pkg.getAnnotation(ModuleGen.class); if (annotation != null) { module = new ModuleInfo(pkg.getName(), annotation.name(), annotation.groupPackage()); break; } else {
TypeElement elt = (TypeElement) type.asElement(); PackageElement pkgElt = elementUtils.getPackageOf(elt); ModuleInfo module = ModuleInfo.resolve(elementUtils, pkgElt); String fqcn = elt.getQualifiedName().toString(); boolean proxyGen = elt.getAnnotation(ProxyGen.class) != null;
@Test public void testModuleScopedSubDataObjectModel() throws Exception { DataObjectModel model = new GeneratorHelper().generateDataObject(ModuleScopedSubDataObject.class); assertEquals(ModuleScopedSubDataObject.class.getName(), model.getFqn()); assertEquals("io.vertx.test.codegen.testmodule.modulescoped", model.getModule().getPackageName()); assertEquals("simple", model.getModule().getName()); }
public String translateName(String id) { return module == null ? name : module.translateQualifiedName(name, id); }
ClassTypeInfo ct = type.getRaw(); return "../../jsdoc/module-" + ct.getModule().getName(Case.KEBAB) + "-js_" + Case.SNAKE.format(Case.CAMEL.parse(elt.getSimpleName().toString())) + "-" + elt.getSimpleName() + ".html";
public ModuleModel getModuleModel(String modulePackage) { PackageElement element = modules.get(modulePackage); ModuleGen annotation = element.getAnnotation(ModuleGen.class); String moduleName = annotation.name(); if (moduleName.isEmpty()) { throw new GenException(element, "A module name cannot be empty"); } try { Case.KEBAB.parse(moduleName); } catch (IllegalArgumentException e) { throw new GenException(element, "Module name '" + moduleName + "' does not follow the snake case format (dash separated name)"); } String groupPackage = annotation.groupPackage(); if (groupPackage.equals("")) { groupPackage = modulePackage; } else if (!modulePackage.startsWith(groupPackage)) { throw new GenException(element, "A module package (" + modulePackage + ") must be prefixed by the group package (" + groupPackage + ")"); } try { Case.QUALIFIED.parse(groupPackage); } catch (Exception e) { throw new GenException(element, "Invalid group package name " + groupPackage); } ModuleInfo info = new ModuleInfo(modulePackage, moduleName, groupPackage); AnnotationValueInfoFactory annotationFactory = new AnnotationValueInfoFactory(new TypeMirrorFactory(elementUtils,typeUtils)); List<AnnotationValueInfo> annotationValueInfos = element.getAnnotationMirrors().stream().map(annotationFactory::processAnnotation).collect(Collectors.toList()); return new ModuleModel(element, info, annotationValueInfos); }
@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()); }
public String translatePackageName(String id) { return module == null ? packageName : module.translateQualifiedName(packageName, id); }