import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 *
 * @param dependency
 * @param excludes list of pattern can either be of the form groupId:artifactId
 * @return
 * @throws Exception
 */
public List<ArtifactResult> getArtifactsWithDep(String dependency,
    Collection<String> excludes) throws Exception {
  Artifact artifact = new DefaultArtifact(inferScalaVersion(dependency));
  DependencyFilter classpathFlter = DependencyFilterUtils.classpathFilter( JavaScopes.COMPILE );
  PatternExclusionsDependencyFilter exclusionFilter =
      new PatternExclusionsDependencyFilter(inferScalaVersion(excludes));

  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRoot(new Dependency(artifact, JavaScopes.COMPILE));

  synchronized (repos) {
    for (RemoteRepository repo : repos) {
      collectRequest.addRepository(repo);
    }
  }
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest,
      DependencyFilterUtils.andFilter(exclusionFilter, classpathFlter));
  return system.resolveDependencies(session, dependencyRequest).getArtifactResults();
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
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();
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * @param dependency
 * @param excludes list of pattern can either be of the form groupId:artifactId
 * @return
 * @throws Exception
 */
@Override
public List<ArtifactResult> getArtifactsWithDep(String dependency,
  Collection<String> excludes) throws RepositoryException {
  Artifact artifact = new DefaultArtifact(dependency);
  DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);
  PatternExclusionsDependencyFilter exclusionFilter =
          new PatternExclusionsDependencyFilter(excludes);

  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRoot(new Dependency(artifact, JavaScopes.COMPILE));

  synchronized (repos) {
    for (RemoteRepository repo : repos) {
      collectRequest.addRepository(repo);
    }
  }
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest,
          DependencyFilterUtils.andFilter(exclusionFilter, classpathFilter));
  try {
    return system.resolveDependencies(session, dependencyRequest).getArtifactResults();
  } catch (NullPointerException | DependencyResolutionException ex) {
    throw new RepositoryException(
            String.format("Cannot fetch dependencies for %s", dependency), ex);
  }
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * @param dependency
 * @param excludes list of pattern can either be of the form groupId:artifactId
 * @return
 * @throws Exception
 */
