Example usage for org.apache.maven.project MavenProject getDependencies

List of usage examples for org.apache.maven.project MavenProject getDependencies

  1. HOME
  2. Java
  3. org.apache.maven
  4. org.apache.maven.project.*
  5. MavenProject
  6. getDependencies

Introduction

In this page you can find the example usage for org.apache.maven.project MavenProject getDependencies.

Prototype

public List<Dependency> getDependencies()

Source Link

Usage

From source file:net.hasor.maven.ExecJavaMojo.java

License:Apache License

/**
 * Resolve the executable dependencies for the specified project
 * /*w  ww. j a v a2s  .  c o m*/
 * @param executablePomArtifact the project's POM
 * @return a set of Artifacts
 * @throws MojoExecutionException if a failure happens
 */
private Set<Artifact> resolveExecutableDependencies(Artifact executablePomArtifact)
        throws MojoExecutionException {
    Set<Artifact> executableDependencies;
    try {
        MavenProject executableProject = this.projectBuilder.buildFromRepository(executablePomArtifact,
                this.remoteRepositories, this.localRepository);
        // get all of the dependencies for the executable project
        List<Dependency> dependencies = executableProject.getDependencies();
        // make Artifacts of all the dependencies
        Set<Artifact> dependencyArtifacts = MavenMetadataSource.createArtifacts(this.artifactFactory,
                dependencies, null, null, null);
        // not forgetting the Artifact of the project itself
        dependencyArtifacts.add(executableProject.getArtifact());
        // resolve all dependencies transitively to obtain a comprehensive list of assemblies
        ArtifactResolutionResult result = artifactResolver.resolveTransitively(dependencyArtifacts,
                executablePomArtifact, Collections.emptyMap(), this.localRepository, this.remoteRepositories,
                metadataSource, null, Collections.emptyList());
        executableDependencies = result.getArtifacts();
    } catch (Exception ex) {
        throw new MojoExecutionException("Encountered problems resolving dependencies of the executable "
                + "in preparation for its execution.", ex);
    }
    return executableDependencies;
}

From source file:net.officefloor.launch.woof.WoofDevelopmentConfigurationLoader.java

License:Open Source License

/**
 * Obtains the GWT development class path to match POM configuration. In
 * particular to ensure same version of <code>gwt-dev</code> as the
 * <code>gwt-user</code> used.
 * /* w w  w  . j a v  a 2  s .c  om*/
 * @param pomFile
 *            Maven POM file.
 * @return GWT development class path.
 * @throws Exception
 *             If fails to obtain the GWT development class path.
 */
public static String[] getDevModeClassPath(File pomFile) throws Exception {

    // Create initial class path factory
    ClassPathFactoryImpl initial = new ClassPathFactoryImpl(null, new RemoteRepository[0]);

    // Obtain the Maven project and its remote repositories
    MavenProject project = initial.getMavenProject(pomFile);
    List<RemoteRepository> remoteRepositories = new LinkedList<RemoteRepository>();
    for (ArtifactRepository repository : project.getRemoteArtifactRepositories()) {
        remoteRepositories.add(
                new RemoteRepository(repository.getId(), repository.getLayout().getId(), repository.getUrl()));
    }

    // Create class path factory from POM remote repositories
    ClassPathFactory factory = new ClassPathFactoryImpl(null,
            remoteRepositories.toArray(new RemoteRepository[remoteRepositories.size()]));

    // Keep track of class path
    List<String> gwtClassPath = new LinkedList<String>();

    // Obtain the GWT version
    String gwtDevVersion = null;
    for (Dependency dependency : project.getDependencies()) {
        String groupId = dependency.getGroupId();
        String artifactId = dependency.getArtifactId();
        if ((GWT_GROUP_ID.equals(groupId)) && (GWT_USER_ARTIFACT_ID.equals(artifactId))) {
            gwtDevVersion = dependency.getVersion();
        }
    }
    if (gwtDevVersion == null) {
        // Use default version of GWT
        gwtDevVersion = DEFAULT_GWT_DEV_VERSION;

        // Must include GWT User for running
        String[] userClassPath = factory.createArtifactClassPath(GWT_GROUP_ID, GWT_USER_ARTIFACT_ID,
                gwtDevVersion, null, null);
        gwtClassPath.addAll(Arrays.asList(userClassPath));
    }

    // Include the class path for gwt-dev
    String[] devClassPath = factory.createArtifactClassPath(GWT_GROUP_ID, GWT_DEV_ARTIFACT_ID, gwtDevVersion,
            null, null);
    for (String classPathEntry : devClassPath) {

        // Ignore if already included
        if (gwtClassPath.contains(classPathEntry)) {
            continue;
        }

        // Include class path
        gwtClassPath.add(classPathEntry);
    }

    // Return the GWT class path
    return gwtClassPath.toArray(new String[gwtClassPath.size()]);
}

From source file:net.oneandone.maven.plugins.prerelease.core.Descriptor.java

License:Apache License

