lifecycle: gradle.allprojects ':'
lifecycle: gradle.allprojects ':a'
lifecycle: gradle.beforeProject ':'
lifecycle: gradle.lifecycle.beforeProject ':'
lifecycle: <evaluating> ':'
lifecycle: <root>.subprojects ':a'
lifecycle: gradle.afterProject ':'
lifecycle: gradle.lifecycle.afterProject ':'
lifecycle: gradle.beforeProject ':a'
lifecycle: gradle.lifecycle.beforeProject ':a'
lifecycle: <evaluating> project ':a'
lifecycle: gradle.afterProject ':a'

    }

    @Override
    public void beforeProject(Action<? super Project> action) {
        // Preserve behavior when Isolated Projects is not enabled:
        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects
        //   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).

            rootProject.name = 'root'
            include 'sub'

            def log = []
            gradle.lifecycle.beforeProject {
                log << "1: before $name $version"
                version = 'from action'
            }
            gradle.lifecycle.beforeProject {
                log << "2: before $name $version"
            }
            gradle.lifecycle.afterProject {

 */
@ServiceScope(Scope.Build.class)
public interface IsolatedProjectEvaluationListenerProvider {

    /**
     * @see org.gradle.api.invocation.GradleLifecycle#beforeProject(IsolatedAction)
     */
    void beforeProject(IsolatedAction<? super Project> action);

    /**
     * @see org.gradle.api.invocation.GradleLifecycle#afterProject(IsolatedAction)
     */

) : IsolatedProjectEvaluationListenerProvider {

    private
    val beforeProject = mutableListOf<IsolatedProjectAction>()

    private
    val afterProject = mutableListOf<IsolatedProjectAction>()

    override fun beforeProject(action: IsolatedProjectAction) {
        // TODO:isolated encode Application instances as part of the Environment to avoid waste
        beforeProject.add(withUserCodeApplicationContext(action))
    }

    def "can use lifecycle service to apply logic to all projects"() {
        settingsFile << """
            include 'foo', 'bar'
            includeBuild 'included'

            $beforeProject {
                def projectPath = it.buildTreePath
                println "Configuring '\$projectPath'"
                it.tasks.register("myTask") {
                }
            }
        """

    }

    @Override
    public void beforeProject(Closure closure) {
        registerProjectEvaluationListener("Gradle.beforeProject", "beforeEvaluate", "beforeProject(Closure)", closure);
    }

    @Override
    public void beforeProject(Action<? super Project> action) {
        registerProjectEvaluationListener("Gradle.beforeProject", "beforeEvaluate", "beforeProject(Action)", action);
    }

    @Override

        given:
        def addGradleListeners = { String source ->
            """
            gradle.beforeProject({
                println "gradle.beforeProject(Action) from $source"
            } as Action)
            gradle.beforeProject {
                println "gradle.beforeProject(Closure) from $source"
            }
            gradle.addListener(new ProjectEvaluationListener() {

            def configureGradleLifecycle() {
                SomeBean bean = new SomeBean()
                ${type} value = ${reference}
                bean.value = ${reference}
                gradle.lifecycle.beforeProject {
                    println "this.value = " + value
                    println "bean.value = " + bean.value
                }
            }

            configureGradleLifecycle()
        """

 * limitations under the License.
 */

import gradlebuild.basics.BuildEnvironmentExtension
import gradlebuild.basics.BuildEnvironmentService

with(layout.rootDirectory) {
    gradle.lifecycle.beforeProject {
        val service = gradle.sharedServices.registerIfAbsent("buildEnvironmentService", BuildEnvironmentService::class) {
            parameters.rootProjectDir = this@with
        }