return NotationParserBuilder.toType(ProjectDependency.class)
                .converter(new ProjectDependencyMapNotationConverter(projectFinder, factory)).toComposite().parseNotation(map);
    }

    static class ProjectDependencyMapNotationConverter extends MapNotationConverter<ProjectDependency> {

        private final ProjectFinder projectFinder;

    public boolean maybeAdd(Map<String, String> args) {
        if (addedRules == null) {
            addedRules = new HashSet<ExcludeRule>();
        }
        return addedRules.add(ExcludeRuleNotationConverter.parser().parseNotation(args));
    }

    @Override
    public Set<ExcludeRule> getRules() {
        return addedRules == null ? Collections.<ExcludeRule>emptySet() : addedRules;
    }

        for (NativeBinaryRequirementResolveResult resolution : nativeBinaryResolveResult.getPendingResolutions()) {
            NativeLibraryRequirement requirement = parser.parseNotation(resolution.getInput());
            if (requirement.getProjectPath() == null || requirement.getProjectPath().isEmpty()) {

    }

    @Override
    public Set<ModuleVersionSelector> getForcedModules() {
        if (parsedForcedModules == null) {
            parsedForcedModules = FORCED_MODULES_PARSER.parseNotation(forcedModules);
        }
        return Collections.unmodifiableSet(parsedForcedModules);
    }

    @Override
    public ResolutionStrategy failOnVersionConflict() {

        this.notationParser = notationParser;
        this.spec = spec;
        spec.setUrl(url);
    }

    @Override
    public void producesModule(String module) {
        modules.add(notationParser.parseNotation(module));
    }

    @Override
    public String getRootDir() {
        return spec.getRootDir();
    }

    @Override
    public void setRootDir(String rootDir) {
        spec.setRootDir(rootDir);

    }

    private static class NoDescriptionValuesJustReturningParser implements NotationParser<CharSequence, String> {
        @Override
        public String parseNotation(CharSequence notation) {
            return notation.toString();
        }

        @Override
        public void describe(DiagnosticsVisitor visitor) {

            targetPluginRequest.getScriptDisplayName(),
            targetPluginRequest.getLineNumber(),
            targetPluginRequest.getVersion(),
            USE_MODULE_NOTATION_PARSER.parseNotation(notation),
            targetPluginRequest,
            targetPluginRequest.getAlternativeCoordinates().orElse(null)
        );
    }

    @Override
    public void useVersion(String version) {

                    context.add(ivyArtifact);
                }
            }
        );
    }

    @Override
    public IvyArtifact artifact(Object source) {
        IvyArtifact artifact = ivyArtifactParser.parseNotation(source);
        add(artifact);
        return artifact;
    }

    @Override
    public IvyArtifact artifact(Object source, Action<? super IvyArtifact> config) {
        IvyArtifact artifact = artifact(source);

        metadataRuleContainer.addClassRule(new SpecConfigurableRule(DefaultConfigurableRule.of(TestComponentMetadataRule), new DefaultComponentMetadataHandler.ModuleVersionIdentifierSpec(moduleIdentifierNotationParser.parseNotation(notation))))
    }

    private SpecConfigurableRule addRuleForModuleWithParams(String notation, Object... params) {

    def spec = Stub(GitVersionControlSpec)
    def repository = new DefaultVersionControlRepository(uri, notationParser, spec)
    def mapping = Mock(VcsMapping)

    def setup() {
        _ * notationParser.parseNotation(_) >> { String s -> def v = s.split(':'); return DefaultModuleIdentifier.newId(v[0], v[1])}
    }

    def "repository definition does nothing by default"() {
        when: