private boolean checkDependencies()

in src/main/java/org/apache/maven/plugins/dependency/analyze/AbstractAnalyzeMojo.java [328:444]
90 lines of code
21 McCabe index (conditional complexity)

    private boolean checkDependencies() throws MojoExecutionException {
        ProjectDependencyAnalysis analysis;
        try {
            analysis = createProjectDependencyAnalyzer().analyze(project, excludedClasses);

            if (usedDependencies != null) {
                analysis = analysis.forceDeclaredDependenciesUsage(usedDependencies);
            }
        } catch (ProjectDependencyAnalyzerException exception) {
            throw new MojoExecutionException("Cannot analyze dependencies", exception);
        }

        if (ignoreNonCompile) {
            analysis = analysis.ignoreNonCompile();
        }

        Set<Artifact> usedDeclared = new LinkedHashSet<>(analysis.getUsedDeclaredArtifacts());
        Map<Artifact, Set<String>> usedUndeclaredWithClasses =
                new LinkedHashMap<>(analysis.getUsedUndeclaredArtifactsWithClasses());
        Set<Artifact> unusedDeclared = new LinkedHashSet<>(analysis.getUnusedDeclaredArtifacts());
        Set<Artifact> nonTestScope = new LinkedHashSet<>(analysis.getTestArtifactsWithNonTestScope());

        Set<Artifact> ignoredUsedUndeclared = new LinkedHashSet<>();
        Set<Artifact> ignoredUnusedDeclared = new LinkedHashSet<>();
        Set<Artifact> ignoredNonTestScope = new LinkedHashSet<>();

        if (ignoreUnusedRuntime) {
            filterArtifactsByScope(unusedDeclared, Artifact.SCOPE_RUNTIME);
        }

        ignoredUsedUndeclared.addAll(filterDependencies(usedUndeclaredWithClasses.keySet(), ignoredDependencies));
        ignoredUsedUndeclared.addAll(
                filterDependencies(usedUndeclaredWithClasses.keySet(), ignoredUsedUndeclaredDependencies));

        ignoredUnusedDeclared.addAll(filterDependencies(unusedDeclared, ignoredDependencies));
        ignoredUnusedDeclared.addAll(filterDependencies(unusedDeclared, ignoredUnusedDeclaredDependencies));

        if (ignoreAllNonTestScoped) {
            ignoredNonTestScope.addAll(filterDependencies(nonTestScope, new String[] {"*"}));
        } else {
            ignoredNonTestScope.addAll(filterDependencies(nonTestScope, ignoredDependencies));
            ignoredNonTestScope.addAll(filterDependencies(nonTestScope, ignoredNonTestScopedDependencies));
        }

        boolean reported = false;
        boolean warning = false;

        if (verbose && !usedDeclared.isEmpty()) {
            getLog().info("Used declared dependencies found:");

            logArtifacts(analysis.getUsedDeclaredArtifacts(), false);
            reported = true;
        }

        if (!usedUndeclaredWithClasses.isEmpty()) {
            logDependencyWarning("Used undeclared dependencies found:");

            if (verbose) {
                logArtifacts(usedUndeclaredWithClasses);
            } else {
                logArtifacts(usedUndeclaredWithClasses.keySet(), true);
            }
            reported = true;
            warning = true;
        }

        if (!unusedDeclared.isEmpty()) {
            logDependencyWarning("Unused declared dependencies found:");

            logArtifacts(unusedDeclared, true);
            reported = true;
            warning = true;
        }

        if (!nonTestScope.isEmpty()) {
            logDependencyWarning("Non-test scoped test only dependencies found:");

            logArtifacts(nonTestScope, true);
            reported = true;
            warning = true;
        }

        if (verbose && !ignoredUsedUndeclared.isEmpty()) {
            getLog().info("Ignored used undeclared dependencies:");

            logArtifacts(ignoredUsedUndeclared, false);
            reported = true;
        }

        if (verbose && !ignoredUnusedDeclared.isEmpty()) {
            getLog().info("Ignored unused declared dependencies:");

            logArtifacts(ignoredUnusedDeclared, false);
            reported = true;
        }

        if (verbose && !ignoredNonTestScope.isEmpty()) {
            getLog().info("Ignored non-test scoped test only dependencies:");

            logArtifacts(ignoredNonTestScope, false);
            reported = true;
        }

        if (outputXML) {
            writeDependencyXML(usedUndeclaredWithClasses.keySet());
        }

        if (scriptableOutput) {
            writeScriptableOutput(usedUndeclaredWithClasses.keySet());
        }

        if (!reported) {
            getLog().info("No dependency problems found");
        }

        return warning;
    }