throws RepositoryException { Artifact artifact = new DefaultArtifact(dependency); DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE); PatternExclusionsDependencyFilter exclusionFilter = new PatternExclusionsDependencyFilter(excludes); DependencyFilterUtils.andFilter(exclusionFilter, classpathFilter)); try { return system.resolveDependencies(session, dependencyRequest).getArtifactResults();
/** * Creates a new filter that negates the specified filter. * * @param filter The filter to negate, must not be {@code null}. * @return The new filter, never {@code null}. */ public static DependencyFilter notFilter( DependencyFilter filter ) { return new NotDependencyFilter( filter ); }
/** * Creates a new filter from the specified filters. * * @param filter1 The first filter to combine, may be {@code null}. * @param filter2 The first filter to combine, may be {@code null}. * @return The combined filter or {@code null} if both filter were {@code null}. */ public static DependencyFilter newInstance( DependencyFilter filter1, DependencyFilter filter2 ) { if ( filter1 == null ) { return filter2; } else if ( filter2 == null ) { return filter1; } return new AndDependencyFilter( filter1, filter2 ); }
private DependencyFilter buildFilter( final Advice advice ) { final ArrayList<DependencyFilter> filters = new ArrayList<DependencyFilter>(); if ( advice.getAppliesTo() != null ) { if ( !advice.getAppliesTo().getIncludes().isEmpty() ) { filters.add( new PatternInclusionsDependencyFilter( advice.getAppliesTo().getIncludes() ) ); } if ( !advice.getAppliesTo().getExcludes().isEmpty() ) { filters.add( new PatternExclusionsDependencyFilter( advice.getAppliesTo().getExcludes() ) ); } } final AndDependencyFilter artifactFilter = new AndDependencyFilter( filters ); return artifactFilter; }
/** * Creates a new filter that selects dependencies whose scope matches one or more of the specified classpath types. * A classpath type is a set of scopes separated by either {@code ','} or {@code '+'}. * * @param classpathTypes The classpath types, may be {@code null} or empty to match no dependency. * @return The new filter, never {@code null}. * @see JavaScopes */ public static DependencyFilter classpathFilter( String... classpathTypes ) { return classpathFilter( ( classpathTypes != null ) ? Arrays.asList( classpathTypes ) : null ); }
@Override public DependencyNode cleanupDependencyTree( final DependencyNode root ) { final CloningDependencyVisitor clonningVisitor = new CloningDependencyVisitor(); final PatternExclusionsDependencyFilter nodeFilter = new PatternExclusionsDependencyFilter( new GenericVersionScheme(), "*:*:advice" ); final FilteringDependencyVisitor filter = new FilteringDependencyVisitor( clonningVisitor, nodeFilter ); root.accept( filter ); return clonningVisitor.getRootNode(); } }
private DependencyFilter buildExceptionsFilter( final Advice advice ) { if ( !advice.getAppliesTo().getExcludes().isEmpty() ) { return new PatternInclusionsDependencyFilter( advice.getAppliesTo().getExcludes() ); } return new DependencyFilter() { public boolean accept( final DependencyNode node, final List<DependencyNode> parents ) { return false; } }; }
/** * Creates a new filter from the specified filters. * * @param filter1 The first filter to combine, may be {@code null}. * @param filter2 The first filter to combine, may be {@code null}. * @return The combined filter or {@code null} if both filter were {@code null}. */ public static DependencyFilter newInstance( DependencyFilter filter1, DependencyFilter filter2 ) { if ( filter1 == null ) { return filter2; } else if ( filter2 == null ) { return filter1; } return new OrDependencyFilter( filter1, filter2 ); }
@Override public boolean accept( final DependencyNode node, List<DependencyNode> parents ) { final Dependency dependency = node.getDependency(); if ( dependency == null ) { return true; } return !super.accept( node, parents ); }
matches = isVersionIncludedInRange( token, pattern );
private boolean accept( final Artifact artifact, final String pattern ) { final String[] tokens = new String[] { artifact.getGroupId(), artifact.getArtifactId(), artifact.getExtension(), artifact.getBaseVersion() }; final String[] patternTokens = pattern.split( ":" ); // fail immediately if pattern tokens outnumber tokens to match boolean matched = ( patternTokens.length <= tokens.length ); for ( int i = 0; matched && i < patternTokens.length; i++ ) { matched = matches( tokens[i], patternTokens[i] ); } return matched; }
private List<ArtifactResult> fetchArtifactWithDep(Dependency dep) throws DependencyResolutionException, ArtifactResolutionException { Artifact artifact = new DefaultArtifact(dep.getGroupArtifactVersion()); DependencyFilter classpathFilter = DependencyFilterUtils .classpathFilter(JavaScopes.COMPILE); PatternExclusionsDependencyFilter exclusionFilter = new PatternExclusionsDependencyFilter( dep.getExclusions()); CollectRequest collectRequest = new CollectRequest(); collectRequest.setRoot(new org.sonatype.aether.graph.Dependency(artifact, JavaScopes.COMPILE)); collectRequest.addRepository(mavenCentral); collectRequest.addRepository(mavenLocal); for (Repository repo : repositories) { RemoteRepository rr = new RemoteRepository(repo.getId(), "default", repo.getUrl()); rr.setPolicy(repo.isSnapshot(), null); collectRequest.addRepository(rr); } DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, DependencyFilterUtils.andFilter(exclusionFilter, classpathFilter)); return system.resolveDependencies(session, dependencyRequest).getArtifactResults(); }
private DependencyFilter buildFilter( final Advice advice ) { final ArrayList<DependencyFilter> filters = new ArrayList<DependencyFilter>(); if ( advice.getAppliesTo() != null ) { if ( !advice.getAppliesTo().getIncludes().isEmpty() ) { filters.add( new PatternInclusionsDependencyFilter( advice.getAppliesTo().getIncludes() ) ); } if ( !advice.getAppliesTo().getExcludes().isEmpty() ) { filters.add( new PatternExclusionsDependencyFilter( advice.getAppliesTo().getExcludes() ) ); } } final AndDependencyFilter artifactFilter = new AndDependencyFilter( filters ); return artifactFilter; }
/** * List of transitive dependencies of the artifact. * @param root The artifact to work with * @param scope The scope to work with ("runtime", "test", etc.) * @return The list of dependencies * @throws DependencyResolutionException If can't fetch it */ public List<Artifact> resolve(final Artifact root, final String scope) throws DependencyResolutionException { final DependencyFilter filter = DependencyFilterUtils.classpathFilter(scope); if (filter == null) { throw new IllegalStateException( String.format("failed to create a filter for '%s'", scope) ); } return this.resolve(root, scope, filter); }
/** * Creates a new filter that combines the specified filters using a logical {@code AND}. If no filters are * specified, the resulting filter accepts everything. * * @param filters The filters to combine, may be {@code null}. * @return The new filter, never {@code null}. */ public static DependencyFilter andFilter( DependencyFilter... filters ) { if ( filters != null && filters.length == 1 ) { return filters[0]; } else { return new AndDependencyFilter( filters ); } }
/** * Creates a new filter that combines the specified filters using a logical {@code OR}. If no filters are specified, * the resulting filter accepts nothing. * * @param filters The filters to combine, may be {@code null}. * @return The new filter, never {@code null}. */ public static DependencyFilter orFilter( DependencyFilter... filters ) { if ( filters != null && filters.length == 1 ) { return filters[0]; } else { return new OrDependencyFilter( filters ); } }
public boolean accept( final DependencyNode node, List<DependencyNode> parents ) { final Dependency dependency = node.getDependency(); if ( dependency == null ) { return true; } final Artifact artifact = dependency.getArtifact(); for ( final String pattern : patterns ) { final boolean matched = accept( artifact, pattern ); if ( matched ) { return true; } } return false; }
public List<Artifact> resolveArtifacts(Iterable<? extends Artifact> sourceArtifacts) { CollectRequest collectRequest = new CollectRequest(); for (Artifact sourceArtifact : sourceArtifacts) { collectRequest.addDependency(new Dependency(sourceArtifact, JavaScopes.RUNTIME)); } for (RemoteRepository repository : repositories) { collectRequest.addRepository(repository); } DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, DependencyFilterUtils.classpathFilter(JavaScopes.RUNTIME)); return resolveArtifacts(dependencyRequest); }
/** * Creates a new filter that combines the specified filters using a logical {@code AND}. If no filters are * specified, the resulting filter accepts everything. * * @param filters The filters to combine, may be {@code null}. * @return The new filter, never {@code null}. */ public static DependencyFilter andFilter( Collection<DependencyFilter> filters ) { if ( filters != null && filters.size() == 1 ) { return filters.iterator().next(); } else { return new AndDependencyFilter( filters ); } }
/** * Creates a new filter that combines the specified filters using a logical {@code OR}. If no filters are specified, * the resulting filter accepts nothing. * * @param filters The filters to combine, may be {@code null}. * @return The new filter, never {@code null}. */ public static DependencyFilter orFilter( Collection<DependencyFilter> filters ) { if ( filters != null && filters.size() == 1 ) { return filters.iterator().next(); } else { return new OrDependencyFilter( filters ); } }