mapToMavenScope('compile')
            }

            components.java.withVariantsFromConfiguration(configurations.custom) {
                mapToMavenScope('runtime')
            }

            components.java.withVariantsFromConfiguration(configurations.custom) {
                mapToMavenScope('compile')
            }

            publishing {

            components.java.addVariantsFromConfiguration(configurations.optionalFeature1RuntimeElements) {
                mapToMavenScope('compile')
                mapToOptional()
            }
            components.java.addVariantsFromConfiguration(configurations.optionalFeature2RuntimeElements) {
                mapToMavenScope('compile')
                mapToOptional()
            }
        """

        when:

        components.add(adhocComponent)
        // and register a variant for publication
        adhocComponent.addVariantsFromConfiguration(outgoing) {
            mapToMavenScope("runtime")
        }
        // end::create_adhoc_component[]
    }

    private fun Project.attachArtifact() {
        val instrumentedJar = tasks.register<Jar>("instrumentedJar") {

        project.components.add(adhocComponent)
        // and register a variant for publication
        adhocComponent.addVariantsFromConfiguration(outgoing) {
            it.mapToMavenScope("runtime")
        }
        // end::create_adhoc_component[]
    }

    private void addVariantToExistingComponent(Project project, Configuration outgoing) {
        // tag::add_variant_to_existing_component[]

            }

            def javaComponent = components.findByName("java")
            javaComponent.addVariantsFromConfiguration(testConf) {
                it.mapToMavenScope("runtime")
            }

            publishing {
                publications {
                    maven(MavenPublication) {
                        from components.java
                    }

     * systematically be published as import scope.
     *  @param scope the Maven scope to use for dependencies found in this configuration variant
     *
     */
    void mapToMavenScope(String scope);

        ConfigurationVariant variant = details.getConfigurationVariant();
        if (UnpublishableArtifactTypeSpec.INSTANCE.isSatisfiedBy(variant)) {
            details.skip();
        } else {
            details.mapToMavenScope(scope);
            if (optional) {
                details.mapToOptional();
            }
            if (resolutionConfiguration != null) {

components.add(gradleApiComponent)

// Published component containing the public Gradle API
gradleApiComponent.addVariantsFromConfiguration(gradleApiElements.get()) {
    mapToMavenScope("compile")

            skip = true;
        }

        @Override
        public void mapToOptional() {
            this.optional = true;
        }

        @Override
        public void mapToMavenScope(String scope) {
            this.mavenScope = assertValidScope(scope);
        }

        @Override
        public void dependencyMapping(Action<? super DependencyMappingDetails> action) {

                    }
                }
            }

            firstChildComponent.addVariantsFromConfiguration(configurations.extraRuntimeElements) {
                mapToMavenScope('runtime')
            }
        """

        buildFile << """
            dependencies {
                firstImplementation create(project(':other'))