@Override
public List<ArtifactResult> getArtifactsWithDep(String dependency,
    Collection<String> excludes) throws Exception {
  Artifact artifact = new DefaultArtifact(inferScalaVersion(dependency));
  DependencyFilter classpathFilter = DependencyFilterUtils.classpathFilter(JavaScopes.COMPILE);
  PatternExclusionsDependencyFilter exclusionFilter =
      new PatternExclusionsDependencyFilter(inferScalaVersion(excludes));

  CollectRequest collectRequest = new CollectRequest();
  collectRequest.setRoot(new Dependency(artifact, JavaScopes.COMPILE));

  synchronized (repos) {
    for (RemoteRepository repo : repos) {
      collectRequest.addRepository(repo);
    }
  }
  DependencyRequest dependencyRequest = new DependencyRequest(collectRequest,
      DependencyFilterUtils.andFilter(exclusionFilter, classpathFilter));
  return system.resolveDependencies(session, dependencyRequest).getArtifactResults();
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Default scopes.
 * @return List of scopes.
 */
private Collection<String> scope() {
    final List<String> scps;
    if (this.eclipseAether()) {
        scps = Arrays.asList(
            org.eclipse.aether.util.artifact.JavaScopes.COMPILE,
            org.eclipse.aether.util.artifact.JavaScopes.PROVIDED,
            org.eclipse.aether.util.artifact.JavaScopes.RUNTIME,
            org.eclipse.aether.util.artifact.JavaScopes.SYSTEM
        );
    } else {
        scps = Arrays.asList(
            JavaScopes.COMPILE,
            JavaScopes.RUNTIME,
            JavaScopes.PROVIDED,
            JavaScopes.SYSTEM
        );
    }
    return scps;
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Classpath can build a classpath.
 * @throws Exception If there is some problem inside
 */
@Test
public void buildsClasspath() throws Exception {
    MatcherAssert.assertThat(
        new Classpath(
            this.project(
                this.dependency(
                    ClasspathTest.GROUP, ClasspathTest.GROUP, "4.10"
                )
            ), this.temp.newFolder(), JavaScopes.TEST
        ),
        Matchers.<File>hasItems(
            Matchers.hasToString(
                Matchers.endsWith(
                    String.format(
                        ClasspathTest.SDIR,
                        System.getProperty(ClasspathTest.FILE_SEP)
                    )
                )
            ),
            Matchers.hasToString(Matchers.endsWith("junit-4.10.jar")),
            Matchers.hasToString(Matchers.endsWith("hamcrest-core-1.1.jar"))
        )
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Classpath can build a classpath with more scopes.
 * @throws Exception If there is some problem inside
 */
@Test
public void buildsClasspathWithMoreScopes() throws Exception {
    final String artf = "jcabi-ssh";
    final String vrs = "1.5.2";
    MatcherAssert.assertThat(
        new Classpath(
            this.project(this.dependency("com.jcabi", artf, vrs)),
            this.temp.newFolder(), JavaScopes.TEST, JavaScopes.COMPILE
        ),
        Matchers.<File>hasItems(
            Matchers.hasToString(
                Matchers.endsWith(
                    String.format(
                        ClasspathTest.SDIR,
                        System.getProperty(ClasspathTest.FILE_SEP)
                    )
                )
            ),
            Matchers.hasToString(
                Matchers.endsWith(String.format("%s-%s.jar", artf, vrs))
            )
        )
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Classpath can build a classpath without optional dependencies.
 * @throws Exception If there is some problem inside
 */
@Test
public void buildsClasspathWithoutOptionalArtifacts() throws Exception {
    final Dependency dep = new Dependency();
    // @checkstyle MultipleStringLiterals (2 lines)
    dep.setGroupId("commons-validator");
    dep.setArtifactId("commons-validator");
    dep.setVersion("1.3.1");
    dep.setScope(JavaScopes.COMPILE);
    MatcherAssert.assertThat(
        new Classpath(
            this.project(dep), this.temp.newFolder(), JavaScopes.COMPILE
        ),
        Matchers.not(
            Matchers.<File>hasItems(
                Matchers.hasToString(
                    Matchers.endsWith("oro-2.0.8.jar")
                )
            )
        )
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Classpath can return a string when a dependency is broken.
 * @throws Exception If there is some problem inside
 */
@Test
public void hasToStringWithBrokenDependency() throws Exception {
    final Dependency dep = new Dependency();
    dep.setGroupId("junit-broken");
    dep.setArtifactId("junit-absent");
    dep.setVersion("1.0");
    dep.setScope(JavaScopes.TEST);
    final Classpath classpath = new Classpath(
        this.project(dep), this.temp.newFolder(), JavaScopes.TEST
    );
    MatcherAssert.assertThat(
        classpath.toString(),
        Matchers.containsString(
            "failed to load 'junit-broken:junit-absent:jar:1.0 (compile)'"
        )
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Classpath can be compared to another classpath.
 * @throws Exception If there is some problem inside
 */
@Test
public void comparesToAnotherClasspath() throws Exception {
    final Dependency dep = new Dependency();
    dep.setGroupId("org.apache.commons");
    dep.setArtifactId("commons-lang3-absent");
    dep.setVersion("3.0");
    dep.setScope(JavaScopes.COMPILE);
    final Classpath classpath = new Classpath(
        this.project(dep), this.temp.newFolder(), JavaScopes.TEST
    );
    MatcherAssert.assertThat(classpath, Matchers.equalTo(classpath));
    MatcherAssert.assertThat(
        classpath.canEqual(classpath),
        Matchers.is(true)
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
public void parsePom(InputStream inputStream) {
    try {
        MavenXpp3Reader reader = new MavenXpp3Reader();

        Model model = reader.read(inputStream);

        if (dependencies == null) {
            dependencies = new LinkedList<>();
        }
        if (repositories == null) {
            repositories = new LinkedList<>();
        }

        parent = model.getParent();
        setPropertiesFromModel(this, model);

        for (org.apache.maven.model.Dependency dependency : model.getDependencies()) {
            if (!"test".equalsIgnoreCase(dependency.getScope())) {
                dependencies.add(new Dependency(new DefaultArtifact(
                        dependency.getGroupId(),
                        dependency.getArtifactId(),
                        dependency.getClassifier(),
                        "jar",
                        dependency.getVersion()
                ), JavaScopes.RUNTIME));
            }
        }

        for (Repository remoteRepository : model.getRepositories()) {
            repositories.add(new RemoteRepository(remoteRepository.getId(), "default", remoteRepository.getUrl()));
        }
    } catch (Exception ex) {
        LOGGER.error("Error while reading POM file", ex);
    }
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
@Override
public BundleInformation installBundleFromRepository(String moduleId, boolean startBundle) {
    try {
        return installFromRepository(new Dependency(new DefaultArtifact(moduleId), JavaScopes.RUNTIME), startBundle);
    } catch (RepositoryException | IOException | BundleException e) {
        throw new MotechException("Unable to install module from repository " + moduleId, e);
    }
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
@Test
public void shouldParsePomFile() throws IOException {
    Properties properties = new Properties();
    properties.put("test.properties", "test");
    properties.put("modules.root.dir", "${basedir}/../..");
    // Because we use <version> and <groupId> tags in our tested pom, the parsing method should add this as properties
    properties.put("project.version", "0-27-SNAPSHOT");
    properties.put("project.groupId", "testGroupId");

    Dependency dependency = new Dependency(new DefaultArtifact(
            "${project.groupId}",
            "motech-osgi-platform",
            "",
            "jar",
            "${project.version}"
    ), JavaScopes.RUNTIME);

    try (InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("pom/pom.xml")) {
        pomInformation = new PomInformation();
        pomInformation.parsePom(inputStream);
    }

    assertEquals(properties, pomInformation.getProperties());

    Parent parentFromParsing = pomInformation.getParent();
    assertEquals("0.27-SNAPSHOT", parentFromParsing.getVersion());
    assertEquals("motech", parentFromParsing.getArtifactId());
    assertEquals("org.motechproject", parentFromParsing.getGroupId());

    assertTrue(pomInformation.getDependencies().contains(dependency));
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
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);
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
public DependencyNode transformGraph( DependencyNode node, DependencyGraphTransformationContext context )
    throws RepositoryException
{
    if ( findPlexusUtils( node ) == null )
    {
        Artifact pu = new DefaultArtifact( GID, AID, null, EXT, VER );
        DefaultDependencyNode child = new DefaultDependencyNode( new Dependency( pu, JavaScopes.RUNTIME ) );
        child.setRepositories( node.getRepositories() );
        child.setRequestContext( node.getRequestContext() );
        node.getChildren().add( child );
    }

    return node;
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Resolves dependencies transitively from the given jar artifact, with the specified Maven scope
 * (compile, runtime, and so on.)
 */
public DependencyResult resolveDependencies(GAV a, String scope) throws DependencyResolutionException {
    DependencyFilter classpathFlter = DependencyFilterUtils.classpathFilter(scope);

    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(new Dependency(new DefaultArtifact(a.toString()), JavaScopes.COMPILE));
    collectRequest.setRepositories(remoteRepositories);

    DependencyRequest dependencyRequest = new DependencyRequest(collectRequest, classpathFlter);

    return resolveDependencies(dependencyRequest);
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Get all dependencies of this root artifact.
 * @return The list of artifacts
 * @throws DependencyResolutionException If fails to resolve
 */
@Cacheable(forever = true)
public Collection<Artifact> children()
    throws DependencyResolutionException {
    return this.aether.resolve(
        this.art, JavaScopes.COMPILE, new NonOptionalFilter()
    );
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
public final void execute() throws MojoFailureException {
    StaticLoggerBinder.getSingleton().setMavenLog(this.getLog());
    final Aether aether = new Aether(
        this.project,
        this.session.getLocalRepository().getBasedir()
    );
    for (final String coord : this.coordinates) {
        Logger.info(this, "%s:", coord);
        try {
            final Collection<Artifact> deps = aether.resolve(
                new DefaultArtifact(coord),
                JavaScopes.RUNTIME
            );
            for (final Artifact dep : deps) {
                Logger.info(this, "    %s", dep);
            }
        } catch (final DependencyResolutionException ex) {
            throw new MojoFailureException(
                String.format("failed to resolve '%s'", coord),
                ex
            );
        }
    }
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Aether can find and load artifacts.
 * @throws Exception If there is some problem inside
 */
@Test
public void findsAndLoadsArtifacts() throws Exception {
    final File local = this.temp.newFolder();
    final Aether aether = new Aether(this.project(), local);
    final Collection<DefaultArtifact> artifacts =
        new LinkedList<DefaultArtifact>(
            Arrays.asList(
                new DefaultArtifact("com.jcabi:jcabi-log:pom:1.0-SNAPSHOT"),
                new DefaultArtifact("log4j:log4j:jar:1.2.16")
            )
        );
    if (AetherTest.AWS_KEY != null) {
        artifacts.add(
            new DefaultArtifact(
                "com.jcabi.aether-test:parent:pom:1.0"
            )
        );
    }
    final Matcher<?> matcher = new CustomMatcher<String>("file exists") {
        @Override
        public boolean matches(final Object file) {
            return File.class.cast(file).exists();
        }
    };
    for (final Artifact artifact : artifacts) {
        MatcherAssert.assertThat(
            aether.resolve(artifact, JavaScopes.RUNTIME),
            Matchers.<Artifact>everyItem(
                Matchers.<Artifact>hasProperty("file", matcher)
            )
        );
    }
}
 

import org.sonatype.aether.util.artifact.JavaScopes; //导入依赖的package包/类
/**
 * Aether can resolve in parallel threads.
 * @throws Exception If there is some problem inside
 */
@Test
public void resolvesArtifactsInParallelThreads() throws Exception {
    final File local = this.temp.newFolder();
    final Aether aether = new Aether(this.project(), local);
    final int threads = Runtime.getRuntime().availableProcessors() * 5;
    final Artifact artifact = new DefaultArtifact(
        "com.jcabi:jcabi-assembly:pom:0.1.10"
    );
    final CountDownLatch start = new CountDownLatch(1);
    final CountDownLatch latch = new CountDownLatch(threads);
    final Runnable task = new VerboseRunnable(
        new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                start.await();
                MatcherAssert.assertThat(
                    aether.resolve(artifact, JavaScopes.RUNTIME),
                    Matchers.not(Matchers.<Artifact>empty())
                );
                latch.countDown();
                return null;
            }
        },
        true
    );
    final ExecutorService svc =
        Executors.newFixedThreadPool(threads, new VerboseThreads());
    for (int thread = 0; thread < threads; ++thread) {
        svc.submit(task);
    }
    start.countDown();
    MatcherAssert.assertThat(
        latch.await(2, TimeUnit.MINUTES),
        Matchers.is(true)
    );
    svc.shutdown();
}