Add ns support

Also split Definer.java in a base class (DefBase) to allow
it to be used for other defining tasks
Also add AntlibInterface to allow antlib to set uri and
classloader for other tasks/types that Definer.

Bugzilla: 19897


git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@275064 13f79535-47bb-0310-9956-ffa450edef68

Author: Peter Reilly

src/main/org/apache/tools/ant/ComponentHelper.java

@@ -58,14 +58,19 @@
 
 import java.util.Enumeration;
 import java.util.Hashtable;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Properties;
+import java.util.Set;
+import java.util.Stack;
 
 import java.util.Vector;
 import java.io.InputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
 
+import org.apache.tools.ant.taskdefs.Typedef;
+
 /**
  * Component creation and configuration.
  *
@@ -98,6 +103,17 @@ public class ComponentHelper  {
     /** flag to rebuild typeClassDefinitions */
     private boolean rebuildTypeClassDefinitions = true;
 
+    /** Set of namespaces that have been checked for antlibs */
+    private Set checkedNamespaces = new HashSet();
+
+    /**
+     * Stack of antlib contexts used to resolve definitions while
+     *   processing antlib
+     */
+    private Stack antLibStack = new Stack();
+    /** current antlib context */
+    private AntTypeTable antLibTypeTable = null;
+
     /**
      * Map from task names to vectors of created tasks
      * (String to Vector of Task). This is used to invalidate tasks if
@@ -175,32 +191,38 @@ public void initSubProject(ComponentHelper helper) {
             AntTypeDefinition def = (AntTypeDefinition) i.next();
             antTypeTable.put(def.getName(), def);
         }
+        // add the parsed namespaces of the parent project
+        checkedNamespaces.add(helper.checkedNamespaces);
     }
 
     /** Factory method to create the components.
      *
      * This should be called by UnknownElement.
      *
-     * @param ue The component helper has access via ue to the entire XML tree.
-     * @param ns Namespace. Also available as ue.getNamespace()
-     * @param taskName The element name. Also available as ue.getTag()
+     * @param ue The Unknown Element creating this component
+     * @param ns Namespace URI. Also available as ue.getNamespace()
+     * @param componentType The component type,
+     *                       Also available as ue.getComponentName()
      * @return the created component
      * @throws BuildException if an error occuries
      */
     public Object createComponent(UnknownElement ue,
                                   String ns,
-                                  String taskName)
+                                  String componentType)
         throws BuildException {
-        Object component = createComponent(taskName);
+        Object component = createComponent(componentType);
         if (component == null) {
             return null;
         }
 
         if (component instanceof Task) {
             Task task = (Task) component;
-            task.setTaskType(taskName);
-            task.setTaskName(taskName);
-            addCreatedTask(taskName, task);
+            task.setLocation(ue.getLocation());
+            task.setTaskType(componentType);
+            task.setTaskName(ue.getTaskName());
+            task.setOwningTarget(ue.getOwningTarget());
+            task.init();
+            addCreatedTask(componentType, task);
         }
 
         return component;
@@ -215,7 +237,11 @@ public Object createComponent(UnknownElement ue,
      * @return the class if found or null if not.
      */
     public Object createComponent(String componentName) {
-        return antTypeTable.create(componentName);
+        AntTypeDefinition def = getDefinition(componentName);
+        if (def == null) {
+            return null;
+        }
+        return def.create(project);
     }
 
     /**
@@ -227,7 +253,11 @@ public Object createComponent(String componentName) {
      * @return the class if found or null if not.
      */
     public Class getComponentClass(String componentName) {
-        return antTypeTable.getExposedClass(componentName);
+        AntTypeDefinition def = getDefinition(componentName);
+        if (def == null) {
+            return null;
+        }
+        return def.getExposedClass(project);
     }
 
     /**
@@ -236,7 +266,15 @@ public Class getComponentClass(String componentName) {
      * @return the ant definition or null if not present
      */
     public AntTypeDefinition getDefinition(String componentName) {
-        return antTypeTable.getDefinition(componentName);
+        checkNamespace(componentName);
+        AntTypeDefinition ret = null;
+        if (antLibTypeTable != null && componentName.indexOf(':') == -1) {
+            ret = antLibTypeTable.getDefinition(componentName);
+        }
+        if (ret == null) {
+            ret = antTypeTable.getDefinition(componentName);
+        }
+        return ret;
     }
 
     /**
@@ -474,15 +512,15 @@ public Task createTask(String taskType) throws BuildException {
      *                           creation fails.
      */
     private Task createNewTask(String taskType) throws BuildException {
-        Class c = antTypeTable.getExposedClass(taskType);
+        Class c = getComponentClass(taskType);
         if (c == null) {
             return null;
         }
 
         if (!(Task.class.isAssignableFrom(c))) {
             return null;
         }
-        Task task = (Task) antTypeTable.create(taskType);
+        Task task = (Task) createComponent(taskType);
         if (task == null) {
             return null;
         }
@@ -557,7 +595,7 @@ private void invalidateCreatedTasks(String type) {
      *                           instance creation fails.
      */
     public Object createDataType(String typeName) throws BuildException {
-        return antTypeTable.create(typeName);
+        return createComponent(typeName);
     }
 
     /**
@@ -660,6 +698,31 @@ private void updateDataTypeDefinition(AntTypeDefinition def) {
             project.log(" +Datatype " + name + " " + def.getClassName(),
                         Project.MSG_DEBUG);
             antTypeTable.put(name, def);
+
+            if (antLibTypeTable != null && name.lastIndexOf(':') != -1) {
+                String baseName = name.substring(name.lastIndexOf(':') + 1);
+                antLibTypeTable.put(baseName, def);
+            }
+        }
+    }
+
+    /**
+     * Called at the start of processing an antlib
+     */
+    public void enterAntLib() {
+        antLibTypeTable = new AntTypeTable(project);
+        antLibStack.push(antLibTypeTable);
+    }
+
+    /**
+     * Called at the end of processing an antlib
+     */
+    public void exitAntLib() {
+        antLibStack.pop();
+        if (antLibStack.size() != 0) {
+            antLibTypeTable = (AntTypeTable) antLibStack.peek();
+        } else {
+            antLibTypeTable = null;
         }
     }
 
@@ -751,6 +814,35 @@ private void initTypes() {
         }
     }
 
+    /**
+     * called for each component name, check if the
+     * associated URI has been examined for antlibs.
+     */
+    private void checkNamespace(String componentName) {
+        if (componentName.indexOf(':') == -1) {
+            return; // not a namespaced name
+        }
+
+        String uri = ProjectHelper.extractUriFromComponentName(componentName);
+        if (!uri.startsWith(ProjectHelper.ANTLIB_URI)) {
+            return; // namespace that does not contain antlib
+        }
+        if (checkedNamespaces.contains(uri)) {
+            return; // Alreay processed
+        }
+        checkedNamespaces.add(uri);
+        Typedef definer = new Typedef();
+        definer.setProject(project);
+        definer.setURI(uri);
+        definer.setResource(
+            uri.substring("antlib:".length()).replace('.', '/')
+            + "/antlib.xml");
+        // a fishing expedition :- ignore errors if antlib not present
+        definer.setOnError(new Typedef.OnError("ignore"));
+        definer.init();
+        definer.execute();
+    }
+
     /**
      * map that contains the component definitions
      */

src/main/org/apache/tools/ant/ProjectHelper.java

@@ -85,6 +85,12 @@
  * @author duncan@x180.com
  */
 public class ProjectHelper {
+    /** The URI for ant name space */
+    public static final String ANT_CORE_URI       = "ant:core";
+
+    /** The URI for defined types/tasks - the format is antlib:<package> */
+    public static final String ANTLIB_URI     = "antlib:";
+
     /**
      * Name of JVM system property which provides the name of the
      * ProjectHelper class to use.
@@ -493,5 +499,34 @@ public static void parsePropertyString(String value, Vector fragments,
         PropertyHelper.parsePropertyStringDefault(value, fragments,
                 propertyRefs);
     }
+    /**
+     * Map a namespaced {uri,name} to an internal string format.
+     * For BC purposes the names from the ant core uri will be
+     * mapped to "name", other names will be mapped to
+     * uri + ":" + name.
+     * @param uri   The namepace URI
+     * @param name  The localname
+     * @return      The stringified form of the ns name
+     */
+    public static String genComponentName(String uri, String name) {
+        if (uri == null || uri.equals("") || uri.equals(ANT_CORE_URI)) {
+            return name;
+        }
+        return uri + ":" + name;
+    }
+
+    /**
+     * extract a uri from a component name
+     *
+     * @param componentName  The stringified form for {uri, name}
+     * @return               The uri or "" if not present
+     */
+    public static String extractUriFromComponentName(String componentName) {
+        int index = componentName.lastIndexOf(':');
+        if (index == -1) {
+            return "";
+        }
+        return componentName.substring(0, index);
+    }
 //end class
 }

src/main/org/apache/tools/ant/RuntimeConfigurable.java

@@ -176,6 +176,14 @@ public String getPolyType() {
         return polyType;
     }
 
+    /**
+     * set the polymorphic type for this element
+     * @param polyType the ant component type name, null if not set
+     */
+    public void setPolyType(String polyType) {
+        this.polyType = polyType;
+    }
+
     /**
      * Sets the attributes for the wrapped element.
      *
@@ -260,10 +268,10 @@ RuntimeConfigurable getChild(int index) {
 
     /**
      * Returns an enumeration of all child wrappers.
-     *
+     * @return an enumeration of the child wrappers.
      * @since Ant 1.5.1
      */
-    Enumeration getChildren() {
+    public Enumeration getChildren() {
         if (children != null) {
             return Collections.enumeration(children);
         } else {

src/main/org/apache/tools/ant/UnknownElement.java

@@ -81,6 +81,11 @@ public class UnknownElement extends Task {
      */
     private String namespace;
 
+    /**
+     * Holds the namespace qname of the element.
+     */
+    private String qname;
+
     /**
      * The real object after it has been loaded.
      */
@@ -129,6 +134,24 @@ public void setNamespace(String namespace) {
         this.namespace = namespace;
     }
 
+    /** Return the qname of the XML element associated with this component.
+     *
+     * @return namespace Qname used in the element declaration.
+     */
+    public String getQName() {
+        return qname;
+    }
+
+    /** Set the namespace qname of the XML element.
+     * This method is typically called by the XML processor.
+     *
+     * @param qname the qualified name of the element
+     */
+    public void setQName(String qname) {
+        this.qname = qname;
+    }
+
+
     /**
      * Get the RuntimeConfigurable instance for this UnknownElement, containing
      * the configuration information.
@@ -334,6 +357,13 @@ protected void handleChildren(Object parent,
         }
     }
 
+    /**
+     * @return the component name - uses ProjectHelper#genComponentName()
+     */
+    protected String getComponentName() {
+        return ProjectHelper.genComponentName(getNamespace(), getTag());
+    }
+
     /**
      * Creates a named task or data type. If the real object is a task,
      * it is configured up to the init() stage.
@@ -345,12 +375,17 @@ protected void handleChildren(Object parent,
      * @return the task or data type represented by the given unknown element.
      */
     protected Object makeObject(UnknownElement ue, RuntimeConfigurable w) {
-        Object o = makeTask(ue, w);
+        ComponentHelper helper = ComponentHelper.getComponentHelper(
+            getProject());
+        String name = ue.getComponentName();
+        Object o = helper.createComponent(ue, ue.getNamespace(), name);
         if (o == null) {
-            o = getProject().createDataType(ue.getTag());
+            throw getNotFoundException("task or type", name);
         }
-        if (o == null) {
-            throw getNotFoundException("task or type", ue.getTag());
+        if (o instanceof Task) {
+            Task task = (Task) o;
+            task.setOwningTarget(getOwningTarget());
+            task.init();
         }
         return o;
     }