/** @return this */
public Descriptor check(World world, MavenProject mavenProject, boolean allowSnapshots,
        boolean allowPrereleaseSnapshots) throws TagAlreadyExists, VersioningProblem, CannotDeterminTagBase,
        MissingScmTag, CannotBumpVersion, MissingDeveloperConnection {
    List<String> problems;
    MavenProject parent;//from   ww w.  ja  v  a 2 s. c  om

    problems = new ArrayList<>();
    checkSnapshot("project", mavenProject.getVersion(), problems);
    parent = mavenProject.getParent();
    if (parent != null) {
        checkRelease("project parent", parent.getVersion(), problems);
    }
    for (Dependency dependency : mavenProject.getDependencies()) {
        checkRelease(dependency.getGroupId() + ":" + dependency.getArtifactId(), dependency.getVersion(),
                problems);
    }
    for (Artifact artifact : mavenProject.getPluginArtifacts()) {
        if (allowPrereleaseSnapshots && "net.oneandone.maven.plugins".equals(artifact.getGroupId())
                && "prerelease".equals(artifact.getArtifactId())) {
            // skip for integration tests
        } else {
            checkRelease(artifact.getGroupId() + ":" + artifact.getArtifactId(), artifact.getVersion(),
                    problems);
        }
    }
    if (problems.size() > 0 && !allowSnapshots) {
        throw new VersioningProblem(problems);
    }
    if (Subversion.exists(world.getTemp(), svnTag)) {
        throw new TagAlreadyExists(svnTag);
    }
    return this;
}

From source file:net.oneandone.maven.rules.common.AbstractFilterableRule.java

License:Apache License

protected void compareDependenciesWithParentManagement(MavenProject project, Log log,
        DifferenceHandler differenceHandler) {
    if (project.getParent() != null) {
        List<Dependency> projectDependencies = project.getDependencies();
        if (project.getDependencyManagement() != null) {
            projectDependencies.addAll(project.getDependencyManagement().getDependencies());
        }/* w  ww. j  a v a2 s. c om*/
        ImmutableListMultimap<String, Dependency> parentProjectDependencies = RuleHelper
                .getManagedDependenciesAsMap(project.getParent());

        for (Dependency dependency : projectDependencies) {
            ImmutableList<Dependency> parentDependencies = parentProjectDependencies
                    .get(RuleHelper.getDependencyIdentifier(dependency));
            if (parentDependencies != null && !isExcluded(dependency.getManagementKey())) {
                for (Dependency parentDependency : parentDependencies) {
                    if (dependency.getManagementKey().equals(parentDependency.getManagementKey())) {
                        if (!dependency.getVersion().equals(parentDependency.getVersion())) {
                            differenceHandler.handleDifference(log, dependency, parentDependency);
                        }
                        break;
                    }
                }
            }
        }

    }
}

From source file:net.oneandone.pommes.model.Database.java

License:Apache License

public static Document document(String origin, MavenProject mavenProject)
        throws InvalidVersionSpecificationException {
    Document doc;//from   w w  w .  j a  v  a 2 s . c o m
    MavenProject parent;
    Pom parPom;

    doc = document(origin, Pom.forProject(origin, mavenProject));
    for (Dependency dependency : mavenProject.getDependencies()) {
        GAV dep = GAV.forDependency(dependency);

        // index groupId:artifactId for non-version searches
        doc.add(new StringField(DEP_GA, dep.toGaString(), Field.Store.YES));
        // index groupId:artifactId:version for exact-version searches
        doc.add(new StringField(DEP_GAV, dep.toGavString(), Field.Store.YES));
        // index groupId:artifactId for searches that need to evaluate the range
        VersionRange vr = VersionRange.createFromVersionSpec(dependency.getVersion());
        if (vr.hasRestrictions()) {
            doc.add(new StringField(DEP_GA_RANGE, dep.toGaString(), Field.Store.YES));
        }
    }

    // parent
    parent = mavenProject.getParent();
    if (parent != null) {
        parPom = Pom.forProject(origin, parent);
        doc.add(new StringField(PAR_GA, parPom.coordinates.toGaString(), Field.Store.YES));
        doc.add(new StringField(PAR_GAV, parPom.coordinates.toGavString(), Field.Store.YES));
    }
    return doc;
}

From source file:net.oneandone.pommes.model.Pom.java

License:Apache License

public static Pom forProject(String origin, MavenProject project) {
    Pom result;/*from www . j a v  a2  s .c  o  m*/

    result = new Pom(origin, new GAV(project.getGroupId(), project.getArtifactId(), project.getVersion()));
    for (Dependency dependency : project.getDependencies()) {
        result.dependencies.add(GAV.forDependency(dependency));
    }
    return result;
}

From source file:nl.pieni.maven.dependency_analyzer.mojo.create.CreateDatabaseMojo.java

License:Apache License

/**
 * process/parse a artifact returned from the nexus query.
 * the project and its found dependencies are added to the database
 *
 * @param source the found artifact//w ww.ja  va 2s.  c o m
 * @throws SettingsBuildingException Unable to parse the settings file
 */
