for (DependencyGraphNodeResult node : getFirstLevelNodes(dependencySpec)) {
            matches.add(node.getPublicView());
        }
        return matches;
    }

    private Set<DependencyGraphNodeResult> getFirstLevelNodes(Spec<? super Dependency> dependencySpec) {
        Set<DependencyGraphNodeResult> matches = new LinkedHashSet<>();

@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().copy(dependencySpec)"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.copy(dependencySpec: Spec<Dependency>) =
    get().copy(dependencySpec)


/**
 * See [Configuration.copyRecursive].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().copyRecursive(dependencySpec)"), level = DeprecationLevel.HIDDEN)

        @Override
        public SelectedArtifactSet select(ArtifactSelectionSpec spec) {
            return this;
        }

        @Override
        public SelectedArtifactSet select(Spec<? super Dependency> dependencySpec) {
            return this;
        }

        @Override
        public void visitDependencies(TaskDependencyResolveContext context) {
        }

        @Override

        assert model.hasDependency(name)
        def data = model.getDependencyData(name)
        assert data != null: "Expected a dependency with alias $name but it wasn't found"
        def dependencySpec = new DependencySpec(data)
        spec.delegate = dependencySpec
        spec.resolveStrategy = Closure.DELEGATE_FIRST
        spec()

     *
     * @param dependencySpec filtering requirements
     * @return copy of this configuration
     */
    Configuration copy(Spec<? super Dependency> dependencySpec);

    /**
     * Creates a copy of this configuration with dependencies from superconfigurations (see {@link #copyRecursive()})
     * but filtering the dependencies using the dependencySpec.
     * <p>

                implementation project(':c')
            }

            task insight(type: DependencyInsightReportTask) {
                showingAllVariants = true
                dependencySpec = { it.requested in ProjectComponentSelector }
                configuration = configurations.compileClasspath
            }
        """
        ['b', 'c'].each {
            file("${it}/build.gradle") << """

        return dependencySpec;
    }

    /**
     * The dependency spec selects the dependency (or dependencies if multiple matches found) to show the report for.
     * The spec receives an instance of {@link DependencyResult} as parameter.
     */
    public void setDependencySpec(@Nullable Spec<DependencyResult> dependencySpec) {
        this.dependencySpec = dependencySpec;

        final Spec<DependencyResult> dependencySpec = new StrictDependencyResultSpec(module);

        final Set<DependencyResult> selectedDependencies = new LinkedHashSet<>();
        DefaultResolvedComponentResult.eachElement(incomingResolution, Actions.doNothing(), it -> {
            if (dependencySpec.isSatisfiedBy(it)) {
                selectedDependencies.add(it);
            }

            // set of build dependencies than actually required. This is because it takes a lot of extra information
            // from the visited graph to properly filter artifacts by dependencySpec, and we don't want capture that when
            // calculating build dependencies.

import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.gradle.ArtifactSelectorSpec
import org.gradle.test.fixtures.gradle.DependencyConstraintSpec
import org.gradle.test.fixtures.gradle.DependencySpec
import org.gradle.test.fixtures.gradle.FileSpec
import org.gradle.test.fixtures.gradle.GradleFileModuleAdapter
import org.gradle.test.fixtures.gradle.VariantMetadataSpec