org.apache.maven.model.Exclusion Java Examples

public List<Exclusion> parseExclusions(String exclusions) {
    List<Exclusion> result = new ArrayList<>();
    if (StringUtils.isBlank(exclusions)) {
        return result;
    }

    Pattern.compile(";")
            .splitAsStream(exclusions)
            .forEach(s -> {
                        String[] mavenIds = Pattern.compile(":").split(s, 2);
                        if (mavenIds.length == 2) {
                            Exclusion exclusion = new Exclusion();
                            exclusion.setGroupId(mavenIds[0]);
                            exclusion.setArtifactId(mavenIds[1]);
                            result.add(exclusion);
                        }
                    }
            );
    return result;
}
 

private void addDependency(MavenDependencyInternal dependency, String artifactId, String scope, String type, String classifier) {
    Dependency mavenDependency = new Dependency();
    mavenDependency.setGroupId(dependency.getGroupId());
    mavenDependency.setArtifactId(artifactId);
    mavenDependency.setVersion(dependency.getVersion());
    mavenDependency.setType(type);
    mavenDependency.setScope(scope);
    mavenDependency.setClassifier(classifier);

    for (ExcludeRule excludeRule : dependency.getExcludeRules()) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(GUtil.elvis(excludeRule.getGroup(), "*"));
        exclusion.setArtifactId(GUtil.elvis(excludeRule.getModule(), "*"));
        mavenDependency.addExclusion(exclusion);
    }

    getModel().addDependency(mavenDependency);
}
 

@Test
public void testTheResolutionWhenATransitiveDependencyIsMissingButOptional() {
  File local = new File("target/test-repos/incomplete");
  new LocalRepoBuilder(local).addArtifact(new LocalArtifact("org.acme", "acme", "1.0").generateMainArtifact()
      .addDependency(new LocalDependency("org.acme", "acme-missing", "1.0").optional(true))).build();

  Exclusion exclusion = new Exclusion();
  exclusion.setArtifactId("acme-missing");
  exclusion.setGroupId("org.acme");

  Dependency dependency = new Dependency("org.acme", "acme", "1.0", "txt");
  Stack stack = new Stack()
      .addDependency(new Dependency("io.vertx", "vertx-core", "3.1.0"))
      .addDependency(dependency);
  StackResolutionOptions options = new StackResolutionOptions().setFailOnConflicts(true)
      .setLocalRepository(local.getAbsolutePath());
  StackResolution resolution = new StackResolution(stack, root, options);
  Map<String, File> map = resolution.resolve();
  assertThat(map).containsKey("io.vertx:vertx-core:jar:3.1.0");
  assertThat(map).containsKey("org.acme:acme:txt:1.0");
}
 

@Test
public void testTheResolutionWhenATransitiveDependencyIsMissingButExcluded() {
  File local = new File("target/test-repos/incomplete");
  new LocalRepoBuilder(local).addArtifact(new LocalArtifact("org.acme", "acme", "1.0").generateMainArtifact()
      .addDependency(new LocalDependency("org.acme", "acme-missing", "1.0"))).build();

  Exclusion exclusion = new Exclusion();
  exclusion.setArtifactId("acme-missing");
  exclusion.setGroupId("org.acme");

  Dependency dependency = new Dependency("org.acme", "acme", "1.0", "txt");
  dependency.addExclusion(exclusion);

  Stack stack = new Stack()
      .addDependency(new Dependency("io.vertx", "vertx-core", "3.1.0"))
      .addDependency(dependency);
  StackResolutionOptions options = new StackResolutionOptions().setFailOnConflicts(true)
      .setLocalRepository(local.getAbsolutePath());
  StackResolution resolution = new StackResolution(stack, root, options);
  Map<String, File> map = resolution.resolve();
  assertThat(map).containsKey("io.vertx:vertx-core:jar:3.1.0");
  assertThat(map).containsKey("org.acme:acme:txt:1.0");
}
 

