}
}
// end::closure[]

tasks.register('conventions') {
    def objects = objects
    doLast {
        // tag::conventions[]
        def files = objects.fileCollection().convention("src")
        files.from("src2")
        def dirNames = files*.name
        println("Source dirs: ${dirNames}") // [src, src2]
        // end::conventions[]
    }
}

tasks.register('usage') {

== Convention Plugins

Convention plugins are a way to encapsulate and reuse common build logic in Gradle.
They allow you to define a set of conventions for a project, and then apply those conventions to other projects or modules.

The example above has been re-written as a convention plugin stored in `buildSrc`:

        ["project"].toSet() == project.stepResults.keySet().collect { it.stepIdentifier.key }.toSet()

        and: 'conventions get properly applied'
        // check the conventions in the resolution results, they should be there, and it is independent of the DOM overlay
        def projectEvaluated = project.stepResults.values()[0] as EvaluationResult.Evaluated<AnalysisStepResult>

     * @param convention the new convention
     * @return the given value, if this value state is not explicit, otherwise the new convention value
     */
    public abstract S applyConvention(S value, S convention);

    /**
     * Marks this value state as being non-explicit. Returns the convention, if any.
     */
    public abstract S implicitValue(S convention);

    public abstract S implicitValue();

# release notes.
releaseNotes:
- |
  **Improved** Gateway naming conventions to be concatenation of `Name` and `GatewayClassName`. 
  Deployment also now deploys with its own Service Account, rather than using the `default` token. 
  Naming convention affects name of Deployment, Service and Service Account.

# upgradeNotes is a markdown listing of any changes that will affect the upgrade

    }
}
// end::closure[]

tasks.register("conventions") {
    val objects = objects
    doLast {
        // tag::conventions[]
        val sourceDirs = objects.fileCollection().convention("src")
        sourceDirs.from("src2")
        val sourceDirNames = sourceDirs.map { it.name }
        println("Source dirs: $sourceDirNames") // [src, src2]
        // end::conventions[]
    }
}

tasks.register("usage") {

@Suppress("deprecation")
fun conventionPluginByName(convention: org.gradle.api.plugins.Convention, name: String): Any =
    convention.plugins[name] ?: throw IllegalStateException("A convention named '$name' could not be found.")


@Suppress("deprecation")
fun conventionOf(target: Any): org.gradle.api.plugins.Convention = when (target) {
    is Project -> DeprecationLogger.whileDisabled(Factory { target.convention })!!

    fun findConventions(softwareTypeName: String): SoftwareTypeConventionResolutionResults?
}


/**
 * Transformation logic for the kinds of resolution results that appear in conventions.
 * For any of the supported result records, supports replacing the `conventions { ... }` receiver in it with
 * the given [targetBaseReceiver].
 */
private
class ConventionTransformer(
    private val targetBaseReceiver: ObjectOrigin.ReceiverOrigin
) {

    @Deprecated
    public org.gradle.api.plugins.Convention getConvention() {
// TODO nag once KGP doesn't register conventions anymore
//        DeprecationLogger.deprecateType(org.gradle.api.internal.HasConvention.class)
//            .willBeRemovedInGradle9()
//            .withUpgradeGuideSection(8, "deprecated_access_to_conventions")
//            .nagUser();
        if (convention == null) {

    }

    public ExtensibleDynamicObject(Object delegate, AbstractDynamicObject dynamicDelegate, org.gradle.api.plugins.Convention convention) {
        this.dynamicDelegate = dynamicDelegate;
        this.convention = convention;
        this.extraPropertiesDynamicObject = new ExtraPropertiesDynamicObjectAdapter(delegate.getClass(), convention.getExtraProperties());

        updateDelegates();
    }