/**
    * Copyright 2005-2015 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.opensource.org/licenses/ecl2.php
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.rice.krad.theme;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.kuali.common.util.Assert;
  import org.kuali.common.util.execute.Executable;
  import org.kuali.rice.krad.theme.postprocessor.ThemeCssFilesProcessor;
  import org.kuali.rice.krad.theme.postprocessor.ThemeFilesProcessor;
  import org.kuali.rice.krad.theme.postprocessor.ThemeJsFilesProcessor;
  import org.kuali.rice.krad.theme.preprocessor.ThemePreProcessor;
  import org.kuali.rice.krad.theme.util.NonHiddenDirectoryFilter;
  import org.kuali.rice.krad.theme.util.ThemeBuilderConstants;
  import org.kuali.rice.krad.theme.util.ThemeBuilderUtils;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  
  /**
   * Class that gets executed from the Spring context to build out view themes.
   *
   * <p>A view theme is a collection of assets that provides the base css and js for one or more views (see
   * {@link org.kuali.rice.krad.uif.view.ViewTheme}. The theme builder provides utilities for creating and
   * configuring themes that follow a standard directory convention.</p>
   *
   * <p>By default, the theme builder processes any directories under '/themes' as theme directories. Other
   * theme directories can be added through the property {@link #getAdditionalThemeDirectories()}
   *
   * The basic functions provided by the theme builder are:
   *
   * <ul>
   * <li>Overlay assets from a parent theme directory (if a parent is configured). Only assets that exist in
   * the parent directory but not in the child will be overlaid</li>
   * <li>Applies one or more configured {@link ThemePreProcessor} instances to the theme files. For example, Less
   * files are compiled to CSS files here by the {@link org.kuali.rice.krad.theme.preprocessor.LessThemePreProcessor}</li>
   * <li>Collects JS and CSS resources for the theme. This includes bringing in plugin resources and base KRAD script.
   * Resources can be filtered and ordered as needed</li>
   * <li>Perform merging and minification for each file type. During this the file types can perform additional
   * processing (for example, URL rewriting is done for CSS files)</li>
   * </ul>
   *
   * To just perform the first step (overlay parent assets), the property {@link #isSkipThemeProcessing()} can be set to
   * true. This is useful in development where an update to a parent file just needs pushed to the output directory.</p>
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   * @see org.kuali.rice.krad.theme.ThemeBuilderOverlays
   * @see org.kuali.rice.krad.theme.preprocessor.ThemePreProcessor
   * @see org.kuali.rice.krad.theme.postprocessor.ThemeFilesProcessor
   */
  public class ThemeBuilder implements Executable {
      private static final Logger LOG = Logger.getLogger(ThemeBuilder.class);
  
      private String webappSourceDir;
      private String themeBuilderOutputDir;
  
      private List<String> themeExcludes;
  
      private List<String> additionalThemeDirectories;
      private List<String> additionalPluginDirectories;
  
      private String projectVersion;
  
      private List<ThemePreProcessor> themePreProcessors;
  
      private Map<String, String> themeNamePathMapping;
      private Map<String, Properties> themeNamePropertiesMapping;
  
      private Map<String, String> pluginNamePathMapping;
  
      private boolean skipThemeProcessing;
  
      /**
       * Invoked from the spring context to execute the theme builder.
       *
       * <p>
       * Invokes processing of the main theme builder functions, this includes:
       *
       * <ul>
       * <li>Copying assets from web source directory to the output directory</li>
      * <li>Retrieving all theme and plugin directories, then setting up convenience maps for acquiring paths</li>
      * <li>Iterating through each theme that should be built (those not excluded with {@link #getThemeExcludes()})</li>
      * <li>For each theme, invoking parent and additional directory overlays, then finally calling a helper method
      * to process the theme assets</li>
      * </ul>
      * </p>
      *
      * <p>
      * To just perform copying of the web assets, and parent/additional directory overlays, set the property
      * {@link #isSkipThemeProcessing()} to true
      * </p>
      */
     @Override
     public void execute() {
         Assert.hasText(this.webappSourceDir, "Webapp source directory not set");
 
         LOG.info("View builder executed on " + this.webappSourceDir);
 
         try {
             ThemeBuilderOverlays.copyAssetsToWorkingDir(this.webappSourceDir, this.themeBuilderOutputDir,
                     this.additionalThemeDirectories, this.additionalPluginDirectories);
         } catch (IOException e) {
             throw new RuntimeException("Unable to copy assets to working directory", e);
         }
 
         List<File> themeDirectories = getThemeDirectories();
         List<File> pluginDirectories = getPluginDirectories();
 
         // build mappings for convenient access
         try {
             buildMappings(themeDirectories, pluginDirectories);
         } catch (IOException e) {
             throw new RuntimeException("Unable to build theme mappings", e);
         }
 
         // themes must be ordered so that we build the parents first, and therefore they have all their files
         // for overlaying to a child theme
         List<String> orderedThemes = orderThemesForBuilding();
 
         if (this.themeExcludes != null) {
             for (String themeToExclude : themeExcludes) {
                 themeToExclude = themeToExclude.toLowerCase();
 
                 if (orderedThemes.contains(themeToExclude)) {
                     orderedThemes.remove(themeToExclude);
                 }
 
                 if (LOG.isDebugEnabled()) {
                     LOG.debug("Skipping build for theme " + themeToExclude);
                 }
             }
         }
 
         // note important that two iterations be done over the themes and not one, all the parent
         // and plugin assets need to be overlaid before processing is done on a theme
         for (String themeName : orderedThemes) {
             copyParentThemeConfig(themeName);
 
             Properties themeProperties = this.themeNamePropertiesMapping.get(themeName);
 
             String themePath = this.themeNamePathMapping.get(themeName);
             File themeDirectory = new File(themePath);
 
             ThemeBuilderOverlays.overlayParentAssets(themeName, themeDirectory, themeProperties,
                     this.themeNamePathMapping);
 
             ThemeBuilderOverlays.overlayAdditionalDirs(themeDirectory, themeProperties, this.webappSourceDir,
                     this.themeBuilderOutputDir);
         }
 
         if (this.skipThemeProcessing) {
             LOG.info("Skipping theme processing");
 
             return;
         }
 
         for (String themeName : orderedThemes) {
             processThemeAssets(themeName);
         }
     }
 
     /**
      * Retrieves the directories that should be processed as themes.
      *
      * <p>
      * By default all directories in '/themes' are included as theme directories. Additional directories can
      * be included by setting {@link #getAdditionalThemeDirectories()}
      * </p>
      *
      * @return list of file objects pointing to the theme directories
      */
     protected List<File> getThemeDirectories() {
         List<File> themeDirectories = new ArrayList<File>();
 
         String defaultThemesDirectoryPath =
                 this.themeBuilderOutputDir + ThemeBuilderConstants.DEFAULT_THEMES_DIRECTORY;
 
         File defaultThemesDirectory = new File(defaultThemesDirectoryPath);
         File[] defaultThemeDirectories = defaultThemesDirectory.listFiles(new NonHiddenDirectoryFilter());
 
         if (defaultThemeDirectories != null) {
             themeDirectories = Arrays.asList(defaultThemeDirectories);
         }
 
         if (this.additionalThemeDirectories != null) {
             List<File> additionalThemeDirs = ThemeBuilderUtils.getSubDirectories(new File(this.themeBuilderOutputDir),
                     this.additionalThemeDirectories);
             themeDirectories.addAll(additionalThemeDirs);
         }
 
         ThemeBuilderUtils.validateFileExistence(themeDirectories, "Invalid theme directory.");
 
         if (LOG.isDebugEnabled()) {
             LOG.debug("Found theme directories: " + StringUtils.join(themeDirectories, ","));
         }
 
         return themeDirectories;
     }
 
     /**
      * Retrieves the directories that should be processed as plugins.
      *
      * <p>
      * By default all directories in '/plugins' are included as plugins. Additional directories can
      * be included by setting {@link #getAdditionalPluginDirectories()}
      * </p>
      *
      * @return list of file objects pointing to the plugin directories
      */
     protected List<File> getPluginDirectories() {
         List<File> pluginDirectories = new ArrayList<File>();
 
         String defaultPluginsDirectoryPath =
                 this.themeBuilderOutputDir + ThemeBuilderConstants.DEFAULT_PLUGINS_DIRECTORY;
         File defaultPluginsDirectory = new File(defaultPluginsDirectoryPath);
 
         File[] pluginDirs = defaultPluginsDirectory.listFiles(new NonHiddenDirectoryFilter());
 
         if (pluginDirs != null) {
             pluginDirectories = Arrays.asList(pluginDirs);
         }
 
         if (this.additionalPluginDirectories != null) {
             List<File> additionalPluginDirs = ThemeBuilderUtils.getSubDirectories(new File(this.themeBuilderOutputDir),
                     this.additionalPluginDirectories);
             pluginDirectories.addAll(additionalPluginDirs);
         }
 
         ThemeBuilderUtils.validateFileExistence(pluginDirectories, "Invalid plugin directory.");
 
         return pluginDirectories;
     }
 
     /**
      * Builds convenience maps (theme name to path map, theme name to properties mapping, and plugin
      * name to path mapping) for the given theme and plugin directories.
      *
      * @param themeDirectories list of theme directories to build mappings for
      * @param pluginDirectories list of file directories to build mappings for
      * @throws IOException
      */
     protected void buildMappings(List<File> themeDirectories, List<File> pluginDirectories) throws IOException {
         if (LOG.isDebugEnabled()) {
             LOG.debug("Building mappings");
         }
 
         this.themeNamePathMapping = new HashMap<String, String>();
         this.themeNamePropertiesMapping = new HashMap<String, Properties>();
 
         for (File themeDirectory : themeDirectories) {
             String themeName = themeDirectory.getName().toLowerCase();
 
             this.themeNamePathMapping.put(themeName, themeDirectory.getPath());
 
             Properties themeProperties = ThemeBuilderUtils.retrieveThemeProperties(themeDirectory.getPath());
             if (themeProperties == null) {
                 themeProperties = new Properties();
             }
 
             this.themeNamePropertiesMapping.put(themeName, themeProperties);
         }
 
         this.pluginNamePathMapping = new HashMap<String, String>();
 
         for (File pluginDirectory : pluginDirectories) {
             String pluginName = pluginDirectory.getName().toLowerCase();
 
             this.pluginNamePathMapping.put(pluginName, pluginDirectory.getPath());
         }
     }
 
     /**
      * Builds a list containing theme names in the order for which they should be processed.
      *
      * <p>
      * For the parent overlays to work correctly, the parent must be processed before the child. There can
      * be multiple parents in the hierarchy, so here we go through and figure out the correct order
      * </p>
      *
      * @return list of ordered theme names
      */
     protected List<String> orderThemesForBuilding() {
         if (LOG.isDebugEnabled()) {
             LOG.debug("Ordering themes for building");
         }
 
         List<String> orderedThemes = new ArrayList<String>();
 
         for (String themeName : this.themeNamePathMapping.keySet()) {
             String themePath = this.themeNamePathMapping.get(themeName);
 
             if (orderedThemes.contains(themeName)) {
                 continue;
             }
 
             List<String> themeParents = getAllThemeParents(themeName, new ArrayList<String>());
             for (String themeParent : themeParents) {
                 if (!orderedThemes.contains(themeParent)) {
                     orderedThemes.add(themeParent);
                 }
             }
 
             orderedThemes.add(themeName);
         }
 
         return orderedThemes;
     }
 
     /**
      * Gets all parents (ancestors) for the given theme name.
      *
      * <p>
      * The parent for a theme is determined by retrieving the theme's properties file, then pulling the
      * property with key 'parent'. Then the properties file for the parent theme is pulled and check to see if
      * it has a parent. So on until a theme is reached that does not have a parent
      * </p>
      *
      * @param themeName name of theme to retrieve parents for
      * @param themeParents list of parents that have been previously found (used to find circular references)
      * @return list of theme names that are parents to the given theme
      */
     protected List<String> getAllThemeParents(String themeName, List<String> themeParents) {
         Properties themeProperties = this.themeNamePropertiesMapping.get(themeName);
         if (themeProperties.containsKey(ThemeBuilderConstants.ThemeConfiguration.PARENT)) {
             String parentThemeName = themeProperties.getProperty(ThemeBuilderConstants.ThemeConfiguration.PARENT);
 
             if (StringUtils.isBlank(parentThemeName)) {
                 return themeParents;
             }
 
             if (!this.themeNamePropertiesMapping.containsKey(parentThemeName)) {
                 throw new RuntimeException("Invalid theme name for parent property: " + parentThemeName);
             }
 
             if (themeParents.contains(parentThemeName)) {
                 throw new RuntimeException("Circular reference found for parent: " + parentThemeName);
             }
 
             themeParents.addAll(getAllThemeParents(parentThemeName, themeParents));
 
             themeParents.add(parentThemeName);
         }
 
         return themeParents;
     }
 
     /**
      * If the given theme has a parent, retrieve the theme properties (if exists) for the parent,
      * then for each config property copy the parent value to the child theme properties if missing
      *
      * @param themeName name of the theme to pull parent config for and copy
      */
     protected void copyParentThemeConfig(String themeName) {
         Properties themeProperties = this.themeNamePropertiesMapping.get(themeName);
 
         if (!themeProperties.containsKey(ThemeBuilderConstants.ThemeConfiguration.PARENT)) {
             return;
         }
 
         String parentThemeName = themeProperties.getProperty(ThemeBuilderConstants.ThemeConfiguration.PARENT);
         Properties parentThemeProperties = this.themeNamePropertiesMapping.get(parentThemeName);
 
         String[] propertiesToCopy = new String[] {ThemeBuilderConstants.ThemeConfiguration.LESS_INCLUDES,
                 ThemeBuilderConstants.ThemeConfiguration.LESS_EXCLUDES,
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_INCLUDES,
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_EXCLUDES,
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_FILE_EXCLUDES,
                 ThemeBuilderConstants.ThemeConfiguration.ADDITIONAL_OVERLAYS,
                 ThemeBuilderConstants.ThemeConfiguration.CSS_LOAD_FIRST,
                 ThemeBuilderConstants.ThemeConfiguration.CSS_LOAD_LAST,
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_JS_LOAD_ORDER,
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_CSS_LOAD_ORDER,
                 ThemeBuilderConstants.ThemeConfiguration.THEME_JS_LOAD_ORDER,
                 ThemeBuilderConstants.ThemeConfiguration.THEME_CSS_LOAD_ORDER,
                 ThemeBuilderConstants.ThemeConfiguration.JS_LOAD_FIRST,
                 ThemeBuilderConstants.ThemeConfiguration.JS_LOAD_LAST,
                 ThemeBuilderConstants.ThemeConfiguration.DEV_JS_INCLUDES};
 
         for (String propertyKey : propertiesToCopy) {
             ThemeBuilderUtils.copyProperty(propertyKey, parentThemeProperties, themeProperties);
         }
     }
 
     /**
      * Performs the various steps to process the given theme
      *
      * <p>
      * The theme is processed first by applying any configured {@link org.kuali.rice.krad.theme.preprocessor.ThemePreProcessor}
      * instances (such as less processing). Once the pre processors are applied, the CSS and JS post processors are
      * then invoked to do the final processing
      *
      * After processing is complete the 'theme-derived.properties' file gets written to the theme directory, which
      * contains all the properties for the theme (set, inherited, derived)
      * </p>
      *
      * @param themeName name of the theme to process
      */
     protected void processThemeAssets(String themeName) {
         Properties themeProperties = this.themeNamePropertiesMapping.get(themeName);
 
         String themePath = this.themeNamePathMapping.get(themeName);
         File themeDirectory = new File(themePath);
 
         LOG.info("Processing assets for theme: " + themeName);
 
         // apply pre-processors which can modify the theme assets before they are collected
         if (this.themePreProcessors != null) {
             for (ThemePreProcessor preProcessor : this.themePreProcessors) {
                 preProcessor.processTheme(themeName, themeDirectory, themeProperties);
             }
         }
 
         // apply processors for CSS and JS files to do final processing
         File workingDir = new File(this.themeBuilderOutputDir);
 
         Map<String, File> themePluginDirsMap = collectThemePluginDirs(themeProperties);
 
         ThemeFilesProcessor filesProcessor = new ThemeCssFilesProcessor(themeName, themeDirectory, themeProperties,
                 themePluginDirsMap, workingDir, this.projectVersion);
         filesProcessor.process();
 
         filesProcessor = new ThemeJsFilesProcessor(themeName, themeDirectory, themeProperties,
                 themePluginDirsMap, workingDir, this.projectVersion);
         filesProcessor.process();
 
         try {
             ThemeBuilderUtils.storeThemeProperties(themePath, themeProperties);
         } catch (IOException e) {
             throw new RuntimeException("Unable to update theme.properties file", e);
         }
     }
 
     /**
      * Helper method that filters the list of all plugins and returns those that should be used
      * with the theme
      *
      * <p>
      * Which plugins to include for a theme can be configured using the pluginIncludes and pluginExlcudes
      * property keys
      * </p>
      *
      * @param themeProperties properties file for the theme, used to retrieve the plugin configuration
      * @return map containing the plugins for the theme, map key is the plugin name and map value gives
      *         the plugin directory
      */
     protected Map<String, File> collectThemePluginDirs(Properties themeProperties) {
         Map<String, File> themePluginDirs = new HashMap<String, File>();
 
         String[] pluginIncludes = ThemeBuilderUtils.getPropertyValueAsArray(
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_INCLUDES, themeProperties);
 
         String[] pluginExcludes = ThemeBuilderUtils.getPropertyValueAsArray(
                 ThemeBuilderConstants.ThemeConfiguration.PLUGIN_EXCLUDES, themeProperties);
 
         for (Map.Entry<String, String> pluginMapping : this.pluginNamePathMapping.entrySet()) {
             String pluginName = pluginMapping.getKey();
 
             if (ThemeBuilderUtils.inExcludeList(pluginName, pluginExcludes)) {
                 continue;
             }
 
             if (ThemeBuilderUtils.inIncludeList(pluginName, pluginIncludes)) {
                 themePluginDirs.put(pluginName, new File(pluginMapping.getValue()));
             }
         }
 
         themeProperties.put(ThemeBuilderConstants.DerivedConfiguration.THEME_PLUGIN_NAMES,
                 StringUtils.join(themePluginDirs.keySet(), ","));
 
         return themePluginDirs;
     }
 
     /**
      * Map that associates theme names with their path, provided here for subclasses
      *
      * @return map of theme name/paths, map key is the theme name, map value is the theme path
      */
     protected Map<String, String> getThemeNamePathMapping() {
         return themeNamePathMapping;
     }
 
     /**
      * Map that associates theme names with their properties, provided here for subclasses
      *
      * @return map of theme name/properties, map key is the theme name, map value is the properties object
      */
     protected Map<String, Properties> getThemeNamePropertiesMapping() {
         return themeNamePropertiesMapping;
     }
 
     /**
      * Absolute path to the directory that contains the web application source
      *
      * <p>
      * Generally this is the base directory for the application/module, then /src/main/webapp
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>webapp.source.dir</code>
      * </p>
      *
      * @return path to webapp source directory
      */
     public String getWebappSourceDir() {
         return webappSourceDir;
     }
 
     /**
      * Setter for the path to the webapp source
      *
      * @param webappSourceDir
      */
     public void setWebappSourceDir(String webappSourceDir) {
         if (StringUtils.isNotBlank(webappSourceDir)) {
             // trim off any trailing path separators
             if (webappSourceDir.endsWith(File.separator) || webappSourceDir.endsWith("/")) {
                 webappSourceDir = webappSourceDir.substring(0, webappSourceDir.length() - 1);
             }
         }
 
         this.webappSourceDir = webappSourceDir;
     }
 
     /**
      * Absolute path to the directory the theme builder should output content to
      *
      * <p>
      * Generally this will be the output directory for the exploded war being created. However you can also
      * choose to output to a temporary directory, then copy the assets over at a later phase
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>theme.builder.output.dir</code>
      * </p>
      *
      * @return path to the output directory
      */
     public String getThemeBuilderOutputDir() {
         return themeBuilderOutputDir;
     }
 
     /**
      * Setter for the path to the output directory
      *
      * @param themeBuilderOutputDir
      */
     public void setThemeBuilderOutputDir(String themeBuilderOutputDir) {
         if (StringUtils.isNotBlank(themeBuilderOutputDir)) {
             // trim off any trailing path separators
             if (themeBuilderOutputDir.endsWith(File.separator) || themeBuilderOutputDir.endsWith("/")) {
                 themeBuilderOutputDir = themeBuilderOutputDir.substring(0, themeBuilderOutputDir.length() - 1);
             }
         }
 
         this.themeBuilderOutputDir = themeBuilderOutputDir;
     }
 
     /**
      * List of theme names that should be excluded from theme processing
      *
      * <p>
      * Directories for themes that are excluded will be copied to the output directory but no further
      * processing will occur on that theme.
      * </p>
      *
      * <p>
      * If your web application receives web overlays which include themes, they will already be processed.
      * Processing them again will result in duplicate content. Therefore you should exclude these themes using
      * this property
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>theme.builder.excludes</code>
      * </p>
      *
      * @return list of excluded theme names
      */
     public List<String> getThemeExcludes() {
         return themeExcludes;
     }
 
     /**
      * Setter for the list of theme names to exclude from processing
      *
      * @param themeExcludes
      */
     public void setThemeExcludes(List<String> themeExcludes) {
         this.themeExcludes = themeExcludes;
     }
 
     /**
      * Convenience setter that takes a string and parses to populate the theme excludes list
      *
      * @param themeExcludes string containing theme names to exclude which are delimited using a comma
      */
     public void setThemeExcludesStr(String themeExcludes) {
         if (StringUtils.isNotBlank(themeExcludes)) {
             String[] themeExcludesArray = themeExcludes.split(",");
             this.themeExcludes = Arrays.asList(themeExcludesArray);
         }
     }
 
     /**
      * List of absolute paths to include as additional theme directories
      *
      * <p>
      * By default all directories under the web root folder <code>themes</code> are included. Other web
      * directories can be processed as themes by including their path in this list
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>theme.builder.theme.adddirs</code>
      * </p>
      *
      * @return list of paths for additional themes
      */
     public List<String> getAdditionalThemeDirectories() {
         return additionalThemeDirectories;
     }
 
     /**
      * Setter for the list of additional theme directory paths
      *
      * @param additionalThemeDirectories
      */
     public void setAdditionalThemeDirectories(List<String> additionalThemeDirectories) {
         this.additionalThemeDirectories = additionalThemeDirectories;
     }
 
     /**
      * Convenience setter that takes a string and parses to populate the additional theme directories list
      *
      * @param additionalThemeDirectories string containing additional theme directories which are
      * delimited using a comma
      */
     public void setAdditionalThemeDirectoriesStr(String additionalThemeDirectories) {
         if (StringUtils.isNotBlank(additionalThemeDirectories)) {
             String[] additionalThemeDirectoriesArray = additionalThemeDirectories.split(",");
             this.additionalThemeDirectories = Arrays.asList(additionalThemeDirectoriesArray);
         }
     }
 
     /**
      * List of absolute paths to include as additional plugin directories
      *
      * <p>
      * By default all directories under the web root folder <code>plugins</code> are included. Other web
      * directories can be processed as plugins by including their path in this list
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>theme.builder.plugin.adddirs</code>
      * </p>
      *
      * @return list of paths for additional plugins
      */
     public List<String> getAdditionalPluginDirectories() {
         return additionalPluginDirectories;
     }
 
     /**
      * Setter for the list of additional plugin directory paths
      *
      * @param additionalPluginDirectories
      */
     public void setAdditionalPluginDirectories(List<String> additionalPluginDirectories) {
         this.additionalPluginDirectories = additionalPluginDirectories;
     }
 
     /**
      * Convenience setter that takes a string and parses to populate the additional plugin directories list
      *
      * @param additionalPluginDirectories string containing additional plugin directories which are
      * delimited using a comma
      */
     public void setAdditionalPluginDirectoriesStr(String additionalPluginDirectories) {
         if (StringUtils.isNotBlank(additionalPluginDirectories)) {
             String[] additionalPluginDirectoriesArray = additionalPluginDirectories.split(",");
             this.additionalPluginDirectories = Arrays.asList(additionalPluginDirectoriesArray);
         }
     }
 
     /**
      * Version for the project that will be used to stamp the minified file
      *
      * <p>
      * In order to facilitate automatic downloads between project releases, the minified files are stamped with
      * the version number.
      * </p>
      *
      * <p>
      * If you are using the maven plugin this can be set by the maven property <code>project.version</code>
      * </p>
      *
      * @return version string for project
      */
     public String getProjectVersion() {
         return projectVersion;
     }
 
     /**
      * Setter for the project version
      *
      * @param projectVersion
      */
     public void setProjectVersion(String projectVersion) {
         this.projectVersion = projectVersion;
     }
 
     /**
      * List of {@link ThemePreProcessor} instances that should be applied to the themes
      *
      * @return list of pre processors to apply
      */
     public List<ThemePreProcessor> getThemePreProcessors() {
         return themePreProcessors;
     }
 
     /**
      * Setter for the list of theme pre processors
      *
      * @param themePreProcessors
      */
     public void setThemePreProcessors(List<ThemePreProcessor> themePreProcessors) {
         this.themePreProcessors = themePreProcessors;
     }
 
     /**
      * Indicates whether processing of the themes should be skipped
      *
      * <p>
      * In development it can be useful to just update the output directory with the theme assets, and skip
      * processing such as Less and minification (which can be time consuming). Setting this flag to true will
      * skip processing of pre and post processors, just doing the overlay. By default this is false
      * </p>
      *
      * @return true if theme processing should be skipped, false if not
      */
     public boolean isSkipThemeProcessing() {
         return skipThemeProcessing;
     }
 
     /**
      * Setter to skip theme processing
      *
      * @param skipThemeProcessing
      */
     public void setSkipThemeProcessing(boolean skipThemeProcessing) {
         this.skipThemeProcessing = skipThemeProcessing;
     }
 
 }