<change id="build-extender">

            <api name="general"/>

            <summary>Support for externally extending the project's build script</summary>

            <version major="1" minor="16"/>

            <date day="10" month="4" year="2007"/>

            <author login="mkleint"/>

            <compatibility addition="yes"/>

            <description>

                <p>

                  Add framework for extending the project's build script with 3rd party snippets,

                  allowing automated extensions to the build process. 

                </p>

            </description>

            <class package="org.netbeans.api.project.ant" name="AntBuildExtender"/>

            <class package="org.netbeans.spi.project.support.ant" name="GeneratedFileHelper"/>

            <class package="org.netbeans.spi.project.ant" name="AntBuildExtenderImplementation"/>

            <class package="org.netbeans.spi.project.support.ant" name="AntBuildExtenderSupport"/>

            <issue number="93509"/>

        </change>

        <junit-version xmlns="http://www.netbeans.org/ns/junit/1" value="junit3"/>

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.project.ant;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.spi.project.AuxiliaryConfiguration;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import org.netbeans.spi.project.support.ant.AntProjectHelper;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

/**

 * Allows extending the project's build script with 3rd party additions.

 * Check the Project's lookup to see if the feature is supported by a given Ant project type.

 * Typical usage:

 * <ul>

 *    <li>Lookup the instance of AntBuildExtender in the project at hand</li>

 *    <li>Create the external build script file with your targets and configuration</li>

 *    <li>Use the AntBuildExtender to wire your script and targets into the main build lifecycle</li>

 *    <li>Call {@link org.netbeans.api.project.ProjectManager#saveProject} to persist the changes and

 *        regenerate the main build script</li>

 * </ul>

 * 

 * Please note that it's easy to break the build script functionality and any script extensions

 * shall be done with care. A few rules to follow:

 * <ul>

 *   <li>Pick a reasonably unique extension id</li>

 *   <li>Prefix target names and properties you define in your extension with the extension id to prevent clashes.</li>

 * </ul>

 * @author mkleint

 * @since org.netbeans.modules.project.ant 1.16

 */

public final class AntBuildExtender {

    private HashMap<String, Extension> extensions;

    private AntBuildExtenderImplementation implementation;

    static {

        AntBuildExtenderAccessorImpl.createAccesor();

    }

    AntBuildExtender(AntBuildExtenderImplementation implementation) {

        this.implementation = implementation;

    }

    /**

     * Get a list of target names in the main build script that are allowed to be 

     * extended by adding the "depends" attribute definition to them.

     * @return list of target names

     */

    public List<String> getExtensibleTargets() {

        List<String> targets = new ArrayList<String>();

        targets.addAll(implementation.getExtensibleTargets());

        targets = Collections.unmodifiableList(targets);

        return targets;

    }

    /**

     * Adds a new build script extension.

     * @param id identification of the extension

     * @param extensionXml fileobject referencing the build script for the extension, 

     * needs to be located in nbproject directory or below.

     * @return the newly created extension.

     */

    public synchronized Extension addExtension(String id, FileObject extensionXml) {

        assert extensionXml != null;

        assert extensionXml.isValid() && extensionXml.isData();

        //TODO assert the owner is the same as the owner of this instance of entender.

        assert FileOwnerQuery.getOwner(extensionXml) == implementation.getOwningProject();

        FileObject nbproj = implementation.getOwningProject().getProjectDirectory().getFileObject(AntProjectHelper.PROJECT_XML_PATH).getParent();

        assert FileUtil.isParentOf(nbproj, extensionXml);

        if (extensions == null) {

            readProjectMetadata();

        }

        if (extensions.get(id) != null) {

            throw new IllegalStateException("Extension with id '" + id + "' already exists.");

        }

        Extension ex = new Extension(id, extensionXml, FileUtil.getRelativePath(nbproj, extensionXml));

        extensions.put(id, ex);

        updateProjectMetadata();

        return ex;

    }

    /**

     * Remove an existing build script extension. Make sure to remove the extension's script file

     * before/after removing the extension.

     * @param id identification of the extension

     */

    public synchronized void removeExtension(String id) {

        if (extensions == null) {

            readProjectMetadata();

        }

        if (extensions.get(id) == null) {

            // oh well, just ignore.

            return;

        }

        extensions.remove(id);

        updateProjectMetadata();

    }

    /**

     * Get an extension by the id.

     * @param id identification token

     * @return Extention with the given id or null if not found.

     */

