ComponentSelector selector = dependencyMetadata.getSelector();
        if (selector instanceof ModuleComponentSelector) {
            StringBuilder sb = new StringBuilder("wants '" + state.getRequested() + "' with attribute " + attribute.getName() + " = ");
            sb.append(selector.getAttributes().getAttribute(attribute));
            return sb.toString();
        } else {

     * </ul>
     * @return the requested component
     */
    ComponentSelector getRequested();

    /**
     * Returns the origin of the dependency.
     *
     * @return the origin of the dependency
     */
    ResolvedComponentResult getFrom();

    /**

            newSelector(mid("org", "module:with:colon"), "3.0"),
            newSelector(mid("org:with:colon", "module2"), "4.0")
        ]).execute(details)

        then:
        _ * details.getRequested() >> requested
        0 * details._

        where:
        requested << [
            newComponentSelector("orgX", "module2", "0.9"),
            newComponentSelector("org", "moduleX", "2.9"),

        this.failure = failure;
        this.constraint = constraint;
        this.fromVariant = fromVariant;
        this.targetVariant = targetVariant;
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override
    public Long getSelected() {
        return selected;
    }

    @Override
    public ComponentSelectionReason getReason() {

    }

    private RenderableUnresolvedDependencyResult dep(ModuleComponentSelector requested, ModuleComponentSelector attempted) {
        UnresolvedDependencyResult dependencyResult = Stub() {
            getRequested() >> requested
            getAttempted() >> attempted
        }
        return new RenderableUnresolvedDependencyResult(dependencyResult)
    }

        } else {
            return matchesRequested(candidate);
        }
    }

    private boolean matchesRequested(DependencyResult candidate) {
        ComponentSelector requested = candidate.getRequested();

        if (requested instanceof ModuleComponentSelector) {
            ModuleComponentSelector requestedModule = (ModuleComponentSelector)requested;

                throw new GradleException("Conflicting external source dependency rules were found in nested builds for " + mapping.getRequested().getDisplayName() + ":\n  " + CollectionUtils.join("\n  ", resolutionDisplayNames));
            }
        }
    }

    @Override
    public boolean hasRules() {

        this.requested = requested;
        this.target = requested;
        this.artifactSelectionDetails = new DefaultArtifactSelectionDetails(this, artifacts);
    }

    @Override
    public ComponentSelector getRequested() {
        return requested;
    }

    @Override
    public void useTarget(Object notation) {
        useTarget(notation, ComponentSelectionReasons.SELECTED_BY_RULE);
    }

    @Override

    public List<ResolvedVariantResult> getAllVariants() {
        return allVariants;
    }

    @Override
    public AttributeContainer getAttributes() {
        ComponentSelector requested = dependency.getRequested();
        return requested instanceof ModuleComponentSelector
            ? requested.getAttributes()
            : ImmutableAttributes.EMPTY;
    }

    @Override
    public List<Section> getExtraDetails() {

     * The requested dependency does not change even if there are multiple dependency substitution rules
     * that manipulate the dependency metadata.
     */
    ComponentSelector getRequested();

    /**
     * This method can be used to replace a dependency before it is resolved,
     * e.g. change group, name or version (or all three of them), or replace it
     * with a project dependency.
     *