org.eclipse.aether.util.graph.manager.DefaultDependencyManager Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-cloud-contract-shade Show documentation
Show all versions of spring-cloud-contract-shade Show documentation
Spring Cloud Contract Shaded Dependencies
/*
* 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.eclipse.aether.util.graph.manager;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Objects;
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;
import static java.util.Objects.requireNonNull;
/**
* 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's default behaviour.
* It ignores all management overrides supported by the {@code MavenModelBuilder}.
*
*
* @author Christian Schulte
* @since 1.4.0
*/
public final class DefaultDependencyManager implements DependencyManager {
private final Map managedVersions;
private final Map managedScopes;
private final Map managedOptionals;
private final Map managedLocalPaths;
private final Map> managedExclusions;
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());
}
private DefaultDependencyManager(
final Map managedVersions,
final Map managedScopes,
final Map managedOptionals,
final Map managedLocalPaths,
final Map> managedExclusions) {
super();
this.managedVersions = managedVersions;
this.managedScopes = managedScopes;
this.managedOptionals = managedOptionals;
this.managedLocalPaths = managedLocalPaths;
this.managedExclusions = managedExclusions;
}
public DependencyManager deriveChildManager(final DependencyCollectionContext context) {
requireNonNull(context, "context cannot be null");
Map versions = this.managedVersions;
Map scopes = this.managedScopes;
Map optionals = this.managedOptionals;
Map localPaths = this.managedLocalPaths;
Map> exclusions = this.managedExclusions;
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);
}
versions.put(key, version);
}
String scope = managedDependency.getScope();
if (scope.length() > 0 && !scopes.containsKey(key)) {
if (scopes == this.managedScopes) {
scopes = new HashMap<>(this.managedScopes);
}
scopes.put(key, scope);
}
Boolean optional = managedDependency.getOptional();
if (optional != null && !optionals.containsKey(key)) {
if (optionals == this.managedOptionals) {
optionals = new HashMap<>(this.managedOptionals);
}
optionals.put(key, optional);
}
String localPath = managedDependency.getArtifact().getProperty(ArtifactProperties.LOCAL_PATH, null);
if (localPath != null && !localPaths.containsKey(key)) {
if (localPaths == this.managedLocalPaths) {
localPaths = new HashMap<>(this.managedLocalPaths);
}
localPaths.put(key, localPath);
}
if (!managedDependency.getExclusions().isEmpty()) {
if (exclusions == this.managedExclusions) {
exclusions = new HashMap<>(this.managedExclusions);
}
Collection managed = exclusions.computeIfAbsent(key, k -> new LinkedHashSet<>());
managed.addAll(managedDependency.getExclusions());
}
}
return new DefaultDependencyManager(versions, scopes, optionals, localPaths, exclusions);
}
public DependencyManagement manageDependency(Dependency dependency) {
requireNonNull(dependency, "dependency cannot be null");
DependencyManagement management = null;
Object key = getKey(dependency.getArtifact());
String version = managedVersions.get(key);
if (version != null) {
management = new DependencyManagement();
management.setVersion(version);
}
String scope = managedScopes.get(key);
if (scope != null) {
if (management == null) {
management = new DependencyManagement();
}
management.setScope(scope);
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);
}
}
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);
}
}
Boolean optional = managedOptionals.get(key);
if (optional != null) {
if (management == null) {
management = new DependencyManagement();
}
management.setOptional(optional);
}
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);
}
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 = Objects.equals(managedVersions, that.managedVersions)
&& Objects.equals(managedScopes, that.managedScopes)
&& Objects.equals(managedOptionals, that.managedOptionals)
&& Objects.equals(managedExclusions, that.managedExclusions);
}
return equal;
}
@Override
public int hashCode() {
if (hashCode == 0) {
hashCode = Objects.hash(managedVersions, managedScopes, managedOptionals, managedExclusions);
}
return hashCode;
}
static class Key {
private final Artifact artifact;
private final int hashCode;
Key(final Artifact artifact) {
this.artifact = artifact;
this.hashCode = Objects.hash(artifact.getGroupId(), artifact.getArtifactId());
}
@Override
public boolean equals(final Object obj) {
boolean equal = obj instanceof Key;
if (equal) {
final Key that = (Key) obj;
return Objects.equals(artifact.getArtifactId(), that.artifact.getArtifactId())
&& Objects.equals(artifact.getGroupId(), that.artifact.getGroupId())
&& Objects.equals(artifact.getExtension(), that.artifact.getExtension())
&& Objects.equals(artifact.getClassifier(), that.artifact.getClassifier());
}
return false;
}
@Override
public int hashCode() {
return this.hashCode;
}
}
}