@Test
public void testConflictManagementUsingExclusions() {
  Dependency dependency = new Dependency("io.vertx", "vertx-core", "3.1.0");
  Exclusion exclusion1 = new Exclusion();
  exclusion1.setGroupId("com.fasterxml.jackson.core");
  exclusion1.setArtifactId("jackson-databind");
  Exclusion exclusion2 = new Exclusion();
  exclusion2.setGroupId("com.fasterxml.jackson.core");
  exclusion2.setArtifactId("jackson-core");
  dependency.addExclusion(exclusion1);
  dependency.addExclusion(exclusion2);
  Stack stack = new Stack()
      .addDependency(dependency)
      // Not the version used by vert.x
      .addDependency(new Dependency("com.fasterxml.jackson.core", "jackson-databind", "2.4.1.3"));
  StackResolution resolution = new StackResolution(stack, root, STRICT);
  resolution.resolve();
  Map<String, File> map = resolution.resolve();
  assertThat(map).containsKey("io.vertx:vertx-core:jar:3.1.0");
  assertThat(map).containsKey("com.fasterxml.jackson.core:jackson-databind:jar:2.4.1.3");
}
 

@Test
public void should_create_dependency_from_gav_with_exclusions() {
    // when
    Dependency dependency =
        MavenCoordinatesResolver.createDependencyFromCoordinates(String.join(":", groupId, artifactId, version),
            true);

    // then
    assertThat(dependency)
        .hasGroupId(groupId)
        .hasArtifactId(artifactId)
        .hasVersion(version)
        .hasType("jar")
        .hasClassifier(null)
        .exclusions().hasSize(1);
    Exclusion exclusion = dependency.getExclusions().get(0);
    Assertions.assertThat(exclusion.getGroupId()).isEqualTo("*");
    Assertions.assertThat(exclusion.getArtifactId()).isEqualTo("*");
}
 

private static void interpolate(Map<String, String> dict, Iterable<Dependency> dependencies) {
    if (dependencies == null) {
        return;
    }

    for (Dependency d: dependencies) {
        d.setGroupId(interpolate(dict, d.getGroupId()));
        d.setArtifactId(interpolate(dict, d.getArtifactId()));
        d.setVersion(interpolate(dict, d.getVersion()));
        d.setClassifier(interpolate(dict, d.getClassifier()));
        d.setSystemPath(interpolate(dict, d.getSystemPath()));
        for (Exclusion e: d.getExclusions()) {
            e.setGroupId(interpolate(dict, e.getGroupId()));
            e.setArtifactId(interpolate(dict, e.getArtifactId()));
        }
    }
}
 

private Dependency toMavenDependency(org.eclipse.aether.graph.Dependency from) {
    org.eclipse.aether.artifact.Artifact fromArt = from.getArtifact();

    Dependency dependency = new Dependency();
    dependency.setGroupId(fromArt.getGroupId());
    dependency.setArtifactId(fromArt.getArtifactId());
    dependency.setVersion(fromArt.getVersion());
    dependency.setType(fromArt.getExtension());
    dependency.setScope(Artifact.SCOPE_COMPILE.equals(from.getScope()) ? null : from.getScope());
    dependency.setClassifier(fromArt.getClassifier());
    dependency.setOptional(dependency.isOptional());

    if (from.getExclusions() != null && from.getExclusions().size() > 0) {
        List<Exclusion> exclusions = new LinkedList<Exclusion>();
        for (org.eclipse.aether.graph.Exclusion fromEx : from.getExclusions()) {
            Exclusion ex = new Exclusion();
            ex.setGroupId(fromEx.getGroupId());
            ex.setArtifactId(fromEx.getArtifactId());
            exclusions.add(ex);
        }
        dependency.setExclusions(exclusions);
    }

    return dependency;
}
 

private void addDependency(MavenDependencyInternal dependency, String artifactId, String scope, String type, String classifier) {
    Dependency mavenDependency = new Dependency();
    mavenDependency.setGroupId(dependency.getGroupId());
    mavenDependency.setArtifactId(artifactId);
    mavenDependency.setVersion(dependency.getVersion());
    mavenDependency.setType(type);
    mavenDependency.setScope(scope);
    mavenDependency.setClassifier(classifier);

    for (ExcludeRule excludeRule : dependency.getExcludeRules()) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(GUtil.elvis(excludeRule.getGroup(), "*"));
        exclusion.setArtifactId(GUtil.elvis(excludeRule.getModule(), "*"));
        mavenDependency.addExclusion(exclusion);
    }

    getModel().addDependency(mavenDependency);
}
 

