/*
* 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.ivy.core.module.descriptor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.ivy.core.module.id.ArtifactId;
import org.apache.ivy.core.module.id.ModuleId;
import org.apache.ivy.core.module.id.ModuleRevisionId;
import org.apache.ivy.plugins.matcher.MatcherHelper;
import org.apache.ivy.plugins.namespace.NameSpaceHelper;
import org.apache.ivy.plugins.namespace.Namespace;
import org.apache.ivy.plugins.namespace.NamespaceTransformer;
import org.apache.ivy.util.Checks;
/**
* This class can be used as the default implementation for DependencyDescriptor. It implements
* required methods and enables to fill dependency information with the addDependencyConfiguration
* method.
*/
public class DefaultDependencyDescriptor implements DependencyDescriptor {
private static final Pattern SELF_FALLBACK_PATTERN = Pattern
.compile("@(\\+[^\\(]+)?(\\(.*\\))?");
private static final Pattern THIS_FALLBACK_PATTERN = Pattern
.compile("#(\\+[^\\(]+)?(\\(.*\\))?");
/**
* Transforms the given dependency descriptor of the given namespace and return a new dependency
* descriptor in the system namespace. <i>Note that exclude rules are not converted in system
* namespace, because they aren't transformable (the name space hasn't the ability to convert
* regular expressions). However, method doesExclude will work with system artifacts.</i>
*
* @param dd
* @param ns
* @return
*/
public static DependencyDescriptor transformInstance(DependencyDescriptor dd, Namespace ns) {
NamespaceTransformer t = ns.getToSystemTransformer();
if (t.isIdentity()) {
return dd;
}
DefaultDependencyDescriptor newdd = transformInstance(dd, t, false);
newdd.namespace = ns;
return newdd;
}
/**
* Transforms a dependency descriptor using the given transformer. Note that no namespace info
* will be attached to the transformed dependency descriptor, so calling doesExclude is not
* recommended (doesExclude only works when namespace is properly set)
*
* @param dd
* @param t
* @return
*/
public static DefaultDependencyDescriptor transformInstance(DependencyDescriptor dd,
NamespaceTransformer t, boolean fromSystem) {
ModuleRevisionId transformParentId = t.transform(dd.getParentRevisionId());
ModuleRevisionId transformMrid = t.transform(dd.getDependencyRevisionId());
ModuleRevisionId transformDynamicMrid = t.transform(dd
.getDynamicConstraintDependencyRevisionId());
DefaultDependencyDescriptor newdd = new DefaultDependencyDescriptor(null, transformMrid,
transformDynamicMrid, dd.isForce(), dd.isChanging(), dd.isTransitive());
newdd.parentId = transformParentId;
ModuleRevisionId sourceModule = dd.getSourceModule();
if (sourceModule != null) {
newdd.sourceModule = t.transform(sourceModule);
}
String[] moduleConfs = dd.getModuleConfigurations();
if (moduleConfs.length == 1 && "*".equals(moduleConfs[0])) {
if (dd instanceof DefaultDependencyDescriptor) {
DefaultDependencyDescriptor ddd = (DefaultDependencyDescriptor) dd;
newdd.confs = new LinkedHashMap(ddd.confs);
newdd.setExcludeRules(new LinkedHashMap(ddd.getExcludeRules()));
newdd.setIncludeRules(new LinkedHashMap(ddd.getIncludeRules()));
newdd.setDependencyArtifacts(new LinkedHashMap(ddd.getDependencyArtifacts()));
} else {
throw new IllegalArgumentException(
"dependency descriptor transformation does not support * module confs "
+ "with descriptors which aren't DefaultDependencyDescriptor");
}
} else {
for (int i = 0; i < moduleConfs.length; i++) {
newdd.confs.put(moduleConfs[i],
new ArrayList(Arrays.asList(dd.getDependencyConfigurations(moduleConfs[i]))));
newdd.getExcludeRules().put(moduleConfs[i],
new ArrayList(Arrays.asList(dd.getExcludeRules(moduleConfs[i]))));
newdd.getIncludeRules().put(moduleConfs[i],
new ArrayList(Arrays.asList(dd.getIncludeRules(moduleConfs[i]))));
newdd.getDependencyArtifacts().put(moduleConfs[i],
new ArrayList(Arrays.asList(dd.getDependencyArtifacts(moduleConfs[i]))));
}
}
if (fromSystem) {
newdd.asSystem = dd;
}
return newdd;
}
private final ModuleRevisionId revId;
private ModuleRevisionId dynamicRevId;
private Map/* <String,List<String>> */confs = new LinkedHashMap();
// Map (String masterConf -> Collection(DependencyArtifactDescriptor))
private Map dependencyArtifacts; // initialized on demand only for memory consumption reason
// Map (String masterConf -> Collection(IncludeRule))
private Map includeRules; // initialized on demand only for memory consumption reason
// Map (String masterConf -> Collection(ExcludeRule))
private Map excludeRules; // initialized on demand only for memory consumption reason
/**
* Used to indicate that this revision must be used in case of conflicts, independently of
* conflicts manager
*/
private boolean isForce;
/**
* Used to indicate that the dependency is a changing one, i.e. that ivy should not rely on the
* version to know if it can trust artifacts in cache
*/
private boolean isChanging;
private ModuleRevisionId parentId;
private boolean isTransitive = true;
/**
* This namespace should be used to check
*/
private Namespace namespace = null;
private final ModuleDescriptor md;
private DependencyDescriptor asSystem = this;
private ModuleRevisionId sourceModule;
private DefaultDependencyDescriptor(DefaultDependencyDescriptor dd, ModuleRevisionId revision) {
Checks.checkNotNull(dd, "dd");
Checks.checkNotNull(revision, "revision");
if (!revision.getModuleId().equals(dd.getDependencyId())) {
throw new IllegalArgumentException(
"new ModuleRevisionId MUST have the same ModuleId as original one."
+ " original = " + dd.getDependencyId() + " new = "
+ revision.getModuleId());
}
md = dd.md;
parentId = dd.parentId;
revId = revision;
dynamicRevId = dd.dynamicRevId;
isForce = dd.isForce;
isChanging = dd.isChanging;
isTransitive = dd.isTransitive;
namespace = dd.namespace;
confs.putAll(dd.confs);
excludeRules = dd.excludeRules == null ? null : new LinkedHashMap(dd.excludeRules);
includeRules = dd.includeRules == null ? null : new LinkedHashMap(dd.includeRules);
dependencyArtifacts = dd.dependencyArtifacts == null ? null : new LinkedHashMap(
dd.dependencyArtifacts);
sourceModule = dd.sourceModule;
}
public DefaultDependencyDescriptor(ModuleDescriptor md, ModuleRevisionId mrid, boolean force,
boolean changing, boolean transitive) {
this(md, mrid, mrid, force, changing, transitive);
}
public DefaultDependencyDescriptor(ModuleRevisionId mrid, boolean force) {
this(mrid, force, false);
}
public DefaultDependencyDescriptor(ModuleRevisionId mrid, boolean force, boolean changing) {
this(null, mrid, mrid, force, changing, true);
}
public DefaultDependencyDescriptor(ModuleDescriptor md, ModuleRevisionId mrid,
ModuleRevisionId dynamicConstraint, boolean force, boolean changing, boolean transitive) {
Checks.checkNotNull(mrid, "mrid");
Checks.checkNotNull(dynamicConstraint, "dynamicConstraint");
this.md = md;
revId = mrid;
dynamicRevId = dynamicConstraint;
isForce = force;
isChanging = changing;
isTransitive = transitive;
sourceModule = md == null ? null : md.getModuleRevisionId();
}
public ModuleId getDependencyId() {
return getDependencyRevisionId().getModuleId();
}
public ModuleRevisionId getDependencyRevisionId() {
return revId;
}
public ModuleRevisionId getDynamicConstraintDependencyRevisionId() {
return dynamicRevId;
}
public String[] getModuleConfigurations() {
return (String[]) confs.keySet().toArray(new String[confs.keySet().size()]);
}
public String[] getDependencyConfigurations(String moduleConfiguration) {
return getDependencyConfigurations(moduleConfiguration, moduleConfiguration);
}
/**
* Return the dependency configurations mapped to the given moduleConfiguration, actually
* resolved because of the given requestedConfiguration
* <p>
* Usually requestedConfiguration and moduleConfiguration are the same, except when a conf
* extends another, then the moduleConfiguration is the configuration currently resolved (the
* extended one), and requestedConfiguration is the one actually requested initially (the
* extending one). Both moduleConfiguration and requestedConfiguration are configurations of the
* caller, the array returned is composed of the required configurations of the dependency
* described by this descriptor.
*/
public String[] getDependencyConfigurations(String moduleConfiguration,
String requestedConfiguration) {
if (md != null) {
Configuration c = md.getConfiguration(moduleConfiguration);
if (c instanceof ConfigurationIntersection) {
ConfigurationIntersection intersection = (ConfigurationIntersection) c;
Set /* <String> */intersectedDepConfs = new HashSet();
String[] intersected = intersection.getIntersectedConfigurationNames();
for (int i = 0; i < intersected.length; i++) {
Collection depConfs = getDependencyConfigurationsIncludingExtending(
intersected[i], requestedConfiguration);
if (intersectedDepConfs.isEmpty()) {
intersectedDepConfs.addAll(depConfs);
} else {
if (intersectedDepConfs.contains("*")) {
intersectedDepConfs.remove("*");
intersectedDepConfs.addAll(depConfs);
} else if (depConfs.contains("*")) {
// nothing to do, intersection of 'something'
// with 'everything' is 'something'
} else {
Set /* <String> */intersectedDepConfsCopy = intersectedDepConfs;
intersectedDepConfs = new HashSet();
for (Iterator it = intersectedDepConfsCopy.iterator(); it.hasNext();) {
String intersectedDepConf = (String) it.next();
if (depConfs.contains(intersectedDepConf)) {
// the conf is present in both sets,
// so it is in the intersection
intersectedDepConfs.add(intersectedDepConf);
continue;
}
/*
* we do not handle special confs like *!sg or [cond]* in right hand
* confs yet: it would require supporting parenthesis grouping in
* configurations intersection interpretation
*
* for (Iterator it2 = depConfs.iterator(); it2.hasNext();) { String
* depConf = (String) it2.next(); if (depConf.startsWith("*")) { if
* (intersectedDepConf .indexOf("(" + depConf + ")") != -1) {
* intersectedDepConfs.add(intersectedDepConf); } else {
* intersectedDepConfs.add( "(" + intersectedDepConf + ")+(" +
* depConf + ")"); } } else if (intersectedDepConf.startsWith("*"))
* { if (depConf .indexOf("(" + intersectedDepConf + ")") != -1) {
* intersectedDepConfs.add(depConf); } else {
* intersectedDepConfs.add( depConf + "+" + intersectedDepConf); } }
* }
*/
}
}
}
}
List confsList = (List) confs.get(moduleConfiguration);
if (confsList != null) {
intersectedDepConfs.addAll(confsList);
}
if (intersectedDepConfs.isEmpty()) {
List defConfs = (List) confs.get("*");
if (defConfs != null) {
for (Iterator it = defConfs.iterator(); it.hasNext();) {
String mappedConf = (String) it.next();
if (mappedConf != null && mappedConf.startsWith("@+")) {
return new String[] {moduleConfiguration + mappedConf.substring(1)};
} else if (mappedConf != null && mappedConf.equals("@")) {
return new String[] {moduleConfiguration};
}
}
}
}
return (String[]) intersectedDepConfs
.toArray(new String[intersectedDepConfs.size()]);
} else if (c instanceof ConfigurationGroup) {
ConfigurationGroup group = (ConfigurationGroup) c;
Set /* <String> */groupDepConfs = new HashSet();
String[] members = group.getMembersConfigurationNames();
for (int i = 0; i < members.length; i++) {
Collection depConfs = getDependencyConfigurationsIncludingExtending(members[i],
requestedConfiguration);
groupDepConfs.addAll(depConfs);
}
return (String[]) groupDepConfs.toArray(new String[groupDepConfs.size()]);
}
}
List confsList = (List) confs.get(moduleConfiguration);
if (confsList == null) {
// there is no mapping defined for this configuration, add the 'other' mappings.
confsList = (List) confs.get("%");
}
List defConfs = (List) confs.get("*");
Collection ret = new LinkedHashSet();
if (confsList != null) {
ret.addAll(confsList);
}
if (defConfs != null) {
ret.addAll(defConfs);
}
Collection replacedRet = new LinkedHashSet();
for (Iterator iter = ret.iterator(); iter.hasNext();) {
String c = (String) iter.next();
String replacedConf = replaceSelfFallbackPattern(c, moduleConfiguration);
if (replacedConf == null) {
replacedConf = replaceThisFallbackPattern(c, requestedConfiguration);
}
if (replacedConf != null) {
c = replacedConf;
}
replacedRet.add(c);
}
ret = replacedRet;
if (ret.remove("*")) {
StringBuffer r = new StringBuffer("*");
// merge excluded configurations as one conf like *!A!B
for (Iterator iter = ret.iterator(); iter.hasNext();) {
String c = (String) iter.next();
if (c.startsWith("!")) {
r.append(c);
}
}
return new String[] {r.toString()};
}
return (String[]) ret.toArray(new String[ret.size()]);
}
private Collection getDependencyConfigurationsIncludingExtending(String conf,
String requestedConfiguration) {
Set/* <String> */allDepConfs = new LinkedHashSet();
allDepConfs
.addAll(Arrays.asList(getDependencyConfigurations(conf, requestedConfiguration)));
Collection extendingConfs = Configuration.findConfigurationExtending(conf,
md.getConfigurations());
for (Iterator it = extendingConfs.iterator(); it.hasNext();) {
Configuration extendingConf = (Configuration) it.next();
allDepConfs.addAll(Arrays.asList(getDependencyConfigurations(extendingConf.getName(),
requestedConfiguration)));
}
return allDepConfs;
}
protected static String replaceSelfFallbackPattern(final String conf,
final String moduleConfiguration) {
return replaceFallbackConfigurationPattern(SELF_FALLBACK_PATTERN, conf, moduleConfiguration);
}
protected static String replaceThisFallbackPattern(final String conf,
final String requestedConfiguration) {
return replaceFallbackConfigurationPattern(THIS_FALLBACK_PATTERN, conf,
requestedConfiguration);
}
/**
* Replaces fallback patterns with correct values if fallback pattern exists.
*
* @param pattern
* pattern to look for
* @param conf
* configuration mapping from dependency element
* @param moduleConfiguration
* module's configuration to use for replacement
* @return Replaced string if pattern matched. Otherwise null.
*/
protected static String replaceFallbackConfigurationPattern(final Pattern pattern,
final String conf, final String moduleConfiguration) {
Matcher matcher = pattern.matcher(conf);
if (matcher.matches()) {
String mappedConf = moduleConfiguration;
if (matcher.group(1) != null) {
mappedConf = mappedConf + matcher.group(1);
}
if (matcher.group(2) != null) {
mappedConf = mappedConf + matcher.group(2);
}
return mappedConf;
}
return null;
}
public String[] getDependencyConfigurations(String[] moduleConfigurations) {
Set confs = new LinkedHashSet();
for (int i = 0; i < moduleConfigurations.length; i++) {
confs.addAll(Arrays.asList(getDependencyConfigurations(moduleConfigurations[i])));
}
if (confs.contains("*")) {
return new String[] {"*"};
}
return (String[]) confs.toArray(new String[confs.size()]);
}
public DependencyArtifactDescriptor[] getDependencyArtifacts(String moduleConfiguration) {
Collection artifacts = getCollectionForConfiguration(moduleConfiguration,
dependencyArtifacts);
return (DependencyArtifactDescriptor[]) artifacts
.toArray(new DependencyArtifactDescriptor[artifacts.size()]);
}
public IncludeRule[] getIncludeRules(String moduleConfiguration) {
Collection rules = getCollectionForConfiguration(moduleConfiguration, includeRules);
return (IncludeRule[]) rules.toArray(new IncludeRule[rules.size()]);
}
public ExcludeRule[] getExcludeRules(String moduleConfiguration) {
Collection rules = getCollectionForConfiguration(moduleConfiguration, excludeRules);
return (ExcludeRule[]) rules.toArray(new ExcludeRule[rules.size()]);
}
private Set getCollectionForConfiguration(String moduleConfiguration, Map collectionMap) {
if (collectionMap == null || collectionMap.isEmpty()) {
return Collections.EMPTY_SET;
}
Collection artifacts = (Collection) collectionMap.get(moduleConfiguration);
Collection defArtifacts = (Collection) collectionMap.get("*");
Set ret = new LinkedHashSet();
if (artifacts != null) {
ret.addAll(artifacts);
}
if (defArtifacts != null) {
ret.addAll(defArtifacts);
}
return ret;
}
public DependencyArtifactDescriptor[] getDependencyArtifacts(String[] moduleConfigurations) {
Set artifacts = new LinkedHashSet();
for (int i = 0; i < moduleConfigurations.length; i++) {
artifacts.addAll(Arrays.asList(getDependencyArtifacts(moduleConfigurations[i])));
}
return (DependencyArtifactDescriptor[]) artifacts
.toArray(new DependencyArtifactDescriptor[artifacts.size()]);
}
public IncludeRule[] getIncludeRules(String[] moduleConfigurations) {
Set rules = new LinkedHashSet();
for (int i = 0; i < moduleConfigurations.length; i++) {
rules.addAll(Arrays.asList(getIncludeRules(moduleConfigurations[i])));
}
return (IncludeRule[]) rules.toArray(new IncludeRule[rules.size()]);
}
public ExcludeRule[] getExcludeRules(String[] moduleConfigurations) {
Set rules = new LinkedHashSet();
for (int i = 0; i < moduleConfigurations.length; i++) {
rules.addAll(Arrays.asList(getExcludeRules(moduleConfigurations[i])));
}
return (ExcludeRule[]) rules.toArray(new ExcludeRule[rules.size()]);
}
public DependencyArtifactDescriptor[] getAllDependencyArtifacts() {
if (dependencyArtifacts == null) {
return new DependencyArtifactDescriptor[0];
}
Set ret = mergeAll(dependencyArtifacts);
return (DependencyArtifactDescriptor[]) ret.toArray(new DependencyArtifactDescriptor[ret
.size()]);
}
public IncludeRule[] getAllIncludeRules() {
if (includeRules == null) {
return new IncludeRule[0];
}
Set ret = mergeAll(includeRules);
return (IncludeRule[]) ret.toArray(new IncludeRule[ret.size()]);
}
public ExcludeRule[] getAllExcludeRules() {
if (excludeRules == null) {
return new ExcludeRule[0];
}
Set ret = mergeAll(excludeRules);
return (ExcludeRule[]) ret.toArray(new ExcludeRule[ret.size()]);
}
private Set mergeAll(Map artifactsMap) {
Set ret = new LinkedHashSet();
for (Iterator it = artifactsMap.values().iterator(); it.hasNext();) {
Collection artifacts = (Collection) it.next();
ret.addAll(artifacts);
}
return ret;
}
public void addDependencyConfiguration(String masterConf, String depConf) {
if ((md != null) && !"*".equals(masterConf) && !"%".equals(masterConf)) {
Configuration config;
if (masterConf.startsWith("!")) {
config = md.getConfiguration(masterConf.substring(1));
} else {
config = md.getConfiguration(masterConf);
}
if (config == null) {
throw new IllegalArgumentException("Cannot add dependency '" + revId
+ "' to configuration '" + masterConf + "' of module "
+ md.getModuleRevisionId() + " because this configuration doesn't exist!");
}
if (config instanceof ConfigurationGroup) {
ConfigurationGroup group = (ConfigurationGroup) config;
String[] members = group.getMembersConfigurationNames();
for (int i = 0; i < members.length; i++) {
addDependencyConfiguration(members[i], depConf);
}
return;
}
}
List confsList = (List) confs.get(masterConf);
if (confsList == null) {
confsList = new ArrayList();
confs.put(masterConf, confsList);
}
if (!confsList.contains(depConf)) {
confsList.add(depConf);
}
}
public void addDependencyArtifact(String masterConf, DependencyArtifactDescriptor dad) {
addObjectToConfiguration(masterConf, dad, getDependencyArtifacts());
}
public void addIncludeRule(String masterConf, IncludeRule rule) {
addObjectToConfiguration(masterConf, rule, getIncludeRules());
}
public void addExcludeRule(String masterConf, ExcludeRule rule) {
addObjectToConfiguration(masterConf, rule, getExcludeRules());
}
private void addObjectToConfiguration(String callerConf, Object toAdd, Map confsMap) {
Collection col = (Collection) confsMap.get(callerConf);
if (col == null) {
col = new ArrayList();
confsMap.put(callerConf, col);
}
col.add(toAdd);
}
/**
* only works when namespace is properly set. The behaviour is not specified if namespace is not
* set
*/
public boolean doesExclude(String[] moduleConfigurations, ArtifactId artifactId) {
if (namespace != null) {
artifactId = NameSpaceHelper
.transform(artifactId, namespace.getFromSystemTransformer());
}
ExcludeRule[] rules = getExcludeRules(moduleConfigurations);
for (int i = 0; i < rules.length; i++) {
if (MatcherHelper.matches(rules[i].getMatcher(), rules[i].getId(), artifactId)) {
return true;
}
}
return false;
}
/**
* Returns true if this descriptor contains any exclusion rule
*
* @return
*/
public boolean canExclude() {
return excludeRules != null && !excludeRules.isEmpty();
}
public String toString() {
return "dependency: " + revId + " " + confs;
}
public boolean isForce() {
return isForce;
}
public ModuleRevisionId getParentRevisionId() {
return md != null ? md.getResolvedModuleRevisionId() : parentId;
}
public boolean isChanging() {
return isChanging;
}
public boolean isTransitive() {
return isTransitive;
}
public Namespace getNamespace() {
return namespace;
}
public String getAttribute(String attName) {
return revId.getAttribute(attName);
}
public Map getAttributes() {
return revId.getAttributes();
}
public String getExtraAttribute(String attName) {
return revId.getExtraAttribute(attName);
}
public Map getExtraAttributes() {
return revId.getExtraAttributes();
}
public Map getQualifiedExtraAttributes() {
return revId.getQualifiedExtraAttributes();
}
public DependencyDescriptor asSystem() {
return asSystem;
}
private void setDependencyArtifacts(Map dependencyArtifacts) {
this.dependencyArtifacts = dependencyArtifacts;
}
private Map getDependencyArtifacts() {
if (dependencyArtifacts == null) {
dependencyArtifacts = new LinkedHashMap();
}
return dependencyArtifacts;
}
private void setIncludeRules(Map includeRules) {
this.includeRules = includeRules;
}
private Map getIncludeRules() {
if (includeRules == null) {
includeRules = new LinkedHashMap();
}
return includeRules;
}
private void setExcludeRules(Map excludeRules) {
this.excludeRules = excludeRules;
}
private Map getExcludeRules() {
if (excludeRules == null) {
excludeRules = new LinkedHashMap();
}
return excludeRules;
}
public ModuleRevisionId getSourceModule() {
return sourceModule;
}
public DependencyDescriptor clone(ModuleRevisionId revision) {
return new DefaultDependencyDescriptor(this, revision);
}
}