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 fun beforeSettings(action: Action<in Settings>) =
        delegate.beforeSettings(action)

    override fun beforeProject(closure: Closure<Any>) =
        delegate.beforeProject(closure)

    override fun beforeProject(action: Action<in Project>) =
        delegate.beforeProject(action)

    override fun afterProject(closure: Closure<Any>) =
        delegate.afterProject(closure)

                    testContainer.create("projectsLoaded")
                }
            }
        """
        buildFile << """
            gradle.beforeProject {
                if (it.name == 'nested') {
                    testContainer.create("beforeProject")
                }
            }

            gradle.afterProject {
                if (it.name == 'nested') {

 * 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
        }

                badReference = ${reference}
                bean.badReference = ${reference}
                beanWithSameType.badReference = ${reference}

                gradle.lifecycle.beforeProject {
                    println "this.reference = " + badReference?.toString()
                    println "bean.reference = " + bean.badReference?.toString()