private void processArtifactInfo(final ArtifactInfo source) {

    try {
        MavenProject mavenProject = artifactInfo2MavenProject(source);
        Dependency project = artifactInfo2Dependency(source);

        getLog().info("Processing: " + project);
        List<Dependency> dependencyList = mavenProject.getDependencies();
        List<Dependency> filtered = getIncludeFilter().filter(dependencyList);
        if (filtered.size() > 0) {
            nodeCreateCount += nodeProcessor.addArtifact(project);
        } else {
            getLog().info("No dependencies for inclusion selected");
        }

        for (Dependency dependency : filtered) {
            getLog().info("Adding dependency: " + dependency);
            nodeCreateCount += nodeProcessor.addArtifact(dependency);
            relationCreateCount += nodeProcessor.addRelation(project, dependency);

        }
    } catch (ProjectBuildingException e) {
        getLog().info("Error building project " + source);
    }
}

From source file:org.apache.camel.guice.maven.RunMojo.java

License:Apache License

private Set<Artifact> resolveExecutableDependencies(Artifact executablePomArtifact)
        throws MojoExecutionException {

    Set<Artifact> executableDependencies;
    try {//from  ww w.ja v  a  2  s  .  c o m
        MavenProject executableProject = this.projectBuilder.buildFromRepository(executablePomArtifact,
                this.remoteRepositories, this.localRepository);

        // get all of the dependencies for the executable project
        List<Artifact> dependencies = CastUtils.cast(executableProject.getDependencies());

        // make Artifacts of all the dependencies
        Set<Artifact> dependencyArtifacts = CastUtils.cast(
                MavenMetadataSource.createArtifacts(this.artifactFactory, dependencies, null, null, null));

        // not forgetting the Artifact of the project itself
        dependencyArtifacts.add(executableProject.getArtifact());

        // resolve all dependencies transitively to obtain a comprehensive
        // list of assemblies
        ArtifactResolutionResult result = artifactResolver.resolveTransitively(dependencyArtifacts,
                executablePomArtifact, Collections.emptyMap(), this.localRepository, this.remoteRepositories,
                metadataSource, null, Collections.emptyList());
        executableDependencies = CastUtils.cast(result.getArtifacts());

    } catch (Exception ex) {
        throw new MojoExecutionException("Encountered problems resolving dependencies of the executable "
                + "in preparation for its execution.", ex);
    }

    return executableDependencies;
}

From source file:org.apache.sling.ide.eclipse.m2e.internal.MavenProjectUtils.java

License:Apache License

public static String guessServletApiVersion(MavenProject project) {

    for (Dependency dependency : project.getDependencies()) {

        if ("servlet-api".equals(dependency.getArtifactId())
                || "javax.servlet-api".equals(dependency.getArtifactId())) {
            Matcher matcher = SERVLET_API_VERSION_MATCHER.matcher(dependency.getVersion());
            if (matcher.matches()) {
                return matcher.group(1);
            }/*from ww  w . j  a v  a2  s .  c o m*/
        }
    }

    return DEFAULT_SERVLET_API_VERSION;
}

From source file:org.axway.grapes.maven.report.ModuleBuilder.java

/**
 * Turn a maven project (Maven data model) into a module (Grapes data model)
 *
 * @param project MavenProject/*from  ww  w .  jav  a  2 s  . com*/
 * @return Module
 */
public Module getModule(final MavenProject project, final LicenseResolver licenseResolver,
        final ArtifactResolver artifactResolver) throws MojoExecutionException {

    final Module module = GrapesTranslator.getGrapesModule(project);
    final List<License> licenses = licenseResolver.resolve(project);

    /* Manage Artifacts */
    final Artifact mainArtifact = GrapesTranslator.getGrapesArtifact(project.getArtifact());
    addLicenses(mainArtifact, licenses);
    module.addArtifact(mainArtifact);

    // Get pom file if main artifact is not already a pom file
    if (!mainArtifact.getType().equals("pom")) {
        final Artifact pomArtifact = GrapesTranslator.getGrapesArtifact(project.getModel());
        addLicenses(pomArtifact, licenses);
        module.addArtifact(pomArtifact);
    }

    for (int i = 0; i < project.getAttachedArtifacts().size(); i++) {
        artifactResolver.resolveArtifact(project, project.getAttachedArtifacts().get(i));
        final Artifact attachedArtifact = GrapesTranslator
                .getGrapesArtifact(project.getAttachedArtifacts().get(i));
        // handle licenses
        addLicenses(attachedArtifact, licenses);
        module.addArtifact(attachedArtifact);
    }

    /* Manage Dependencies */
    for (int i = 0; i < project.getDependencies().size(); i++) {
        final Dependency dependency = GrapesTranslator.getGrapesDependency(
                artifactResolver.resolveArtifact(project, project.getDependencies().get(i)),
                project.getDependencies().get(i).getScope());

        // handle licenses
        for (License license : licenseResolver.resolve(project, dependency.getTarget().getGroupId(),
                dependency.getTarget().getArtifactId(), dependency.getTarget().getVersion())) {
            dependency.getTarget().addLicense(license.getName());
        }

        module.addDependency(dependency);
    }

    return module;
}