ProjectComponentIdentifier projectId = module.getProjectId();

        if (projectId != null) {
            return projectId;
        }

        return new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId(module.getGroup(), module.getName()), module.getVersion());
    }

    @Override
    public ProjectComponentSelector createProjectComponentSelector(String projectPath) {

        duplicatePublicationTracker.checkCanPublish(
            projectDisplayName, publication.getName(), DefaultModuleVersionIdentifier.newId(publication.getProjectIdentity()), repositoryLocation, repositoryName);
    }

    public void checkCanPublishToMavenLocal(MavenNormalizedPublication publication) {

    public String getSnapshotVersion() {
        return getVersion().replace(timestamp, "SNAPSHOT");
    }

    public ModuleComponentIdentifier getSnapshotComponent() {
        return DefaultModuleComponentIdentifier.newId(getModuleIdentifier(), getSnapshotVersion());
    }

    public String getTimestampedVersion() {
        return getVersion().replace("SNAPSHOT", timestamp);
    }

    }

    @Override
    ComponentIdResolveResult resolve(VersionSelector allRejects) {
        def result = new DefaultBuildableComponentIdResolveResult()
        result.resolved(projectId, DefaultModuleVersionIdentifier.newId("org", projectId.projectName, VERSION))
        return result
    }

    @Override
    ComponentIdResolveResult resolvePrefer(VersionSelector allRejects) {
        return null
    }

    @Override

import spock.lang.Specification

import static org.gradle.util.Matchers.strictlyEquals

class MavenUniqueSnapshotComponentIdentifierTest extends Specification {
    private ModuleIdentifier moduleIdentifier = DefaultModuleIdentifier.newId("group", "module")

    def "delegates module version to owner"() {
        def id = new MavenUniqueSnapshotComponentIdentifier(moduleIdentifier, version, "timestamp")

        expect:
        id.group == "group"

    val id = identities.getId(reference)
    if (id != null) {
        writeSmallInt(id)
    } else {
        val newId = identities.putInstance(reference)
        writeSmallInt(newId)
        circularReferences.enter(reference)
        try {
            encode(reference)
        } finally {
            circularReferences.leave(reference)
        }
    }

    def 'converts a ModuleComponentIdentifier to a lock notation'() {
        given:
        def converter = new DependencyLockingNotationConverter()
        def module = new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('org', 'foo'), '1.1')

        when:
        def converted = converter.convertToLockNotation(module)

        then:
        converted == 'org:foo:1.1'
    }

        when:
        def componentIdentifier = componentIdentifierFactory.createComponentIdentifier(module)

        then:
        componentIdentifier == new DefaultModuleComponentIdentifier(DefaultModuleIdentifier.newId('some-group', 'some-name'), '1.0')
    }

            String libraryName = GUtil.elvis(libraryComponentSelector.getLibraryName(), "");
            return DefaultModuleVersionSelector.newSelector(DefaultModuleIdentifier.newId(libraryComponentSelector.getProjectPath(), libraryName), "undefined");
        }
        throw new GradleException("Unrecognized component selector: " + selector);
    }

    private AttributeContainer attributes = ImmutableAttributes.EMPTY;

    public AbstractDependencyImpl(String group, String name, String version) {
        this.moduleIdentifier = DefaultModuleIdentifier.newId(group, name);
        this.versionConstraint = new DefaultMutableVersionConstraint(version);
    }

    @Override
    public String getGroup() {
        return moduleIdentifier.getGroup();
    }

    @Override