( dependency.getExclusions() );
result.addAll( exclusions );
management.setExclusions( result );
+
+ final Object sourceHint = this.managedExclusionsSourceHints.get( key );
+ if ( sourceHint != null )
+ {
+ management.setExclusionsSourceHint( sourceHint.toString() );
+ }
}
return management;
@@ -261,8 +343,8 @@ else if ( null == obj || !getClass().equals( obj.getClass() ) )
ClassicDependencyManager that = (ClassicDependencyManager) obj;
return depth == that.depth && managedVersions.equals( that.managedVersions )
- && managedScopes.equals( that.managedScopes ) && managedOptionals.equals( that.managedOptionals )
- && managedExclusions.equals( that.managedExclusions );
+ && managedScopes.equals( that.managedScopes ) && managedOptionals.equals( that.managedOptionals )
+ && managedExclusions.equals( that.managedExclusions );
}
@Override
@@ -311,9 +393,9 @@ else if ( !( obj instanceof Key ) )
}
Key that = (Key) obj;
return artifact.getArtifactId().equals( that.artifact.getArtifactId() )
- && artifact.getGroupId().equals( that.artifact.getGroupId() )
- && artifact.getExtension().equals( that.artifact.getExtension() )
- && artifact.getClassifier().equals( that.artifact.getClassifier() );
+ && artifact.getGroupId().equals( that.artifact.getGroupId() )
+ && artifact.getExtension().equals( that.artifact.getExtension() )
+ && artifact.getClassifier().equals( that.artifact.getClassifier() );
}
@Override
diff --git a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DefaultDependencyManager.java b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DefaultDependencyManager.java
new file mode 100644
index 000000000..d19caa56b
--- /dev/null
+++ b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DefaultDependencyManager.java
@@ -0,0 +1,383 @@
+package org.eclipse.aether.util.graph.manager;
+
+/*
+ * 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.
+ */
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.ArtifactProperties;
+import org.eclipse.aether.collection.DependencyCollectionContext;
+import org.eclipse.aether.collection.DependencyManagement;
+import org.eclipse.aether.collection.DependencyManager;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.Exclusion;
+import org.eclipse.aether.util.artifact.JavaScopes;
+
+/**
+ * A dependency manager managing dependencies on all levels supporting transitive dependency management.
+ *
+ * Note:Unlike the {@code ClassicDependencyManager} and the {@code TransitiveDependencyManager} this
+ * implementation applies management also on the first level. This is considered the resolver default behaviour. It
+ * ignores all management overrides supported by the {@code MavenModelBuilder}.
+ *
+ *
+ * @author Christian Schulte
+ * @since 1.2.0
+ */
+public final class DefaultDependencyManager
+ implements DependencyManager
+{
+
+ private final Map managedVersions;
+
+ private final Map managedVersionsSourceHints;
+
+ private final Map managedScopes;
+
+ private final Map managedScopesSourceHints;
+
+ private final Map managedOptionals;
+
+ private final Map managedOptionalsSourceHints;
+
+ private final Map managedLocalPaths;
+
+ private final Map managedLocalPathsSourceHints;
+
+ private final Map> managedExclusions;
+
+ private final Map> managedExclusionsSourceHints;
+
+ private int hashCode;
+
+ /**
+ * Creates a new dependency manager without any management information.
+ */
+ public DefaultDependencyManager()
+ {
+ this( Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.>emptyMap(),
+ Collections.>emptyMap() );
+ }
+
+ private DefaultDependencyManager( final Map managedVersions,
+ final Map managedVersionsSourceHints,
+ final Map managedScopes,
+ final Map managedScopesSourceHints,
+ final Map managedOptionals,
+ final Map managedOptionalsSourceHints,
+ final Map managedLocalPaths,
+ final Map managedLocalPathsSourceHints,
+ final Map> managedExclusions,
+ final Map> managedExclusionsSourceHints )
+ {
+ super();
+ this.managedVersions = managedVersions;
+ this.managedVersionsSourceHints = managedVersionsSourceHints;
+ this.managedScopes = managedScopes;
+ this.managedScopesSourceHints = managedScopesSourceHints;
+ this.managedOptionals = managedOptionals;
+ this.managedOptionalsSourceHints = managedOptionalsSourceHints;
+ this.managedLocalPaths = managedLocalPaths;
+ this.managedLocalPathsSourceHints = managedLocalPathsSourceHints;
+ this.managedExclusions = managedExclusions;
+ this.managedExclusionsSourceHints = managedExclusionsSourceHints;
+ }
+
+ public DependencyManager deriveChildManager( final DependencyCollectionContext context )
+ {
+ Map versions = this.managedVersions;
+ Map versionsSourceHints = this.managedVersionsSourceHints;
+ Map scopes = this.managedScopes;
+ Map scopesSourceHints = this.managedScopesSourceHints;
+ Map optionals = this.managedOptionals;
+ Map optionalsSourceHints = this.managedOptionalsSourceHints;
+ Map localPaths = this.managedLocalPaths;
+ Map localPathsSourceHints = this.managedLocalPathsSourceHints;
+ Map> exclusions = this.managedExclusions;
+ Map> exclusionsSourceHints = this.managedExclusionsSourceHints;
+
+ for ( Dependency managedDependency : context.getManagedDependencies() )
+ {
+ Artifact artifact = managedDependency.getArtifact();
+ Object key = getKey( artifact );
+
+ String version = artifact.getVersion();
+ if ( version.length() > 0 && !versions.containsKey( key ) )
+ {
+ if ( versions == this.managedVersions )
+ {
+ versions = new HashMap( this.managedVersions );
+ versionsSourceHints = new HashMap( this.managedVersionsSourceHints );
+ }
+ versions.put( key, version );
+ versionsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ String scope = managedDependency.getScope();
+ if ( scope.length() > 0 && !scopes.containsKey( key ) )
+ {
+ if ( scopes == this.managedScopes )
+ {
+ scopes = new HashMap( this.managedScopes );
+ scopesSourceHints = new HashMap( this.managedScopesSourceHints );
+ }
+ scopes.put( key, scope );
+ scopesSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ Boolean optional = managedDependency.getOptional();
+ if ( optional != null && !optionals.containsKey( key ) )
+ {
+ if ( optionals == this.managedOptionals )
+ {
+ optionals = new HashMap( this.managedOptionals );
+ optionalsSourceHints = new HashMap( this.managedOptionalsSourceHints );
+ }
+ optionals.put( key, optional );
+ optionalsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ String localPath = managedDependency.getArtifact().getProperty( ArtifactProperties.LOCAL_PATH, null );
+ if ( localPath != null && !localPaths.containsKey( key ) )
+ {
+ if ( localPaths == this.managedLocalPaths )
+ {
+ localPaths = new HashMap( this.managedLocalPaths );
+ localPathsSourceHints = new HashMap( this.managedLocalPathsSourceHints );
+ }
+ localPaths.put( key, localPath );
+ localPathsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ if ( !managedDependency.getExclusions().isEmpty() )
+ {
+ if ( exclusions == this.managedExclusions )
+ {
+ exclusions = new HashMap>( this.managedExclusions );
+ exclusionsSourceHints =
+ new HashMap>( this.managedExclusionsSourceHints );
+
+ }
+ Collection managed = exclusions.get( key );
+ if ( managed == null )
+ {
+ managed = new LinkedHashSet();
+ exclusions.put( key, managed );
+ }
+ managed.addAll( managedDependency.getExclusions() );
+
+ Collection managedSources = exclusionsSourceHints.get( key );
+ if ( managedSources == null )
+ {
+ managedSources = new LinkedHashSet();
+ exclusionsSourceHints.put( key, managedSources );
+ }
+
+ managedSources.add( managedDependency.getSourceHint() );
+ }
+ }
+
+ return new DefaultDependencyManager( versions, versionsSourceHints, scopes, scopesSourceHints, optionals,
+ optionalsSourceHints, localPaths, localPathsSourceHints, exclusions,
+ exclusionsSourceHints );
+
+ }
+
+ public DependencyManagement manageDependency( Dependency dependency )
+ {
+ DependencyManagement management = null;
+
+ Object key = getKey( dependency.getArtifact() );
+
+ String version = managedVersions.get( key );
+ if ( version != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setVersion( version );
+ management.setVersionSourceHint( this.managedVersionsSourceHints.get( key ) );
+ }
+
+ String scope = managedScopes.get( key );
+ if ( scope != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setScope( scope );
+ management.setScopeSourceHint( this.managedScopesSourceHints.get( key ) );
+
+ if ( !JavaScopes.SYSTEM.equals( scope )
+ && dependency.getArtifact().getProperty( ArtifactProperties.LOCAL_PATH, null ) != null )
+ {
+ Map properties =
+ new HashMap( dependency.getArtifact().getProperties() );
+
+ properties.remove( ArtifactProperties.LOCAL_PATH );
+ management.setProperties( properties );
+ management.setPropertiesSourceHint( this.managedScopesSourceHints.get( key ) );
+ }
+ }
+
+ if ( ( scope != null && JavaScopes.SYSTEM.equals( scope ) )
+ || ( scope == null && JavaScopes.SYSTEM.equals( dependency.getScope() ) ) )
+ {
+ String localPath = managedLocalPaths.get( key );
+ if ( localPath != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+
+ Map properties =
+ new HashMap( dependency.getArtifact().getProperties() );
+
+ properties.put( ArtifactProperties.LOCAL_PATH, localPath );
+ management.setProperties( properties );
+ management.setPropertiesSourceHint( this.managedLocalPathsSourceHints.get( key ) );
+ }
+ }
+
+ Boolean optional = managedOptionals.get( key );
+ if ( optional != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setOptional( optional );
+ management.setOptionalitySourceHint( this.managedOptionalsSourceHints.get( key ) );
+ }
+
+ Collection exclusions = managedExclusions.get( key );
+ if ( exclusions != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ Collection result = new LinkedHashSet( dependency.getExclusions() );
+ result.addAll( exclusions );
+ management.setExclusions( result );
+
+ final Object sourceHint = this.managedExclusionsSourceHints.get( key );
+ if ( sourceHint != null )
+ {
+ management.setExclusionsSourceHint( sourceHint.toString() );
+ }
+ }
+
+ return management;
+ }
+
+ private Object getKey( Artifact a )
+ {
+ return new Key( a );
+ }
+
+ @Override
+ public boolean equals( final Object obj )
+ {
+ boolean equal = obj instanceof DefaultDependencyManager;
+
+ if ( equal )
+ {
+ final DefaultDependencyManager that = (DefaultDependencyManager) obj;
+ equal = this.managedVersions.equals( that.managedVersions )
+ && this.managedScopes.equals( that.managedScopes )
+ && this.managedOptionals.equals( that.managedOptionals )
+ && this.managedExclusions.equals( that.managedExclusions );
+
+ }
+
+ return equal;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ if ( this.hashCode == 0 )
+ {
+ int hash = 17;
+ hash = hash * 31 + this.managedVersions.hashCode();
+ hash = hash * 31 + this.managedScopes.hashCode();
+ hash = hash * 31 + this.managedOptionals.hashCode();
+ hash = hash * 31 + this.managedExclusions.hashCode();
+ this.hashCode = hash;
+ }
+ return this.hashCode;
+ }
+
+ static class Key
+ {
+
+ private final Artifact artifact;
+
+ private final int hashCode;
+
+ Key( final Artifact artifact )
+ {
+ this.artifact = artifact;
+
+ int hash = 17;
+ hash = hash * 31 + artifact.getGroupId().hashCode();
+ hash = hash * 31 + artifact.getArtifactId().hashCode();
+ this.hashCode = hash;
+ }
+
+ @Override
+ public boolean equals( final Object obj )
+ {
+ boolean equal = obj instanceof Key;
+
+ if ( equal )
+ {
+ final Key that = (Key) obj;
+ return this.artifact.getArtifactId().equals( that.artifact.getArtifactId() )
+ && this.artifact.getGroupId().equals( that.artifact.getGroupId() )
+ && this.artifact.getExtension().equals( that.artifact.getExtension() )
+ && this.artifact.getClassifier().equals( that.artifact.getClassifier() );
+
+ }
+
+ return equal;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return this.hashCode;
+ }
+
+ }
+
+}
diff --git a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DependencyManagerUtils.java b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DependencyManagerUtils.java
index f549367d7..dd5db312a 100644
--- a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DependencyManagerUtils.java
+++ b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/DependencyManagerUtils.java
@@ -46,18 +46,39 @@ public final class DependencyManagerUtils
*/
public static final String NODE_DATA_PREMANAGED_VERSION = "premanaged.version";
+ /**
+ * The key in the dependency node's {@link DependencyNode#getData() custom data} under which the informational hint
+ * describing the source declaring the version management is stored.
+ * @since 1.2.0
+ */
+ public static final String NODE_DATA_VERSION_MANAGEMENT_SOURCE_HINT = "version.management.source.hint";
+
/**
* The key in the dependency node's {@link DependencyNode#getData() custom data} under which the original scope is
* stored.
*/
public static final String NODE_DATA_PREMANAGED_SCOPE = "premanaged.scope";
+ /**
+ * The key in the dependency node's {@link DependencyNode#getData() custom data} under which the informational hint
+ * describing the source declaring the scope management is stored.
+ * @since 1.2.0
+ */
+ public static final String NODE_DATA_SCOPE_MANAGEMENT_SOURCE_HINT = "scope.management.source.hint";
+
/**
* The key in the dependency node's {@link DependencyNode#getData() custom data} under which the original optional
* flag is stored.
*/
public static final String NODE_DATA_PREMANAGED_OPTIONAL = "premanaged.optional";
+ /**
+ * The key in the dependency node's {@link DependencyNode#getData() custom data} under which the informational hint
+ * describing the source declaring the optionality management is stored.
+ * @since 1.2.0
+ */
+ public static final String NODE_DATA_OPTIONALITY_MANAGEMENT_SOURCE_HINT = "optionality.management.source.hint";
+
/**
* The key in the dependency node's {@link DependencyNode#getData() custom data} under which the original exclusions
* are stored.
@@ -66,6 +87,13 @@ public final class DependencyManagerUtils
*/
public static final String NODE_DATA_PREMANAGED_EXCLUSIONS = "premanaged.exclusions";
+ /**
+ * The key in the dependency node's {@link DependencyNode#getData() custom data} under which the informational hint
+ * describing the source declaring the exclusion management is stored.
+ * @since 1.2.0
+ */
+ public static final String NODE_DATA_EXCLUSIONS_MANAGEMENT_SOURCE_HINT = "exlusions.management.source.hint";
+
/**
* The key in the dependency node's {@link DependencyNode#getData() custom data} under which the original properties
* are stored.
@@ -74,6 +102,13 @@ public final class DependencyManagerUtils
*/
public static final String NODE_DATA_PREMANAGED_PROPERTIES = "premanaged.properties";
+ /**
+ * The key in the dependency node's {@link DependencyNode#getData() custom data} under which the informational hint
+ * describing the source declaring the properties management is stored.
+ * @since 1.2.0
+ */
+ public static final String NODE_DATA_PROPERTIES_MANAGEMENT_SOURCE_HINT = "properties.management.source.hint";
+
/**
* Gets the version or version range of the specified dependency node before dependency management was applied (if
* any).
@@ -81,7 +116,7 @@ public final class DependencyManagerUtils
* @param node The dependency node to retrieve the premanaged data for, must not be {@code null}.
*
* @return The node's dependency version before dependency management or {@code null} if the version was not managed
- * or if {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * or if {@link #CONFIG_PROP_VERBOSE} was not enabled.
*/
public static String getPremanagedVersion( DependencyNode node )
{
@@ -92,13 +127,32 @@ public static String getPremanagedVersion( DependencyNode node )
return cast( node.getData().get( NODE_DATA_PREMANAGED_VERSION ), String.class );
}
+ /**
+ * Gets an informational hint describing the source declaring the version management of the specified dependency
+ * node after dependency management was applied (if any).
+ *
+ * @param node The dependency node to retrieve the data of, must not be {@code null}.
+ *
+ * @return The node's version management source hint or {@code null} if no such information is available or if
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * @since 1.2.0
+ */
+ public static String getVersionManagementSourceHint( DependencyNode node )
+ {
+ if ( ( node.getManagedBits() & DependencyNode.MANAGED_VERSION ) == 0 )
+ {
+ return null;
+ }
+ return cast( node.getData().get( NODE_DATA_VERSION_MANAGEMENT_SOURCE_HINT ), String.class );
+ }
+
/**
* Gets the scope of the specified dependency node before dependency management was applied (if any).
*
* @param node The dependency node to retrieve the premanaged data for, must not be {@code null}.
*
* @return The node's dependency scope before dependency management or {@code null} if the scope was not managed or
- * if {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * if {@link #CONFIG_PROP_VERBOSE} was not enabled.
*/
public static String getPremanagedScope( DependencyNode node )
{
@@ -109,13 +163,32 @@ public static String getPremanagedScope( DependencyNode node )
return cast( node.getData().get( NODE_DATA_PREMANAGED_SCOPE ), String.class );
}
+ /**
+ * Gets an informational hint describing the source declaring the scope management of the specified dependency
+ * node after dependency management was applied (if any).
+ *
+ * @param node The dependency node to retrieve the data of, must not be {@code null}.
+ *
+ * @return The node's scope management source hint or {@code null} if no such information is available or if
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * @since 1.2.0
+ */
+ public static String getScopeManagementSourceHint( DependencyNode node )
+ {
+ if ( ( node.getManagedBits() & DependencyNode.MANAGED_SCOPE ) == 0 )
+ {
+ return null;
+ }
+ return cast( node.getData().get( NODE_DATA_SCOPE_MANAGEMENT_SOURCE_HINT ), String.class );
+ }
+
/**
* Gets the optional flag of the specified dependency node before dependency management was applied (if any).
*
* @param node The dependency node to retrieve the premanaged data for, must not be {@code null}.
*
* @return The node's optional flag before dependency management or {@code null} if the flag was not managed or if
- * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
*/
public static Boolean getPremanagedOptional( DependencyNode node )
{
@@ -126,13 +199,32 @@ public static Boolean getPremanagedOptional( DependencyNode node )
return cast( node.getData().get( NODE_DATA_PREMANAGED_OPTIONAL ), Boolean.class );
}
+ /**
+ * Gets an informational hint describing the source declaring the optionality management of the specified
+ * dependency node after dependency management was applied (if any).
+ *
+ * @param node The dependency node to retrieve the data of, must not be {@code null}.
+ *
+ * @return The node's optionality management source hint or {@code null} if no such information is available or if
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * @since 1.2.0
+ */
+ public static String getOptionalityManagementSourceHint( DependencyNode node )
+ {
+ if ( ( node.getManagedBits() & DependencyNode.MANAGED_OPTIONAL ) == 0 )
+ {
+ return null;
+ }
+ return cast( node.getData().get( NODE_DATA_OPTIONALITY_MANAGEMENT_SOURCE_HINT ), String.class );
+ }
+
/**
* Gets the {@code Exclusion}s of the specified dependency node before dependency management was applied (if any).
*
* @param node The dependency node to retrieve the premanaged data for, must not be {@code null}.
*
* @return The nodes' {@code Exclusion}s before dependency management or {@code null} if exclusions were not managed
- * or if {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * or if {@link #CONFIG_PROP_VERBOSE} was not enabled.
*
* @since 1.1.0
*/
@@ -146,13 +238,32 @@ public static Collection getPremanagedExclusions( DependencyNode node
return cast( node.getData().get( NODE_DATA_PREMANAGED_EXCLUSIONS ), Collection.class );
}
+ /**
+ * Gets an informational hint describing the source declaring the exclusions management of the specified dependency
+ * node after dependency management was applied (if any).
+ *
+ * @param node The dependency node to retrieve the data of, must not be {@code null}.
+ *
+ * @return The node's exclusions management source hint or {@code null} if no such information is available or if
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * @since 1.2.0
+ */
+ public static String getExclusionsManagementSourceHint( DependencyNode node )
+ {
+ if ( ( node.getManagedBits() & DependencyNode.MANAGED_EXCLUSIONS ) == 0 )
+ {
+ return null;
+ }
+ return cast( node.getData().get( NODE_DATA_EXCLUSIONS_MANAGEMENT_SOURCE_HINT ), String.class );
+ }
+
/**
* Gets the properties of the specified dependency node before dependency management was applied (if any).
*
* @param node The dependency node to retrieve the premanaged data for, must not be {@code null}.
*
* @return The nodes' properties before dependency management or {@code null} if properties were not managed or if
- * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
*
* @since 1.1.0
*/
@@ -166,6 +277,25 @@ public static Map getPremanagedProperties( DependencyNode node )
return cast( node.getData().get( NODE_DATA_PREMANAGED_PROPERTIES ), Map.class );
}
+ /**
+ * Gets an informational hint describing the source declaring the properties management of the specified dependency
+ * node after dependency management was applied (if any).
+ *
+ * @param node The dependency node to retrieve the data of, must not be {@code null}.
+ *
+ * @return The node's properties management source hint or {@code null} if no such information is available or if
+ * {@link #CONFIG_PROP_VERBOSE} was not enabled.
+ * @since 1.2.0
+ */
+ public static String getPropertiesManagementSourceHint( DependencyNode node )
+ {
+ if ( ( node.getManagedBits() & DependencyNode.MANAGED_EXCLUSIONS ) == 0 )
+ {
+ return null;
+ }
+ return cast( node.getData().get( NODE_DATA_EXCLUSIONS_MANAGEMENT_SOURCE_HINT ), String.class );
+ }
+
private static T cast( Object obj, Class type )
{
return type.isInstance( obj ) ? type.cast( obj ) : null;
diff --git a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/TransitiveDependencyManager.java b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/TransitiveDependencyManager.java
new file mode 100644
index 000000000..3a5195c29
--- /dev/null
+++ b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/TransitiveDependencyManager.java
@@ -0,0 +1,387 @@
+package org.eclipse.aether.util.graph.manager;
+
+/*
+ * 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.
+ */
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.ArtifactProperties;
+import org.eclipse.aether.collection.DependencyCollectionContext;
+import org.eclipse.aether.collection.DependencyManagement;
+import org.eclipse.aether.collection.DependencyManager;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.Exclusion;
+import org.eclipse.aether.util.artifact.JavaScopes;
+
+/**
+ * A dependency manager managing transitive dependencies supporting transitive dependency management.
+ *
+ * @author Christian Schulte
+ * @since 1.2.0
+ */
+public final class TransitiveDependencyManager
+ implements DependencyManager
+{
+
+ private final Map managedVersions;
+
+ private final Map managedVersionsSourceHints;
+
+ private final Map managedScopes;
+
+ private final Map managedScopesSourceHints;
+
+ private final Map managedOptionals;
+
+ private final Map managedOptionalsSourceHints;
+
+ private final Map managedLocalPaths;
+
+ private final Map managedLocalPathsSourceHints;
+
+ private final Map> managedExclusions;
+
+ private final Map> managedExclusionsSourceHints;
+
+ private final int depth;
+
+ private int hashCode;
+
+ /**
+ * Creates a new dependency manager without any management information.
+ */
+ public TransitiveDependencyManager()
+ {
+ this( 0, Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.emptyMap(), Collections.emptyMap(),
+ Collections.>emptyMap(),
+ Collections.>emptyMap() );
+ }
+
+ private TransitiveDependencyManager( int depth,
+ Map managedVersions,
+ Map managedVersionsSourceHints,
+ Map managedScopes,
+ Map managedScopesSourceHints,
+ Map managedOptionals,
+ Map managedOptionalsSourceHints,
+ Map managedLocalPaths,
+ Map managedLocalPathsSourceHints,
+ Map> managedExclusions,
+ Map> managedExclusionsSourceHints )
+ {
+ super();
+ this.depth = depth;
+ this.managedVersions = managedVersions;
+ this.managedVersionsSourceHints = managedVersionsSourceHints;
+ this.managedScopes = managedScopes;
+ this.managedScopesSourceHints = managedScopesSourceHints;
+ this.managedOptionals = managedOptionals;
+ this.managedOptionalsSourceHints = managedOptionalsSourceHints;
+ this.managedLocalPaths = managedLocalPaths;
+ this.managedLocalPathsSourceHints = managedLocalPathsSourceHints;
+ this.managedExclusions = managedExclusions;
+ this.managedExclusionsSourceHints = managedExclusionsSourceHints;
+ }
+
+ public DependencyManager deriveChildManager( final DependencyCollectionContext context )
+ {
+ Map versions = this.managedVersions;
+ Map versionsSourceHints = this.managedVersionsSourceHints;
+ Map scopes = this.managedScopes;
+ Map scopesSourceHints = this.managedScopesSourceHints;
+ Map optionals = this.managedOptionals;
+ Map optionalsSourceHints = this.managedOptionalsSourceHints;
+ Map localPaths = this.managedLocalPaths;
+ Map localPathsSourceHints = this.managedLocalPathsSourceHints;
+ Map> exclusions = this.managedExclusions;
+ Map> exclusionsSourceHints = this.managedExclusionsSourceHints;
+
+ for ( Dependency managedDependency : context.getManagedDependencies() )
+ {
+ Artifact artifact = managedDependency.getArtifact();
+ Object key = getKey( artifact );
+
+ String version = artifact.getVersion();
+ if ( version.length() > 0 && !versions.containsKey( key ) )
+ {
+ if ( versions == this.managedVersions )
+ {
+ versions = new HashMap( this.managedVersions );
+ versionsSourceHints = new HashMap( this.managedVersionsSourceHints );
+ }
+ versions.put( key, version );
+ versionsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ String scope = managedDependency.getScope();
+ if ( scope.length() > 0 && !scopes.containsKey( key ) )
+ {
+ if ( scopes == this.managedScopes )
+ {
+ scopes = new HashMap( this.managedScopes );
+ scopesSourceHints = new HashMap( this.managedScopesSourceHints );
+ }
+ scopes.put( key, scope );
+ scopesSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ Boolean optional = managedDependency.getOptional();
+ if ( optional != null && !optionals.containsKey( key ) )
+ {
+ if ( optionals == this.managedOptionals )
+ {
+ optionals = new HashMap( this.managedOptionals );
+ optionalsSourceHints = new HashMap( this.managedOptionalsSourceHints );
+ }
+ optionals.put( key, optional );
+ optionalsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ String localPath = managedDependency.getArtifact().getProperty( ArtifactProperties.LOCAL_PATH, null );
+ if ( localPath != null && !localPaths.containsKey( key ) )
+ {
+ if ( localPaths == this.managedLocalPaths )
+ {
+ localPaths = new HashMap( this.managedLocalPaths );
+ localPathsSourceHints = new HashMap( this.managedLocalPathsSourceHints );
+ }
+ localPaths.put( key, localPath );
+ localPathsSourceHints.put( key, managedDependency.getSourceHint() );
+ }
+
+ if ( !managedDependency.getExclusions().isEmpty() )
+ {
+ if ( exclusions == this.managedExclusions )
+ {
+ exclusions = new HashMap>( this.managedExclusions );
+ exclusionsSourceHints =
+ new HashMap>( this.managedExclusionsSourceHints );
+
+ }
+ Collection managed = exclusions.get( key );
+ if ( managed == null )
+ {
+ managed = new LinkedHashSet();
+ exclusions.put( key, managed );
+ }
+ managed.addAll( managedDependency.getExclusions() );
+
+ Collection managedSourceHints = exclusionsSourceHints.get( key );
+ if ( managedSourceHints == null )
+ {
+ managedSourceHints = new LinkedHashSet();
+ exclusionsSourceHints.put( key, managedSourceHints );
+ }
+
+ managedSourceHints.add( managedDependency.getSourceHint() );
+ }
+ }
+
+ return new TransitiveDependencyManager( depth + 1,
+ versions, versionsSourceHints,
+ scopes, scopesSourceHints,
+ optionals, optionalsSourceHints,
+ localPaths, localPathsSourceHints,
+ exclusions, exclusionsSourceHints );
+
+ }
+
+ public DependencyManagement manageDependency( Dependency dependency )
+ {
+ DependencyManagement management = null;
+
+ Object key = getKey( dependency.getArtifact() );
+
+ if ( this.depth >= 2 )
+ {
+ String version = managedVersions.get( key );
+ if ( version != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setVersion( version );
+ management.setVersionSourceHint( this.managedVersionsSourceHints.get( key ) );
+ }
+
+ String scope = managedScopes.get( key );
+ if ( scope != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setScope( scope );
+ management.setScopeSourceHint( this.managedScopesSourceHints.get( key ) );
+
+ if ( !JavaScopes.SYSTEM.equals( scope )
+ && dependency.getArtifact().getProperty( ArtifactProperties.LOCAL_PATH, null ) != null )
+ {
+ Map properties =
+ new HashMap( dependency.getArtifact().getProperties() );
+ properties.remove( ArtifactProperties.LOCAL_PATH );
+ management.setProperties( properties );
+ management.setPropertiesSourceHint( this.managedScopesSourceHints.get( key ) );
+ }
+ }
+
+ if ( ( scope != null && JavaScopes.SYSTEM.equals( scope ) )
+ || ( scope == null && JavaScopes.SYSTEM.equals( dependency.getScope() ) ) )
+ {
+ String localPath = managedLocalPaths.get( key );
+ if ( localPath != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ Map properties =
+ new HashMap( dependency.getArtifact().getProperties() );
+ properties.put( ArtifactProperties.LOCAL_PATH, localPath );
+ management.setProperties( properties );
+ management.setPropertiesSourceHint( this.managedLocalPathsSourceHints.get( key ) );
+ }
+ }
+
+ Boolean optional = managedOptionals.get( key );
+ if ( optional != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ management.setOptional( optional );
+ management.setOptionalitySourceHint( this.managedOptionalsSourceHints.get( key ) );
+ }
+ }
+
+ Collection exclusions = managedExclusions.get( key );
+ if ( exclusions != null )
+ {
+ if ( management == null )
+ {
+ management = new DependencyManagement();
+ }
+ Collection result = new LinkedHashSet( dependency.getExclusions() );
+ result.addAll( exclusions );
+ management.setExclusions( result );
+
+ final Object sourceHint = this.managedExclusionsSourceHints.get( key );
+ if ( sourceHint != null )
+ {
+ management.setExclusionsSourceHint( sourceHint.toString() );
+ }
+ }
+
+ return management;
+ }
+
+ private Object getKey( Artifact a )
+ {
+ return new Key( a );
+ }
+
+ @Override
+ public boolean equals( final Object obj )
+ {
+ boolean equal = obj instanceof TransitiveDependencyManager;
+
+ if ( equal )
+ {
+ final TransitiveDependencyManager that = (TransitiveDependencyManager) obj;
+ return this.depth == that.depth
+ && this.managedVersions.equals( that.managedVersions )
+ && this.managedScopes.equals( that.managedScopes )
+ && this.managedOptionals.equals( that.managedOptionals )
+ && this.managedExclusions.equals( that.managedExclusions );
+
+ }
+
+ return equal;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ if ( this.hashCode == 0 )
+ {
+ int hash = 17;
+ hash = hash * 31 + this.depth;
+ hash = hash * 31 + this.managedVersions.hashCode();
+ hash = hash * 31 + this.managedScopes.hashCode();
+ hash = hash * 31 + this.managedOptionals.hashCode();
+ hash = hash * 31 + this.managedExclusions.hashCode();
+ this.hashCode = hash;
+ }
+ return this.hashCode;
+ }
+
+ static class Key
+ {
+
+ private final Artifact artifact;
+
+ private final int hashCode;
+
+ Key( final Artifact artifact )
+ {
+ this.artifact = artifact;
+
+ int hash = 17;
+ hash = hash * 31 + artifact.getGroupId().hashCode();
+ hash = hash * 31 + artifact.getArtifactId().hashCode();
+ this.hashCode = hash;
+ }
+
+ @Override
+ public boolean equals( final Object obj )
+ {
+ boolean equal = obj instanceof Key;
+
+ if ( equal )
+ {
+ final Key that = (Key) obj;
+ return this.artifact.getArtifactId().equals( that.artifact.getArtifactId() )
+ && this.artifact.getGroupId().equals( that.artifact.getGroupId() )
+ && this.artifact.getExtension().equals( that.artifact.getExtension() )
+ && this.artifact.getClassifier().equals( that.artifact.getClassifier() );
+
+ }
+
+ return equal;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return this.hashCode;
+ }
+
+ }
+
+}
diff --git a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/selector/ScopeDependencySelector.java b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/selector/ScopeDependencySelector.java
index 552fc0966..92db1417e 100644
--- a/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/selector/ScopeDependencySelector.java
+++ b/maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/selector/ScopeDependencySelector.java
@@ -8,9 +8,9 @@
* 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
@@ -24,7 +24,6 @@
import java.util.Collection;
import java.util.HashSet;
import java.util.TreeSet;
-
import org.eclipse.aether.collection.DependencyCollectionContext;
import org.eclipse.aether.collection.DependencySelector;
import org.eclipse.aether.graph.Dependency;
@@ -33,14 +32,14 @@
* A dependency selector that filters transitive dependencies based on their scope. Direct dependencies are always
* included regardless of their scope. Note: This filter does not assume any relationships between the scopes.
* In particular, the filter is not aware of scopes that logically include other scopes.
- *
+ *
* @see Dependency#getScope()
*/
public final class ScopeDependencySelector
implements DependencySelector
{
- private final boolean transitive;
+ private final int depth;
private final Collection included;
@@ -48,13 +47,14 @@ public final class ScopeDependencySelector
/**
* Creates a new selector using the specified includes and excludes.
- *
+ *
* @param included The set of scopes to include, may be {@code null} or empty to include any scope.
* @param excluded The set of scopes to exclude, may be {@code null} or empty to exclude no scope.
*/
public ScopeDependencySelector( Collection included, Collection excluded )
{
- transitive = false;
+ super();
+ this.depth = 0;
this.included = clone( included );
this.excluded = clone( excluded );
}
@@ -81,7 +81,7 @@ private static Collection clone( Collection scopes )
/**
* Creates a new selector using the specified excludes.
- *
+ *
* @param excluded The set of scopes to exclude, may be {@code null} or empty to exclude no scope.
*/
public ScopeDependencySelector( String... excluded )
@@ -89,32 +89,28 @@ public ScopeDependencySelector( String... excluded )
this( null, ( excluded != null ) ? Arrays.asList( excluded ) : null );
}
- private ScopeDependencySelector( boolean transitive, Collection included, Collection excluded )
+ private ScopeDependencySelector( int depth, Collection included, Collection excluded )
{
- this.transitive = transitive;
+ super();
+ this.depth = depth;
this.included = included;
this.excluded = excluded;
}
public boolean selectDependency( Dependency dependency )
{
- if ( !transitive )
- {
- return true;
- }
+ return this.depth < 2
+ || ( ( included == null || included.contains( dependency.getScope() ) )
+ && ( excluded == null || !excluded.contains( dependency.getScope() ) ) );
- String scope = dependency.getScope();
- return ( included == null || included.contains( scope ) ) && ( excluded == null || !excluded.contains( scope ) );
}
public DependencySelector deriveChildSelector( DependencyCollectionContext context )
{
- if ( this.transitive || context.getDependency() == null )
- {
- return this;
- }
+ return this.depth >= 2
+ ? this
+ : new ScopeDependencySelector( this.depth + 1, this.included, this.excluded );
- return new ScopeDependencySelector( true, included, excluded );
}
@Override
@@ -130,7 +126,7 @@ else if ( null == obj || !getClass().equals( obj.getClass() ) )
}
ScopeDependencySelector that = (ScopeDependencySelector) obj;
- return transitive == that.transitive && eq( included, that.included ) && eq( excluded, that.excluded );
+ return this.depth == that.depth && eq( included, that.included ) && eq( excluded, that.excluded );
}
private static boolean eq( T o1, T o2 )
@@ -142,7 +138,7 @@ private static boolean eq( T o1, T o2 )
public int hashCode()
{
int hash = 17;
- hash = hash * 31 + ( transitive ? 1 : 0 );
+ hash = hash * 31 + this.depth;
hash = hash * 31 + ( included != null ? included.hashCode() : 0 );
hash = hash * 31 + ( excluded != null ? excluded.hashCode() : 0 );
return hash;
diff --git a/pom.xml b/pom.xml
index 3b849a7c6..721cde9b1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -30,7 +30,7 @@
org.apache.maven.resolver
maven-resolver
- 1.1.2-SNAPSHOT
+ 1.2.0-SNAPSHOT
pom
Maven Artifact Resolver