private List<Exclusion> getExclusions(ModuleDependency dependency, Set<Configuration> configurations) {
    List<Exclusion> mavenExclusions = new ArrayList<Exclusion>();
    Set<ExcludeRule> excludeRules = new HashSet<ExcludeRule>(dependency.getExcludeRules());
    for (Configuration configuration : configurations) {
        excludeRules.addAll(configuration.getExcludeRules());
    }
    for (ExcludeRule excludeRule : excludeRules) {
        Exclusion mavenExclusion = (Exclusion) excludeRuleConverter.convert(excludeRule);
        if (mavenExclusion != null) {
            mavenExclusions.add(mavenExclusion);
        }
    }
    return mavenExclusions;
}
 

private boolean excluded(DeployConfiguration activeConfiguration, Dependency dependency) {
    if (activeConfiguration.getExclusions() == null) {
        return false;
    }
    for (Exclusion exclusion : activeConfiguration.getExclusions()) {
        if (exclusion.getArtifactId().equals(dependency.getArtifactId()) &&
                exclusion.getGroupId().equals(dependency.getGroupId())) {
            log.info("Excluding dependency " + dependency.getArtifactId());
            return true;
        }
    }
    return false;
}
 

public void addExclusion( Exclusion e ) throws ManipulationException
{
    if ( dependency == null )
    {
        throw new ManipulationException( "Type is not a dependency {}", e);
    }
    dependency.addExclusion(e);
}
 

static String coordsWithExclusions(final Dependency dependency) {
	final StringBuilder coords = new StringBuilder(coords(dependency));
	if (dependency.getExclusions().size() > 0) {
		final StringBuilder exclusionsList = new StringBuilder();
		int i = 0;
		for (final Exclusion exclusion : dependency.getExclusions()) {
			if (i > 0) exclusionsList.append(",");
			exclusionsList.append(exclusion.getGroupId()).append(":").append(exclusion.getArtifactId());
			i++;
		}
		coords.append("(").append(exclusionsList.toString()).append(")");
	}
	return coords.toString();
}
 

/**
 * Creates the {@link ResolutionOptions} object for the dependency.
 *
 * @return the {@link ResolutionOptions} instructing the dependency resolution.
 */
public ResolutionOptions getResolutionOptions() {
  ResolutionOptions options = new ResolutionOptions();
  options.setWithTransitive(transitive);
  for (Exclusion exclusion : getExclusions()) {
    options.addExclusion(exclusion.getGroupId() + ":" + exclusion.getArtifactId());
  }

  return options;
}
 

public Exclusion convert(ExcludeRule excludeRule) {
    if (isConvertable(excludeRule)) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(excludeRule.getGroup());
        exclusion.setArtifactId(excludeRule.getModule());
        return exclusion;
    }
    return null;
}
 

private List<Exclusion> getExclusions(ModuleDependency dependency, Set<Configuration> configurations) {
    List<Exclusion> mavenExclusions = new ArrayList<Exclusion>();
    Set<ExcludeRule> excludeRules = new HashSet<ExcludeRule>(dependency.getExcludeRules());
    for (Configuration configuration : configurations) {
        excludeRules.addAll(configuration.getExcludeRules());
    }
    for (ExcludeRule excludeRule : excludeRules) {
        Exclusion mavenExclusion = (Exclusion) excludeRuleConverter.convert(excludeRule);
        if (mavenExclusion != null) {
            mavenExclusions.add(mavenExclusion);
        }
    }
    return mavenExclusions;
}
 

public Exclusion convert(ExcludeRule excludeRule) {
    if (isConvertable(excludeRule)) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(excludeRule.getGroup());
        exclusion.setArtifactId(excludeRule.getModule());
        return exclusion;
    }
    return null;
}
 

