@Override
    protected String getConfiguredModule() {
        return "idea.module"
    }

    @Override
    protected String projectName(String path) {
        File iml = file(path).listFiles().find { it.name.endsWith("iml") }
        assert iml != null
        return iml.name - ".iml"
    }

    @Override
    String[] getGenerationTaskNames(String projectPath) {
        def taskNames = []
        if (projectPath == ":") {

    }

    def "chained lookup of tasks.withType.matching"() {
        buildFile """
            tasks.withType(Copy).matching({ it.name.endsWith("foo") }).all { task ->
                assert task.path in [':foo']
            }

            tasks.register("foo", Copy)
            tasks.register("bar", Copy)
            tasks.register("foobar", Delete)

        fun collectPackages(files: Iterable<Path>): Trie {
            val builder = Trie.Builder()
            for (file in files) {
                if (Files.exists(file)) {
                    if (file.fileName.toString().endsWith(".jar")) {
                        processJarFile(file, builder)
                    } else {
                        processDirectory(file, builder)
                    }
                }
            }

        final Set<String> excludedPrefixes = new HashSet<>();
        final Set<String> excludedPackages = new HashSet<>();
        for (String excludePattern : excludedPackagePatterns) {
            if (excludePattern.endsWith(".**")) {
                String baseName = excludePattern.substring(0, excludePattern.length() - 3);
                excludedPrefixes.add(baseName + '.');
                excludedPackages.add(baseName);
            } else {

abstract class AbstractGroovySourceFileMutator extends AbstractFileChangeMutator {
    AbstractGroovySourceFileMutator(File sourceFile) {
        super(sourceFile)
        if (!sourceFile.getName().endsWith(".groovy")) {
            throw new IllegalArgumentException("Can only modify Groovy source files")
        }
    }

    @Override
    protected void applyChangeTo(BuildContext context, StringBuilder text) {

            url = uri(if (project.hasProperty("release")) releasesRepoUrl else snapshotsRepoUrl)
// end::repo-url-from-project-property[]
// tag::repo-url-from-variable[]
            url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
// tag::repo-url-from-project-property[]
        }
    }
}
// end::repo-url-from-project-property[]

plugins {
    java
    `maven-publish`
    signing
}

group = "gradle"

// tag::conditional-signing[]
version = "1.0-SNAPSHOT"
extra["isReleaseVersion"] = !version.toString().endsWith("SNAPSHOT")

// end::conditional-signing[]
publishing {
    publications {
        create<MavenPublication>("main") {
            from(components["java"])
        }
    }
    repositories {
        maven {
            name = "localRepo"

     * @param file the file
     * @param extension candidate extension including leading dot
     * @return true if {@code file.getPath().endsWith(extension)}
     */
    public static boolean hasExtension(File file, String extension) {
        return file.getPath().endsWith(extension);
    }

    /**
     * Checks if the given file path ends with the given extension (ignoring case).
     * @param fileName the file name

    }

    public SingleIncludePatternFileTree(File baseDir, String includePattern, Spec<FileTreeElement> excludeSpec) {
        this.baseDir = baseDir;
        if (includePattern.endsWith("/") || includePattern.endsWith("\\")) {
            includePattern += "**";
        }
        this.includePattern = includePattern;
        this.patternSegments = Arrays.asList(includePattern.split("[/\\\\]"));

private
val File.isClassPathArchive
    get() = extension.run { equals("jar", ignoreCase = true) || equals("zip", ignoreCase = true) }


private
val String.isClassFilePath
    get() = endsWith(classFileExtension)
        && !endsWith("package-info$classFileExtension")
        && !matches(compilerGeneratedClassFilePath)


private
const val classFileExtension = ".class"


private