Support transitive excludes in dependency-tools

Update spring-boot-dependency-tools to support transitive excludes.
Transitive excludes are useful with Gradle which considers each
dependency independently (see GRADLE-3061).

Transitive excludes are supported by parsing the dependency-tree file
from spring-boot-versions.

See gh-1047

Author: Phillip Webb

spring-boot-tools/spring-boot-dependency-tools/pom.xml

@@ -31,7 +31,7 @@
 				<artifactId>maven-dependency-plugin</artifactId>
 				<executions>
 					<execution>
-						<id>copy-effective-pom</id>
+						<id>copy-resources</id>
 						<phase>generate-resources</phase>
 						<goals>
 							<goal>copy</goal>
@@ -47,6 +47,15 @@
 									<outputDirectory>${generated.pom.dir}</outputDirectory>
 									<destFileName>effective-pom.xml</destFileName>
 								</artifactItem>
+								<artifactItem>
+									<groupId>org.springframework.boot</groupId>
+									<artifactId>spring-boot-versions</artifactId>
+									<version>${project.version}</version>
+									<type>dependency-tree</type>
+									<overWrite>true</overWrite>
+									<outputDirectory>${generated.pom.dir}</outputDirectory>
+									<destFileName>dependency-tree.txt</destFileName>
+								</artifactItem>
 							</artifactItems>
 						</configuration>
 					</execution>

spring-boot-tools/spring-boot-dependency-tools/src/main/java/org/springframework/boot/dependency/tools/DependenciesWithTransitiveExclusions.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2012-2014 the original author or authors.
+ *
+ * Licensed 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.springframework.boot.dependency.tools;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.boot.dependency.tools.Dependency.Exclusion;
+import org.springframework.boot.dependency.tools.Dependency.ExclusionType;
+
+/**
+ * {@link Dependencies} to extend an existing {@link Dependencies} instance with
+ * transitive {@link Exclusion}s located from a {@link DependencyTree}.
+ * 
+ * @author Phillip Webb
+ * @since 1.1.0
+ */
+class DependenciesWithTransitiveExclusions extends AbstractDependencies {
+
+	public DependenciesWithTransitiveExclusions(Dependencies dependencies,
+			DependencyTree tree) {
+		DependencyBuilder builder = new DependencyBuilder(dependencies);
+		builder.addTransitiveExcludes(tree);
+		builder.finish();
+	}
+
+	/**
+	 * Builder used to collect the transitive exclusions.
+	 */
+	private class DependencyBuilder {
+
+		private Map<ArtifactAndGroupId, DependencyAndTransitiveExclusions> dependencies;
+
+		public DependencyBuilder(Dependencies dependencies) {
+			this.dependencies = new LinkedHashMap<ArtifactAndGroupId, DependencyAndTransitiveExclusions>();
+			for (Dependency dependency : dependencies) {
+				this.dependencies.put(new ArtifactAndGroupId(dependency),
+						new DependencyAndTransitiveExclusions(dependency));
+			}
+		}
+
+		public void addTransitiveExcludes(DependencyTree tree) {
+			for (DependencyNode node : tree) {
+				DependencyAndTransitiveExclusions dependency = this.dependencies
+						.get(asArtifactAndGroupId(node));
+				if (dependency != null) {
+					for (DependencyNode child : node) {
+						addTransitiveExcludes(dependency, child);
+					}
+				}
+			}
+		}
+
+		private void addTransitiveExcludes(DependencyAndTransitiveExclusions dependency,
+				DependencyNode node) {
+			DependencyAndTransitiveExclusions exclusions = this.dependencies
+					.get(asArtifactAndGroupId(node));
+			if (exclusions != null) {
+				dependency.addTransitiveExclusions(exclusions.getSourceDependency());
+			}
+			for (DependencyNode child : node) {
+				addTransitiveExcludes(dependency, child);
+			}
+		}
+
+		private ArtifactAndGroupId asArtifactAndGroupId(DependencyNode node) {
+			return new ArtifactAndGroupId(node.getGroupId(), node.getArtifactId());
+		}
+
+		public void finish() {
+			for (Map.Entry<ArtifactAndGroupId, DependencyAndTransitiveExclusions> entry : this.dependencies
+					.entrySet()) {
+				add(entry.getKey(), entry.getValue().createNewDependency());
+			}
+		}
+
+	}
+
+	/**
+	 * Holds a {@link Dependency} with additional transitive {@link Exclusion}s.
+	 */
+	private static class DependencyAndTransitiveExclusions {
+
+		private Dependency dependency;
+
+		private Set<Exclusion> transitiveExclusions = new LinkedHashSet<Exclusion>();
+
+		public DependencyAndTransitiveExclusions(Dependency dependency) {
+			this.dependency = dependency;
+		}
+
+		public Dependency getSourceDependency() {
+			return this.dependency;
+		}
+
+		public void addTransitiveExclusions(Dependency dependency) {
+			for (Exclusion exclusion : dependency.getExclusions()) {
+				this.transitiveExclusions.add(new Exclusion(exclusion.getGroupId(),
+						exclusion.getArtifactId(), ExclusionType.TRANSITIVE));
+			}
+		}
+
+		public Dependency createNewDependency() {
+			Set<Exclusion> exclusions = new LinkedHashSet<Dependency.Exclusion>();
+			exclusions.addAll(this.dependency.getExclusions());
+			exclusions.addAll(this.transitiveExclusions);
+			return new Dependency(this.dependency.getGroupId(),
+					this.dependency.getArtifactId(), this.dependency.getVersion(),
+					new ArrayList<Exclusion>(exclusions));
+		}
+
+	}
+
+}

