FORGE-1493: Created cdi-new-stereotype command

javaee/impl/src/main/java/org/jboss/forge/addon/javaee/cdi/ui/NewStereotypeCommand.java

@@ -0,0 +1,158 @@
+/**
+ * Copyright 2014 Red Hat, Inc. and/or its affiliates.
+ *
+ * Licensed under the Eclipse Public License version 1.0, available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.jboss.forge.addon.javaee.cdi.ui;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import javax.enterprise.inject.Alternative;
+import javax.enterprise.inject.Stereotype;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.jboss.forge.addon.parser.java.facets.JavaSourceFacet;
+import org.jboss.forge.addon.parser.java.resources.JavaResource;
+import org.jboss.forge.addon.parser.java.ui.AbstractJavaSourceCommand;
+import org.jboss.forge.addon.ui.context.UIBuilder;
+import org.jboss.forge.addon.ui.context.UIContext;
+import org.jboss.forge.addon.ui.context.UIExecutionContext;
+import org.jboss.forge.addon.ui.input.UIInput;
+import org.jboss.forge.addon.ui.input.UISelectMany;
+import org.jboss.forge.addon.ui.metadata.WithAttributes;
+import org.jboss.forge.addon.ui.result.Failed;
+import org.jboss.forge.addon.ui.result.Result;
+import org.jboss.forge.addon.ui.util.Categories;
+import org.jboss.forge.addon.ui.util.Metadata;
+import org.jboss.forge.parser.java.JavaAnnotation;
+import org.jboss.forge.parser.java.JavaSource;
+
+/**
+ * Creates a new CDI Scope annotation
+ * 
+ * @author <a href="ggastald@redhat.com">George Gastaldi</a>
+ */
+public class NewStereotypeCommand extends AbstractJavaSourceCommand
+{
+   @Inject
+   @WithAttributes(label = "Inherited")
+   private UIInput<Boolean> inherited;
+
+   @Inject
+   @WithAttributes(label = "Alternative")
+   private UIInput<Boolean> alternative;
+
+   @Inject
+   @WithAttributes(label = "Named")
+   private UIInput<Boolean> withNamed;
+
+   @Inject
+   @WithAttributes(label = "Target Element Types", required = true, requiredMessage = "No target element types selected")
+   private UISelectMany<ElementType> targetTypes;
+
+   @Override
+   public Metadata getMetadata(UIContext context)
+   {
+      return Metadata.from(super.getMetadata(context), getClass())
+               .name("CDI: New Stereotype")
+               .description("Creates a new CDI Stereotype annotation")
+               .category(Categories.create(super.getMetadata(context).getCategory(), "CDI"));
+   }
+
+   @Override
+   public void initializeUI(UIBuilder builder) throws Exception
+   {
+      super.initializeUI(builder);
+      targetTypes.setValue(Arrays.asList(TYPE, METHOD, FIELD));
+      builder.add(alternative).add(withNamed).add(inherited).add(targetTypes);
+   }
+
+   @Override
+   public Result execute(UIExecutionContext context) throws Exception
+   {
+      // TODO: Super implementation should have an "overwrite" flag for existing files?
+      Result result = super.execute(context);
+      if (!(result instanceof Failed))
+      {
+         JavaSourceFacet javaSourceFacet = getSelectedProject(context).getFacet(JavaSourceFacet.class);
+         JavaResource javaResource = context.getUIContext().getSelection();
+         JavaSource<?> stereotype = javaResource.getJavaSource();
+         stereotype.addAnnotation(Stereotype.class);
+         if (inherited.getValue())
+         {
+            stereotype.addAnnotation(Inherited.class);
+         }
+         if (withNamed.getValue())
+         {
+            stereotype.addAnnotation(Named.class);
+         }
+         if (alternative.getValue())
+         {
+            stereotype.addAnnotation(Alternative.class);
+         }
+         stereotype.addAnnotation(Retention.class).setEnumValue(RUNTIME);
+         Collection<ElementType> types = toCollection(targetTypes.getValue());
+         stereotype.addAnnotation(Target.class).setEnumValue(types.toArray(new ElementType[types.size()]));
+         stereotype.addAnnotation(Documented.class);
+
+         javaSourceFacet.saveJavaSource(stereotype);
+      }
+      return result;
+   }
+
+   private <T> Collection<T> toCollection(Iterable<T> iterable)
+   {
+      if (iterable == null)
+      {
+         return null;
+      }
+      else if (iterable instanceof Collection)
+      {
+         return (Collection<T>) iterable;
+      }
+      else
+      {
+         List<T> list = new ArrayList<>();
+         for (T obj : iterable)
+         {
+            list.add(obj);
+         }
+         return list;
+      }
+   }
+
+   @Override
+   protected boolean isProjectRequired()
+   {
+      return true;
+   }
+
+   @Override
+   protected String getType()
+   {
+      return "CDI Stereotype";
+   }
+
+   @Override
+   protected Class<? extends JavaSource<?>> getSourceType()
+   {
+      return JavaAnnotation.class;
+   }
+
+}

