dev.gradleplugins.runnerkit.logging.OutputScrappingBuildLogVisitor Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of gradle-runner-kit-impl Show documentation

Gradle runner kit implementation.

There is a newer version: 0.0.148

Show newest version

package dev.gradleplugins.runnerkit.logging;

import dev.gradleplugins.runnerkit.*;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;

import static java.util.Collections.unmodifiableMap;
import static java.util.stream.Collectors.toMap;

public final class OutputScrappingBuildLogVisitor implements BuildLogVisitor {
    private final Map discoveredTasks = new LinkedHashMap<>();
    private ActionableTaskCount actionableTaskCount = null;
    private BuildOutcome buildOutcome = null;

    public Optional getActionableTaskCount() {
        return Optional.ofNullable(actionableTaskCount);
    }

    public BuildOutcome getBuildOutcome() {
        return buildOutcome;
    }

    public Map getDiscoveredTasks() {
        return unmodifiableMap(discoveredTasks.entrySet().stream().collect(toMap(Map.Entry::getKey, it -> it.getValue().build(), throwingMerger(), LinkedHashMap::new)));
    }

    public void visitTaskHeader(TaskPath taskPath) {
        discoveredTasks.computeIfAbsent(taskPath, this::newTaskBuilder);
    }

    private BuildTaskBuilder newTaskBuilder(TaskPath taskPath) {
        return BuildTaskBuilder.newBuilder().withPath(taskPath);
    }

    public void visitTaskHeader(TaskPath taskPath, TaskOutcome taskOutcome) {
        discoveredTasks.compute(taskPath, updateOutcome(taskOutcome));
    }

    private static BiFunction updateOutcome(TaskOutcome taskOutcome) {
        return (taskPath, buildTask) -> {
            if (buildTask == null) {
                return BuildTaskBuilder.newBuilder().withPath(taskPath).withOutcome(taskOutcome);
            }
            return buildTask.withOutcome(taskOutcome);
        };
    }

    @Override
    public void visitTaskOutput(TaskPath taskPath, String line) {
        discoveredTasks.compute(taskPath, appendContent(line));
    }

    @Override
    public void visitBuildResult(BuildOutcome buildOutcome) {
        this.buildOutcome = buildOutcome;
    }

    @Override
    public void visitBuildFailure() { /* currently handled by BuildFailures */ }

    @Override
    public void visitActionableTasks(ActionableTaskCount actionableTaskCount) {
        this.actionableTaskCount = actionableTaskCount;
    }

    @Override
    public void visitContentLine(String line) {}

    private static BiFunction appendContent(String line) {
        return (taskPath, buildTask) -> {
            assert buildTask != null;
            return buildTask.appendToOutput(line);
        };
    }

    private static  BinaryOperator throwingMerger() {
        return (u,v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); };
    }
}