AbstractSingleProcessorMojo.java

/**
 * Copyright Alex Objelean
 */
package ro.isdc.wro.maven.plugin;

import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.Callable;

import javax.servlet.FilterConfig;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mockito.Mockito;

import ro.isdc.wro.config.Context;
import ro.isdc.wro.config.jmx.WroConfiguration;
import ro.isdc.wro.http.support.DelegatingServletOutputStream;
import ro.isdc.wro.manager.WroManager.Builder;
import ro.isdc.wro.manager.factory.WroManagerFactory;
import ro.isdc.wro.manager.factory.WroManagerFactoryDecorator;
import ro.isdc.wro.model.resource.ResourceType;
import ro.isdc.wro.model.resource.processor.ResourcePreProcessor;
import ro.isdc.wro.model.resource.processor.factory.ProcessorsFactory;
import ro.isdc.wro.model.resource.processor.factory.SimpleProcessorsFactory;
import ro.isdc.wro.util.io.NullOutputStream;


/**
 * Maven plugin which use a single processor.
 *
 * @author Alex Objelean
 */
public abstract class AbstractSingleProcessorMojo
    extends AbstractWro4jMojo {
  /**
   * Comma separated options. This field is optional. If no value is provided, no options will be used..
   *
   * @parameter property="options"
   * @optional
   */
  private String options;
  /**
   * When true, all the plugin won't stop its execution and will log all found errors.
   *
   * @parameter default-value="false" property="failNever"
   * @optional
   */
  private boolean failNever;

  /**
   * {@inheritDoc}
   */
  @Override
  public final void doExecute()
      throws Exception {
    getLog().info("options: " + options);

    final Collection<Callable<Void>> callables = new ArrayList<Callable<Void>>();

    final Collection<String> groupsAsList = getTargetGroupsAsList();
    for (final String group : groupsAsList) {
      for (final ResourceType resourceType : ResourceType.values()) {
        if (isParallelProcessing()) {
          callables.add(Context.decorate(new Callable<Void>() {
            public Void call()
                throws Exception {
              processGroup(group, resourceType);
              return null;
            }
          }));
        } else {
          processGroup(group, resourceType);
        }
      }
    }
    if (isParallelProcessing()) {
      getTaskExecutor().submit(callables);
    }
  }

  /**
   * @param group
   *          the name of the group to process.
   */
  private void processGroup(final String groupName, final ResourceType resourceType)
      throws Exception {
    if (wantProcessGroup(groupName, resourceType)) {
      // group With Extension
      final String group = groupName + "." + resourceType.name().toLowerCase();
      getLog().info("processing group: " + group);

      // mock request
      final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
      Mockito.when(request.getRequestURI()).thenReturn(group);
      // mock response
      final HttpServletResponse response = Mockito.mock(HttpServletResponse.class);
      Mockito.when(response.getOutputStream()).thenReturn(new DelegatingServletOutputStream(new NullOutputStream()));

      // init context
      final WroConfiguration config = Context.get().getConfig();
      Context.set(Context.webContext(request, response, Mockito.mock(FilterConfig.class)), config);
      // perform processing
      getManagerFactory().create().process();

      getLog().debug("Processing group: " + group + " [OK]");
    }
  }

  /**
   * Allow subclasses to decide if a group needs to be processed. Useful for plugins which process only resources of a
   * certain type (ex: jshint).
   *
   * @return true if the resource of a certain type from a group should be processed.
   */
  protected boolean wantProcessGroup(final String groupName, final ResourceType resourceType) {
    return true;
  }

  /**
   * Initialize the manager factory with a processor factory using a single processor.
   */
  @Override
  protected WroManagerFactory decorateManagerFactory(final WroManagerFactory managerFactory) {
    return new WroManagerFactoryDecorator(managerFactory) {
      @Override
      protected void onBeforeBuild(final Builder builder) {
        builder.setProcessorsFactory(createSingleProcessorsFactory());
      }
    };
  }

  private ProcessorsFactory createSingleProcessorsFactory() {
    final SimpleProcessorsFactory factory = new SimpleProcessorsFactory();
    final ResourcePreProcessor processor = createResourceProcessor();
    factory.addPreProcessor(processor);
    return factory;
  }

  /**
   * Factory method responsible for creating the processor which will be applied for this build.
   */
  protected abstract ResourcePreProcessor createResourceProcessor();

  /**
   * @return raw representation of the option value.
   */
  protected String getOptions() {
    return options;
  }

  /**
   * Used for tests only.
   *
   * @param options
   *          the options to set
   */
  void setOptions(final String options) {
    this.options = options;
  }

  /**
   * @param failNever
   *          the failFast to set
   */
  public void setFailNever(final boolean failNever) {
    this.failNever = failNever;
  }

  /**
   * @return the failNever
   */
  public boolean isFailNever() {
    return failNever;
  }
}