public ProjectsInputInfo calculateChecksum()

in src/main/java/org/apache/maven/buildcache/checksum/MavenProjectInput.java [188:288]
83 lines of code
21 McCabe index (conditional complexity)

    public ProjectsInputInfo calculateChecksum() throws IOException {
        final long t0 = System.currentTimeMillis();

        final String effectivePom = getEffectivePom(normalizedModelProvider.normalizedModel(project));
        final SortedSet<Path> inputFiles = isPom(project) ? Collections.emptySortedSet() : getInputFiles();
        final SortedMap<String, String> dependenciesChecksum = getMutableDependencies();
        final SortedMap<String, String> pluginDependenciesChecksum = getMutablePluginDependencies();

        final long t1 = System.currentTimeMillis();

        // hash items: effective pom + version + input files paths + input files contents + dependencies
        final int count = 1
                + (config.calculateProjectVersionChecksum() ? 1 : 0)
                + 2 * inputFiles.size()
                + dependenciesChecksum.size()
                + pluginDependenciesChecksum.size();

        final List<DigestItem> items = new ArrayList<>(count);
        final HashChecksum checksum = config.getHashFactory().createChecksum(count);

        Optional<ProjectsInputInfo> baselineHolder = Optional.empty();
        if (config.isBaselineDiffEnabled()) {
            baselineHolder =
                    remoteCache.findBaselineBuild(project).map(b -> b.getDto().getProjectsInputInfo());
        }

        if (config.calculateProjectVersionChecksum()) {
            DigestItem projectVersion = new DigestItem();
            projectVersion.setType("version");
            projectVersion.setIsText("yes");
            projectVersion.setValue(project.getVersion());
            items.add(projectVersion);

            checksum.update(project.getVersion().getBytes(StandardCharsets.UTF_8));
        }

        DigestItem effectivePomChecksum = DigestUtils.pom(checksum, effectivePom);
        items.add(effectivePomChecksum);
        final boolean compareWithBaseline = config.isBaselineDiffEnabled() && baselineHolder.isPresent();
        if (compareWithBaseline) {
            checkEffectivePomMatch(baselineHolder.get(), effectivePomChecksum);
        }

        boolean sourcesMatched = true;
        for (Path file : inputFiles) {
            DigestItem fileDigest = DigestUtils.file(checksum, baseDirPath, file);
            items.add(fileDigest);
            if (compareWithBaseline) {
                sourcesMatched &= checkItemMatchesBaseline(baselineHolder.get(), fileDigest);
            }
        }
        if (compareWithBaseline) {
            LOGGER.info("Source code: {}", sourcesMatched ? "MATCHED" : "OUT OF DATE");
        }

        boolean dependenciesMatched = true;
        for (Map.Entry<String, String> entry : dependenciesChecksum.entrySet()) {
            DigestItem dependencyDigest = DigestUtils.dependency(checksum, entry.getKey(), entry.getValue());
            items.add(dependencyDigest);
            if (compareWithBaseline) {
                dependenciesMatched &= checkItemMatchesBaseline(baselineHolder.get(), dependencyDigest);
            }
        }

        if (compareWithBaseline) {
            LOGGER.info("Dependencies: {}", dependenciesMatched ? "MATCHED" : "OUT OF DATE");
        }

        boolean pluginDependenciesMatched = true;
        for (Map.Entry<String, String> entry : pluginDependenciesChecksum.entrySet()) {
            DigestItem dependencyDigest = DigestUtils.pluginDependency(checksum, entry.getKey(), entry.getValue());
            items.add(dependencyDigest);
            if (compareWithBaseline) {
                pluginDependenciesMatched &= checkItemMatchesBaseline(baselineHolder.get(), dependencyDigest);
            }
        }

        if (compareWithBaseline) {
            LOGGER.info("Plugin dependencies: {}", pluginDependenciesMatched ? "MATCHED" : "OUT OF DATE");
        }

        final ProjectsInputInfo projectsInputInfoType = new ProjectsInputInfo();
        projectsInputInfoType.setChecksum(checksum.digest());
        projectsInputInfoType.getItems().addAll(items);

        final long t2 = System.currentTimeMillis();

        if (LOGGER.isDebugEnabled()) {
            for (DigestItem item : projectsInputInfoType.getItems()) {
                LOGGER.debug("Hash calculated, item: {}, hash: {}", item.getType(), item.getHash());
            }
        }

        LOGGER.info(
                "Project inputs calculated in {} ms. {} checksum [{}] calculated in {} ms.",
                t1 - t0,
                config.getHashFactory().getAlgorithm(),
                projectsInputInfoType.getChecksum(),
                t2 - t1);
        return projectsInputInfoType;
    }