Refine search
private static void adjustLocalFavoriteInfo() throws Exception { JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, new File(LOCAL_FAVORITE_INFO_PATH)); javaClass.removeField(javaClass.getField("gid")); javaClass.removeField(javaClass.getField("token")); javaClass.removeField(javaClass.getField("title")); javaClass.removeField(javaClass.getField("titleJpn")); "\t\tsuper(in);\n" + "\t\tthis.time = in.readLong();\n" + "\t}").setConstructor(true); javaClass.addField("\tpublic static final Creator<LocalFavoriteInfo> CREATOR = new Creator<LocalFavoriteInfo>() {\n" + "\t\t@Override\n" + "\t\tthis.simpleTags = galleryInfo.simpleTags;\n" + "\t\tthis.simpleLanguage = galleryInfo.simpleLanguage;\n" + "\t}").setConstructor(true); javaClass.addImport("com.hippo.ehviewer.client.data.GalleryInfo");
accessor.getJavaDoc() .setText("Get the list of " + childClassName + " resources") .addTagValue("@return", "the list of resources"); accessor.setPublic() .setName(propName) .setReturnType(propType) .setBody("return this." + propName + ";"); getByKey.addParameter(String.class, "key"); getByKey.setPublic() .setName(singularName) .setReturnType(childClassName) .setBody("return this." + propName + ".stream().filter( e->e.getKey().equals(key) ).findFirst().orElse(null);"); listMutator.getJavaDoc() .setText("Add all " + childClassName + " objects to this subresource") .addTagValue("@return", "this") .addTagValue("@param", "value List of " + childClassName + " objects."); listMutator.addParameter(propType, "value"); listMutator.setPublic() .setName(propName) .setReturnType("T") .setBody("this.subresources." + propName + " = value;\nreturn (T) this;") .addAnnotation("SuppressWarnings").setStringValue("unchecked"); mutator.getJavaDoc() .setText("Add the " + childClassName + " object to the list of subresources") .addTagValue("@param", "value The " + childClassName + " to add") .addTagValue("@return", "this");
final String componentName = (overrideComponentName != null ? overrideComponentName : model.getScheme()).toLowerCase(Locale.US); final JavaClassSource javaClass = Roaster.create(JavaClassSource.class); javaClass.addNestedType( Roaster.create(JavaClassSource.class) .setName("GroupConditions") .setStatic(true) .setPackagePrivate() .extendSuperType(Roaster.create(JavaClassSource.class).setName("GroupCondition")) .addMethod() .setName("GroupConditions") .setConstructor(true) .setPublic() .setBody("super(\"camel.component\", \"camel.component." + componentName + "\");") .getOrigin() ); MethodSource<JavaClassSource> method = javaClass.addMethod() .setName(methodName) .setPublic() .setBody(body) .setReturnType(model.getShortJavaType()) .addThrows(Exception.class); method.addAnnotation(Lazy.class); method.addAnnotation(Bean.class).setStringArrayValue("name", springBeanAliases); method.addAnnotation(ConditionalOnMissingBean.class).setLiteralValue(model.getShortJavaType() + ".class");
private void createRestModuleAutoConfigurationSource(String packageName, OtherModel model) throws MojoFailureException { final JavaClassSource javaClass = Roaster.create(JavaClassSource.class); final int pos = model.getJavaType().lastIndexOf("."); final String name = model.getJavaType().substring(pos + 1) + "AutoConfiguration"; final String configType = model.getJavaType().substring(pos + 1) + "Properties"; javaClass.setPackage(packageName); javaClass.setName(name); javaClass.getJavaDoc().setFullText(doc); javaClass.addAnnotation(Generated.class).setStringValue("value", SpringBootAutoConfigurationMojo.class.getName()); method = javaClass.addMethod(); method.setName("configure" + model.getShortJavaType()); method.setPublic(); method.addThrows(Exception.class); method.setReturnType("org.apache.camel.spi.RestConfiguration"); method.addAnnotation(Lazy.class); method.addAnnotation(Bean.class).setLiteralValue("name", "RestConstants.DEFAULT_REST_CONFIGURATION_ID"); method.addAnnotation(ConditionalOnClass.class).setLiteralValue("value", "CamelContext.class"); method.addAnnotation(ConditionalOnMissingBean.class); method.setBody("" + "Map<String, Object> properties = new HashMap<>();\n" + "IntrospectionSupport.getProperties(config, properties, null, false);\n"
private void writeMapPut(final JavaClassSource javaClass, final Property propDef) { final String name = "put" + propDef.getPropertyName(); if (!javaClass.hasMethodSignature(name)) { final StringBuilder javadoc = new StringBuilder(); javadoc .append("@return the pSourcePath\n"); String body = ""; javaClass.addImport("javafx.collections.FXCollections"); body = Templates.use(TemplateName.PropertyPutMap, propDef); final MethodSource<?> method = javaClass.addMethod() .setName(name) .setPublic() .setBody(body.toString()) .setReturnType(javaClass.getTypeVariables().isEmpty() ? javaClass.getName() : javaClass.getTypeVariables().get(0).getName()); method.getJavaDoc().setFullText(javadoc.toString()); } else { // javaClass.getMethod(propDef.getName()).setBody(javaClass.getMethod(propDef.getName()).getBody() // + body.toString()); } }
.setPublic().setConstructor(true); constructor.addParameter(javaSource, "delegate"); constructor.setBody("this.delegate = delegate;"); if (method.isPrivate()) continue; MethodSource<JavaClassSource> decoratorMethod = decoratorClass .addMethod().setPublic().setName(method.getName()); StringBuilder sb = new StringBuilder(); if (method.isReturnTypeVoid()) decoratorMethod.setReturnTypeVoid(); sb.append("delegate."); decoratorMethod.setReturnType(method.getReturnType() .getQualifiedName()); sb.append(method.getName()).append("("); List<ParameterSource<?>> parameters = method.getParameters(); for (Iterator<ParameterSource<?>> iterator = parameters .iterator(); iterator.hasNext();) decoratorMethod.addParameter(param.getType() .getQualifiedName(), param.getName()); for (String o : (List<String>) method.getThrownExceptions()) decoratorMethod.addThrows(o);
String builderClassName = javaClass.getName() + "Builder"; JavaClassSource builderClass = Roaster.create(JavaClassSource.class) .setName(builderClassName) .setPackage(javaClass.getPackage()); for (Import i : javaClass.getImports()) .setLiteralInitializer("new " + javaClass.getName() + "();"); builderClass.addMethod() .setPublic().setStatic(true).setName("create").setReturnType(builderClass) .setBody("return new " + builderClassName + "();"); builderClass.addMethod() .setConstructor(true).setPrivate().setBody(""); builderClass.addMethod() .setPublic().setReturnType(javaClass).setName("build").setBody("return obj;"); for (PropertySource<JavaClassSource> property : javaClass.getProperties()) MethodSource<JavaClassSource> method = builderClass.addMethod().setPublic().setReturnType(builderClass) .setName("with" + upperCasedName); method.addParameter(property.getType().getQualifiedName(), "param"); method.setBody("obj.set" + upperCasedName + "(param);return this;");
private JavaClassSource getOrCreateSubresourceClass(ClassPlan plan, JavaClassSource javaClass) { JavaClassSource subresourceClass = plan.getSubresourceClass(); if (subresourceClass != null) { return subresourceClass; } subresourceClass = Roaster.parse( JavaClassSource.class, "class " + javaClass.getName() + "Resources" + " {}" ); subresourceClass.setPackage(plan.getPackageName()); subresourceClass.getJavaDoc().setText("Child mutators for " + javaClass.getName()); subresourceClass.setPublic(); subresourceClass.setStatic(true); javaClass.addField() .setPrivate() .setType(subresourceClass.getName()) .setName("subresources") .setLiteralInitializer("new " + subresourceClass.getName() + "();"); final MethodSource<JavaClassSource> subresourcesMethod = javaClass.addMethod() .setName("subresources") .setPublic(); subresourcesMethod.setReturnType(subresourceClass.getName()); subresourcesMethod.setBody("return this.subresources;"); javaClass.addImport("java.util.List"); javaClass.addImport(Subresource.class); plan.setSubresourceClass(subresourceClass); return subresourceClass; }
}}; .setName("setup") .setBody( "vertx = Vertx.vertx();\nvertx.deployVerticle("+className+".class.getName(), context.asyncAssertSuccess());") .setPublic() .setReturnTypeVoid(); setupMethod.addAnnotation("Before"); setupMethod.addParameter("TestContext","context"); .setName("tearDown") .setBody( "vertx.close(context.asyncAssertSuccess());") .setPublic() .setReturnTypeVoid(); tearDownMethod.addAnnotation("After"); tearDownMethod.addParameter("TestContext","context"); .setName("myAppTest") .setBody( "// add your test case here") .setPublic() .setReturnTypeVoid(); sampleTestMethod.addAnnotation("Test"); sampleTestMethod.addParameter("TestContext","context");
JavaClassSource javaClass = Roaster.create(JavaClassSource.class).setName(named.getValue()) .setPackage(packageName.getValue()); javaClass.addImport("org.jboss.arquillian.container.test.api.Deployment"); javaClass.addImport("org.jboss.arquillian.junit.Arquillian"); javaClass.addImport("org.jboss.forge.arquillian.AddonDependency"); MethodSource<JavaClassSource> getDeployment = javaClass.addMethod().setName("getDeployment").setPublic() .setStatic(true) .setBody("return ShrinkWrap.create(AddonArchive.class).addBeansXML();").setReturnType("AddonArchive"); getDeployment.addAnnotation("Deployment"); AnnotationSource<JavaClassSource> addonDependenciesAnn = getDeployment.addAnnotation("AddonDependencies"); javaClass.addMethod().setName("testAddon").setPublic().setReturnTypeVoid() .setBody("Assert.fail(\"Not yet implemented\");").addAnnotation("Test");
private void addExecuteMethod(JavaClassSource command) { command.addMethod() .setPublic() .setName("execute") .setReturnType(Result.class) .setParameters("UIExecutionContext context") .setBody( "return Results.success(\"Command '" + commandName.getValue() + "' successfully executed!\");") .addThrows(Exception.class) .addAnnotation(Override.class); }
JavaClassSource commonClass = Roaster.create(JavaClassSource.class); commonClass.setPackage(packageName); commonClass.setName(commonName); doc = model.getDescription() + "\n\n" + doc; commonClass.getJavaDoc().setFullText(doc); commonClass.addAnnotation(Generated.class).setStringValue("value", SpringBootAutoConfigurationMojo.class.getName()); method = configClass.addMethod(); method.setName("getConfigurations"); method.setReturnType("Map<String, " + commonName + ">"); method.setPublic(); method.setBody("return configurations;"); method = configClass.addMethod(); method.setName("isEnabled"); method.setReturnType(boolean.class); method.setPublic(); method.setBody("return enabled;"); method = configClass.addMethod(); method.setName("setEnabled"); method.addParameter(boolean.class, "enabled"); method.setPublic(); method.setBody("this.enabled = enabled;");
private JavaClassSource createCommand(JavaClassSource command, String commandName, Iterable<String> categories) { MethodSource<JavaClassSource> commandMethod = command.addMethod().setName(toMethodName(command, commandName)) .setReturnType(String.class) .setBody(String.format("return \"Command %s executed\";", commandName)).setPublic(); AnnotationSource<JavaClassSource> commandAnn = commandMethod.addAnnotation(Command.class); List<String> categoryList = new ArrayList<>(Lists.toList(categories)); commandAnn.setStringValue("value", commandName); if (!categoryList.isEmpty()) { commandAnn.setStringArrayValue("categories", categoryList.toArray(new String[categoryList.size()])); } // build the thing return command; }
/** * Generates a getXXX and setXXX method for the supplied field * * @param clazz * @param field */ public static void createGetterAndSetter(final JavaClassSource clazz, final FieldSource<JavaClassSource> field) { if (!clazz.hasField(field)) { throw new IllegalArgumentException("Entity did not contain the given field [" + field + "]"); } clazz.getMethods(); String fieldName = field.getName(); String methodNameSuffix = Strings.capitalize(fieldName); clazz.addMethod().setReturnType(field.getType().toString()).setName("get" + methodNameSuffix) .setPublic() .setBody("return this." + fieldName + ";"); if (!field.isFinal()) { clazz.addMethod().setReturnTypeVoid().setName("set" + methodNameSuffix).setPublic() .setParameters("final " + field.getType().toString() + " " + fieldName) .setBody("this." + fieldName + " = " + fieldName + ";"); } }
final String pkg = moduleName.substring(0, moduleName.lastIndexOf('.')); final JavaClassSource javaClass = Roaster.create(JavaClassSource.class); javaClass.setPackage(pkg).setName(starterName); javaClass.extendSuperType(AbstractModuleStarter.class); if (!javaClass.hasMethodSignature("start")) { final MethodSource<?> method = javaClass.addMethod() .setName("start") .setPublic() .setBody(body.toString()) .setReturnTypeVoid(); method.getJavaDoc().setFullText("{@inheritDoc}"); method.addAnnotation(Override.class); javaClass.getMethod("start").setBody(javaClass.getMethod("start").getBody() + body.toString());
commandName.setValue(calculateCommandName(command.getName())); MethodSource<JavaClassSource> getMetadataMethod = command.addMethod() .setPublic() .setName("getMetadata") .setReturnType(UICommandMetadata.class) .setParameters("UIContext context"); getMetadataMethod.addAnnotation(Override.class); getMetadataMethod.setBody(getMetadataMethodBody); command.addMethod() .setPublic() .setName("initializeUI") .setReturnTypeVoid() .setBody("// not implemented") .setParameters("UIBuilder builder") .addThrows(Exception.class) .addAnnotation(Override.class); command.addMethod() .setPublic() .setName("execute") .setReturnType(Result.class) .setParameters("UIExecutionContext context") .setBody("return Results.success(\"Command '" + commandName.getValue() + "' successfully executed!\");") .addThrows(Exception.class) .addAnnotation(Override.class);
private String addJavaVerticle(Project project, String packageName, String className, boolean isMain) { JavaSourceFacet source = project.getFacet(JavaSourceFacet.class); String topLevelPackage; if (packageName == null) { topLevelPackage = source.getBasePackage(); } else { topLevelPackage = packageName; } if (className.endsWith(".java")) { className = className.substring(0, className.length() - ".java".length()); } JavaClassSource mainVerticle = Roaster.create(JavaClassSource.class) .setPackage(topLevelPackage) .setAbstract(false) .setName(className) .setSuperType("io.vertx.core.AbstractVerticle"); mainVerticle .addImport("io.vertx.core.*"); mainVerticle.addMethod().setName("start").setBody( "vertx.createHttpServer().requestHandler(req -> req.response().end(\"Hello World!\")).listen(8080);") .setPublic() .addAnnotation(Override.class); JavaResource resource = source.saveJavaSource(mainVerticle.getEnclosingType()); if (isMain) { ForgeUtils.addPropertyToProject(project, "vertx.verticle", topLevelPackage + "." + className); } addJavaVerticleTest(project,packageName,className); return resource.toString(); }
private void createLanguageConfigurationSource(String packageName, LanguageModel model, String overrideLanguageName) throws MojoFailureException { final JavaClassSource javaClass = Roaster.create(JavaClassSource.class); javaClass.setPackage(packageName).setName(name); javaClass.extendSuperType(Roaster.create(JavaClassSource.class).setName("LanguageConfigurationPropertiesCommon")); javaClass.addImport("org.apache.camel.spring.boot.LanguageConfigurationPropertiesCommon"); if ("true".equals(option.getDeprecated())) { prop.getField().addAnnotation(Deprecated.class); prop.getAccessor().addAnnotation(Deprecated.class); prop.getMutator().addAnnotation(Deprecated.class); prop.getAccessor().addAnnotation(DeprecatedConfigurationProperty.class);
JavaClassSource restEndpoint = Roaster.create(JavaClassSource.class) .setPackage(facet.getBasePackage() + ".rest") .setName("HelloWorldEndpoint"); if (hasCDI(installedFractions)) restEndpoint.addAnnotation(ApplicationScoped.class); restEndpoint.addAnnotation(Path.class).setStringValue("/hello"); MethodSource<JavaClassSource> method = restEndpoint.addMethod().setPublic().setReturnType(Response.class) .setName("doGet") .setBody("return Response.ok(\"Hello from WildFly Swarm!\").build();"); method.addAnnotation(GET.class); method.addAnnotation(javax.ws.rs.Produces.class).setStringArrayValue(new String[] { MediaType.TEXT_PLAIN }); facet.saveJavaSource(restEndpoint);
public JavaEnumSource create(ClassIndex index, EnumPlan plan) { final JavaEnumSource enumType = Roaster.create(JavaEnumSource.class) .setName(plan.getClassName()) .setPublic(); .getJavaDoc() .setText("Returns the allowed value for the management model.") .addTagValue("@return", "the allowed model value"); .setConstructor(true); constructor.addParameter(String.class, "allowedValue"); constructor.setBody("this.allowedValue = allowedValue;"); .setName("toString") .setReturnType(String.class) .setPublic() .setBody("return allowedValue;") .addAnnotation(Override.class);