Subversion Repositories DevTools

/**
 * AntShield - A project release tool for ant.
 */
package com.erggroup.mass.ant;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.taskdefs.Property;

/**
 * AntShield
 * Implementation of an ant Task which displays an
 * AntShieldReleaseFrame, then an AntShieldFieldFrame.
 */
public class AntShield extends org.apache.tools.ant.Task
{
    static final String JatsHomeProperty = "${env.JATS_HOME}";

    private ArrayList fields = new ArrayList();
    private String dpkgDir = null;
    private String packageName = null;
    private String type = null;
    private String releaseProperty = null;
    private boolean doRelease = true;
    private boolean undo = false;

    public AntShield()
    {
    } // Antshield

    /**
     * Creates, stores and returns an object that handles
     * the "field" nested tag.
     * @return
     */
    public FieldElement createField()
    {
        FieldElement element = new FieldElement(this, project);
        fields.add(element);
        return element;
    } // createField

    /**
     * Set the optional property "dpkgDir".
     * Default value "${JATS_HOME}".
     * @param s
     */
    public void setDpkgDir(String s)
    {
        dpkgDir = s;
    } // setDpkgDir

    /**
     * Set the mandatory property "packageName".
     * @param s
     */
    public void setPackageName(String s)
    {
        packageName = s;
    } // setPackageName

    /**
     * Set the mandatory property "type".
     * Valid strings are "major", "minor" and "patch".
     * @param s
     */
    public void setType(String s)
    {
        type = s;
    } // setType

    /**
     * Set the optional property "releaseProperty".
     * Default value "antshield.property".
     * @param s
     */
    public void setReleaseProperty(String s)
    {
        releaseProperty = s;
    } // setType

    /**
     * Set the optional property "release".
     * Default value "true".
     * @param b
     */
    public void setRelease(boolean b)
    {
        doRelease = b;
    } // setRelease

    /**
     * Set the optional property "undo".
     * Default value "false".
     * @param b
     */
    public void setUndo(boolean b)
    {
        undo = b;
    } // setRelease

    /**
     * Execute this task.
     * Check all supplied parameters.
     * If "release" is true (default), display an AntShieldReleaseDialog.
     * If fields are specified, display an AntShieldFieldDialog.
     * Throw a BuildException if any dialogs are cancelled.
     * Create properties for release (antshield.release) and all fields
     * which are passed back to ant.
     * @throws BuildException
     */
        public void execute() throws BuildException
        {
        Property p = new Property();
        p.setProject(project);
        p.setTaskName(this.getTaskName());
        p.setName("env");
        p.setEnvironment("env");
        p.setValue("");
        p.execute();

        if (doRelease)
        {
            if (dpkgDir == null)
            {
                // Check JATS_HOME
                dpkgDir = project.replaceProperties(JatsHomeProperty);
                if (JatsHomeProperty.equals(dpkgDir))
                {
                    throw new BuildException("<" + this.getTaskName() + "> JATS_HOME environment variable not set");
                }
            }
            File dpkgdir = new File(dpkgDir);
            if (!dpkgdir.exists() || !dpkgdir.isDirectory())
            {
                throw new BuildException("<" + this.getTaskName() + "> " + dpkgDir + " is not a directory");
            }
            // Check for valid input
            if ((packageName == null) || (packageName.length() == 0))
            {
                throw new BuildException("<" + this.getTaskName() + "> Parameter 'packageName' cannot be empty");
            }
        }
        if ((type == null) || (type.length() == 0))
        {
            type = "patch";
        }
        if (!type.equals("major") && !type.equals("minor") && !type.equals("patch"))
        {
            throw new BuildException("<" + this.getTaskName() + "> Parameter 'type' must be either 'major', 'minor' or 'patch'");
        }

        // Check field values
        Iterator i = fields.iterator();
        while (i.hasNext())
        {
            ((FieldElement)i.next()).check();
        }

        ArrayList dirlist = new ArrayList();
        if (doRelease)
        {
            // Retrieve list of release directories for package
            File pkgdir = new File(dpkgDir + "/" + packageName);
            if (pkgdir.exists() && !pkgdir.isDirectory())
            {
                throw new BuildException("<" + this.getTaskName() + "> " + dpkgDir + "/" + packageName + " is not a directory");
            }
            if (pkgdir.exists())
            {
                for (int n = 0; n < pkgdir.list().length; n++)
                {
                    String dir = pkgdir.list()[n];
                    File d = new File(dpkgDir + "/" + packageName + "/" + dir);
                    if (d.isDirectory())
                    {
                        dirlist.add(dir);
                    }
                }
            }
        }

        // Release dialog
        boolean guiOk = true;
        if (doRelease)
        {
            AntShieldReleaseFrame releaseGui = new AntShieldReleaseFrame(packageName, type, dirlist, undo);
            guiOk = releaseGui.isOk();
            if (guiOk)
            {
                // Create property to pass back to ANT
                if ((releaseProperty == null) || (releaseProperty.length() == 0))
                {
                    releaseProperty = new String("antshield.release");
                }
                p.setName(releaseProperty);
                p.setValue(releaseGui.getRelease());
                p.execute();
            }
        }
        if (guiOk && !fields.isEmpty())
        {
            // Fields dialog
            AntShieldFieldFrame fieldGui = new AntShieldFieldFrame(fields);
            guiOk = fieldGui.isOk();
        }
        if (!guiOk)
        {
            throw new BuildException("<" + this.getTaskName() + "> Action cancelled");
        }

        // Create properties to pass back to ANT
        i = fields.iterator();
        while (i.hasNext())
        {
            FieldElement e = (FieldElement)i.next();
            p.setName(e.getName());
            p.setValue(e.getValue());
            p.execute();
        }
        } // execute
}