javaee/tests/src/test/java/org/jboss/forge/addon/javaee/cdi/ui/NewStereotypeCommandTest.java

@@ -0,0 +1,185 @@
+/**
+ * Copyright 2014 Red Hat, Inc. and/or its affiliates.
+ *
+ * Licensed under the Eclipse Public License version 1.0, available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.jboss.forge.addon.javaee.cdi.ui;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.util.Arrays;
+
+import javax.enterprise.inject.Alternative;
+import javax.enterprise.inject.Stereotype;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.jboss.arquillian.container.test.api.Deployment;
+import org.jboss.arquillian.junit.Arquillian;
+import org.jboss.forge.addon.javaee.ProjectHelper;
+import org.jboss.forge.addon.parser.java.facets.JavaSourceFacet;
+import org.jboss.forge.addon.parser.java.resources.JavaResource;
+import org.jboss.forge.addon.projects.Project;
+import org.jboss.forge.addon.ui.controller.CommandController;
+import org.jboss.forge.addon.ui.result.Failed;
+import org.jboss.forge.addon.ui.result.Result;
+import org.jboss.forge.addon.ui.test.UITestHarness;
+import org.jboss.forge.arquillian.AddonDependency;
+import org.jboss.forge.arquillian.Dependencies;
+import org.jboss.forge.arquillian.archive.ForgeArchive;
+import org.jboss.forge.furnace.repositories.AddonDependencyEntry;
+import org.jboss.forge.parser.java.JavaAnnotation;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * 
+ * @author <a href="ggastald@redhat.com">George Gastaldi</a>
+ */
+@RunWith(Arquillian.class)
+public class NewStereotypeCommandTest
+{
+   @Deployment
+   @Dependencies({
+            @AddonDependency(name = "org.jboss.forge.addon:ui"),
+            @AddonDependency(name = "org.jboss.forge.addon:ui-test-harness"),
+            @AddonDependency(name = "org.jboss.forge.addon:javaee"),
+            @AddonDependency(name = "org.jboss.forge.addon:maven")
+   })
+   public static ForgeArchive getDeployment()
+   {
+      return ShrinkWrap
+               .create(ForgeArchive.class)
+               .addClass(ProjectHelper.class)
+               .addBeansXML()
+               .addAsAddonDependencies(
+                        AddonDependencyEntry.create("org.jboss.forge.furnace.container:cdi"),
+                        AddonDependencyEntry.create("org.jboss.forge.addon:projects"),
+                        AddonDependencyEntry.create("org.jboss.forge.addon:javaee"),
+                        AddonDependencyEntry.create("org.jboss.forge.addon:maven"),
+                        AddonDependencyEntry.create("org.jboss.forge.addon:ui"),
+                        AddonDependencyEntry.create("org.jboss.forge.addon:ui-test-harness")
+               );
+   }
+
+   @Inject
+   private UITestHarness testHarness;
+
+   @Inject
+   private ProjectHelper projectHelper;
+
+   @Test
+   public void testCreateNewStereotype() throws Exception
+   {
+      Project project = projectHelper.createJavaLibraryProject();
+      CommandController controller = testHarness.createCommandController(NewStereotypeCommand.class,
+               project.getRootDirectory());
+      controller.initialize();
+      controller.setValueFor("named", "MyStereotype");
+      controller.setValueFor("targetPackage", "org.jboss.forge.test");
+      controller.setValueFor("targetTypes", Arrays.asList(ElementType.TYPE));
+      Assert.assertTrue(controller.isValid());
+      Assert.assertTrue(controller.canExecute());
+      Result result = controller.execute();
+      Assert.assertThat(result, is(not(instanceOf(Failed.class))));
+
+      JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
+      JavaResource javaResource = facet.getJavaResource("org.jboss.forge.test.MyStereotype");
+      Assert.assertNotNull(javaResource);
+      Assert.assertThat(javaResource.getJavaSource(), is(instanceOf(JavaAnnotation.class)));
+      JavaAnnotation ann = (JavaAnnotation) javaResource.getJavaSource();
+      Assert.assertTrue(ann.hasAnnotation(Stereotype.class));
+      Assert.assertFalse(ann.hasAnnotation(Inherited.class));
+      Assert.assertFalse(ann.hasAnnotation(Named.class));
+      Assert.assertFalse(ann.hasAnnotation(Alternative.class));
+   }
+
+   @Test
+   public void testCreateNewInheritedStereotype() throws Exception
+   {
+      Project project = projectHelper.createJavaLibraryProject();
+      CommandController controller = testHarness.createCommandController(NewStereotypeCommand.class,
+               project.getRootDirectory());
+      controller.initialize();
+      controller.setValueFor("named", "MyStereotype");
+      controller.setValueFor("targetPackage", "org.jboss.forge.test");
+      controller.setValueFor("inherited", Boolean.TRUE);
+      controller.setValueFor("targetTypes", Arrays.asList(ElementType.TYPE));
+      Assert.assertTrue(controller.isValid());
+      Assert.assertTrue(controller.canExecute());
+      Result result = controller.execute();
+      Assert.assertThat(result, is(not(instanceOf(Failed.class))));
+
+      JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
+      JavaResource javaResource = facet.getJavaResource("org.jboss.forge.test.MyStereotype");
+      Assert.assertNotNull(javaResource);
+      Assert.assertThat(javaResource.getJavaSource(), is(instanceOf(JavaAnnotation.class)));
+      JavaAnnotation ann = (JavaAnnotation) javaResource.getJavaSource();
+      Assert.assertTrue(ann.hasAnnotation(Stereotype.class));
+      Assert.assertTrue(ann.hasAnnotation(Inherited.class));
+      Assert.assertFalse(ann.hasAnnotation(Named.class));
+      Assert.assertFalse(ann.hasAnnotation(Alternative.class));
+   }
+
+   @Test
+   public void testCreateNewNamedStereotype() throws Exception
+   {
+      Project project = projectHelper.createJavaLibraryProject();
+      CommandController controller = testHarness.createCommandController(NewStereotypeCommand.class,
+               project.getRootDirectory());
+      controller.initialize();
+      controller.setValueFor("named", "MyStereotype");
+      controller.setValueFor("targetPackage", "org.jboss.forge.test");
+      controller.setValueFor("withNamed", Boolean.TRUE);
+      controller.setValueFor("targetTypes", Arrays.asList(ElementType.TYPE));
+      Assert.assertTrue(controller.isValid());
+      Assert.assertTrue(controller.canExecute());
+      Result result = controller.execute();
+      Assert.assertThat(result, is(not(instanceOf(Failed.class))));
+
+      JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
+      JavaResource javaResource = facet.getJavaResource("org.jboss.forge.test.MyStereotype");
+      Assert.assertNotNull(javaResource);
+      Assert.assertThat(javaResource.getJavaSource(), is(instanceOf(JavaAnnotation.class)));
+      JavaAnnotation ann = (JavaAnnotation) javaResource.getJavaSource();
+      Assert.assertTrue(ann.hasAnnotation(Stereotype.class));
+      Assert.assertFalse(ann.hasAnnotation(Inherited.class));
+      Assert.assertTrue(ann.hasAnnotation(Named.class));
+      Assert.assertFalse(ann.hasAnnotation(Alternative.class));
+   }
+
+   @Test
+   public void testCreateNewAlternativeStereotype() throws Exception
+   {
+      Project project = projectHelper.createJavaLibraryProject();
+      CommandController controller = testHarness.createCommandController(NewStereotypeCommand.class,
+               project.getRootDirectory());
+      controller.initialize();
+      controller.setValueFor("named", "MyStereotype");
+      controller.setValueFor("targetPackage", "org.jboss.forge.test");
+      controller.setValueFor("alternative", Boolean.TRUE);
+      controller.setValueFor("targetTypes", Arrays.asList(ElementType.TYPE));
+      Assert.assertTrue(controller.isValid());
+      Assert.assertTrue(controller.canExecute());
+      Result result = controller.execute();
+      Assert.assertThat(result, is(not(instanceOf(Failed.class))));
+
+      JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
+      JavaResource javaResource = facet.getJavaResource("org.jboss.forge.test.MyStereotype");
+      Assert.assertNotNull(javaResource);
+      Assert.assertThat(javaResource.getJavaSource(), is(instanceOf(JavaAnnotation.class)));
+      JavaAnnotation ann = (JavaAnnotation) javaResource.getJavaSource();
+      Assert.assertTrue(ann.hasAnnotation(Stereotype.class));
+      Assert.assertFalse(ann.hasAnnotation(Inherited.class));
+      Assert.assertFalse(ann.hasAnnotation(Named.class));
+      Assert.assertTrue(ann.hasAnnotation(Alternative.class));
+   }
+}