private List<Exclusion> getExclusions(ModuleDependency dependency, Set<Configuration> configurations) {
    List<Exclusion> mavenExclusions = new ArrayList<Exclusion>();
    Set<ExcludeRule> excludeRules = new HashSet<ExcludeRule>(dependency.getExcludeRules());
    for (Configuration configuration : configurations) {
        excludeRules.addAll(configuration.getExcludeRules());
    }
    for (ExcludeRule excludeRule : excludeRules) {
        Exclusion mavenExclusion = (Exclusion) excludeRuleConverter.convert(excludeRule);
        if (mavenExclusion != null) {
            mavenExclusions.add(mavenExclusion);
        }
    }
    return mavenExclusions;
}
 

static Dependency createDependencyFromCoordinates(String coordinatesString, boolean excludeTransitive) {
    final String[] coordinates = coordinatesString.split(":");
    int amountOfCoordinates = coordinates.length;
    if (amountOfCoordinates < 2) {
        throw new IllegalArgumentException(
            "Coordinates of the specified strategy [" + coordinatesString + "] doesn't have the correct format.");
    }
    final Dependency dependency = new Dependency();
    dependency.setGroupId(coordinates[0]);
    dependency.setArtifactId(coordinates[1]);
    if (amountOfCoordinates == 3) {
        dependency.setVersion(coordinates[2]);
    } else if (amountOfCoordinates >= 4) {
        dependency.setType(coordinates[2].isEmpty() ? "jar" : coordinates[2]);
        dependency.setClassifier(coordinates[3]);
    }
    if (amountOfCoordinates >= 5) {
        dependency.setVersion(coordinates[4]);
    }
    if (amountOfCoordinates == 6) {
        dependency.setScope(coordinates[5]);
    }
    if (dependency.getVersion() == null || dependency.getVersion().isEmpty()) {
        dependency.setVersion(ExtensionVersion.version().toString());
    }
    if (excludeTransitive) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId("*");
        exclusion.setArtifactId("*");
        dependency.setExclusions(Arrays.asList(exclusion));
    }
    return dependency;
}
 

private void writeExclusion(Exclusion exclusion, String tagName, XmlSerializer serializer)
        throws java.io.IOException {
    serializer.startTag(NAMESPACE, tagName);
    flush(serializer);
    StringBuffer b = b(serializer);
    int start = b.length();
    if (exclusion.getGroupId() != null) {
        writeValue(serializer, "groupId", exclusion.getGroupId(), exclusion);
    }
    if (exclusion.getArtifactId() != null) {
        writeValue(serializer, "artifactId", exclusion.getArtifactId(), exclusion);
    }
    serializer.endTag(NAMESPACE, tagName).flush();
    logLocation(exclusion, "", start, b.length());
}
 

public Exclusion convert(ExcludeRule excludeRule) {
    if (isConvertable(excludeRule)) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(excludeRule.getGroup());
        exclusion.setArtifactId(excludeRule.getModule());
        return exclusion;
    }
    return null;
}
 

private List<Exclusion> getExclusions(ModuleDependency dependency, Set<Configuration> configurations) {
    List<Exclusion> mavenExclusions = new ArrayList<Exclusion>();
    Set<ExcludeRule> excludeRules = new HashSet<ExcludeRule>(dependency.getExcludeRules());
    for (Configuration configuration : configurations) {
        excludeRules.addAll(configuration.getExcludeRules());
    }
    for (ExcludeRule excludeRule : excludeRules) {
        Exclusion mavenExclusion = (Exclusion) excludeRuleConverter.convert(excludeRule);
        if (mavenExclusion != null) {
            mavenExclusions.add(mavenExclusion);
        }
    }
    return mavenExclusions;
}
 

public Exclusion convert(ExcludeRule excludeRule) {
    if (isConvertable(excludeRule)) {
        Exclusion exclusion = new Exclusion();
        exclusion.setGroupId(excludeRule.getGroup());
        exclusion.setArtifactId(excludeRule.getModule());
        return exclusion;
    }
    return null;
}
 

