* limitations under the License.
 */

package org.gradle.groovy.scripts.internal;

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.service.scopes.EventScope;
import org.gradle.internal.service.scopes.Scope;

@EventScope(Scope.Build.class)
public interface ScriptSourceListener {

    /**
     * Called when remote script was applied.
     */
    void scriptSourceObserved(ScriptSource scriptSource);

== Step 1. Gradle scripts

Build scripts and setting files are code.
They are written in Kotlin or Groovy.

You use the link:{kotlinDslPath}[Kotlin DSL], link:{groovyDslPath}[Groovy DSL] and link:{javadocPath}[Gradle APIs] to write the scripts.

The methods that can be used within a Gradle script primarily include:

project script behaves as if the body of the script is enclosed within a `with(project) { ... }` block, a settings script as if the body of the script is enclosed within a `with(settings) { ... }` block and an init script as if the body of the script is enclosed within a `with(gradle) { ... }` block. This implies the corresponding model object is also available as a property in the body of the script, the `project` property for project scripts, the `settings` property for settings scripts and the...

        failure.assertThatCause(containsString("Only Settings scripts can contain a pluginManagement {} block."))
        includesLinkToUserguide()

        and:
        verifyAll(receivedProblem) {
            fqid == 'compilation:groovy-dsl:compilation-failed'
            contextualLabel == "Could not compile initialization script '${initScript.absolutePath}'."
        }
    }

                case SHARED_SCRIPTPLUGIN:
                    // share the same script file by applying it as a script plugin in the subproject's build file
                    subprojectNames.each { subprojectName ->
                        file("${subprojectName}/build.gradle") << """
                            apply from: new File(rootDir, 'script.gradle')
                        """.stripIndent()
                    }

 * limitations under the License.
 */

package org.gradle.jvm.application.scripts;

import java.io.Writer;

/**
 * Generates a script to start a JVM application.
 *
 * @see TemplateBasedScriptGenerator
 */
public interface ScriptGenerator {

    /**
     * Generate the script.
     * <p>
     * Implementations should not close the given writer.

[[sec:settings_file_script]]
== Settings script

The settings file is a script.
It is either a `settings.gradle` file written in Groovy or a `settings.gradle.kts` file in Kotlin.

The link:{groovyDslPath}/index.html[Groovy DSL^] and the link:{kotlinDslPath}/index.html[Kotlin DSL^] are the only accepted languages for Gradle scripts.

The settings file is typically found in the root directory of the project.

		})
}

// Stop returns a sentinel error that causes script execution to halt
// and s.Execute to return with a nil error.
func Stop() Cmd {
	return Command(
		CmdUsage{
			Summary: "stop execution of the script",
			Args:    "[msg]",
			Detail: []string{
				"The message is written to the script log, but no error is reported from the script engine.",
			},
		},

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.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)
    }