@Test
 public void javaTypeTypeVariableBounds() throws ClassNotFoundException {
   JavaInterface<?> foo =
       Roaster.create(JavaInterfaceSource.class).setPackage("it.coopservice.test").setName("Foo");
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable().setName("T").setBounds(foo);
   Assert.assertTrue(javaClass.toString().contains("<T extends Foo>"));
   JavaInterface<?> bar =
       Roaster.create(JavaInterfaceSource.class).setPackage("it.coopservice.test").setName("Bar");
   javaClass.getTypeVariable("T").setBounds(foo, bar);
   Assert.assertTrue(javaClass.toString().contains("<T extends Foo & Bar>"));
   javaClass.getTypeVariable("T").removeBounds();
   Assert.assertTrue(javaClass.toString().contains("<T>"));
 }
  @Test
  public void testCreateEnum() throws Exception {
    Project project = projectFactory.createTempProject();
    facetFactory.install(project, JavaSourceFacet.class);
    JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
    JavaEnumSource javaEnum =
        Roaster.parse(
            JavaEnumSource.class, "package org.jboss.forge.test; public enum CreditCardType{}");
    facet.saveJavaSource(javaEnum);

    JavaResource javaResource = facet.getJavaResource("org.jboss.forge.test.CreditCardType");
    Assert.assertNotNull(javaResource);
    Assert.assertThat(javaResource.getJavaType(), is(instanceOf(JavaEnum.class)));

    CommandController controller =
        testHarness.createCommandController(JavaAddEnumConstantCommand.class, javaResource);
    controller.initialize();
    controller.setValueFor("named", "VISA");
    Assert.assertTrue(controller.isValid());
    Assert.assertTrue(controller.canExecute());
    Result result = controller.execute();
    Assert.assertThat(result, is(not(instanceOf(Failed.class))));

    javaResource = facet.getJavaResource("org.jboss.forge.test.CreditCardType");
    JavaEnumSource enumClass = javaResource.getJavaType();
    List<EnumConstantSource> enumConstants = enumClass.getEnumConstants();
    Assert.assertEquals(1, enumConstants.size());

    Assert.assertEquals("VISA", enumConstants.get(0).getName());
  }
Esempio n. 3
0
 public JavaResource createEmptyEnum(Project project, String enumName) throws IOException {
   JavaSourceFacet javaSourceFacet = project.getFacet(JavaSourceFacet.class);
   JavaEnumSource enumSource = Roaster.create(JavaEnumSource.class).setName(enumName);
   String packageName =
       project.getFacet(JavaSourceFacet.class).getBasePackage() + "." + DEFAULT_ENTITY_PACKAGE;
   enumSource.setPackage(packageName);
   return javaSourceFacet.saveJavaSource(enumSource);
 }
 @Test
 public void addGenericSuperTypeWithoutPackage() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.setSuperType("Bar<T>");
   Assert.assertTrue(javaClass.toString().contains("Bar<T>"));
   Assert.assertNull(javaClass.getImport("it.coopservice.test.Bar"));
 }
Esempio n. 5
0
 @Test
 public void testJavaDocParsing() throws Exception {
   String text = "/** Text */ public class MyClass{}";
   JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, text);
   JavaDocSource<JavaClassSource> javaDoc = javaClass.getJavaDoc();
   Assert.assertNotNull(javaDoc);
   Assert.assertEquals("Text", javaDoc.getText());
   Assert.assertTrue(javaDoc.getTagNames().isEmpty());
 }
 @Test
 public void addMultipleGenerics() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable().setName("I");
   javaClass.addTypeVariable().setName("O");
   Assert.assertTrue(javaClass.toString().contains("<I, O>"));
   javaClass.removeTypeVariable("I");
   Assert.assertTrue(javaClass.toString().contains("<O>"));
 }
 @Test
 public void addAndRemoveGenericType() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable().setName("T");
   Assert.assertTrue(javaClass.getTypeVariables().get(0).getBounds().isEmpty());
   Assert.assertTrue(javaClass.toString().contains("<T>"));
   javaClass.removeTypeVariable("T");
   Assert.assertFalse(javaClass.toString().contains("<T>"));
 }
 @Test
 public void classTypeVariableBounds() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable().setName("T").setBounds(CharSequence.class);
   Assert.assertTrue(javaClass.toString().contains("<T extends CharSequence>"));
   javaClass.getTypeVariable("T").setBounds(CharSequence.class, Serializable.class);
   Assert.assertTrue(javaClass.toString().contains("<T extends CharSequence & Serializable>"));
   javaClass.getTypeVariable("T").removeBounds();
   Assert.assertTrue(javaClass.toString().contains("<T>"));
 }
