/**
     * A working directory to be used to stage documentation as its generated.
     * All of the sections of the documentation have working directories off of this one.
     */
    public abstract DirectoryProperty getStagingRoot();

    /**
     * The final location to place all rendered documentation.
     */
    public abstract DirectoryProperty getDocumentationRenderedRoot();

    /**

 *
 * Doing it correctly would require running a Gradle build with the full
 * distribution and extracting the generated api jar from its Gradle user home,
 * slowing down building documentation.
 *
 * All this would be so much simpler if the Kotlin extensions to the Gradle API
 * were generated at build time instead.
 *
 * This is a first step to get the doc to be complete and will be revisited.
 */
@CacheableTask

            attributes.put("gradleVersion", project.getVersion().toString());
            attributes.put("snippetsPath", "snippets");
            // Make sure the 'raw' location of the samples is available in all AsciidoctorTasks to access files with expected outputs in the 'tests' folder for inclusion in READMEs
            attributes.put("samplesPath", extension.getUserManual().getStagingRoot().dir("raw/samples").get().getAsFile());

    private void checkOutputContains(MethodCallExpression call) {
        ASTNode receiver = call.getReceiver();
        if (receiver instanceof PropertyExpression) {
            if (((PropertyExpression) receiver).getPropertyAsString().equals("output")) {
                Expression objectExpr = ((PropertyExpression) receiver).getObjectExpression();
                checkIndirectOutputContains(objectExpr, call);
            }
        }
    }

        classes.put(fullyQualifiedClassName, metaData);
    }

    @Override
    public void each(Closure cl) {
        for (Map.Entry<String, T> entry : classes.entrySet()) {
            cl.call(new Object[]{entry.getKey(), entry.getValue()});
        }
    }

    public void each(Action<? super T> action) {
        for (T t : classes.values()) {
            action.execute(t);
        }
    }

public abstract class ReleaseNotes {
    /**
     * The source markdown file for the release notes.
     */
    public abstract RegularFileProperty getMarkdownFile();

    /**
     * The base CSS file used by all documentation.
     */
    public abstract RegularFileProperty getBaseCssFile();

    /**
     * The release notes specific CSS file
     */
    public abstract RegularFileProperty getReleaseNotesCssFile();

            }
        }
    }

    private void addAnchorsForHeadings(Document document) {
        // add anchors for all of the headings
        for (Element heading : document.body().select("h2,h3,h4")) {
            String anchorName = heading.text().toLowerCase().replaceAll(" ", "-");
            heading.attr("id", anchorName);
        }

            task.getPort().convention(webserverPort);

            task.dependsOn(extension.getRenderedDocumentation());
        });

        tasks.register("docs", task -> {
            task.setDescription("Generates all documentation");
            task.setGroup("documentation");
            task.dependsOn(extension.getRenderedDocumentation());
        });
    }

        TaskProvider<Javadoc> javadocAll = tasks.register("javadocAll", Javadoc.class, task -> {
            task.setGroup("documentation");
            task.setDescription("Generate Javadocs for all API classes");

            task.setTitle("Gradle API " + version);

            Javadocs javadocs = extension.getJavadocs();

            // TODO: This should be part of Javadoc task

        try (PrintWriter fw = new PrintWriter(new FileWriter(reportFile))) {
            writeHeader(fw);
            if (errors.isEmpty()) {
                fw.println("All clear!");
                return;
            }
            for (Map.Entry<File, List<Error>> e : errors.entrySet()) {
                File file = e.getKey();
                List<Error> errorsForFile = e.getValue();