    public synchronized Extension getExtension(String id) {

        if (extensions == null) {

            readProjectMetadata();

        }

        return extensions.get(id);

    }

    synchronized Set<Extension> getExtensions() {

        Set<Extension> ext =  new HashSet<Extension>();

        if (extensions == null) {

            readProjectMetadata();

        }

        ext.addAll(extensions.values());

        return ext;

    }

    private static final DocumentBuilder db;

    static {

        try {

            db = DocumentBuilderFactory.newInstance().newDocumentBuilder();

        } catch (ParserConfigurationException e) {

            throw new AssertionError(e);

        }

    }

    private static Document createNewDocument() {

        // #50198: for thread safety, use a separate document.

        // Using XMLUtil.createDocument is much too slow.

        synchronized (db) {

            return db.newDocument();

        }

    }

    private void updateProjectMetadata() {

        Document doc = createNewDocument();

        Element root = doc.createElementNS(AntBuildExtenderImplementation.AUX_NAMESPACE, 

                                           AntBuildExtenderImplementation.ELEMENT_ROOT);

        if (extensions  != null) {

            FileObject nbproj = implementation.getOwningProject().getProjectDirectory().getFileObject(AntProjectHelper.PROJECT_XML_PATH).getParent();

            for (Extension ext : extensions.values()) {

                Element child = doc.createElement(AntBuildExtenderImplementation.ELEMENT_EXTENSION);

                child.setAttribute(AntBuildExtenderImplementation.ATTR_ID, ext.id);

                String relPath = FileUtil.getRelativePath(nbproj, ext.file);

                assert relPath != null;

                child.setAttribute(AntBuildExtenderImplementation.ATTR_FILE, relPath);

                root.appendChild(child);

                for (String target : ext.dependencies.keySet()) {

                    for (String depTarget : ext.dependencies.get(target)) {

                        Element dep = doc.createElement(AntBuildExtenderImplementation.ELEMENT_DEPENDENCY);

                        dep.setAttribute(AntBuildExtenderImplementation.ATTR_TARGET, target);

                        dep.setAttribute(AntBuildExtenderImplementation.ATTR_DEPENDSON, depTarget);

                        child.appendChild(dep);

                    }

                }

            }

        }

        AuxiliaryConfiguration config = implementation.getOwningProject().getLookup().lookup(AuxiliaryConfiguration.class);

        config.putConfigurationFragment(root, true);

    }

    private void readProjectMetadata() {

        AuxiliaryConfiguration config = implementation.getOwningProject().getLookup().lookup(AuxiliaryConfiguration.class);

        Element cfgEl = config.getConfigurationFragment(AntBuildExtenderImplementation.ELEMENT_ROOT, AntBuildExtenderImplementation.AUX_NAMESPACE, true);

        FileObject nbproj = implementation.getOwningProject().getProjectDirectory().getFileObject(AntProjectHelper.PROJECT_XML_PATH).getParent();

        extensions = new HashMap<String, Extension>();

        if (cfgEl != null) {

            String namespace = cfgEl.getNamespaceURI();

            NodeList roots = cfgEl.getElementsByTagNameNS(namespace, AntBuildExtenderImplementation.ELEMENT_EXTENSION);

            for (int i=0; i <roots.getLength(); i++) {

                Element root = (Element) roots.item(i);

                String id = root.getAttribute(AntBuildExtenderImplementation.ATTR_ID);

                assert id.length() > 0 : "Illegal project.xml";

                String value = root.getAttribute(AntBuildExtenderImplementation.ATTR_FILE);

                FileObject script = nbproj.getFileObject(value);

                assert script != null : "Missing file " + script;

                Extension ext = new Extension(id, script, value);

                extensions.put(id, ext);

                NodeList deps = root.getElementsByTagNameNS(namespace, AntBuildExtenderImplementation.ELEMENT_DEPENDENCY);

                for (int j = 0; j < deps.getLength(); j++) {

                    Element dep = (Element)deps.item(j);

                    String target = dep.getAttribute(AntBuildExtenderImplementation.ATTR_TARGET);

                    String dependsOn = dep.getAttribute(AntBuildExtenderImplementation.ATTR_DEPENDSON);

                    assert target != null;

                    assert dependsOn != null;

                    ext.loadDependency(target, dependsOn);

                }

            }

        }

    }

    /**

     * Describes and allows to manipulate the build script extension and it's links to the main build script

     * of the project.

     */

    public final class Extension {

        String id;

        FileObject file;