spring-boot-tools/spring-boot-dependency-tools/src/main/java/org/springframework/boot/dependency/tools/Dependency.java

@@ -137,11 +137,15 @@ public static final class Exclusion {
 
 		private final String artifactId;
 
-		Exclusion(String groupId, String artifactId) {
+		private final ExclusionType type;
+
+		Exclusion(String groupId, String artifactId, ExclusionType type) {
 			Assert.notNull(groupId, "GroupId must not be null");
 			Assert.notNull(groupId, "ArtifactId must not be null");
+			Assert.notNull(type, "Type must not be null");
 			this.groupId = groupId;
 			this.artifactId = artifactId;
+			this.type = type;
 		}
 
 		/**
@@ -158,6 +162,10 @@ public String getGroupId() {
 			return this.groupId;
 		}
 
+		public ExclusionType getType() {
+			return this.type;
+		}
+
 		@Override
 		public String toString() {
 			return this.groupId + ":" + this.artifactId;
@@ -188,4 +196,22 @@ public boolean equals(Object obj) {
 
 	}
 
+	public static enum ExclusionType {
+
+		/**
+		 * An exclusion that was specified directly on the dependency.
+		 */
+		DIRECT,
+
+		/**
+		 * An exclusion that is was specified on a dependency of this dependency. For
+		 * example if {@literal commons-logging} is directly excluded from
+		 * {@literal spring-core} then it is also transitive exclude on
+		 * {@literal spring-context} (since {@literal spring-context} depends on
+		 * {@literal spring-core}).
+		 */
+		TRANSITIVE
+
+	}
+
 }

spring-boot-tools/spring-boot-dependency-tools/src/main/java/org/springframework/boot/dependency/tools/DependencyNode.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2012-2014 the original author or authors.
+ *
+ * Licensed 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.springframework.boot.dependency.tools;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * A single node in a {@link DependencyTree}.
+ * 
+ * @author Phillip Webb
+ * @see DependencyTree
+ * @since 1.1.0
+ */
+class DependencyNode implements Iterable<DependencyNode> {
+
+	private final String groupId;
+
+	private final String artifactId;
+
+	private final String version;
+
+	private List<DependencyNode> dependencies;
+
+	DependencyNode(String groupId, String artifactId, String version) {
+		this.groupId = groupId;
+		this.artifactId = artifactId;
+		this.version = version;
+		this.dependencies = new ArrayList<DependencyNode>();
+	}
+
+	@Override
+	public Iterator<DependencyNode> iterator() {
+		return getDependencies().iterator();
+	}
+
+	public String getGroupId() {
+		return this.groupId;
+	}
+
+	public String getArtifactId() {
+		return this.artifactId;
+	}
+
+	public String getVersion() {
+		return this.version;
+	}
+
+	public List<DependencyNode> getDependencies() {
+		return Collections.unmodifiableList(this.dependencies);
+	}
+
+	@Override
+	public String toString() {
+		return this.groupId + ":" + this.artifactId + ":" + this.version;
+	}
+
+	void addDependency(DependencyNode node) {
+		this.dependencies.add(node);
+	}
+
+	DependencyNode getLastDependency() {
+		return this.dependencies.get(this.dependencies.size() - 1);
+	}
+
+}