public ListAssert<Exclusion> exclusions() {
    isNotNull();
    return Assertions.assertThat(actual.getExclusions());
}
 

private void writeDependency(Dependency dependency, String tagName, XmlSerializer serializer)
        throws java.io.IOException {
    serializer.startTag(NAMESPACE, tagName);
    flush(serializer);
    StringBuffer b = b(serializer);
    int start = b.length();
    if (dependency.getGroupId() != null) {
        writeValue(serializer, "groupId", dependency.getGroupId(), dependency);
    }
    if (dependency.getArtifactId() != null) {
        writeValue(serializer, "artifactId", dependency.getArtifactId(), dependency);
    }
    if (dependency.getVersion() != null) {
        writeValue(serializer, "version", dependency.getVersion(), dependency);
    }
    if ((dependency.getType() != null) && !dependency.getType().equals("jar")) {
        writeValue(serializer, "type", dependency.getType(), dependency);
    }
    if (dependency.getClassifier() != null) {
        writeValue(serializer, "classifier", dependency.getClassifier(), dependency);
    }
    if (dependency.getScope() != null) {
        writeValue(serializer, "scope", dependency.getScope(), dependency);
    }
    if (dependency.getSystemPath() != null) {
        writeValue(serializer, "systemPath", dependency.getSystemPath(), dependency);
    }
    if ((dependency.getExclusions() != null) && (dependency.getExclusions().size() > 0)) {
        serializer.startTag(NAMESPACE, "exclusions");
        for (Iterator<Exclusion> iter = dependency.getExclusions().iterator(); iter.hasNext();) {
            Exclusion o = iter.next();
            writeExclusion(o, "exclusion", serializer);
        }
        serializer.endTag(NAMESPACE, "exclusions");
    }
    if (dependency.getOptional() != null) {
        writeValue(serializer, "optional", dependency.getOptional(), dependency);
    }
    serializer.endTag(NAMESPACE, tagName).flush();
    logLocation(dependency, "", start, b.length());
}
 

/**
 * Apply explicit overrides to a set of dependencies from a project. The explicit overrides come from
 * dependencyExclusion. However they have to be separated out from standard overrides so we can easily
 * ignore any property references (and overwrite them).
 *
 * @param project the current Project
 * @param dependencies dependencies to check
 * @param explicitOverrides a custom map to handle wildcard overrides
 * @param state the CommonState, to retrieve Common Properties
 * @param versionPropertyUpdateMap properties to update
 * @throws ManipulationException if an error occurs
 */
protected void applyExplicitOverrides( final Project project,
                                       final Map<? extends ProjectVersionRef, ? extends InputLocationTracker> dependencies,
                                       final WildcardMap<String> explicitOverrides, final CommonState state,
                                       final Map<Project, Map<String, PropertyMapper>> versionPropertyUpdateMap )
                throws ManipulationException
{
    // Apply matching overrides to dependencies
    for ( final ProjectVersionRef projectVersionRef : dependencies.keySet() )
    {
        final ProjectRef groupIdArtifactId = new SimpleProjectRef( projectVersionRef.getGroupId(), projectVersionRef.getArtifactId() );

        if ( explicitOverrides.containsKey( groupIdArtifactId ) )
        {
            final String overrideVersion = explicitOverrides.get( groupIdArtifactId );
            final DependencyPluginWrapper wrapper = new DependencyPluginWrapper( dependencies.get( projectVersionRef ) );
            final String oldVersion = wrapper.getVersion();

            if ( isEmpty( overrideVersion ) || isEmpty( oldVersion ) )
            {
                if ( isEmpty( oldVersion ) )
                {
                    logger.debug( "Unable to force align as no existing version field to update for " + groupIdArtifactId + "; ignoring" );
                }
                else
                {
                    logger.warn( "Unable to force align as override version is empty for " + groupIdArtifactId
                                                 + "; ignoring" );
                }
            }
            else
            {
                for ( String target : overrideVersion.split( "," ) )
                {
                    if ( target.startsWith( "+" ) )
                    {
                        logger.info( "Adding dependency exclusion {} to dependency {} ", target.substring( 1 ),
                                     projectVersionRef );
                        Exclusion e = new Exclusion();
                        e.setGroupId( target.substring( 1 ).split( ":" )[0] );
                        e.setArtifactId( target.split( ":" )[1] );
                        wrapper.addExclusion( e );
                    }
                    else
                    {
                        logger.info( "Explicit overrides : force aligning {} to {}.", groupIdArtifactId, target );

                        if ( !PropertiesUtils.cacheProperty( project, state, versionPropertyUpdateMap, oldVersion,
                                                             target, projectVersionRef, true ) )
                        {
                            if ( oldVersion.contains( "${" ) )
                            {
                                // This might happen if the property was inherited from an external parent.
                                logger.warn( "Overriding version with {} when old version contained a property {} "
                                                             + "that was not found in the current project",
                                             target, oldVersion );
                            }
                            // Not checking strict version alignment here as explicit overrides take priority.
                            wrapper.setVersion( target );
                        }
                    }
                }
            }
        }
    }
}
 

