import javax.annotation.Nullable;

public interface TaskDetails {
    Path getPath();

    @Nullable
    String getDescription();

    String getTypeName();

    static TaskDetails of(Path path, Task task) {
        return of(path, new DslObject(task).getPublicType().getFullyQualifiedName(), task.getDescription());
    }

    static TaskDetails of(Path path, String typeName, @Nullable String description) {

import java.util.stream.Collectors;

/**
 * A configuration-cache friendly view of a {@link Task} that only projects information
 * that is relevant for the {@link Help} task.
 */
@NonNullApi
class TaskDetails {
    final static Comparator<TaskDetails> DEFAULT_COMPARATOR = (o1, o2) -> {
        // tasks in higher-up projects first
        int depthCompare = o1.getProjectDepth() - o2.getProjectDepth();
        if (depthCompare != 0) {

    }

    def "merges the tasks with a given name from each project into a single task"() {
        TaskDetails task1 = taskDetails(':task')
        TaskDetails task2 = taskDetails(':other')
        TaskDetails task3 = taskDetails(':sub:task')
        _ * task1.findTask(_) >> Mock(Task)
        _ * task2.findTask(_) >> Mock(Task)
        _ * task3.findTask(_) >> Mock(Task)

        }
    }

    private Map<String, List<TaskDetails>> groupTasksByType(Collection<TaskDetails> tasks) {
        return tasks.stream().collect(Collectors.groupingBy(TaskDetails::getTaskType, LinkedHashMap::new, Collectors.toList()));
    }

    private void printTaskDescription(StyledTextOutput output, List<TaskDetails> tasks) {
        printTaskAttribute(output, "Description", tasks, TaskDetails::getDescription);
    }

        try {
            Stream<Task> selectedTasks = taskSelector.resolveTaskName(taskPath).getTasks().stream();
            List<TaskDetails> tasks = selectedTasks.map(t -> TaskDetails.from(t, optionReader))
                .sorted(TaskDetails.DEFAULT_COMPARATOR).collect(Collectors.toList());
            return new TaskDetailsModel(taskPath, tasks);
        } catch (TaskSelectionException exception) {

                    }
                }
            }
        }
    }

    private TaskDetails mergedTaskDetails(TaskDetails task) {
        return TaskDetails.of(
            Path.path(task.getPath().getName()),
            task.getTypeName(),
            task.getDescription()
        );
    }

    private boolean isVisible(String group) {
        if (Strings.isNullOrEmpty(group)) {
            return detail;

     */
    public void addTask(TaskDetails task) {
        writeTask(task, "");
    }

    private void writeTask(TaskDetails task, String prefix) {
        getTextOutput().text(prefix);
        maybeWriteTaskNameAndType(task);
        maybeWriteTaskDescription(task);
        getTextOutput().println();
    }

    private void maybeWriteTaskNameAndType(TaskDetails task) {

        this.project = project;
        this.projects = project.getAllprojects();
    }

    public TaskDetails create(final Task task) {
        String path = projects.contains(task.getProject())
            ? project.relativeProjectPath(task.getPath())
            : task.getPath();
        return TaskDetails.of(
            Path.path(path),
            task
        );
    }

import org.gradle.api.tasks.diagnostics.internal.RuleDetails;
import org.gradle.api.tasks.diagnostics.internal.SingleProjectTaskReportModel;
import org.gradle.api.tasks.diagnostics.internal.TaskDetails;
import org.gradle.api.tasks.diagnostics.internal.TaskDetailsFactory;
import org.gradle.api.tasks.diagnostics.internal.TaskReportRenderer;
import org.gradle.api.tasks.options.Option;
import org.gradle.internal.Try;