# its own file.

on:
  - pr_created
  - commit
  - comment_added

automations:

  javadoc_on_new_files:
    # Triggered for new Java files that lack Javadoc content.
    if:

      - {{ ('javadoc_on_new_files' | isEnabledAutomation(pr)) }}
      - {{ is.java and is.new }}
      - {{ source.diff.files | matchDiffLines(regex=r/\/*\*([\s\S]*?)\//) | nope }}
    run:
      - action: add-label@v1

const enabled = new Map();

// Require Opt-In/User Request/Community PR
enabled.set('includes_todos', ['community', 'tresat']);
enabled.set('javadoc_on_new_files', ['community', 'tresat']);
enabled.set('lacks_tests', ['community', 'tresat']);
enabled.set('summary_table_owners', ['tresat']);
enabled.set('summary_table_platforms', ['community', 'tresat']);

// Require Opt-In/User Request
enabled.set('code_experts', []);

// Always run

    final ClassMetaData owner = Mock()
    final MethodMetaData method = new MethodMetaData('method', owner)

    def formatsSignature() {
        method.returnType = new TypeMetaData('ReturnType')
        method.addParameter('param1', new TypeMetaData('ParamType'))
        method.addParameter('param2', new TypeMetaData('ParamType2'))

        expect:

        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
        throw new GradleException("Documentation assertion failed: found invalid internal links. See " + new org.gradle.internal.logging.ConsoleRenderer().asClickableFileUrl(reportFile));
    }

    private void writeHeader(PrintWriter fw) {
        fw.println("# Valid links are:");
        fw.println("# * Inside the same file: <<(#)section-name(,text)>>");

        if (!table) {
            throw new RuntimeException("Section '$title' does not contain a <table> element.")
        }
        if (!table.thead[0]) {
            throw new RuntimeException("Table '$title' does not contain a <thead> element.")
        }
        if (!table.thead[0].tr[0]) {
            throw new RuntimeException("Table '$title' does not contain a <thead>/<tr> element.")
        }

    }

    public void pushText(String rawCommentText) {
        if (rawCommentText == null) {
            return;
        }

        StringBuilder builder = new StringBuilder();
        try {
            BufferedReader reader = new BufferedReader(new StringReader(rawCommentText));
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.replaceFirst("\\s*\\* ?", "");

        try (PrintWriter mappingFileWriter = new PrintWriter(new FileWriter(getMappingDestFile().getAsFile().get()))) {
            for (Map.Entry<String, Collection<String>> entry : simpleNames.asMap().entrySet()) {
                if (entry.getValue().size() > 1) {
                    StringBuilder warning = new StringBuilder();

    private final MethodTableRenderer methodTableRenderer = new MethodTableRenderer();
    private final ExtensionMethodsSummaryRenderer extensionMethodsSummaryRenderer;
    private final MethodDetailRenderer methodDetailRenderer;

    public MethodsRenderer(LinkRenderer linkRenderer, GenerationListener listener) {
        methodDetailRenderer = new MethodDetailRenderer(linkRenderer, listener);

import spock.lang.Specification

class ParameterMetaDataTest extends Specification {
    def "formats signature"() {
        MethodMetaData method = Mock()
        def parameter = new ParameterMetaData('param')
        def type = new TypeMetaData('org.gradle.SomeType')
        parameter.type = type

        expect:
        parameter.signature == 'org.gradle.SomeType param'
    }

    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();
    private final Deque<ClassMetaData> classStack = new LinkedList<ClassMetaData>();
    private String packageName;

    @Override
    public void visit(CompilationUnit compilationUnit, ClassMetaDataRepository<ClassMetaData> repository) {