ajarmoniuk commented on code in PR #198:
URL: https://github.com/apache/maven-enforcer/pull/198#discussion_r1051431973
##########
enforcer-rules/src/main/java/org/apache/maven/plugins/enforcer/utils/ArtifactUtils.java:
##########
@@ -18,70 +18,201 @@
*/
package org.apache.maven.plugins.enforcer.utils;
+import static java.util.Optional.ofNullable;
+
+import java.util.Collection;
+import java.util.HashMap;
import java.util.HashSet;
-import java.util.List;
+import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
+import org.apache.maven.RepositoryUtils;
import org.apache.maven.artifact.Artifact;
import
org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
+import org.apache.maven.enforcer.rule.api.EnforcerRuleHelper;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.model.DependencyManagement;
import org.apache.maven.plugins.enforcer.utils.ArtifactMatcher.Pattern;
-import org.apache.maven.shared.dependency.graph.DependencyNode;
+import org.apache.maven.project.MavenProject;
+import
org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
+import
org.codehaus.plexus.component.repository.exception.ComponentLookupException;
+import org.eclipse.aether.DefaultRepositorySystemSession;
+import org.eclipse.aether.RepositorySystem;
+import org.eclipse.aether.artifact.ArtifactTypeRegistry;
+import org.eclipse.aether.collection.CollectRequest;
+import org.eclipse.aether.collection.DependencyCollectionException;
+import org.eclipse.aether.collection.DependencySelector;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
+import org.eclipse.aether.util.graph.selector.AndDependencySelector;
+import org.eclipse.aether.util.graph.transformer.ConflictResolver;
+import org.eclipse.aether.util.graph.transformer.JavaScopeDeriver;
+import org.eclipse.aether.util.graph.transformer.JavaScopeSelector;
+import org.eclipse.aether.util.graph.transformer.NearestVersionSelector;
+import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector;
/**
*
* @author Robert Scholte
* @since 3.0.0
*/
public final class ArtifactUtils {
- private ArtifactUtils() {}
+ private static final Map<DependencyNode, Artifact> NODE_ARTIFACT_MAP = new
HashMap<>();
+ private static final Map<Artifact, org.eclipse.aether.artifact.Artifact>
AETHER_ARTIFACT_MAP = new HashMap<>();
+
+ /**
+ * Converts {@link DependencyNode} to {@link Artifact}; in comparison
+ * to {@linkpl
RepositoryUtils#toArtifact(org.eclipse.aether.artifact.Artifact)}, this method
+ * assigns {@link Artifact#getScope()} and {@link Artifact#isOptional()}
based on
+ * the dependency information from the node.
+ *
+ * @param node {@link DependencyNode} to convert to {@link Artifact}
+ * @return target artifact
+ */
+ public static Artifact toArtifact(DependencyNode node) {
+ Artifact result = NODE_ARTIFACT_MAP.computeIfAbsent(node, n ->
RepositoryUtils.toArtifact(n.getArtifact()));
+ ofNullable(node.getDependency()).ifPresent(dependency -> {
+ ofNullable(dependency.getScope()).ifPresent(result::setScope);
+ result.setOptional(dependency.isOptional());
+ });
+ AETHER_ARTIFACT_MAP.putIfAbsent(result, node.getArtifact());
+ return result;
+ }
+
+ /**
+ * Converts {@link Artifact} to {@link
org.eclipse.aether.artifact.Artifact}
+ * @param artifact source artifact
+ * @return target artifact
+ */
+ public static org.eclipse.aether.artifact.Artifact toArtifact(Artifact
artifact) {
+ return AETHER_ARTIFACT_MAP.computeIfAbsent(artifact,
RepositoryUtils::toArtifact);
+ }
+
+ /**
+ * Retrieves the {@link DependencyNode} instance containing the result of
the transitive dependency
+ * for the current {@link MavenProject}.
+ *
+ * @param helper (may not be null) an instance of the {@link
EnforcerRuleHelper} class
+ * @param selectors zero or more {@link DependencySelector} instances
+ * @return a Dependency Node which is the root of the project's dependency
tree
+ * @throws EnforcerRuleException thrown if the lookup fails
+ */
+ public static DependencyNode resolveTransitiveDependencies(
+ EnforcerRuleHelper helper, DependencySelector... selectors) throws
EnforcerRuleException {
+ try {
+ RepositorySystem repositorySystem =
helper.getComponent(RepositorySystem.class);
+ MavenSession session = (MavenSession)
helper.evaluate("${session}");
+ MavenProject project = session.getCurrentProject();
+ ArtifactTypeRegistry artifactTypeRegistry =
+ session.getRepositorySession().getArtifactTypeRegistry();
- public static Set<Artifact> getAllDescendants(DependencyNode node) {
- Set<Artifact> children = null;
- if (node.getChildren() != null) {
- children = new HashSet<>();
- for (DependencyNode depNode : node.getChildren()) {
- children.add(depNode.getArtifact());
- Set<Artifact> subNodes = getAllDescendants(depNode);
- if (subNodes != null) {
- children.addAll(subNodes);
- }
+ DefaultRepositorySystemSession repositorySystemSession =
+ new
DefaultRepositorySystemSession(session.getRepositorySession());
+ repositorySystemSession.setDependencyGraphTransformer(new
ConflictResolver(
+ new NearestVersionSelector(),
+ new JavaScopeSelector(),
+ new SimpleOptionalitySelector(),
+ new JavaScopeDeriver()));
+
repositorySystemSession.setConfigProperty(ConflictResolver.CONFIG_PROP_VERBOSE,
true);
+
repositorySystemSession.setConfigProperty(DependencyManagerUtils.CONFIG_PROP_VERBOSE,
true);
+ if (selectors.length > 0) {
+ repositorySystemSession.setDependencySelector(new
AndDependencySelector(selectors));
}
+
+ CollectRequest collectRequest = new CollectRequest(
+ project.getDependencies().stream()
+ .map(d -> RepositoryUtils.toDependency(d,
artifactTypeRegistry))
+ .collect(Collectors.toList()),
+ ofNullable(project.getDependencyManagement())
+ .map(DependencyManagement::getDependencies)
+ .map(list -> list.stream()
+ .map(d -> RepositoryUtils.toDependency(d,
artifactTypeRegistry))
+ .collect(Collectors.toList()))
+ .orElse(null),
+ project.getRemoteProjectRepositories());
+
collectRequest.setRootArtifact(ArtifactUtils.toArtifact(project.getArtifact()));
+
+ return repositorySystem
+ .collectDependencies(repositorySystemSession,
collectRequest)
+ .getRoot();
+ } catch (ExpressionEvaluationException | ComponentLookupException e) {
+ throw new EnforcerRuleException("Unable to lookup a component " +
e.getLocalizedMessage(), e);
+ } catch (DependencyCollectionException e) {
+ throw new EnforcerRuleException("Could not build dependency tree "
+ e.getLocalizedMessage(), e);
}
- return children;
}
/**
- * Checks the set of dependencies against the list of patterns.
+ * <p>Retrieves all <em>child</em> dependency artifacts from the given
{@link DependencyNode} and returns them
+ * as a set of {@link Artifact}.</p>
+ * <p><u>Note:</u> Thus, the result will not contain the root
artifact.</p>
+ * @param node root node
+ * @return set of all <em>child</em> dependency artifacts
+ */
+ public static Set<Artifact> getDependencyArtifacts(DependencyNode node) {
+ return getDependencyArtifacts(node, new HashSet<>());
+ }
+
+ private static Set<Artifact> getDependencyArtifacts(DependencyNode node,
Set<Artifact> set) {
+ node.getChildren().forEach(child -> {
+ set.add(toArtifact(child));
+ getDependencyArtifacts(child, set);
+ });
+ return set;
+ }
+
+ /**
+ * Returns a subset of dependency artifacts that match the given
collection of patterns
*
- * @param thePatterns the patterns
- * @param dependencies the dependencies
+ * @param dependencies dependency artifacts to match against patterns
+ * @param patterns patterns to match against the artifacts
* @return a set containing artifacts matching one of the patterns or
<code>null</code>
* @throws EnforcerRuleException the enforcer rule exception
*/
- public static Set<Artifact> checkDependencies(Set<Artifact> dependencies,
List<String> thePatterns)
+ public static Set<Artifact> filterDependencyArtifacts(Set<Artifact>
dependencies, Collection<String> patterns)
throws EnforcerRuleException {
- Set<Artifact> foundMatches = null;
-
- if (thePatterns != null && thePatterns.size() > 0) {
-
- for (String pattern : thePatterns) {
- String[] subStrings = pattern.split(":");
- subStrings = StringUtils.stripAll(subStrings);
- String resultPattern = StringUtils.join(subStrings, ":");
+ try {
+ return ofNullable(patterns)
+ .map(collection -> collection.parallelStream()
+ .map(p -> p.split(":"))
+ .map(StringUtils::stripAll)
+ .map(arr -> String.join(":", arr))
+ .flatMap(pattern -> dependencies.parallelStream()
+ .filter(artifact ->
compareDependency(pattern, artifact)))
+ .collect(Collectors.toSet()))
Review Comment:
Yes...
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: issues-unsubscr...@maven.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