        String path;

        TreeMap<String, Collection<String>> dependencies;

        Extension(String id, FileObject script, String relPath) {

            this.id = id;

            file = script;

            path = relPath;

            dependencies = new TreeMap<String, Collection<String>>();

        }

        String getPath() {

            return path;

        }

        /**

         * Add a dependency of a main build script target on the target in the extension's script.

         * @param mainBuildTarget name of target in the main build script (see {@link org.netbeans.api.project.ant.AntBuildExtender#getExtendableTargets})

         * @param extensionTarget name of target in the extention script

         */

        public void addDependency(String mainBuildTarget, String extensionTarget) {

            assert implementation.getExtensibleTargets().contains(mainBuildTarget) : 

                "The target '" + mainBuildTarget + "' is not designated by the project type as extensible.";

            synchronized (AntBuildExtender.class) {

                loadDependency(mainBuildTarget, extensionTarget);

                updateProjectMetadata();

            }

        }

        private void loadDependency(String mainBuildTarget, String extensionTarget) {

            synchronized (AntBuildExtender.class) {

                Collection<String> tars = dependencies.get(mainBuildTarget);

                if (tars == null) {

                    tars = new ArrayList<String>();

                    dependencies.put(mainBuildTarget, tars);

                }

                if (!tars.contains(extensionTarget)) {

                    tars.add(extensionTarget);

                } else {

                    //log?

                }

            }

        }

        /**

         * Remove a dependency of a main build script target on the target in the extension's script.

         * 

         * @param mainBuildTarget name of target in the main build script (see {@link org.netbeans.api.project.ant.AntBuildExtender#getExtendableTargets})

         * @param extensionTarget name of target in the extention script

         */

        public void removeDependency(String mainBuildTarget, String extensionTarget) {

            Collection<String> str = dependencies.get(mainBuildTarget);

            if (str != null) {

                str.remove(extensionTarget);

                updateProjectMetadata();

            } else {

                //oh well, just ignore, nothing to update anyway..

            }

        }

        Map<String, Collection<String>> getDependencies() {

            TreeMap<String, Collection<String>> toRet = new TreeMap<String, Collection<String>>();

            synchronized (AntBuildExtender.class) {

                for (String str : dependencies.keySet()) {

                    ArrayList<String> col = new ArrayList<String>();

                    col.addAll(dependencies.get(str));

                    toRet.put(str, col);

                }

            }

            return toRet;

        }

    }

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 * 

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 * 

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 * 

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.api.project.ant;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.util.Collection;

import java.util.Map;

import java.util.Set;

import org.netbeans.api.project.ant.AntBuildExtender.Extension;

import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

/**

 *

 * @author mkleint

 */

class AntBuildExtenderAccessorImpl extends  AntBuildExtenderAccessor {

    static void createAccesor() {

        if (DEFAULT == null) {

            DEFAULT= new AntBuildExtenderAccessorImpl();

        }

    }

    private AntBuildExtenderAccessorImpl() {

    }

    public AntBuildExtender createExtender(AntBuildExtenderImplementation impl) {

        return new AntBuildExtender(impl);

    }

    public Set<Extension> getExtensions(AntBuildExtender ext) {

        return ext.getExtensions();

    }

    public String getPath(Extension extension) {

        return extension.getPath();

    }

    public Map<String, Collection<String>> getDependencies(Extension extension) {

        return extension.getDependencies();

    }

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.modules.project.ant;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.util.Collection;

import java.util.Map;

import java.util.Set;

import org.netbeans.api.project.ant.AntBuildExtender;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

/**

 * @author  mkleint

 */

public abstract class AntBuildExtenderAccessor {

    public static AntBuildExtenderAccessor DEFAULT = null;