private void overwriteDependencyManagement(Document pom, List<Dependency> dependencies) throws Exception {
    XPath xpath = XPathFactory.newInstance().newXPath();
    XPathExpression expr = xpath.compile("/project/dependencyManagement/dependencies");

    NodeList nodes = (NodeList) expr.evaluate(pom, XPathConstants.NODESET);
    if (nodes.getLength() == 0) {
        throw new IllegalStateException("No dependencies found in the dependencyManagement section of the current pom");
    }

    Node dependenciesSection = nodes.item(0);
    // cleanup the dependency management section
    while (dependenciesSection.hasChildNodes()) {
        Node child = dependenciesSection.getFirstChild();
        dependenciesSection.removeChild(child);
    }

    for (Dependency dep : dependencies) {

        if ("target".equals(dep.getArtifactId())) {
            // skip invalid artifact that somehow gets included
            continue;
        }

        Element dependencyEl = pom.createElement("dependency");

        Element groupIdEl = pom.createElement("groupId");
        groupIdEl.setTextContent(dep.getGroupId());
        dependencyEl.appendChild(groupIdEl);

        Element artifactIdEl = pom.createElement("artifactId");
        artifactIdEl.setTextContent(dep.getArtifactId());
        dependencyEl.appendChild(artifactIdEl);

        Element versionEl = pom.createElement("version");
        versionEl.setTextContent(dep.getVersion());
        dependencyEl.appendChild(versionEl);

        if (!"jar".equals(dep.getType())) {
            Element typeEl = pom.createElement("type");
            typeEl.setTextContent(dep.getType());
            dependencyEl.appendChild(typeEl);
        }

        if (dep.getClassifier() != null) {
            Element classifierEl = pom.createElement("classifier");
            classifierEl.setTextContent(dep.getClassifier());
            dependencyEl.appendChild(classifierEl);
        }

        if (dep.getScope() != null && !"compile".equals(dep.getScope())) {
            Element scopeEl = pom.createElement("scope");
            scopeEl.setTextContent(dep.getScope());
            dependencyEl.appendChild(scopeEl);
        }

        if (dep.getExclusions() != null && !dep.getExclusions().isEmpty()) {

            Element exclsEl = pom.createElement("exclusions");

            for (Exclusion e : dep.getExclusions()) {
                Element exclEl = pom.createElement("exclusion");

                Element groupIdExEl = pom.createElement("groupId");
                groupIdExEl.setTextContent(e.getGroupId());
                exclEl.appendChild(groupIdExEl);

                Element artifactIdExEl = pom.createElement("artifactId");
                artifactIdExEl.setTextContent(e.getArtifactId());
                exclEl.appendChild(artifactIdExEl);

                exclsEl.appendChild(exclEl);
            }

            dependencyEl.appendChild(exclsEl);
        }


        dependenciesSection.appendChild(dependencyEl);
    }


}
 

public List<Exclusion> getExclusions() {
    return exclusions;
}
 

public DeployConfiguration withExclusions(List<Exclusion> exclusions) {
    this.exclusions = exclusions;
    return this;
}