* limitations under the License.
 */

package org.gradle.internal.component.external.model.ivy;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.gradle.api.artifacts.component.ModuleComponentIdentifier;
import org.gradle.internal.component.external.descriptor.Artifact;
import org.gradle.internal.component.external.model.DefaultModuleComponentArtifactMetadata;

                }

                if (details.minSeen != details.component) {
                    // Part of a strongly connected component (ie cycle) - move values to root of the component
                    // The root is the first node of the component we encountered
                    NodeDetails<N, T> rootDetails = components.get(details.minSeen);
                    rootDetails.values.addAll(details.values);

        // The nodes in the graph represent variants (mostly) and multiple variants of a component may be included in the graph, so a given component may be visited multiple times
        if (!components.containsKey(id)) {
            components.put(id, new DefaultResolvedComponentResult(moduleVersion, selectionReason, componentId, ImmutableMap.copyOf(selectedVariants), allVariants, repoName));
        }
        selectedVariants.clear();

        other 'org.test:projectA:1.0'

        // Component metadata rule that applies only to the 'sub' project
        components {
            withModule('org.test:projectA', AddDependencyRule)
        }
    }
    task res {
        def conf = configurations.conf
        def other = configurations.other
        doLast {
            // If we resolve twice the modified component metadata for 'projectA' must not be cached in-memory

    def "component results match the ones passed into the constructor"() {
        ArtifactResolutionResult artifactResolutionResult = new DefaultArtifactResolutionResult([componentArtifactsResult1, unresolvedComponentResult1] as LinkedHashSet)

        expect:
        artifactResolutionResult.components.size() == 2
        artifactResolutionResult.components.contains(componentArtifactsResult1)

[[sec:declaring-additional-capabilities-for-a-local-component]]
== Declaring additional capabilities for a local component

All components have an _implicit capability_ corresponding to the same GAV coordinates as the component.
However, it is also possible to declare additional _explicit capabilities_ for a component.

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.internal.component.external.model.ImmutableCapabilities;

/**
 * Identifier of a variant of a component.
 */
public class ComponentVariantIdentifier {

    private final ComponentIdentifier componentId;
    private final AttributeContainer attributes;

    }

    public void renderComponents(Set<ComponentSpec> components) {
        if (components.isEmpty()) {
            getTextOutput().withStyle(Info).println("No components.");
            return;
        }
        for (ComponentSpec component : components) {
            getBuilder().item(component, dependentComponentsRenderer);
        }
    }

    public void renderLegend() {

import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.internal.component.local.model.LocalComponentGraphResolveState;

import javax.annotation.concurrent.ThreadSafe;

/**
 * A registry of all dependency resolution state for locally produced components.
 * These components may be produced within the same project, another project in the same multi-project build,

/**
 * Allows the build to provide rules that modify the metadata of depended-on software components.
 *
 * Component metadata rules are applied in the components section of the dependencies block
 * {@link DependencyHandler} of a build script. The rules can be defined in two different ways:
 * <ol>
 *     <li>As an action directly when they are applied in the components section</li>