Esempio n. 9
0
 @Test
 public void testJavaDocParsingTags() throws Exception {
   String text = "/** Do Something\n*@author George Gastaldi*/ public class MyClass{}";
   JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, text);
   JavaDocSource<JavaClassSource> javaDoc = javaClass.getJavaDoc();
   Assert.assertNotNull(javaDoc);
   Assert.assertEquals("Do Something", javaDoc.getText());
   Assert.assertEquals(1, javaDoc.getTagNames().size());
   JavaDocTag authorTag = javaDoc.getTags("@author").get(0);
   Assert.assertEquals("@author", authorTag.getName());
   Assert.assertEquals("George Gastaldi", authorTag.getValue());
 }
  @Override
  public String generateJavaTemplateSource(SourceGenerationContext context) {
    JavaClassSource viewClass = Roaster.create(JavaClassSource.class);
    String packageName = getPackageName(context);

    addTypeSignature(context, viewClass, packageName);
    addImports(context, viewClass);
    addAnnotations(context, viewClass);
    addAdditional(context, viewClass);

    addBaseViewFieldsAndMethodImpls(context, viewClass);
    return viewClass.toString();
  }
 @Test
 public void stringTypeVariableBounds() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable().setName("T").setBounds("com.something.Foo");
   Assert.assertTrue(javaClass.toString().contains("<T extends com.something.Foo>"));
   javaClass.getTypeVariable("T").setBounds("com.something.Foo", "com.something.Bar<T>");
   Assert.assertTrue(
       javaClass.toString().contains("<T extends com.something.Foo & com.something.Bar<T>>"));
   javaClass.getTypeVariable("T").removeBounds();
   Assert.assertTrue(javaClass.toString().contains("<T>"));
 }
 @Test
 public void addMultipleConcreteGenericSuperTypeWithPackage() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.setSuperType(
       "it.coopservice.test.Bar<com.coopservice.test.MyConcreteSuperClass,com.coopservice.test.MyOtherClass>");
   Assert.assertTrue(
       javaClass.toString().contains("extends Bar<MyConcreteSuperClass, MyOtherClass>"));
   Assert.assertNotNull(javaClass.getImport("it.coopservice.test.Bar"));
   Assert.assertNotNull(javaClass.getImport("com.coopservice.test.MyConcreteSuperClass"));
   Assert.assertNotNull(javaClass.getImport("com.coopservice.test.MyOtherClass"));
 }
 @Test
 public void getClassGenericsName() throws ClassNotFoundException {
   JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
   javaClass.setPackage("it.coopservice.test");
   javaClass.setName("SimpleClass");
   javaClass.addTypeVariable("I");
   javaClass.addTypeVariable("O");
   List<TypeVariableSource<JavaClassSource>> typeVariables = javaClass.getTypeVariables();
   Assert.assertNotNull(typeVariables);
   Assert.assertEquals(2, typeVariables.size());
   Assert.assertEquals("I", typeVariables.get(0).getName());
   Assert.assertTrue(typeVariables.get(0).getBounds().isEmpty());
   Assert.assertEquals("O", typeVariables.get(1).getName());
   Assert.assertTrue(typeVariables.get(1).getBounds().isEmpty());
 }
Esempio n. 14
0
 @Test
 public void testJavaDocMultiLineShouldNotConcatenateWords() throws Exception {
   String text =
       "/**"
           + LINE_SEPARATOR
           + "* The country where this currency is used mostly. This field is just for"
           + LINE_SEPARATOR
           + "* informational purposes and have no effect on any processing."
           + LINE_SEPARATOR
           + "*/"
           + LINE_SEPARATOR
           + "public class MyClass{}";
   JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, text);
   JavaDocSource<JavaClassSource> javaDoc = javaClass.getJavaDoc();
   String expected =
       "The country where this currency is used mostly. This field is just for informational purposes and have no effect on any processing.";
   Assert.assertEquals(expected, javaDoc.getFullText());
 }
Esempio n. 15
0
 @Test
 public void testJavaDocEnumConstant() throws Exception {
   String text =
       "public enum MyEnum {"
           + "/**"
           + LINE_SEPARATOR
           + " * Do Something"
           + LINE_SEPARATOR
           + " * @author George Gastaldi"
           + LINE_SEPARATOR
           + " */"
           + LINE_SEPARATOR
           + ""
           + "MY_CONSTANT;}";
   JavaEnumSource javaEnum = Roaster.parse(JavaEnumSource.class, text);
   Assert.assertFalse(javaEnum.hasJavaDoc());
   EnumConstantSource enumConstant = javaEnum.getEnumConstant("MY_CONSTANT");
   Assert.assertTrue(enumConstant.hasJavaDoc());
   JavaDocSource<EnumConstantSource> javaDoc = enumConstant.getJavaDoc();
   String expected = "Do Something" + LINE_SEPARATOR + "@author George Gastaldi";
   Assert.assertEquals(expected, javaDoc.getFullText());
 }
