GrandTask.java

  1. // $Id$
  2. /* ====================================================================
  3.  * Copyright (c) 2002-2003, Christophe Labouisse
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * 1. Redistributions of source code must retain the above copyright
  11.  *    notice, this list of conditions and the following disclaimer.
  12.  *
  13.  * 2. Redistributions in binary form must reproduce the above
  14.  *    copyright notice, this list of conditions and the following
  15.  *    disclaimer in the documentation and/or other materials provided
  16.  *    with the distribution.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21.  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  22.  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  24.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  27.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  29.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  30.  */

  32. package net.ggtools.grand.tasks;

  34. import java.io.File;
  35. import java.io.FileInputStream;
  36. import java.io.IOException;
  37. import java.util.ArrayList;
  38. import java.util.LinkedList;
  39. import java.util.List;
  40. import java.util.Map;
  41. import java.util.Properties;

  43. import net.ggtools.grand.ant.AntProject;
  44. import net.ggtools.grand.exceptions.GrandException;
  45. import net.ggtools.grand.filters.GraphFilter;
  46. import net.ggtools.grand.graph.GraphProducer;
  47. import net.ggtools.grand.graph.GraphWriter;
  48. import net.ggtools.grand.log.AntLog;
  49. import net.ggtools.grand.output.DotWriter;

  51. import org.apache.tools.ant.BuildException;
  52. import org.apache.tools.ant.BuildListener;
  53. import org.apache.tools.ant.Project;
  54. import org.apache.tools.ant.ProjectHelper;
  55. import org.apache.tools.ant.Task;
  56. import org.apache.tools.ant.taskdefs.Property;
  57. import org.apache.tools.ant.types.PropertySet;

  59. /**
  60.  * A task to create graphs.
  61.  *
  62.  * @author Christophe Labouisse
  63.  */
  64. public class GrandTask extends Task {

  66.     /**
  67.      * Field DEFAULT_OUTCONFIG_PREFIX.
  68.      */
  69.     private static final String DEFAULT_OUTCONFIG_PREFIX = "dot";

  71.     /**
  72.      * Field buildFile.
  73.      */
  74.     private File buildFile;

  76.     /**
  77.      * Field output.
  78.      */
  79.     private File output;

  81.     /**
  82.      * Field outputConfigurationFile.
  83.      */
  84.     private File outputConfigurationFile;

  86.     /**
  87.      * Field outputConfigurationPrefix.
  88.      */
  89.     private String outputConfigurationPrefix;

  91.     /**
  92.      * The sets of properties to pass to the graphed project.
  93.      */
  94.     private final List<PropertySet> propertySets = new ArrayList<PropertySet>();

  96.     /**
  97.      * Field filters.
  98.      */
  99.     private final List<FilterType> filters = new LinkedList<FilterType>();

  101.     /**
  102.      * Field showGraphName.
  103.      */
  104.     private boolean showGraphName = false;

  106.     /**
  107.      * Field inheritAll.
  108.      */
  109.     private boolean inheritAll = false;

  111.     /**
  112.      * Field properties.
  113.      */
  114.     private final List<Property> properties = new LinkedList<Property>();

  116.     /**
  117.      * Check the parameters validity before execution.
  118.      *
  119.      */
  120.     private void checkParams() {
  121.         if (output == null) {
  122.             final String message = "required attribute missing";
  123.             log(message, Project.MSG_ERR);
  124.             throw new BuildException(message);
  125.         }

  127.         if (outputConfigurationFile != null && outputConfigurationPrefix != null) {
  128.             final String message = "cannot specify both outputconfigfile and outputconfigprefix";
  129.             log(message, Project.MSG_ERR);
  130.             throw new BuildException(message);
  131.         }

  133.         for (FilterType filter : filters) {
  134.             filter.checkParameters();
  135.         }
  136.     }

  138.     /**
  139.      * Method execute.
  140.      * @see org.apache.tools.ant.Task#execute()
  141.      */
  142.     @Override
  143.     public final void execute() {
  144.         checkParams();

  146.         final GraphProducer graphProject = initAntProject();

  148.         log("Done loading project ", Project.MSG_VERBOSE);

  150.         log("Setting up filter chain");
  151.         GraphProducer producer = graphProject;
  152.         int numFilters = 0;

  154.         for (FilterType f : filters) {
  155.             log("Adding filter " + f.getFilterName(), Project.MSG_VERBOSE);
  156.             final GraphFilter filter = f.getFilter();
  157.             filter.setProducer(producer);
  158.             producer = filter;
  159.             numFilters++;
  160.         }

  162.         if (numFilters > 0) {
  163.             log("Loaded " + numFilters + " filter"
  164.                     + ((numFilters > 1) ? "s" : ""));
  165.         }

  167.         try {
  168.             Properties override = null;
  169.             if (outputConfigurationFile != null) {
  170.                 log("Overriding default output configuration from " + outputConfigurationFile);
  171.                 override = new Properties();
  172.                 override.load(new FileInputStream(outputConfigurationFile));
  173.             }
  174.             if (outputConfigurationPrefix != null) {
  175.                 log("Overriding default output configuration from project properties "
  176.                         + outputConfigurationPrefix + ".*");
  177.                 override = new Properties();
  178.                 for (String property : getProject().getProperties().keySet()) {
  179.                     if (property.startsWith(outputConfigurationPrefix)) {
  180.                         // one may use &quot; or &apos; or just ' in project properties
  181.                         override.put(property.replace(outputConfigurationPrefix, DEFAULT_OUTCONFIG_PREFIX),
  182.                                 getProject().getProperty(property).replaceAll("'", "\""));
  183.                     }
  184.                 }
  185.             }

  187.             final GraphWriter writer = new DotWriter(override);
  188.             writer.setProducer(producer);
  189.             writer.setShowGraphName(showGraphName);

  191.             log("Writing output to " + output);
  192.             writer.write(output);
  193.         } catch (final IOException e) {
  194.             log("Cannot write graph", Project.MSG_ERR);
  195.             throw new BuildException("Cannot write graph", e);
  196.         } catch (final GrandException e) {
  197.             log("Cannot process graph", Project.MSG_ERR);
  198.             throw new BuildException("Cannot write graph", e);
  199.         }
  200.     }

  202.     /**
  203.      * Create and initialize a GraphProducer according to the
  204.      * task parameters.
  205.      *
  206.      * @return an initialized GraphProducer.
  207.      */
  208.     private GraphProducer initAntProject() {

  210.         Project antProject;

  212.         if (buildFile == null) {
  213.             // Working with current project
  214.             log("Using current project");
  215.             antProject = getProject();
  216.         } else {
  217.             // Open a new project.
  218.             log("Loading project " + buildFile);

  220.             antProject = loadNewProject();
  221.         }

  223.         for (PropertySet ps : propertySets) {
  224.             addAlmostAll(antProject, ps.getProperties());
  225.         }

  227.         if (properties.size() > 0) {
  228.             for (Property prop : properties) {
  229.                 prop.setProject(antProject);
  230.                 prop.setTaskName("property");
  231.                 prop.execute();
  232.             }
  233.         }

  235.         return new AntProject(antProject);
  236.     }

  238.     /**
  239.      * Load an initialize a new project from a Ant build file.
  240.      *
  241.      * @return a new initialized Ant project.
  242.      */
  243.     private Project loadNewProject() {
  244.         final Project antProject = new Project();

  246.         // Set the current project listeners to the graphed project
  247.         // in order to get some trace if we need to execute some tasks
  248.         // in the graphed project.
  249.         for (final BuildListener listener : getProject().getBuildListeners()) {
  250.             antProject.addBuildListener(listener);
  251.         }

  253.         antProject.init();

  255.         if (!inheritAll) {
  256.             // set Java built-in properties separately,
  257.             // b/c we won't inherit them.
  258.             antProject.setSystemProperties();

  260.         } else {
  261.             // set all properties from calling project
  262.             final Properties props = new Properties();
  263.             for (Map.Entry<String, Object> entry : getProject().getProperties().entrySet()) {
  264.                 props.put(entry.getKey(), entry.getValue());
  265.             }
  266.             addAlmostAll(antProject, props);
  267.         }

  269.         antProject.setUserProperty("ant.file", buildFile.getAbsolutePath());
  270.         final ProjectHelper loader = ProjectHelper.getProjectHelper();
  271.         antProject.addReference("ant.projectHelper", loader);
  272.         loader.parse(antProject, buildFile);

  274.         getProject().copyUserProperties(antProject);

  276.         return antProject;
  277.     }

  279.     /**
  280.      * Method setProject.
  281.      * @param project Project
  282.      * @see org.apache.tools.ant.ProjectComponent#setProject(org.apache.tools.ant.Project)
  283.      */
  284.     @Override
  285.     public final void setProject(final Project project) {
  286.         super.setProject(project);
  287.         AntLog.setCurrentProject(project);
  288.         AntLog.setCurrentTask(this);
  289.     }

  291.     /**
  292.      * Sets the buildFile.
  293.      *
  294.      * @param file File
  295.      */
  296.     public final void setBuildFile(final File file) {
  297.         buildFile = file;
  298.     }

  300.     /**
  301.      * Sets the output file.
  302.      *
  303.      * @param file File
  304.      */
  305.     public final void setOutput(final File file) {
  306.         output = file;
  307.     }

  309.     /**
  310.      * Set a property file to override the output default configuration.
  311.      * @deprecated use {@link #setOutputConfigFile(File)}.
  312.      * @param propertyFile File
  313.      */
  314.     @Deprecated
  315.     public final void setPropertyFile(final File propertyFile) {
  316.         log("Using of deprecated \"propertyfile\" attribute, use \"outputconfigfile\" from now on",
  317.                 Project.MSG_WARN);
  318.         outputConfigurationFile = propertyFile;
  319.     }

  321.     /**
  322.      * Set a property file to override the output default configuration.
  323.      * @param propertyFile File
  324.      */
  325.     public final void setOutputConfigFile(final File propertyFile) {
  326.         outputConfigurationFile = propertyFile;
  327.     }

  329.     /**
  330.      * Set a property prefix to override the output default configuration.
  331.      * @param propertyPrefix String
  332.      */
  333.     public final void setOutputConfigPrefix(final String propertyPrefix) {
  334.         if (propertyPrefix == null) {
  335.             return;
  336.         }
  337.         if (propertyPrefix.isEmpty()) {
  338.             outputConfigurationPrefix = DEFAULT_OUTCONFIG_PREFIX;
  339.             return;
  340.         }
  341.         outputConfigurationPrefix = propertyPrefix;
  342.     }

  344.     /**
  345.      * Method setShowGraphName.
  346.      * @param show boolean
  347.      */
  348.     public final void setShowGraphName(final boolean show) {
  349.         showGraphName = show;
  350.     }

  352.     /**
  353.      * If true, pass all properties to the new Ant project.
  354.      * Defaults to true.
  355.      * @param value if true pass all properties to the new Ant project.
  356.      */
  357.     public final void setInheritAll(final boolean value) {
  358.         inheritAll = value;
  359.     }

  361.     /**
  362.      * Add a filter to the task.
  363.      * @param filter FilterType
  364.      */
  365.     public final void addFilter(final FilterType filter) {
  366.         filters.add(filter);
  367.     }

  369.     /**
  370.      * Add a new property to be passed to the graphed project.
  371.      *
  372.      * @param p the property to set.
  373.      */
  374.     public final void addProperty(final Property p) {
  375.         properties.add(p);
  376.     }

  378.     /**
  379.      * Set of properties to pass to the graphed project.
  380.      *
  381.      * @param ps property set to add
  382.      */
  383.     public final void addPropertyset(final PropertySet ps) {
  384.         propertySets.add(ps);
  385.     }

  387.     /**
  388.      * Copies all properties from the given table to the destination project -
  389.      * omitting those that have already been set in the destination project as
  390.      * well as properties named basedir or ant.file.
  391.      * @param props properties to copy to the new project
  392.      * @since Ant 1.6
  393.      * @param destProject Project
  394.      */
  395.     private void addAlmostAll(final Project destProject, final Properties props) {
  396.         for (Map.Entry<Object, Object> entry : props.entrySet()) {
  397.             final String key = entry.getKey().toString();
  398.             if ("basedir".equals(key) || "ant.file".equals(key)) {
  399.                 // basedir and ant.file should not be altered.
  400.                 continue;
  401.             }

  403.             final String value = entry.getValue().toString();
  404.             // don't re-set user properties, avoid the warning message
  405.             if (destProject.getProperty(key) == null) {
  406.                 // no user property
  407.                 destProject.setNewProperty(key, value);
  408.             }
  409.         }
  410.     }

  412. }
Created with JaCoCo 0.8.5.201910111838