| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache 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.apache.org/licenses/LICENSE-2.0 |
| * |
| * 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.apache.easyant.core.parser; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.text.ParseException; |
| import java.util.Arrays; |
| import java.util.Enumeration; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.apache.easyant.core.EasyAntConstants; |
| import org.apache.easyant.core.descriptor.AdvancedInheritableItem; |
| import org.apache.easyant.core.descriptor.ConfigureProjectDescriptor; |
| import org.apache.easyant.core.descriptor.DefaultEasyAntDescriptor; |
| import org.apache.easyant.core.descriptor.EasyAntModuleDescriptor; |
| import org.apache.easyant.core.descriptor.ExtensionPointMappingDescriptor; |
| import org.apache.easyant.core.descriptor.PluginDescriptor; |
| import org.apache.easyant.core.descriptor.PluginType; |
| import org.apache.easyant.core.descriptor.PropertyDescriptor; |
| import org.apache.easyant.core.ivy.InheritableScope; |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.ant.IvyConflict; |
| import org.apache.ivy.ant.IvyDependency; |
| import org.apache.ivy.ant.IvyDependencyArtifact; |
| import org.apache.ivy.ant.IvyDependencyConf; |
| import org.apache.ivy.ant.IvyDependencyExclude; |
| import org.apache.ivy.ant.IvyDependencyInclude; |
| import org.apache.ivy.ant.IvyExclude; |
| import org.apache.ivy.core.IvyContext; |
| import org.apache.ivy.core.module.descriptor.Configuration; |
| import org.apache.ivy.core.module.descriptor.DefaultExtendsDescriptor; |
| import org.apache.ivy.core.module.descriptor.ModuleDescriptor; |
| import org.apache.ivy.core.module.id.ModuleId; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParser; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry; |
| import org.apache.ivy.plugins.parser.ParserSettings; |
| import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorParser; |
| import org.apache.ivy.plugins.repository.Resource; |
| import org.apache.ivy.plugins.repository.file.FileResource; |
| import org.apache.ivy.util.FileUtil; |
| import org.apache.ivy.util.Message; |
| import org.apache.ivy.util.PropertiesFile; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.SAXException; |
| |
| /** |
| * Parses an easyant module descriptor and output an EasyAntModuleDescriptor |
| */ |
| public class DefaultEasyAntXmlModuleDescriptorParser extends XmlModuleDescriptorParser implements |
| EasyAntModuleDescriptorParser { |
| |
| private static final DefaultEasyAntXmlModuleDescriptorParser INSTANCE = new DefaultEasyAntXmlModuleDescriptorParser(); |
| |
| public static DefaultEasyAntXmlModuleDescriptorParser getInstance() { |
| return INSTANCE; |
| } |
| |
| static final String[] PLUGIN_REGULAR_ATTRIBUTES = new String[] { "organisation", "org", "module", "revision", |
| "rev", "mrid", "conf", "mode", "as", "inheritable", "inherit-scope" }; |
| |
| public boolean accept(Resource res) { |
| return res.getName().endsWith(".ivy") || res.getName().endsWith(".xml"); |
| } |
| |
| protected Parser newParser(ParserSettings ivySettings) { |
| |
| return new EasyAntParser(this, ivySettings); |
| } |
| |
| private EasyAntModuleDescriptor easyAntModuleDescriptor; |
| |
| public EasyAntModuleDescriptor getEasyAntModuleDescriptor() { |
| return easyAntModuleDescriptor; |
| } |
| |
| public ModuleDescriptor parseDescriptor(ParserSettings ivySettings, URL xmlURL, Resource res, boolean validate) |
| throws ParseException, IOException { |
| |
| EasyAntParser parser = (EasyAntParser) newParser(ivySettings); |
| parser.setValidate(validate); |
| parser.setResource(res); |
| parser.setInput(xmlURL); |
| parser.parse(); |
| easyAntModuleDescriptor = parser.getEasyAntModuleDescriptor(); |
| return parser.getModuleDescriptor(); |
| } |
| |
| private enum EasyAntState { |
| NONE, BUILDTYPE, PLUGIN, PLUGIN_DEPENDENCY, CONFIGURE_PROJECT |
| } |
| |
| public class EasyAntParser extends Parser { |
| |
| private EasyAntState easyAntState; |
| |
| private DefaultEasyAntDescriptor easyAntModuleDescriptor; |
| |
| private String easyantPrefix; |
| |
| private PluginDescriptor currentPluginDescriptor; |
| private IvyDependency currentPluginDependency; |
| |
| public EasyAntParser(ModuleDescriptorParser parser, ParserSettings ivySettings) { |
| super(parser, ivySettings); |
| easyAntState = EasyAntState.NONE; |
| easyAntModuleDescriptor = new DefaultEasyAntDescriptor(); |
| easyantPrefix = ""; |
| } |
| |
| public void startElement(String uri, String localName, String name, Attributes attributes) throws SAXException { |
| super.startElement(uri, localName, name, attributes); |
| if (name.equals(easyantPrefix + ":build") && State.EXTRA_INFO == getState()) { |
| eaBuildStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":plugin") && State.EXTRA_INFO == getState()) { |
| pluginStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":property") && State.EXTRA_INFO == getState()) { |
| easyantPropertyStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":bindtarget") && State.EXTRA_INFO == getState()) { |
| bindTargetStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":configure-project") && State.EXTRA_INFO == getState()) { |
| if (easyAntState != EasyAntState.NONE) { |
| throw new SAXException("configure-project is not supported as a nested element"); |
| } |
| configureProjectStarted(attributes); |
| } |
| |
| if (name.equals(easyantPrefix + ":dependency") && easyAntState == EasyAntState.PLUGIN) { |
| pluginDependencyStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":exclude") && easyAntState == EasyAntState.PLUGIN_DEPENDENCY) { |
| pluginDependencyExcludeStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":include") && easyAntState == EasyAntState.PLUGIN_DEPENDENCY) { |
| pluginDependencyIncludeStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":artifact") && easyAntState == EasyAntState.PLUGIN_DEPENDENCY) { |
| pluginDependencyIncludeStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":conf") && easyAntState == EasyAntState.PLUGIN_DEPENDENCY) { |
| pluginDependencyConfStarted(attributes); |
| } |
| |
| if (name.equals(easyantPrefix + ":exclude") && easyAntState == EasyAntState.PLUGIN) { |
| pluginExcludeStarted(attributes); |
| } |
| if (name.equals(easyantPrefix + ":conflict") && easyAntState == EasyAntState.PLUGIN) { |
| pluginConflictStarted(attributes); |
| } |
| } |
| |
| @Override |
| public void endElement(String uri, String localName, String name) throws SAXException { |
| super.endElement(uri, localName, name); |
| if (name.equals(easyantPrefix + ":plugin") && easyAntState == EasyAntState.PLUGIN) { |
| endPlugin(); |
| } |
| |
| if (name.equals(easyantPrefix + ":dependency") && easyAntState == EasyAntState.PLUGIN_DEPENDENCY) { |
| endPluginDependency(); |
| } |
| |
| if (name.equals(easyantPrefix + ":configure-project") && easyAntState == EasyAntState.CONFIGURE_PROJECT) { |
| easyAntState = EasyAntState.NONE; |
| } |
| } |
| |
| protected void endPlugin() { |
| currentPluginDescriptor = null; |
| easyAntState = EasyAntState.NONE; |
| } |
| |
| public void endPluginDependency() { |
| currentPluginDependency = null; |
| easyAntState = EasyAntState.PLUGIN; |
| |
| } |
| |
| @Override |
| protected void ivyModuleStarted(Attributes attributes) throws SAXException { |
| super.ivyModuleStarted(attributes); |
| // lookup easyant namespace |
| for (Object o : getMd().getExtraAttributesNamespaces().entrySet()) { |
| Entry<?, ?> namespace = (Entry<?, ?>) o; |
| if (EasyAntConstants.EASYANT_MD_NAMESPACE.equals(namespace.getValue())) { |
| easyantPrefix = (String) namespace.getKey(); |
| } |
| } |
| } |
| |
| @Override |
| public void endDocument() throws SAXException { |
| super.endDocument(); |
| |
| for (Configuration conf : getMd().getConfigurations()) { |
| if ("profile".equals(conf.getExtraAttribute(easyantPrefix + ":type"))) { |
| Message.debug("Adding build configuration named " + conf.getName()); |
| easyAntModuleDescriptor.addBuildConfiguration(conf.getName()); |
| } |
| } |
| try { |
| easyAntModuleDescriptor.setIvyModuleDescriptor(super.getModuleDescriptor()); |
| } catch (ParseException e) { |
| throw new SAXException(e); |
| } |
| } |
| |
| /** |
| * Parses configure-project tag |
| * |
| * @param attributes |
| * represents configure project attributes |
| */ |
| protected void configureProjectStarted(Attributes attributes) { |
| easyAntState = EasyAntState.CONFIGURE_PROJECT; |
| ConfigureProjectDescriptor configureProjectDescriptor = new ConfigureProjectDescriptor(); |
| String basedir = getSettings().substitute(attributes.getValue("basedir")); |
| String defaultTarget = getSettings().substitute(attributes.getValue("defaulttarget")); |
| configureProjectDescriptor.setBasedir(basedir); |
| configureProjectDescriptor.setDefaultTarget(defaultTarget); |
| handlePropertyAsAttribute(attributes, Arrays.asList("basedir", "defaulttarget"), |
| configureProjectDescriptor, null); |
| handleInheritedScopeAttribute(attributes, configureProjectDescriptor); |
| easyAntModuleDescriptor.setConfigureProjectDescriptor(configureProjectDescriptor); |
| } |
| |
| /** |
| * Parsing the plugin tag |
| * |
| * @param attributes |
| * reprensents the plugins attributes |
| */ |
| protected void pluginStarted(Attributes attributes) { |
| easyAntState = EasyAntState.PLUGIN; |
| PluginDescriptor plugin = handleCommonPluginDescriptorAttributes(attributes, PluginType.PLUGIN); |
| // plugin specific attribute |
| boolean mandatory = false; |
| String mandatoryValue = getSettings().substitute(attributes.getValue("mandatory")); |
| if (mandatoryValue != null && "true".equals(mandatoryValue)) { |
| mandatory = true; |
| } |
| plugin.setMandatory(mandatory); |
| handleInheritedScopeAttribute(attributes, plugin); |
| |
| currentPluginDescriptor = plugin; |
| easyAntModuleDescriptor.addPlugin(plugin); |
| handlePropertyAsAttribute(attributes, Arrays.asList(PLUGIN_REGULAR_ATTRIBUTES), plugin, |
| plugin.getBuildConfigurations()); |
| } |
| |
| /** |
| * Parsing the easyant tag |
| * |
| * @param attributes |
| * reprensents the easyant attributes |
| */ |
| protected void eaBuildStarted(Attributes attributes) { |
| easyAntState = EasyAntState.BUILDTYPE; |
| PluginDescriptor buildtype = handleCommonPluginDescriptorAttributes(attributes, PluginType.BUILDTYPE); |
| // a build type cannot be skipped |
| buildtype.setMandatory(true); |
| easyAntModuleDescriptor.setBuildType(buildtype); |
| handlePropertyAsAttribute(attributes, Arrays.asList(PLUGIN_REGULAR_ATTRIBUTES), buildtype, |
| buildtype.getBuildConfigurations()); |
| } |
| |
| private PluginDescriptor handleCommonPluginDescriptorAttributes(Attributes attributes, PluginType pluginType) { |
| PluginDescriptor pluginDescriptor = new PluginDescriptor(); |
| String mrid = getSettings().substitute(attributes.getValue("mrid")); |
| if (mrid != null) { |
| if (!mrid.matches(".*#.*")) { |
| if (pluginType == PluginType.BUILDTYPE) { |
| Message.debug("No organisation specified for buildtype " + mrid + " using the default one"); |
| mrid = EasyAntConstants.EASYANT_BUILDTYPES_ORGANISATION + "#" + mrid; |
| } else { |
| Message.debug("No organisation specified for plugin " + mrid + " using the default one"); |
| mrid = EasyAntConstants.EASYANT_PLUGIN_ORGANISATION + "#" + mrid; |
| } |
| } |
| pluginDescriptor.setMrid(mrid); |
| } else { |
| String module = getSettings().substitute(attributes.getValue("module")); |
| String org = attributes.getValue("org") != null ? attributes.getValue("org") : attributes |
| .getValue("organisation"); |
| org = getSettings().substitute(org); |
| if (org == null) { |
| if (pluginType == PluginType.BUILDTYPE) { |
| Message.debug("No organisation specified for buildtype " + module + " using the default one"); |
| org = EasyAntConstants.EASYANT_BUILDTYPES_ORGANISATION; |
| } else { |
| Message.debug("No organisation specified for plugin " + module + " using the default one"); |
| org = EasyAntConstants.EASYANT_PLUGIN_ORGANISATION; |
| } |
| } |
| String revision = attributes.getValue("rev") != null ? attributes.getValue("rev") : attributes |
| .getValue("revision"); |
| revision = getSettings().substitute(revision); |
| pluginDescriptor.setOrganisation(org); |
| pluginDescriptor.setModule(module); |
| pluginDescriptor.setRevision(revision); |
| } |
| |
| String conf = getSettings().substitute(attributes.getValue("conf")); |
| pluginDescriptor.setBuildConfigurations(conf); |
| |
| pluginDescriptor.setMode(getSettings().substitute(attributes.getValue("mode"))); |
| pluginDescriptor.setAs(getSettings().substitute(attributes.getValue("as"))); |
| return pluginDescriptor; |
| } |
| |
| public void pluginDependencyStarted(Attributes attributes) { |
| easyAntState = EasyAntState.PLUGIN_DEPENDENCY; |
| IvyDependency ivyDependency = new IvyDependency(); |
| ivyDependency.setOrg(getSettings().substitute(attributes.getValue("org"))); |
| ivyDependency.setForce(Boolean.valueOf(getSettings().substitute(attributes.getValue("force")))); |
| ivyDependency.setChanging(Boolean.valueOf(getSettings().substitute(attributes.getValue("changing")))); |
| String transitiveValue = getSettings().substitute(attributes.getValue("transitive")); |
| boolean transitive = (transitiveValue == null) ? true : Boolean.valueOf(attributes.getValue("transitive")); |
| ivyDependency.setTransitive(transitive); |
| |
| ivyDependency.setName(getSettings().substitute(attributes.getValue("name"))); |
| ivyDependency.setBranch(getSettings().substitute(attributes.getValue("branch"))); |
| |
| ivyDependency.setRev(getSettings().substitute(attributes.getValue("rev"))); |
| currentPluginDescriptor.addDependency(ivyDependency); |
| currentPluginDependency = ivyDependency; |
| } |
| |
| public void pluginDependencyExcludeStarted(Attributes attributes) { |
| IvyDependencyExclude ivyDependencyExclude = currentPluginDependency.createExclude(); |
| ivyDependencyExclude.setOrg(getSettings().substitute(attributes.getValue("org"))); |
| ivyDependencyExclude.setModule(getSettings().substitute(attributes.getValue("module"))); |
| ivyDependencyExclude.setName(getSettings().substitute(attributes.getValue("name"))); |
| ivyDependencyExclude.setExt(getSettings().substitute(attributes.getValue("ext"))); |
| ivyDependencyExclude.setType(getSettings().substitute(attributes.getValue("type"))); |
| ivyDependencyExclude.setMatcher(getSettings().substitute(attributes.getValue("matcher"))); |
| |
| } |
| |
| public void pluginDependencyIncludeStarted(Attributes attributes) { |
| IvyDependencyInclude ivyDependencyInclude = currentPluginDependency.createInclude(); |
| ivyDependencyInclude.setName(getSettings().substitute(attributes.getValue("name"))); |
| ivyDependencyInclude.setExt(getSettings().substitute(attributes.getValue("ext"))); |
| ivyDependencyInclude.setType(getSettings().substitute(attributes.getValue("type"))); |
| ivyDependencyInclude.setMatcher(getSettings().substitute(attributes.getValue("matcher"))); |
| } |
| |
| public void pluginDependencyArtifactStarted(Attributes attributes) { |
| IvyDependencyArtifact ivyDependencyArtifact = currentPluginDependency.createArtifact(); |
| ivyDependencyArtifact.setName(getSettings().substitute(attributes.getValue("name"))); |
| ivyDependencyArtifact.setExt(getSettings().substitute(attributes.getValue("ext"))); |
| ivyDependencyArtifact.setType(getSettings().substitute(attributes.getValue("type"))); |
| ivyDependencyArtifact.setUrl(getSettings().substitute(attributes.getValue("url"))); |
| } |
| |
| public void pluginDependencyConfStarted(Attributes attributes) { |
| IvyDependencyConf ivyDependencyConf = currentPluginDependency.createConf(); |
| ivyDependencyConf.setMapped(getSettings().substitute(attributes.getValue("mapped"))); |
| } |
| |
| public void pluginConflictStarted(Attributes attributes) { |
| IvyConflict ivyConflict = new IvyConflict(); |
| ivyConflict.setOrg(getSettings().substitute(attributes.getValue("org"))); |
| ivyConflict.setModule(getSettings().substitute(attributes.getValue("module"))); |
| ivyConflict.setRev(getSettings().substitute(attributes.getValue("rev"))); |
| ivyConflict.setManager(getSettings().substitute(attributes.getValue("manager"))); |
| ivyConflict.setMatcher(getSettings().substitute(attributes.getValue("matcher"))); |
| currentPluginDescriptor.addConflict(ivyConflict); |
| } |
| |
| public void pluginExcludeStarted(Attributes attributes) { |
| IvyExclude ivyExclude = new IvyExclude(); |
| ivyExclude.setOrg(getSettings().substitute(attributes.getValue("org"))); |
| ivyExclude.setModule(getSettings().substitute(attributes.getValue("module"))); |
| ivyExclude.setArtifact(getSettings().substitute(attributes.getValue("artifact"))); |
| ivyExclude.setType(getSettings().substitute(attributes.getValue("type"))); |
| ivyExclude.setExt(getSettings().substitute(attributes.getValue("ext"))); |
| ivyExclude.setMatcher(getSettings().substitute(attributes.getValue("matcher"))); |
| currentPluginDescriptor.addExcludes(ivyExclude); |
| } |
| |
| /** |
| * handle properties as attribute |
| * |
| * @param attributes |
| * a set of attributes |
| * @param ignoredAttributes |
| * a list of ignored attributes |
| * @param parentNode |
| * parent node used to apply some attributes to subelements (can be null) |
| * @param buildConf |
| * build configurations where this property should be applied (can be null) |
| * |
| */ |
| private void handlePropertyAsAttribute(Attributes attributes, List<String> ignoredAttributes, |
| AdvancedInheritableItem parentNode, String buildConf) { |
| for (int i = 0; i < attributes.getLength(); i++) { |
| if (!ignoredAttributes.contains(attributes.getQName(i))) { |
| String propertyName = attributes.getQName(i); |
| String value = IvyContext.getContext().getSettings().substitute(attributes.getValue(i)); |
| PropertyDescriptor property = new PropertyDescriptor(propertyName); |
| property.setValue(value); |
| property.setBuildConfigurations(buildConf); |
| if (parentNode != null) { |
| property.setInheritScope(parentNode.getInheritScope()); |
| property.setInheritable(parentNode.isInheritable()); |
| } |
| easyAntModuleDescriptor.getProperties().put(propertyName, property); |
| } |
| } |
| } |
| |
| /** |
| * Handle inherited scope specific attributes |
| * |
| * @param attributes |
| * a set of attributes |
| * @param inheritScopeElement |
| * an element supporting inherit scope attributes |
| */ |
| private void handleInheritedScopeAttribute(Attributes attributes, AdvancedInheritableItem inheritScopeElement) { |
| String inheritScopeValue = getSettings().substitute(attributes.getValue("inherit-scope")); |
| if (inheritScopeValue != null) { |
| InheritableScope scope = InheritableScope.valueOf(inheritScopeValue.toUpperCase()); |
| inheritScopeElement.setInheritScope(scope); |
| } |
| |
| String inheritableValue = getSettings().substitute(attributes.getValue("inheritable")); |
| if (inheritableValue != null) { |
| inheritScopeElement.setInheritable("true".equalsIgnoreCase(inheritableValue)); |
| } |
| |
| } |
| |
| /** |
| * Parsing the bindtarget tag |
| * |
| * @param attributes |
| * reprensents the bindtarget attributes |
| */ |
| protected void bindTargetStarted(Attributes attributes) { |
| String target = getSettings().substitute(attributes.getValue("target")); |
| String toExtensionPoint = getSettings().substitute(attributes.getValue("extensionOf")); |
| String conf = getSettings().substitute(attributes.getValue("conf")); |
| if (EasyAntState.PLUGIN == easyAntState && conf == null) { |
| conf = currentPluginDescriptor.getBuildConfigurations(); |
| } |
| |
| // if bindtarget tag is a subelement and look if an alias was |
| // defined on the plugin |
| if (EasyAntState.PLUGIN == easyAntState && currentPluginDescriptor.getAs() != null) { |
| // check if the fully qualified name was defined, if not get |
| // the alias defined on the plugin |
| if (!target.startsWith(currentPluginDescriptor.getAs())) { |
| target = currentPluginDescriptor.getAs() + target; |
| } |
| |
| } |
| ExtensionPointMappingDescriptor extensionPointMappingDescriptor = new ExtensionPointMappingDescriptor(); |
| extensionPointMappingDescriptor.setBuildConfigurations(conf); |
| extensionPointMappingDescriptor.setTarget(target); |
| extensionPointMappingDescriptor.setExtensionPoint(toExtensionPoint); |
| |
| handleInheritedScopeAttribute(attributes, extensionPointMappingDescriptor); |
| |
| easyAntModuleDescriptor.addExtensionPointMapping(extensionPointMappingDescriptor); |
| |
| } |
| |
| public EasyAntModuleDescriptor getEasyAntModuleDescriptor() { |
| return easyAntModuleDescriptor; |
| } |
| |
| /** |
| * Parse the property tag |
| * |
| * @param attributes |
| * reprensents the plugins attributes |
| * @throws SAXException |
| */ |
| protected void easyantPropertyStarted(Attributes attributes) throws SAXException { |
| String conf = getSettings().substitute(attributes.getValue("conf")); |
| // if property tag is a subelement and |
| // no build configuration was defined looked at plugin build |
| // configurations |
| if (EasyAntState.PLUGIN == easyAntState && conf == null) { |
| conf = currentPluginDescriptor.getBuildConfigurations(); |
| } |
| |
| if (attributes.getValue("file") != null) { |
| String fileName = getSettings().substitute(attributes.getValue("file")); |
| File file = new File(fileName); |
| if (!file.exists()) { |
| throw new SAXException(fileName + " doesn't exists !"); |
| } |
| PropertiesFile props = new PropertiesFile(file, "project properties"); |
| Enumeration<?> enumeration = props.propertyNames(); |
| while (enumeration.hasMoreElements()) { |
| String key = (String) enumeration.nextElement(); |
| String value = getSettings().substitute(props.getProperty(key)); |
| |
| // put this variable on the context |
| IvyContext.getContext().getSettings().getVariableContainer().setVariable(key, value, true); |
| PropertyDescriptor property = new PropertyDescriptor(key); |
| property.setValue(value); |
| property.setBuildConfigurations(conf); |
| |
| applyInheritableItemAttributesFromParentNode(property); |
| // override with explicit inherited scope attributes |
| handleInheritedScopeAttribute(attributes, property); |
| |
| easyAntModuleDescriptor.getProperties().put(key, property); |
| } |
| } else if (attributes.getValue("name") != null) { |
| String propertyName = getSettings().substitute(attributes.getValue("name")); |
| String value = getSettings().substitute(attributes.getValue("value")); |
| |
| // put this variable on the context |
| IvyContext.getContext().getSettings().getVariableContainer().setVariable(propertyName, value, true); |
| PropertyDescriptor property = new PropertyDescriptor(propertyName, getMd().getModuleRevisionId()); |
| property.setValue(value); |
| property.setBuildConfigurations(conf); |
| |
| applyInheritableItemAttributesFromParentNode(property); |
| // override with explicit inherited scope attributes |
| handleInheritedScopeAttribute(attributes, property); |
| |
| easyAntModuleDescriptor.getProperties().put(propertyName, property); |
| } |
| } |
| |
| /** |
| * Apply {@link AdvancedInheritableItem} attributes from current plugin |
| * |
| * @param currentItem |
| */ |
| private void applyInheritableItemAttributesFromParentNode(AdvancedInheritableItem currentItem) { |
| AdvancedInheritableItem parentNode = null; |
| if (easyAntState == EasyAntState.PLUGIN) { |
| parentNode = currentPluginDescriptor; |
| } else if (easyAntState == EasyAntState.CONFIGURE_PROJECT) { |
| parentNode = easyAntModuleDescriptor.getConfigureProjectDescriptor(); |
| } |
| |
| if (parentNode != null) { |
| currentItem.setInheritable(parentNode.isInheritable()); |
| currentItem.setInheritScope(parentNode.getInheritScope()); |
| } |
| } |
| |
| /** |
| * Merge all metadata with an other module descriptor |
| * |
| * @param parent |
| * an other module descriptor |
| */ |
| protected void mergeAll(ModuleDescriptor parent) { |
| super.mergeAll(parent); |
| if (parent.getParser() instanceof DefaultEasyAntXmlModuleDescriptorParser) { |
| DefaultEasyAntXmlModuleDescriptorParser parser = (DefaultEasyAntXmlModuleDescriptorParser) parent |
| .getParser(); |
| mergeEasyantProperties(parser.getEasyAntModuleDescriptor().getProperties()); |
| mergeEasyantPlugins(parser.getEasyAntModuleDescriptor().getPlugins()); |
| mergeBindTargets(parser.getEasyAntModuleDescriptor().getExtensionPointsMappings()); |
| mergeConfigureProject(parser.getEasyAntModuleDescriptor().getConfigureProjectDescriptor()); |
| } |
| } |
| |
| /** |
| * Merge with other module descriptor |
| * |
| * @param extendTypes |
| * a string that represents what we should extends |
| * @param parent |
| * an other module descriptor |
| * @throws ParseException |
| */ |
| protected void mergeWithOtherModuleDescriptor(@SuppressWarnings("rawtypes") List extendTypes, |
| ModuleDescriptor parent) throws ParseException { |
| super.mergeWithOtherModuleDescriptor(extendTypes, parent); |
| if (parent.getParser() instanceof DefaultEasyAntXmlModuleDescriptorParser) { |
| DefaultEasyAntXmlModuleDescriptorParser parser = (DefaultEasyAntXmlModuleDescriptorParser) parent |
| .getParser(); |
| |
| if (extendTypes.contains("properties")) { |
| mergeEasyantProperties(parser.getEasyAntModuleDescriptor().getProperties()); |
| } |
| if (extendTypes.contains("plugins")) { |
| mergeEasyantPlugins(parser.getEasyAntModuleDescriptor().getPlugins()); |
| } |
| if (extendTypes.contains("bindtarget")) { |
| mergeBindTargets(parser.getEasyAntModuleDescriptor().getExtensionPointsMappings()); |
| } |
| if (extendTypes.contains("configure-project")) { |
| mergeConfigureProject(parser.getEasyAntModuleDescriptor().getConfigureProjectDescriptor()); |
| } |
| } |
| |
| } |
| |
| /** |
| * Merge easyant plugins |
| * |
| * @param plugins |
| * a list of plugins that will be merged with current one |
| */ |
| protected void mergeEasyantPlugins(List<PluginDescriptor> plugins) { |
| for (PluginDescriptor plugin : plugins) { |
| if (plugin.isInheritable()) { |
| StringBuilder sb = new StringBuilder("Merging plugin : "); |
| sb.append(plugin.toString()); |
| if (plugin.getSourceModule() != null) { |
| sb.append(" from ").append(plugin.getSourceModule().toString()); |
| } |
| Message.debug(sb.toString()); |
| |
| easyAntModuleDescriptor.addPlugin(plugin); |
| } |
| } |
| } |
| |
| /** |
| * Merge easyant properties |
| * |
| * @param properties |
| * a map of properties that will be merged with current one |
| */ |
| protected void mergeEasyantProperties(Map<String, PropertyDescriptor> properties) { |
| for (PropertyDescriptor prop : properties.values()) { |
| if (prop.isInheritable()) { |
| IvyContext.getContext().getSettings().getVariableContainer() |
| .setVariable(prop.getName(), prop.getValue(), true); |
| StringBuilder sb = new StringBuilder("Merging property"); |
| sb.append(prop.getName()); |
| if (prop.getSourceModule() != null) { |
| sb.append(" from ").append(prop.getSourceModule().toString()); |
| } |
| Message.debug(sb.toString()); |
| easyAntModuleDescriptor.getProperties().put(prop.getName(), prop); |
| } |
| } |
| } |
| |
| protected void mergeBindTargets(List<ExtensionPointMappingDescriptor> extensionPointsMappings) { |
| for (ExtensionPointMappingDescriptor extensionPointMappingDescriptor : extensionPointsMappings) { |
| if (extensionPointMappingDescriptor.isInheritable()) { |
| StringBuilder sb = new StringBuilder("Merging extension-point binding : "); |
| sb.append(extensionPointMappingDescriptor.toString()); |
| if (extensionPointMappingDescriptor.getSourceModule() != null) { |
| sb.append(" from ").append(extensionPointMappingDescriptor.getSourceModule().toString()); |
| } |
| Message.debug(sb.toString()); |
| easyAntModuleDescriptor.addExtensionPointMapping(extensionPointMappingDescriptor); |
| } |
| } |
| } |
| |
| /** |
| * Merge configure project |
| * |
| * @param configureProjectDescriptor |
| * {@link ConfigureProjectDescriptor} that will be merged with current one |
| */ |
| protected void mergeConfigureProject(ConfigureProjectDescriptor configureProjectDescriptor) { |
| if (configureProjectDescriptor != null && configureProjectDescriptor.isInheritable()) { |
| StringBuilder sb = new StringBuilder("Merging configure project : "); |
| sb.append(configureProjectDescriptor.toString()); |
| if (configureProjectDescriptor.getSourceModule() != null) { |
| sb.append(" from ").append(configureProjectDescriptor.getSourceModule().toString()); |
| } |
| Message.debug(sb.toString()); |
| |
| ConfigureProjectDescriptor currentDescriptor = easyAntModuleDescriptor.getConfigureProjectDescriptor(); |
| if (currentDescriptor == null) { |
| currentDescriptor = new ConfigureProjectDescriptor(); |
| easyAntModuleDescriptor.setConfigureProjectDescriptor(configureProjectDescriptor); |
| } |
| currentDescriptor.setDefaultTarget(configureProjectDescriptor.getDefaultTarget()); |
| } |
| |
| } |
| |
| /** |
| * Get the default parent location |
| * |
| * @return a string that represents the default parent location |
| */ |
| protected String getDefaultParentLocation() { |
| return "../parent.ivy"; |
| } |
| |
| /** |
| * TODO: Fix for IVY-1391, should be removed on next ivy upgrade |
| */ |
| /** |
| * Handle extends elements. It checks : |
| * <ul> |
| * <li>filesystem based on location attribute, if no one is specified it will check the default parent location</li> |
| * <li>cache to find a resolved parent descriptor</li> |
| * <li>ask repositories to retrieve the parent module descriptor</li> |
| * </ul> |
| * |
| * @param attributes |
| * @throws ParseException |
| */ |
| protected void extendsStarted(Attributes attributes) throws ParseException { |
| String parentOrganisation = getSettings().substitute(attributes.getValue("organisation")); |
| String parentModule = getSettings().substitute(attributes.getValue("module")); |
| String parentRevision = attributes.getValue("revision") != null ? getSettings().substitute( |
| attributes.getValue("revision")) : Ivy.getWorkingRevision(); |
| String location = attributes.getValue("location") != null ? getSettings().substitute( |
| attributes.getValue("location")) : getDefaultParentLocation(); |
| ModuleDescriptor parent = null; |
| |
| String extendType = attributes.getValue("extendType") != null ? getSettings().substitute( |
| attributes.getValue("extendType").toLowerCase(Locale.US)) : "all"; |
| |
| List<String> extendTypes = Arrays.asList(extendType.split(",")); |
| ModuleId parentMid = new ModuleId(parentOrganisation, parentModule); |
| ModuleRevisionId parentMrid = new ModuleRevisionId(parentMid, parentRevision); |
| |
| // check on filesystem based on location attribute (for dev ONLY) |
| boolean local = false; |
| try { |
| parent = parseParentModuleOnFilesystem(location); |
| if (parent != null) { |
| ModuleId foundMid = parent.getResolvedModuleRevisionId().getModuleId(); |
| if (!foundMid.equals(parentMid)) { |
| // the filesystem contains a parent module with different organisation |
| // or module name; ignore that parent module |
| Message.info("Found a parent module with unexpected ModuleRevisionId at source location " |
| + location + "! Expected: " + parentMid + ". Found: " + foundMid |
| + ". This parent module will be ignored."); |
| parent = null; |
| } |
| } |
| |
| local = parent != null; |
| } catch (IOException e) { |
| Message.warn("Unable to parse included ivy file " + location + " : " + e.getMessage()); |
| } |
| |
| // if not found, tries to resolve using repositories |
| if (parent == null) { |
| try { |
| parent = parseOtherIvyFile(parentMrid); |
| } catch (ParseException e) { |
| Message.warn("Unable to parse included ivy file for " + parentMrid.toString() + " : " |
| + e.getMessage()); |
| } |
| } |
| |
| // if still not found throw an exception |
| if (parent == null) { |
| throw new ParseException("Unable to parse included ivy file for " + parentMrid.toString(), 0); |
| } |
| |
| DefaultExtendsDescriptor ed = new DefaultExtendsDescriptor(parent, location, |
| extendTypes.toArray(new String[extendTypes.size()]), local); |
| getMd().addInheritedDescriptor(ed); |
| |
| mergeWithOtherModuleDescriptor(extendTypes, parent); |
| } |
| |
| /** |
| * Returns the parent module using the location attribute (for dev purpose). |
| * |
| * @param location |
| * a given location |
| * @throws IOException |
| * @throws ParseException |
| */ |
| private ModuleDescriptor parseParentModuleOnFilesystem(String location) throws IOException, ParseException { |
| if (!"file".equals(getDescriptorURL().getProtocol())) { |
| return null; |
| } |
| |
| File file = new File(location); |
| if (!file.isAbsolute()) { |
| URL url = getSettings().getRelativeUrlResolver().getURL(getDescriptorURL(), location); |
| try { |
| file = new File(new URI(url.toExternalForm())); |
| } catch (URISyntaxException e) { |
| file = new File(url.getPath()); |
| } |
| } |
| |
| file = FileUtil.normalize(file.getAbsolutePath()); |
| if (!file.exists()) { |
| Message.verbose("Parent module doesn't exist on the filesystem: " + file.getAbsolutePath()); |
| return null; |
| } |
| |
| FileResource res = new FileResource(null, file); |
| ModuleDescriptorParser parser = ModuleDescriptorParserRegistry.getInstance().getParser(res); |
| return parser.parseDescriptor(getSettings(), file.toURI().toURL(), res, isValidate()); |
| } |
| |
| } |
| } |