Esempio n. 16
0
 @Test
 public void testJavaDocGetFullText() throws Exception {
   String text =
       "/**"
           + LINE_SEPARATOR
           + " * Do Something"
           + LINE_SEPARATOR
           + " * @author George Gastaldi"
           + LINE_SEPARATOR
           + " */"
           + LINE_SEPARATOR
           + "public class MyClass"
           + LINE_SEPARATOR
           + "{"
           + LINE_SEPARATOR
           + "}";
   JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, text);
   Assert.assertTrue(javaClass.hasJavaDoc());
   JavaDocSource<JavaClassSource> javaDoc = javaClass.getJavaDoc();
   String expected = "Do Something" + LINE_SEPARATOR + "@author George Gastaldi";
   Assert.assertEquals(expected, javaDoc.getFullText());
 }
Esempio n. 17
0
 @Test
 public void testJavaDocMethod() throws Exception {
   String text =
       "public class MyClass {"
           + "/**"
           + LINE_SEPARATOR
           + " * Do Something"
           + LINE_SEPARATOR
           + " * @author George Gastaldi"
           + LINE_SEPARATOR
           + " */"
           + LINE_SEPARATOR
           + ""
           + "private void foo(){};}";
   JavaClassSource javaClass = Roaster.parse(JavaClassSource.class, text);
   Assert.assertFalse(javaClass.hasJavaDoc());
   Assert.assertEquals(1, javaClass.getMethods().size());
   MethodSource<JavaClassSource> method = javaClass.getMethods().get(0);
   Assert.assertTrue(method.hasJavaDoc());
   JavaDocSource<MethodSource<JavaClassSource>> javaDoc = method.getJavaDoc();
   String expected = "Do Something" + LINE_SEPARATOR + "@author George Gastaldi";
   Assert.assertEquals(expected, javaDoc.getFullText());
 }
Esempio n. 18
0
 @Test
 public void testJavaDocSetFullText() throws Exception {
   String expected =
       "/**"
           + LINE_SEPARATOR
           + " * Do Something"
           + LINE_SEPARATOR
           + " * "
           + LINE_SEPARATOR
           + " * @author George Gastaldi"
           + LINE_SEPARATOR
           + " */"
           + LINE_SEPARATOR
           + "public class MyClass {"
           + LINE_SEPARATOR
           + "}";
   JavaClassSource javaClass =
       Roaster.create(JavaClassSource.class).setPublic().setName("MyClass");
   Assert.assertFalse(javaClass.hasJavaDoc());
   JavaDocSource<JavaClassSource> javaDoc = javaClass.getJavaDoc();
   javaDoc.setFullText("Do Something" + LINE_SEPARATOR + "* @author George Gastaldi");
   Assert.assertEquals(expected, javaClass.toString());
 }
