'matching(patternSet)',
            'matching(patternSet).filter { it.file }',
            'matching(patternSet).asFileTree.filter { it.file }',
            'filter { it.path.endsWith "ok" }.asFileTree',
            'filter { it.file }.asFileTree.matching(patternSet)',
        ]
    }

                false
            }
            fileCollection is FilteredFileTree -> {
                when {
                    // Optimize a common case, where fileCollection.asFileTree.matching(emptyPatterns) is used,
                    // e.g. in SourceTask and in CopySpec.
                    // Skip applying the filters to the tree
                    fileCollection.patterns.isEmpty -> {

    components {
        withModule<CodeNarcRule>("org.codenarc:CodeNarc") {
            params(groovyVersion)
        }
    }
}

fun configFile(fileName: String) = resources.text.fromFile(rules.asFileTree.filter { it.name == fileName })

checkstyle {
    toolVersion = "8.12"
    config = configFile("checkstyle.xml")
    val projectDirectory = layout.projectDirectory
    configDirectory = rules.elements.map {

                .replaceAll("[^a-zA-Z0-9\\-]", "_")
                .toLowerCase(Locale.ROOT) + ".2";
    }

    private File unpack(File jdkArchive) {
        final FileTree fileTree = asFileTree(jdkArchive);
        String unpackFolderName = getNameWithoutExtension(jdkArchive);
        final File unpackFolder = temporaryFileProvider.createTemporaryDirectory(unpackFolderName, null, "jdks");

                writeText(readText().replace("\\Q<lastUpdated>\\E\\d+\\Q</lastUpdated>\\E".toRegex(), "<lastUpdated>${Year.now().value}0101000000</lastUpdated>"))
            }
            localRepository.get().asFileTree.matching { include("**/*.module") }.forEach {
                val content = it.readText()
                    .replace("\"buildId\":\\s+\"\\w+\"".toRegex(), "\"buildId\": \"\"")

    doFirst {
        // On daemon crash, read-only cache tests can leave read-only files around.
        // clean now takes care of those files as well
        testFiles.get().asFileTree.matching {
            include("**/read-only-cache/**")
        }.visit { this.file.setWritable(true) }
    }

                            ${server.callFromBuild("zipFileSnapshottingStarted")}
                        }
                        countResolved++
                        it.asFileTree.matching {
                            include "src/**"
                            include "build.gradle"
                        }
                    })
                }

                @TaskAction

docsPath.description = "Resolves to the complete Gradle documentation - automatically adds dependency to the :docs project"

// Gradle API Sources
val gradleApiSources = sourcesPath.incoming.artifactView { lenient(true) }.files.asFileTree.matching {
    include(PublicApi.includes)
    exclude(PublicApi.excludes)
}

// Tasks to generate metadata about the distribution that is required at runtime

            myExt.artifactDir = producer.flatMap { it.output }

            tasks.register("consumer", Consumer) {
               fileNames = myExt.artifactDir.map {
                  it.asFileTree.collect { it.absolutePath }
               }.orElse([ "else" ])
            }
        """

        when:
        run 'consumer'

        then:
        executedAndNotSkipped(":producer", ":consumer")

        expectReindentedValidationMessage()
        buildScript """
            task myTask {
                inputs.file file('input.txt')
                outputs.files(files('build/output.txt').asFileTree).withPropertyName('output')
                doLast {
                    file('build/output.txt').text = new File('input.txt').text
                }
            }
        """.stripIndent()