Example usage for org.apache.maven.project MavenProjectBuilder buildFromRepository

Introduction

In this page you can find the example usage for org.apache.maven.project MavenProjectBuilder buildFromRepository.

Prototype

MavenProject buildFromRepository(Artifact artifact, List<ArtifactRepository> remoteRepositories,
            ArtifactRepository localRepository, boolean allowStubModel) throws ProjectBuildingException;

Source Link

Usage

From source file:org.codehaus.mojo.license.ArtifactHelper.java

License:Open Source License

/**
 * Get the list of project dependencies after applying transitivity and filtering rules.
 * /*from  w w w  .  j ava  2  s. c o  m*/
 * @param mojo
 * @param log
 * @param cache
 * @return
 */
public static SortedMap<String, MavenProject> loadProjectDependencies(MavenProjectDependenciesLoader mojo,
        Log log, SortedMap<String, MavenProject> cache) {

    boolean haveNoIncludedGroups = StringUtils.isEmpty(mojo.getIncludedGroups());
    boolean haveNoIncludedArtifacts = StringUtils.isEmpty(mojo.getIncludedArtifacts());

    boolean haveExcludedGroups = StringUtils.isNotEmpty(mojo.getExcludedGroups());
    boolean haveExcludedArtifacts = StringUtils.isNotEmpty(mojo.getExcludedArtifacts());
    boolean haveExclusions = haveExcludedGroups || haveExcludedArtifacts;

    Pattern includedGroupPattern = null;
    Pattern includedArtifactPattern = null;
    Pattern excludedGroupPattern = null;
    Pattern excludedArtifactPattern = null;

    if (!haveNoIncludedGroups) {
        includedGroupPattern = Pattern.compile(mojo.getIncludedGroups());
    }
    if (!haveNoIncludedArtifacts) {
        includedArtifactPattern = Pattern.compile(mojo.getIncludedArtifacts());
    }
    if (haveExcludedGroups) {
        excludedGroupPattern = Pattern.compile(mojo.getExcludedGroups());
    }
    if (haveExcludedArtifacts) {
        excludedArtifactPattern = Pattern.compile(mojo.getExcludedArtifacts());
    }

    MavenProject project = mojo.getProject();

    Set<?> depArtifacts;

    if (mojo.isIncludeTransitiveDependencies()) {
        // All project dependencies
        depArtifacts = project.getArtifacts();
    } else {
        // Only direct project dependencies
        depArtifacts = project.getDependencyArtifacts();
    }

    ArtifactRepository localRepository = mojo.getLocalRepository();
    List remoteRepositories = mojo.getRemoteRepositories();
    MavenProjectBuilder projectBuilder = mojo.getMavenProjectBuilder();

    List<String> excludeScopes = mojo.getExcludeScopes();

    boolean verbose = mojo.isVerbose();

    SortedMap<String, MavenProject> result = new TreeMap<String, MavenProject>();

    for (Object o : depArtifacts) {
        Artifact artifact = (Artifact) o;

        if (excludeScopes.contains(artifact.getScope())) {

            // never treate system artifacts (they are mysterious and
            // no information can be retrive from anywhere)...
            continue;
        }

        String id = getArtifactId(artifact);

        if (verbose) {
            log.info("detected artifact " + id);
        }

        // Check if the project should be included
        // If there is no specified artifacts and group to include, include all
        boolean isToInclude = haveNoIncludedArtifacts && haveNoIncludedGroups
                || isIncludable(log, artifact, includedGroupPattern, includedArtifactPattern);

        // Check if the project should be excluded
        boolean isToExclude = isToInclude && haveExclusions
                && isExcludable(log, artifact, excludedGroupPattern, excludedArtifactPattern);

        if (!isToInclude || isToExclude) {
            if (verbose) {
                log.info("skip artifact " + id);
            }
            continue;
        }

        MavenProject depMavenProject = null;

        if (cache != null) {

            // try to get project from cache
            depMavenProject = cache.get(id);
        }

        if (depMavenProject != null) {
            if (verbose) {
                log.info("add dependency [" + id + "] (from cache)");
            }
        } else {

            // build project

            try {
                depMavenProject = projectBuilder.buildFromRepository(artifact, remoteRepositories,
                        localRepository, true);
            } catch (ProjectBuildingException e) {
                log.warn("Unable to obtain POM for artifact : " + artifact);
                log.warn(e);
                continue;
            }

            if (verbose) {
                log.info("add dependency [" + id + "]");
            }
            if (cache != null) {

                // store it also in cache
                cache.put(id, depMavenProject);
            }
        }

        // keep the project
        result.put(id, depMavenProject);
    }

    return result;
}

---

From source file:org.itcollege.valge.licenseaudit.LicenseAuditMojo.java

@SuppressWarnings("unchecked")
public List<Dependency> loadAllDependencies(MavenProject project, ArtifactRepository localRepository,
        List<ArtifactRepository> remoteRepositories, MavenProjectBuilder mavenProjectBuilder)
        throws MojoExecutionException {

    Set<Artifact> artifacts = project.getArtifacts();

    List<Dependency> deps = Lists.newArrayList();
    for (Artifact artifact : artifacts) {
        try {// w  ww.j av a  2  s.  c o  m
            MavenProject depMavenProject = mavenProjectBuilder.buildFromRepository(artifact, remoteRepositories,
                    localRepository, true);
            depMavenProject.getArtifact().setScope(artifact.getScope());
            deps.add(new Dependency(artifact, depMavenProject));
        } catch (ProjectBuildingException e) {
            throw new MojoExecutionException("Failed to load dependencies", e);
        }
    }

    return deps;
}

---