ProjectState stateFor(ProjectComponentIdentifier identifier) throws IllegalArgumentException;

    /**
     * Locates the state object that owns the project with the identity path.
     */
    ProjectState stateFor(Path identityPath) throws IllegalArgumentException;

    /**
     * Locates the state objects for all projects of the given build.
     */

                    ProjectDependency projectDependency = (ProjectDependency) dependency;
                    Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
                    SwiftPmTarget identifier = publicationResolver.resolveComponent(SwiftPmTarget.class, identityPath);
                    target.getRequiredTargets().add(identifier.getTargetName());

                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {
                                    projects.addAll(b.projects.allProjects.collect { p -> p.identityPath.path })
                                }
                            }
                            println "projects = " + projects

        sources.asSequence().mapNotNull { addSource(it) }

    private
    fun isolatedClassLoaderFor(classpath: Set<File>) =
        classLoaderFactory.createIsolatedClassLoader(identityPath.path, DefaultClassPath.of(classpath)) as URLClassLoader

        addBuilderRegisteringPluginImplementation(childBuildName, "MyModelBuilder", """
            def model = project.extensions.create("myExtension", MyExtension)
            model.message = "It works from project \${project.identityPath}"
        """)
    }

    void withParameterizedSomeToolingModelBuilderPluginInChildBuild(String childBuildName, String builderContent = "") {
        addPluginBuildScript(childBuildName)

        public ScriptScopedContext(DomainObjectContext delegate) {
            this.delegate = delegate;
        }

        @Override
        public Path identityPath(String name) {
            return delegate.identityPath(name);
        }

        @Override
        public Path projectPath(String name) {
            return delegate.projectPath(name);
        }

        @Override

            services.stop()
        }
        return result
    }

    BuildServices build(TreeServices services, BuildIdentifier identifier) {
        def identityPath = Stub(Path)
        def gradle = Stub(GradleInternal) {
            getIdentityPath() >> identityPath
        }
        return new BuildServices(services, identifier, gradle)
    }

    TaskInternal task(BuildServices services, Node dependsOn) {

                }

                @TaskAction def collect() {
                    def gradle = services.get(Gradle)
                    def scopeIds = [
                        "\${gradle.identityPath}": [
                            buildInvocation: services.get(${BuildInvocationScopeId.name}).id.asString(),
                            workspace: services.get(${WorkspaceScopeId.name}).id.asString(),

        and:
        canRunFromCache(buildA, 'help')
    }

    def "included root build is only configured one time"() {
        given:
        buildA.buildFile << """
            println("Configuring \$identityPath")
        """
        buildB.settingsFile << "includeBuild '../buildA'"

        when:
        execute(buildA, 'help')

        then:
        output.count("Configuring :") == 1

    def "can specify target project"() {
        def projectState = Mock(ProjectState)
        projectState.componentIdentifier >> Stub(ProjectComponentIdentifier)
        def project = Mock(ProjectInternal)
        project.identityPath >> Path.path(":id:path")
        project.projectPath >> Path.path(":bar")
        project.name >> "bar"
        project.owner >> projectState

        when:
        details.useTarget(project)