plugins {
    id("gradlebuild.platform")
}

description = "Defines which JARs go into the core part (libs/*.jar) of a Gradle distribution (NOT libs/plugins/*.jar)."

javaPlatform.allowDependencies()

dependencies {
    runtime(project(":installation-beacon"))
    runtime(project(":api-metadata"))
    runtime(project(":daemon-server")) {
        because("This is the Gradle daemon implementation, which transitively depends on all other core projects.")

     * expected directory layout.
     *
     * The expected directory layout for JARs of a distribution looks as such:
     *
     * dist-root
     * |_ lib
     * |_ plugins
     *
     * @param codeSource Code source of JAR file
     * @return Distribution root directory

                @Test void ok() { new Thing() }
            }
        """

        and:
        def expectedTasks = [
            ":compileJava", ":compileGroovy", ":processResources", ":classes", ":jar", ":assemble",
            ":compileTestJava", ":compileTestGroovy", ":processTestResources", ":testClasses", ":test", ":check",
            ":build"
        ]
        def classFile = file("build/classes/groovy/main/Thing.class")

            ":classes",
            ":jar",
            ":assemble"
        )
        fixture.assertStateStored()

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(
            ":processResources",
            ":compileJava",
            ":classes",
            ":jar",
            ":assemble"
        )

        runtime.artifacts.name.name == ["runtime.jar"]
        runtime.excludes.empty
        def defaultConfig = immutable.getConfiguration("default")
        defaultConfig.hierarchy as List == ["default", "runtime"]
        defaultConfig.transitive
        defaultConfig.visible
        defaultConfig.artifacts.name.name == ["api.jar", "runtime.jar"]
        defaultConfig.excludes.empty

        and:

    def registry = new ClientSidePayloadClassLoaderFactory(Mock(PayloadClassLoaderFactory))

    def "creates ClassLoader for classpath"() {
        def url1 = new URL("http://localhost/file1.jar")
        def url2 = new URL("http://localhost/file2.jar")

        when:
        def cl = registry.getClassLoaderFor(new VisitableURLClassLoader.Spec("test", [url1, url2]), [null])

        then:
        cl instanceof VisitableURLClassLoader

        assertThat(
            classPath.collect { it.name } as List<String>,
            hasItems(
                matching("gradle-kotlin-dsl-$version\\.jar"),
                matching("gradle-api-$version\\.jar"),
                matching("gradle-kotlin-dsl-extensions-$version\\.jar")
            )
        )
    }

    protected void assertClassPathFor(
        File buildScript,
        Set<? extends File> includes,

        prepareToExecute()
        buildFile << buildScript
        buildFile << """
            jar {
                archiveFileName = "$testFile.name"
                destinationDirectory = file("${TextUtil.escapeString(testFile.parentFile.absolutePath)}")
            }
        """
        executer.inDirectory(projectDir).withTasks("jar").run()
    }

        then:
        projectA.classpath.collect { it.file.name } as Set == [ 'commons-lang3-3.9.jar' ] as Set
        projectA.projectDependencies.collect { it.path } as Set == [ 'b' ] as Set
        projectB.classpath.collect { it.file.name } as Set == [ 'commons-lang3-3.9.jar', 'commons-io-1.4.jar' ] as Set
        projectB.projectDependencies.collect { it.path } as Set == [ 'c', 'd' ] as Set
        projectC.classpath.empty

	<modelVersion>4.0.0</modelVersion>
	<artifactId>fess-crawler-lasta</artifactId>
	<packaging>jar</packaging>
	<name>Fess Crawler for LastaFlute</name>
	<description>This is LastaFlute support.</description>
	<parent>
		<groupId>org.codelibs.fess</groupId>
		<artifactId>fess-crawler-parent</artifactId>