componentSelection {
                            all { ComponentSelection selection ->
                                if ($descriptorArg != null) {
                                    println "A is evaluating \$selection.candidate"
                                    if (selection.candidate.version != "1.1") { selection.reject("Rejected by A") }
                                }
                            }

    }

    /**
     * If false, selection is restricted only to the artifacts exposed a selected node in the graph.
     * If true, selection is expanded to include artifacts from any variant exposed by the component that a given node belongs to.
     */
    public boolean getSelectFromAllVariants() {
        return selectFromAllVariants;
    }

    /**

import org.gradle.api.internal.artifacts.transform.ArtifactVariantSelector
import spock.lang.Specification

class DefaultVisitedArtifactResultsTest extends Specification {
    def "strict selection includes selected variant of each node"() {
        def artifacts1 = Stub(ArtifactSet)
        def artifacts2 = Stub(ArtifactSet)
        def variant1Artifacts = Stub(ResolvedArtifactSet)

                resolutionStrategy.capabilitiesResolution.all { details ->
                    def selection =
                        details.candidates.find { it.variantName.endsWith('PrefApiElements') }
                    println("Selecting \$selection from \${details.candidates}")
                    details.select(selection)
                }
            }

            configurations.runtimeClasspath {

            String path = remainingPaths.remove(0);
            TaskSelection selection = taskSelector.resolveTaskName(taskExecutionRequest.getRootDir(), taskExecutionRequest.getProjectPath(), targetBuild, path);
            Set<Task> tasks = selection.getTasks();
            remainingPaths = taskConfigurer.configureTasks(tasks, remainingPaths);
            out.add(selection);
        }
        return out;
    }

package match

import (
	"path/filepath"
	"strings"

	"istio.io/istio/pkg/log"
)

func MatchesMap(selection, cluster map[string]string) bool {
	if len(selection) == 0 {
		return true
	}
	if len(cluster) == 0 {
		return false
	}

	for ks, vs := range selection {
		vc, ok := cluster[ks]
		if !ok {
			return false
		}
		if !MatchesGlob(vc, vs) {
			return false
		}
	}

*/

package fields

import "k8s.io/apimachinery/pkg/selection"

// Requirements is AND of all requirements.
type Requirements []Requirement

// Requirement contains a field, a value, and an operator that relates the field and value.
// This is currently for reading internal selection information of field selector.
type Requirement struct {
	Operator selection.Operator
	Field    string
	Value    string

tasks.register("printRejectConfig") {
    val rejectConfig: FileCollection = configurations["rejectConfig"]
    doLast {
        rejectConfig.forEach { println("Resolved: ${it.name}") }
    }
}

// tag::component-selection-with-metadata[]
configurations {
    create("metadataRulesConfig") {
        resolutionStrategy {
            componentSelection {
                // Reject any versions with a status of 'experimental'

[[sec:resolving-variant-aware-errors]]
=== Variant Selection Errors

Sometimes a selection error happens at the <<variant_model.adoc#understanding-variant-selection,variant selection level>>.
Have a look at the <<variant_model.adoc#sec:variant-select-errors,dedicated section>> to understand these errors and how to resolve them.

include::sample[dir="snippets/dependencyManagement/customizingResolution-selectionRule/groovy",files="build.gradle[tags=targeted-component-selection]"]
====

Component selection rules can also consider component metadata when selecting a version.