# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# A single script that runs a predefined set of update-* scripts, as they often go together.
set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
source "${KUBE_ROOT}/hack/lib/init.sh"

SILENT=${SILENT:-true}

[[sec:customizing_start_script_generation]]
=== Customizing start script generation

The application plugin can generate Unix (suitable for Linux, macOS etc.) and Windows start scripts out of the box.
The start scripts launch a JVM with the specified settings defined as part of the original build and runtime environment (e.g. `JAVA_OPTS` env var).

            writer.println("            BasicScript script = precompiledScriptClass.getDeclaredConstructor().newInstance();");
            writer.println("            script.setScriptSource(scriptSource(precompiledScriptClass));");
            writer.println("            script.init(target, target.getServices());");
            writer.println("            script.run();");
            writer.println("        } catch (Exception e) {");

import org.gradle.integtests.tooling.fixture.ToolingApiSpecification
import org.gradle.tooling.ProjectConnection

class BuildProgressCrossVersionSpec extends ToolingApiSpecification {
    def "generates init script operation when there are init scripts"() {
        file("init.gradle") << "println 'init'"

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

<4> Does the same as the previous line but allows the property to have a null value

This approach works for all Gradle scripts: project build scripts, script plugins, settings scripts and initialization scripts.

You can also access extra properties on a root project from a subproject using the following syntax:

.my-sub-project/build.gradle.kts
[source,kotlin]
----

## Level 2: Container diagram

When used for the compilation of scripts of a Gradle build, the Kotlin DSL Provider compiles scripts using an embedded Kotlin compiler.

When used for the compilation of Kotlin source sets, e.g. in `buildSrc`, the `kotlin-dsl` plugin provide Kotlin DSL features to source sets and compiles Kotlin code using the Kotlin Gradle Plugin.

    def "init script file is a dotfile"() {
        def initScript = file('.empty')
        initScript << 'println "greetings from empty init script"'
        executer.withArguments('--init-script', initScript.absolutePath)

        when:
        run()

        then:
        output.contains("greetings from empty init script")
    }

    private def createExternalJar() {

    }

    def "scripts can be disabled"() {
        assumeTrue(supportsScriptsInGroovydoc())
        when:
        buildFile << "groovydoc { processScripts = false }"
        run "groovydoc"

        then:
        def doc = file('build/docs/groovydoc/DefaultPackage/Script.html')
        !doc.exists()
    }

    def "main method can be disabled for scripts"() {
        assumeTrue(supportsScriptsInGroovydoc())

        lock.lock();
        try {
            scripts.clear();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void childScopeCreated(ClassLoaderScopeId parentId, ClassLoaderScopeId childId, @javax.annotation.Nullable ClassLoaderScopeOrigin origin) {
        if (origin instanceof ClassLoaderScopeOrigin.Script) {
            ClassLoaderScopeOrigin.Script scriptOrigin = (ClassLoaderScopeOrigin.Script) origin;

  <configuration default="false" name="run IR test in node.js" type="js.build_tools.npm">
    <package-json value="$PROJECT_DIR$/js/js.translator/testData/package.json" />
    <command value="run" />
    <scripts>
      <script value="runIrTestInNode" />
    </scripts>
    <arguments value="$FilePath$" />
    <node-interpreter value="project" />
    <envs />
    <method v="2" />
  </configuration>