    static {

        // invokes static initializer of Item.class

        // that will assign value to the DEFAULT field above

        Class c = AntBuildExtender.class;

        try {

            Class.forName(c.getName(), true, c.getClassLoader());

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }    

    public abstract AntBuildExtender createExtender(AntBuildExtenderImplementation impl);

    public abstract Set<AntBuildExtender.Extension> getExtensions(AntBuildExtender ext);

    public abstract String getPath(AntBuildExtender.Extension extension);

    public abstract Map<String, Collection<String>> getDependencies(AntBuildExtender.Extension extension);

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.project.ant;

import java.util.List;

import org.netbeans.api.project.Project;

/**

 * A project type's spi for {@link org.netbeans.api.project.ant.AntBuildExtender}'s wiring.

 * A typical setup in the project type includes:

 * <ul>

 * <li>Provide an instance of {@link org.netbeans.api.project.ant.AntBuildExtender} in project's lookup for use by 3rd

 * party modules.</<li>

 * <li>Use the new {@link org.netbeans.spi.project.support.ant.GeneratedFilesHelper#GeneratedFilesHelper(AntProjectHelper,AntBuildExtender)} constructor to

 *  create the helper for generating build related files.</<li>

 * </ul>

 * @author mkleint

 * @since org.netbeans.modules.project.ant 1.16

 */

public interface AntBuildExtenderImplementation {

    String AUX_NAMESPACE        = "http://www.netbeans.org/ns/ant-build-extender/1"; //NOI18N

    /**

     * 

     */

    String ELEMENT_ROOT         = "buildExtensions"; //NOI18N

    /**

     * 

     */

    String ELEMENT_EXTENSION    = "extension"; //NOI18N

    /**

     * 

     */

    String ELEMENT_DEPENDENCY   = "dependency"; //NOI18N

    /**

     * 

     */

    String ATTR_TARGET      = "target";

    /**

     * 

     */

    String ATTR_DEPENDSON   = "dependsOn";

    /**

     * 

     */

    String ATTR_ID          = "id";

    /**

     * 

     */

    String ATTR_FILE        = "file";

    /**

     * A declarative list of targets that are intended by the project type to be used

     * for extensions to plug into.

     * @return list of target names

     */

    List<String> getExtensibleTargets();

    /**

     * Returns Ant Project instance.

     * @return The project that this instance of AntBuildExtenderImplementation describes

     */

    Project getOwningProject();

}

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.project.support.ant;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import org.netbeans.api.project.ant.AntBuildExtender;

import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;

/**

 * Factory class for creation of AntBuildExtender instances

 * @author mkleint

 * @since org.netbeans.modules.project.ant 1.16

 */

public final class AntBuildExtenderSupport {

    /** Creates a new instance of AntBuildExtenderSupport */

    private AntBuildExtenderSupport() {

    }

    /**

     * 

     * @param implementation 

     * @return 

     */

    public static AntBuildExtender createAntExtender(AntBuildExtenderImplementation implementation) {

        return AntBuildExtenderAccessor.DEFAULT.createExtender(implementation);

    }

}

import java.util.Collection;

import org.netbeans.api.project.ant.AntBuildExtender;

import org.netbeans.api.project.ant.AntBuildExtender.Extension;

import org.netbeans.modules.project.ant.AntBuildExtenderAccessor;

import org.openide.util.Exceptions;

import org.openide.xml.XMLUtil;

import org.w3c.dom.Attr;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.Text;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

    private AntBuildExtender extender;

    /**

     * Create a helper based on the supplied project helper handle. The created

     * instance is capable of extending the generated files with 3rd party content.

     * @param h an Ant-based project helper supplied to the project type provider

     * @param ex build extensibility support

     * @since org.netbeans.modules.project.ant 1.16

     * 

     */

    public GeneratedFilesHelper(AntProjectHelper h, AntBuildExtender ex) {

        this(h);

        extender = ex;

    }

    private byte[] applyBuildExtensions(byte[] resultData, AntBuildExtender ext) {

        if (ext == null) {

            return resultData;

        }

        try {

            ByteArrayInputStream in2 = new ByteArrayInputStream(resultData);

            InputSource is = new InputSource(in2);

            Document doc = XMLUtil.parse(is, false, true, null, null);

            Element el = doc.getDocumentElement();

            Node firstSubnode = el.getFirstChild();

            //TODO check if first one is text and use it as indentation..

            for (Extension extension : AntBuildExtenderAccessor.DEFAULT.getExtensions(ext)) {

                Text after = doc.createTextNode("\n");

                el.insertBefore(after, firstSubnode);

                Element imp = createImportElement(AntBuildExtenderAccessor.DEFAULT.getPath(extension), doc);

                el.insertBefore(imp, after);

                Text before = doc.createTextNode("    ");

                el.insertBefore(before, imp);

                firstSubnode = before;

                NodeList nl = el.getElementsByTagName("target"); //NOI18N

                Map<String, Collection<String>> deps  = AntBuildExtenderAccessor.DEFAULT.getDependencies(extension);

                for (String targetName : deps.keySet()) {

                    Element targetEl = null;

                    for (int i = 0; i < nl.getLength(); i++) {

                        Element elem = (Element)nl.item(i);

                        String at = elem.getAttribute("name"); //NOI18N

                        if (at != null && at.equals(targetName)) {

                            targetEl = elem;

                            break;

                        }

                    }

//                    System.out.println("target name=" + targetName);

//                    System.out.println("target elem=" + targetEl);

                    if (targetEl != null) {

                        Attr depend = targetEl.getAttributeNode("depends"); //NOI18N

                        if (depend == null) {

                            depend = doc.createAttribute("depends"); //NOI18N

                            depend.setValue("");

                            targetEl.setAttributeNode(depend);

                        }

                        String oldVal = depend.getValue();

                        for (String targ : deps.get(targetName)) {

                            oldVal = oldVal + "," + targ; //NOI18N

                        }

                        if (oldVal.startsWith(",")) { //NOI18N

                            oldVal = oldVal.substring(1);

                        }

                        depend.setValue(oldVal);

                    } else {

                        //TODO log??

                    }

                }

            }

            ByteArrayOutputStream out = new ByteArrayOutputStream();

            XMLUtil.write(doc, out, "UTF-8"); //NOI18N

            return out.toByteArray();

        }

        catch (IOException ex) {

            ex.printStackTrace();

            Exceptions.printStackTrace(ex);

            return resultData;

        }

        catch (SAXException ex) {

            ex.printStackTrace();

            Exceptions.printStackTrace(ex);

            return resultData;

        }

    }

    private Element createImportElement(String path, Document doc) {

        Element el = doc.createElement("import"); //NOI18N

        el.setAttribute("file", path);

        return el;

    }

<p>To allow 3rd party extensions to build scripts, use {@link org.netbeans.spi.project.ant.AntBuildExtenderImplementation} and

{@link org.netbeans.spi.project.support.ant.AntBuildExtenderSupport}.

</p>

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.beans.PropertyChangeEvent;

import org.netbeans.api.project.ant.AntBuildExtender;

    public static AntBasedProjectType testAntBasedProjectType(AntBuildExtenderImplementation extender) {

        return new TestAntBasedProjectType(extender);

    }

        private AntBuildExtenderImplementation ext;

        TestAntBasedProjectType(AntBuildExtenderImplementation ext) {

            this.ext = ext;

        }

                extContent

/*

 * The contents of this file are subject to the terms of the Common Development

 * and Distribution License (the License). You may not use this file except in

 * compliance with the License.

 *

 * You can obtain a copy of the License at http://www.netbeans.org/cddl.html

 * or http://www.netbeans.org/cddl.txt.

 *

 * When distributing Covered Code, include this CDDL Header Notice in each file

 * and include the License file at http://www.netbeans.org/cddl.txt.

 * If applicable, add the following below the CDDL Header, with the fields

 * enclosed by brackets [] replaced by your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.netbeans.spi.project.support.ant;

import org.netbeans.spi.project.AuxiliaryConfiguration;

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.util.Collections;

import java.util.List;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectManager;

import org.netbeans.api.project.TestUtil;

import org.netbeans.api.project.ant.AntBuildExtender;

import org.netbeans.junit.NbTestCase;

import org.openide.filesystems.FileObject;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

/**

 * Test functionality of AntBuildExtender.

 * @author mkleint

 */

public class AntBuildExtenderTest extends NbTestCase {

    public AntBuildExtenderTest(String name) {

        super(name);

    }

    private FileObject scratch;

    private FileObject projdir;

    private FileObject extension1;

    private ProjectManager pm;

    private Project p;

    private AntProjectHelper h;

    private GeneratedFilesHelper gfh;

    private ExtImpl extenderImpl;

    protected void setUp() throws Exception {

        super.setUp();

        scratch = TestUtil.makeScratchDir(this);

        projdir = scratch.createFolder("proj");

        TestUtil.createFileFromContent(GeneratedFilesHelperTest.class.getResource("data/project.xml"), projdir, "nbproject/project.xml");

        extension1 = TestUtil.createFileFromContent(GeneratedFilesHelperTest.class.getResource("data/extension1.xml"), projdir, "nbproject/extension1.xml");

        extenderImpl = new ExtImpl();

        TestUtil.setLookup(new Object[] {

            AntBasedTestUtil.testAntBasedProjectType(extenderImpl),

        });

        pm = ProjectManager.getDefault();

        p = pm.findProject(projdir);

        extenderImpl.project = p;

        h = p.getLookup().lookup(AntProjectHelper.class);

        gfh = p.getLookup().lookup(GeneratedFilesHelper.class);

        assertNotNull(gfh);

    }

    public void testGetExtendableTargets() {

        AntBuildExtender instance = p.getLookup().lookup(AntBuildExtender.class);

        List<String> result = instance.getExtensibleTargets();

        assertEquals(1, result.size());

        assertEquals("all", result.get(0));

    }

    public void testAddExtension() {

        AntBuildExtender instance = p.getLookup().lookup(AntBuildExtender.class);

        instance.addExtension("milos", extension1);

        Element el = p.getLookup().lookup(AuxiliaryConfiguration.class).getConfigurationFragment(

                AntBuildExtenderImplementation.ELEMENT_ROOT, AntBuildExtenderImplementation.AUX_NAMESPACE, true);

        assertNotNull(el);

        NodeList nl = el.getElementsByTagName(AntBuildExtenderImplementation.ELEMENT_EXTENSION);

        assertEquals(1, nl.getLength());

        Element extens = (Element) nl.item(0);

        assertEquals("milos", extens.getAttribute(AntBuildExtenderImplementation.ATTR_ID));

        assertEquals("extension1.xml", extens.getAttribute(AntBuildExtenderImplementation.ATTR_FILE));

    }

    public void testRemoveExtension() {

        AntBuildExtender instance = p.getLookup().lookup(AntBuildExtender.class);

        testAddExtension();

        extenderImpl.oldElement = p.getLookup().lookup(AuxiliaryConfiguration.class).getConfigurationFragment(

                AntBuildExtenderImplementation.ELEMENT_ROOT, AntBuildExtenderImplementation.AUX_NAMESPACE, true);

        instance.removeExtension("milos");

        Element el = p.getLookup().lookup(AuxiliaryConfiguration.class).getConfigurationFragment(

                AntBuildExtenderImplementation.ELEMENT_ROOT, AntBuildExtenderImplementation.AUX_NAMESPACE, true);

        assertNotNull(el);

        NodeList nl = el.getElementsByTagName(AntBuildExtenderImplementation.ELEMENT_EXTENSION);

        assertEquals(0, nl.getLength());

    }

    public void testGetExtension() {

        AntBuildExtender instance = p.getLookup().lookup(AntBuildExtender.class);

        testAddExtension();

        AntBuildExtender.Extension ext = instance.getExtension("milos");

        assertNotNull(ext);

    }

    private class ExtImpl implements AntBuildExtenderImplementation {

        Project project;

        Element newElement;

        Element oldElement;

        List<String> targets = Collections.singletonList("all");

        public List<String> getExtensibleTargets() {

            return targets;

        }

        public void updateBuildExtensionMetadata(Element element) {

            newElement = element;

        }

        public Element getBuildExtensionMetadata() {

            return oldElement;

        }

        public Project getOwningProject() {

            return project;

        }

    }

}

import org.netbeans.spi.project.ant.AntBuildExtenderImplementation;

import java.util.Collections;

import java.util.List;

import org.netbeans.spi.project.AuxiliaryConfiguration;

    private FileObject extension1;

    private ExtImpl extenderImpl;

        extension1 = TestUtil.createFileFromContent(GeneratedFilesHelperTest.class.getResource("data/extension1.xml"), projdir, "nbproject/extension1.xml");

        extenderImpl = new ExtImpl();

        extenderImpl.project = p;

    }

    private class ExtImpl implements AntBuildExtenderImplementation {

        Project project;

        Element newElement;

        Element oldElement;

        public List<String> getExtensibleTargets() {

            return Collections.singletonList("all");

        }

        public void updateBuildExtensionMetadata(Element element) {

            newElement = element;

        }

        public Element getBuildExtensionMetadata() {

            Element el = project.getLookup().lookup(AuxiliaryConfiguration.class).getConfigurationFragment(ELEMENT_ROOT, "urn:test:extension", true);

            if (el != null) {

                NodeList nl = el.getElementsByTagName(AntBuildExtenderImplementation.ELEMENT_ROOT);

                if (nl.getLength() == 1) {

                    return (Element) nl.item(0);

                }

            }

            return null;

        }

        public Project getOwningProject() {

            return project;

        }

<?xml version="1.0" encoding="UTF-8"?>

<!--

    Document   : extension1.xml.xml

    Created on : March 28, 2007, 3:56 PM

    Author     : mkleint

    Description:

        Purpose of the document follows.

-->

<root>

</root>