import javax.annotation.Nullable;
import java.util.Objects;

/**
 * Provides common projections for selected project properties.
 */
public interface ProjectDetails {

    String getDisplayName();

    @Nullable
    String getDescription();

    static ProjectDetails of(Project project) {
        return withDisplayNameAndDescription(project);
    }

    static ProjectNameAndPath withNameAndPath(Project project) {

    @Rule
    public TestNameTestDirectoryProvider tmpDir = TestNameTestDirectoryProvider.newInstance(getClass())
    private ProjectInternal project = TestUtil.create(tmpDir).rootProject()
    private ProjectDetails projectDetails = ProjectDetails.of(project)

    def setup() throws Exception {
        task = TestUtil.createTask(TestReportTask.class, project)
        task.setGenerator(generator)
        task.setRenderer(renderer)

        1 * renderer.setOutput(styledTextOutput)
        0 * renderer.setOutputFile(_)

        then:
        1 * renderer.startProject(projectDetails)

        then:
        1 * projectReportGenerator.execute(project)

        then:
        1 * renderer.completeProject(projectDetails)

        then:
        1 * renderer.complete()
    }

    def 'sets outputFileName on renderer before generation'() {
        setup:

        }

        def projectDetails = Mock(DependencySubstitutionInternal)

        when:
        substitutions.ruleAction.execute(projectDetails)

        then:
        _ * projectDetails.requested >> TestComponentIdentifiers.newSelector(":api")
        1 * projectDetails.useTarget(matchingSubstitute, SELECTED_BY_RULE)
        1 * projectDetails.artifactSelection(Actions.doNothing())
        0 * _

            projectReportHeaderGenerator.execute();
            for (T project : projects) {
                ProjectDetails projectDetails = projectDetailsProvider.apply(project);
                renderer.startProject(projectDetails);
                projectReportGenerator.execute(project);
                renderer.completeProject(projectDetails);
            }
            projectReportFooterGenerator.execute();
            renderer.complete();

    private final Transformer<String, ProjectDetails.ProjectNameAndPath> namingScheme;

    public ProjectsPageRenderer(Transformer<String, ProjectDetails.ProjectNameAndPath> namingScheme) {
        this.namingScheme = namingScheme;
    }

    @Override

        ComponentReportRenderer renderer = new ComponentReportRenderer(getFileResolver(), getBinaryRenderer());
        renderer.setOutput(textOutput);

        ProjectDetails projectDetails = ProjectDetails.of(project);
        renderer.startProject(projectDetails);

        Collection<ComponentSpec> components = new ArrayList<>();
        ComponentSpecContainer componentSpecs = modelElement("components", ComponentSpecContainer.class);

    private ProjectBasedReportModel<T> calculateReportModel() {
        Map<ProjectDetails, T> map = new LinkedHashMap<>();
        for (Project project : getProjects()) {
            map.put(
                ProjectDetails.of(project),
                calculateReportModelFor(project)
            );
        }
        return new ProjectBasedReportModel<>(map);
    }

 * @param <C> the kind of configuration details being projected
 */
public interface ProjectsWithConfigurations<P extends ProjectDetails, C extends ConfigurationDetails> {

    Set<P> getProjects();

    Iterable<C> getConfigurationsFor(P project);

    private static final class BuildEnvironmentReportModel {

        private final ProjectDetails project;
        private final ConfigurationDetails configuration;

        public BuildEnvironmentReportModel(ProjectDetails project, ConfigurationDetails configuration) {
            this.project = project;
            this.configuration = configuration;
        }
    }