import java.io.File;
import java.util.Set;

/**
 * <p>A {@code ProjectDependency} is a {@link Dependency} on another project in the current project hierarchy.</p>
 */
@HasInternalProtocol
@SuppressWarnings("deprecation") // Because of SelfResolvingDependency
public interface ProjectDependency extends ModuleDependency, SelfResolvingDependency {
    /**

    private projectDependency

    def setup() {
        projectDependency = new DefaultProjectDependency(project, null, false, TestFiles.taskDependencyFactory())
        project.version = "1.2"
        project.group = "org.gradle"
    }

    void "provides dependency information"() {
        expect:
        projectDependency.transitive
        projectDependency.name == project.name

    private final ProjectDependency projectDependency;
    private String reason;
    private boolean force;

    public DefaultProjectDependencyConstraint(ProjectDependency projectDependency) {
        this.projectDependency = projectDependency;
    }

    public ProjectDependency getProjectDependency() {
        return projectDependency;
    }

    @Override

        EclipseProjectDependency projectDependency = project.projectDependencies.find { it.path.contains 'sub' }
        EclipseExternalDependency externalDependency = project.classpath.find { it.file.path.contains 'example-lib' }

        then:
        projectDependency.accessRules.size() == 2
        projectDependency.accessRules[0].kind == 0
        projectDependency.accessRules[0].pattern == 'sub-accessibleFilesPattern'

        projectDependency from: 'c', to: ['a', 'b']
        when:
        run ':c:build'

        then:
        jarsBuilt 'a', 'b', 'c'
        depsCopied 'a', []
        depsCopied 'b', []
        depsCopied 'c', ['a', 'b']
    }

    def "project dependency c->b->a"() {

        projectDependency from: 'c', to: ['b']
        projectDependency from: 'b', to: ['a']

        when:

        for (ClasspathEntry entry : entries) {
            if (entry instanceof ProjectDependency) {
                ProjectDependency projectDependency = (ProjectDependency) entry;
                if (!hasTestSourcesAttribute(projectDependency)) {
                    mainSourcePaths.add(projectDependency.getPath());
                }
            }
        }

        return library
    }

    private ProjectDependency createProjectDependency(String path, String publicationPath, Map entryAttributes) {
        def projectDependency = new ProjectDependency(path)
        projectDependency.publication = fileReferenceFactory.fromPath(publicationPath)
        projectDependency.entryAttributes.putAll(entryAttributes)
        return projectDependency
    }

    private InputStream getToXmlReader() {

     * @return a {@link ProjectDependency} for the given path
     *
     * @see org.gradle.api.Project#project(String)
     */
    @Restricted
    default ProjectDependency project(String projectPath) {
        return getDependencyFactory().create(getProject().project(projectPath));
    }

    /**
     * Returns the current project as a {@link ProjectDependency}.
     *

            Set<ProjectDependency> projectDependencies = configuration.getAllDependencies().withType(ProjectDependency.class);
            for (ProjectDependency projectDependency : projectDependencies) {
                Path dependencyIdentityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
                if (dependencyIdentityPath.equals(identityPath)) {

        return minimalExternalModuleDependencyNotationParser;
    }

    public NotationParser<ProjectDependency, ? extends DependencyConstraint> getProjectDependencyNotationParser() {
        return projectDependencyNotationParser;
    }

    private static class ProjectDependencyNotationConverter extends TypedNotationConverter<ProjectDependency, DependencyConstraint> {
        private final Instantiator instantiator;