)

    val excludes = listOf("**/internal/**")

    private val includePackagePatterns: List<Pattern> by lazy {
        includes.map {
            if (it.endsWith("/**")) {
                Pattern.compile(it.substring(0, it.length - 3).replace("/", "\\.") + "(\\..+)?")
            } else {
                Pattern.compile(it.substring(0, it.length - 2).replace("/", "\\.") + "\\.[^.]+")

                String shortName = zipEntry.name
                if (shortName.contains('/')) {
                    shortName = shortName.substring(shortName.lastIndexOf('/') + 1)
                }
                if (shortName.endsWith('.jar')) {
                    def outputDir = shortName.startsWith('gradle-') ? gradleJars : dependencies
                    def out = new File(outputDir, shortName)
                    Files.copy(zin, out.toPath())

            if (entry.getValue().isDependencyToAll()) {
                usedClasses.add(entry.getKey());
            }
        }
        for (String cls : classHashes.keySet()) {
            if (cls.endsWith(PACKAGE_INFO)) {
                usedClasses.add(cls);
            }
        }
        usedClasses.addAll(other.dependents.keySet());

        Multimap<String, String> dependencies = getForwardDependencyView();

                    super.connect(snk)
                    close()
                }
            })
        }
        killToStop = true

        then:
        succeeds "build" // tests message
        output.endsWith("...\n")

        when:
        file("src/main/java/Thing.java") << "class Thing {}"

        then:
        buildTriggeredAndSucceeded()
    }

        assert iml.contains('1.44')

        def ipr = getFile([:], 'root.ipr').text
        assert ipr.contains('!?*.ruby')
    }


    private containsDir(path, urls) {
        urls.any { it.endsWith(path) }
    }

    public static String inferStatusFromEffectiveVersion(String effectiveVersion) {
        return effectiveVersion != null && effectiveVersion.endsWith("SNAPSHOT") ? "integration" : "release";
    }

    public static String inferStatusFromVersionNumber(String version) {
        return inferStatusFromEffectiveVersion(toEffectiveVersion(version));
    }

        }
        if (version.equals(LATEST_RELEASE)) {
            return RELEASE;
        }
        if (version.startsWith("]")) {
            version = '(' + version.substring(1);
        }
        if (version.endsWith("[")) {
            version = version.substring(0, version.length() - 1) + ')';
        }
        return version;
    }

                }
            }
        }

        return false;
    }

    private static boolean isJarUrl(URL location) {
        return location.getProtocol().equals(FILE_PROTOCOL) && location.getPath().endsWith(JAR_FILE_EXTENSION);
    }

    private static boolean findMarkerFileInJar(File jar) {
        JarFile jarFile = null;

        try {
            jarFile = new JarFile(jar);

        if (!classNames.isEmpty()) {
            return classNames;
        }

        for (String fileExtension : fileExtensions) {
            if (sourceFileRelativePath.endsWith(fileExtension)) {
                return Collections.singleton(StringUtils.removeEnd(sourceFileRelativePath.replace('/', '.'), fileExtension));
            }
        }

        return Collections.emptySet();
    }

tasks.register('filterTextFiles') {
    Directory projectDirectory = layout.projectDirectory
    doLast {
        // tag::filtering-file-collections[]
        FileCollection textFiles = collection.filter { File f ->
            f.name.endsWith(".txt")
        }
        // end::filtering-file-collections[]

        textFiles.collect { projectDirectory.asFile.relativePath(it).toString() }.sort().each { String path ->
            println path
        }