import org.gradle.jvm.application.scripts.JavaAppStartScriptGenerationDetails
import org.gradle.util.internal.TextUtil
import org.gradle.util.internal.WrapUtil
import spock.lang.Specification

class UnixStartScriptGeneratorTest extends Specification {

    UnixStartScriptGenerator generator = new UnixStartScriptGenerator()

    def "classpath for unix script uses slashes as path separator"() {
        given:

import org.gradle.plugin.use.PluginDependenciesSpec
import kotlin.script.experimental.annotations.KotlinScript
import kotlin.script.experimental.api.baseClass
import kotlin.script.experimental.api.filePathPattern
import kotlin.script.experimental.api.implicitReceivers
import kotlin.script.templates.ScriptTemplateDefinition


private

import org.gradle.configuration.ScriptPlugin
import org.gradle.groovy.scripts.ScriptSource


internal
class DeclarativeDslPlugin(
    private val scriptSource: ScriptSource,
    private val script: (Any) -> Unit
) : ScriptPlugin {

    override fun getSource() =
        scriptSource

    override fun apply(target: Any) {
        script(target)
    }

The choice between script, precompiled script, or binary plugins depends on your specific requirements and preferences.

*Script Plugins* are simple and easy to write.
They are written in Kotlin DSL or Groovy DSL.
They are suitable for small, one-off tasks or for quick experimentation.
However, they can become hard to maintain as the build script grows in size and complexity.

[Fess Site Search](https://github.com/codelibs/fess-site-search) provides [scripts](https://fss-generator.codelibs.org/docs/manual) (see below) to help you migrate from GSS/CSE.
Using the, you can replace existing GSS/CSE JavaScript codes with:

```
<script>
  (function() {
    var fess = document.createElement('script');
    fess.type = 'text/javascript';
    fess.async = true;

├── shared
│   ├── src
│   │   └──...
│   └── build.gradle
└── settings.gradle
----
<1> Create the `MyCustomTask` task.
<2> A shared build script.
<3> Uses the `MyCustomTask` task and shared build script.
=====

In the `buildSrc`, the build script `shared.gradle(.kts)` is created.
It contains dependencies and other build information that is common to multiple subprojects:

[.multi-language-sample]
=====

    }

    @Test
    fun `can extract plugins block from script with only plugins`() {

        extractPluginsFrom(
            scriptPlugin(
                "plugins-only.gradle.kts",
                """
                // this comment will be removed
                plugins {
                    java
                }
                // and so will the rest of the script
                """
            )
        )

        when:
        succeeds(":myTask")
        then:
        executedAndNotSkipped(":myTask")

        when:
        file(buildFileName) << """
            println("Hello from Build Script")
        """
        then:
        // TODO: Script compilation happens to early to be detected as an input.
        //   That is why the change is not yet picked up.
        noBuildTriggered()

        where:

        padding: .5em;
    }

    table th,
    table td {
        padding: .5em;
        border: 1px solid lightgrey;
    }
</style>
{% endblock %}

{% block scripts %}
<script src="static/tailwind/tailwind.css"></script>
{% endblock %}

{% block content %}
<div class="mx-auto px-4 sm:px-6 lg:px-8">
    <div class="flex flex-col space-y-5 py-32 mx-auto max-w-7xl">

// limitations under the License.

[[implemention_precompiled_plugins]]
= Implementing Pre-compiled Script Plugins

A *precompiled script plugin* is typically a Kotlin script that has been compiled and distributed as Java class files packaged in a library.
These scripts are intended to be consumed as binary Gradle plugins and are recommended for use as convention plugins.