Esempio n. 19
0
  @SuppressWarnings({"unchecked", "rawtypes"})
  private List<Resource<?>> generateFromEntity(
      String targetDir, final Resource<?> template, final JavaClassSource entity) {
    resetMetaWidgets();

    // Track the list of resources generated

    List<Resource<?>> result = new ArrayList<>();
    try {
      JavaSourceFacet java = this.project.getFacet(JavaSourceFacet.class);
      WebResourcesFacet web = this.project.getFacet(WebResourcesFacet.class);
      JPAFacet<PersistenceCommonDescriptor> jpa = this.project.getFacet(JPAFacet.class);

      loadTemplates();
      Map<Object, Object> context = CollectionUtils.newHashMap();
      context.put("entity", entity);
      String ccEntity = StringUtils.decapitalize(entity.getName());
      context.put("ccEntity", ccEntity);
      context.put("rmEntity", ccEntity + "ToDelete");
      setPrimaryKeyMetaData(context, entity);

      // Prepare qbeMetawidget
      this.qbeMetawidget.setPath(entity.getQualifiedName());
      StringWriter stringWriter = new StringWriter();
      this.qbeMetawidget.write(stringWriter, this.backingBeanTemplateQbeMetawidgetIndent);
      context.put("qbeMetawidget", stringWriter.toString().trim());

      // Prepare removeEntityMetawidget
      this.rmEntityMetawidget.setPath(entity.getQualifiedName());
      stringWriter = new StringWriter();
      this.rmEntityMetawidget.write(stringWriter, this.backingBeanTemplateRmEntityMetawidgetIndent);
      context.put("rmEntityMetawidget", stringWriter.toString().trim());

      // Prepare Java imports
      Set<String> qbeMetawidgetImports = this.qbeMetawidget.getImports();
      Set<String> rmEntityMetawidgetImports = this.rmEntityMetawidget.getImports();
      Set<String> metawidgetImports = CollectionUtils.newHashSet();
      metawidgetImports.addAll(qbeMetawidgetImports);
      metawidgetImports.addAll(rmEntityMetawidgetImports);
      metawidgetImports.remove(entity.getQualifiedName());
      context.put(
          "metawidgetImports",
          CollectionUtils.toString(metawidgetImports, ";\r\nimport ", true, false));

      // Prepare JPA Persistence Unit
      context.put("persistenceUnitName", jpa.getConfig().getOrCreatePersistenceUnit().getName());

      // Create the Backing Bean for this entity
      JavaClassSource viewBean =
          Roaster.parse(
              JavaClassSource.class,
              FreemarkerTemplateProcessor.processTemplate(context, this.backingBeanTemplate));
      viewBean.setPackage(java.getBasePackage() + "." + DEFAULT_FACES_PACKAGE);
      result.add(
          ScaffoldUtil.createOrOverwrite(java.getJavaResource(viewBean), viewBean.toString()));

      // Set new context for view generation
      context = getTemplateContext(targetDir, template);
      String beanName = StringUtils.decapitalize(viewBean.getName());
      context.put("beanName", beanName);
      context.put("ccEntity", ccEntity);
      context.put("entityName", StringUtils.uncamelCase(entity.getName()));
      setPrimaryKeyMetaData(context, entity);

      // Prepare entityMetawidget
      this.entityMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + "." + ccEntity));
      this.entityMetawidget.setPath(entity.getQualifiedName());
      this.entityMetawidget.setReadOnly(false);
      this.entityMetawidget.setStyle(null);

      // Generate create
      writeEntityMetawidget(
          context, this.createTemplateEntityMetawidgetIndent, this.createTemplateNamespaces);

      result.add(
          ScaffoldUtil.createOrOverwrite(
              web.getWebResource(targetDir + "/" + ccEntity + "/create.xhtml"),
              FreemarkerTemplateProcessor.processTemplate(context, this.createTemplate)));

      // Generate view
      this.entityMetawidget.setReadOnly(true);
      writeEntityMetawidget(
          context, this.viewTemplateEntityMetawidgetIndent, this.viewTemplateNamespaces);

      result.add(
          ScaffoldUtil.createOrOverwrite(
              web.getWebResource(targetDir + "/" + ccEntity + "/view.xhtml"),
              FreemarkerTemplateProcessor.processTemplate(context, this.viewTemplate)));

      // Generate search
      this.searchMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + ".example"));
      this.searchMetawidget.setPath(entity.getQualifiedName());
      this.beanMetawidget.setValue(StaticFacesUtils.wrapExpression(beanName + ".pageItems"));
      this.beanMetawidget.setPath(viewBean.getQualifiedName() + "/pageItems");
      writeSearchAndBeanMetawidget(
          context,
          this.searchTemplateSearchMetawidgetIndent,
          this.searchTemplateBeanMetawidgetIndent,
          this.searchTemplateNamespaces);

      result.add(
          ScaffoldUtil.createOrOverwrite(
              web.getWebResource(targetDir + "/" + ccEntity + "/search.xhtml"),
              FreemarkerTemplateProcessor.processTemplate(context, this.searchTemplate)));

      // Generate navigation
      result.add(generateNavigation(targetDir));

      // Need ViewUtils and forge.taglib.xml for forgeview:asList
      JavaClassSource viewUtils =
          Roaster.parse(
              JavaClassSource.class,
              FreemarkerTemplateProcessor.processTemplate(context, this.viewUtilsTemplate));
      viewUtils.setPackage(viewBean.getPackage());
      result.add(
          ScaffoldUtil.createOrOverwrite(java.getJavaResource(viewUtils), viewUtils.toString()));

      context.put("viewPackage", viewBean.getPackage());
      result.add(
          ScaffoldUtil.createOrOverwrite(
              web.getWebResource("WEB-INF/classes/META-INF/forge.taglib.xml"),
              FreemarkerTemplateProcessor.processTemplate(context, this.taglibTemplate)));

      createInitializers(entity);
    } catch (Exception e) {
      throw new RuntimeException("Error generating default scaffolding: " + e.getMessage(), e);
    }
    return result;
  }