CreateDecoratorCommand.java

package org.myaddon.commands;

import java.util.Iterator;
import java.util.List;

import javax.inject.Inject;

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.projects.ProjectFactory;
import org.jboss.forge.addon.projects.ui.AbstractProjectCommand;
import org.jboss.forge.addon.resource.Resource;
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.context.UISelection;
import org.jboss.forge.addon.ui.metadata.UICommandMetadata;
import org.jboss.forge.addon.ui.result.Result;
import org.jboss.forge.addon.ui.result.Results;
import org.jboss.forge.addon.ui.util.Categories;
import org.jboss.forge.addon.ui.util.Metadata;
import org.jboss.forge.roaster.Roaster;
import org.jboss.forge.roaster.model.JavaType;
import org.jboss.forge.roaster.model.source.Import;
import org.jboss.forge.roaster.model.source.Importer;
import org.jboss.forge.roaster.model.source.JavaClassSource;
import org.jboss.forge.roaster.model.source.MethodHolderSource;
import org.jboss.forge.roaster.model.source.MethodSource;
import org.jboss.forge.roaster.model.source.ParameterSource;

public class CreateDecoratorCommand extends AbstractProjectCommand {

	@Inject
	private ProjectFactory projectFactory;

	@Override
	public UICommandMetadata getMetadata(UIContext context) {
		return Metadata.forCommand(CreateDecoratorCommand.class)
				.name("GoF: Create Decorator")
				.category(Categories.create("GoF Patterns"));
	}

	@Override
	public void initializeUI(UIBuilder builder) throws Exception {
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	public Result execute(UIExecutionContext context) throws Exception {
		UISelection<Resource<?>> selection = context.getUIContext()
				.getInitialSelection();
		Project project = getSelectedProject(context);
		JavaSourceFacet facet = project.getFacet(JavaSourceFacet.class);
		Resource<?> resource = selection.get();
		if (resource instanceof JavaResource) {
			JavaResource javaResource = (JavaResource) resource;
			JavaType<?> javaSource = javaResource.getJavaType();
			// Create Decorator Class
			JavaClassSource decoratorClass = Roaster
					.create(JavaClassSource.class)
					.setName(javaSource.getName() + "Decorator")
					.setPackage(javaSource.getPackage());
			if (javaSource instanceof Importer) {
				List<Import> imports = ((Importer) javaSource).getImports();
				for (Import import_ : imports) {
					decoratorClass.addImport(import_);
				}
			}
			MethodSource<JavaClassSource> constructor = decoratorClass
					.addMethod().setPublic().setConstructor(true);
			constructor.addParameter(javaSource, "delegate");
			constructor.setBody("this.delegate = delegate;");
			// Create the Delegate final field
			decoratorClass.addField().setPrivate().setFinal(true)
					.setType(javaSource).setName("delegate");

			if (javaSource instanceof MethodHolderSource) {
				List<MethodSource<?>> methods = ((MethodHolderSource) javaSource)
						.getMethods();
				for (MethodSource method : methods) {
					MethodSource<JavaClassSource> decoratorMethod = decoratorClass
							.addMethod().setPublic().setName(method.getName());
					StringBuilder sb = new StringBuilder();
					if (method.isReturnTypeVoid()) {
						decoratorMethod.setReturnTypeVoid();
						sb.append("delegate.");
					} else {
						sb.append("return delegate.");
						decoratorMethod.setReturnType(method.getReturnType()
								.getQualifiedName());
					}
					sb.append(method.getName()).append("(");

					List<ParameterSource<?>> parameters = method
							.getParameters();
					for (Iterator<ParameterSource<?>> iterator = parameters
							.iterator(); iterator.hasNext();) {
						ParameterSource<JavaClassSource> param = (ParameterSource<JavaClassSource>) iterator
								.next();
						sb.append(param.getName());
						if (iterator.hasNext()) {
							sb.append(",");
						}
						decoratorMethod.addParameter(param.getType()
								.getQualifiedName(), param.getName());
					}
					sb.append(");");
					for (String type : (List<String>) method
							.getThrownExceptions()) {
						decoratorMethod.addThrows(type);
					}
					decoratorMethod.setBody(sb.toString());
				}
			}
			facet.saveJavaSource(decoratorClass);
			return Results.success("Decorator class '"
					+ decoratorClass.getCanonicalName() + "' created");
		} else {
			return Results
					.fail("Select a java class before executing this command");
		}
	}

	@Override
	protected ProjectFactory getProjectFactory() {
		return projectFactory;
	}

	@Override
	protected boolean isProjectRequired() {
		return true;
	}
}