val mirrorUrls: Map<String, String> =
        providers.environmentVariable("REPO_MIRROR_URLS").orNull
            ?.ifBlank { null }
            ?.split(',')
            ?.associate { nameToUrl ->
                val (name, url) = nameToUrl.split(':', limit = 2)
                name to url
            }
            ?: emptyMap()

    fun ignoreMirrors() = providers.environmentVariable("IGNORE_MIRROR").orNull?.toBoolean() == true

        final String value = environmentVariableValue(environmentVariable);
        if (value != null) {
            final String path = value.trim();
            if (!path.isEmpty()) {
                return Optional.of(InstallationLocation.userDefined(fileResolver.resolve(path), "environment variable '" + environmentVariable + "'"));
            }
        }

// tag::configuration[]
// Using the Java API
println System.getenv('ENVIRONMENTAL')

// Using the Gradle API, provides a lazy Provider<String>
println providers.environmentVariable('ENVIRONMENTAL').get()
// end::configuration[]

abstract class PrintValue extends DefaultTask {
    @Input abstract Property<String> getInputValue()
    @TaskAction void action() { println(inputValue.get()) }
}

// tag::execution[]

fun Project.environmentVariable(propertyName: String) = providers.environmentVariable(propertyName)


fun Project.propertyFromAnySource(propertyName: String) = gradleProperty(propertyName)
    .orElse(systemProperty(propertyName))
    .orElse(environmentVariable(propertyName))


val Project.buildBranch: Provider<String>

public class TestProviderFactory extends DefaultProviderFactory {

    @Override
    Provider<String> environmentVariable(String variableName) {
        return Providers.ofNullable(System.getenv(variableName))
    }

    @Override
    Provider<String> environmentVariable(Provider<String> variableName) {
        return environmentVariable(variableName.get())
    }

    @Override
    Provider<String> systemProperty(String propertyName) {

        options.add(new JvmArg(value))
    }

    void systemProperty(String name, String value) {
        options.add(new SystemProperty(name, value))
    }

    void environmentVariable(String name, String value) {
        options.add(new EnvironmentVariable(name, value))
    }

    void defaultCharacterEncoding(String value) {
        options.add(new DefaultCharacterEncoding(value))
    }

    void enableAssertions() {

// tag::configuration[]
// Using the Java API
println(System.getenv("ENVIRONMENTAL"))

// Using the Gradle API, provides a lazy Provider<String>
println(providers.environmentVariable("ENVIRONMENTAL").get())

// end::configuration[]

abstract class PrintValue : DefaultTask() {
    @get:Input abstract val inputValue: Property<String>
    @TaskAction fun action() { println(inputValue.get()) }
}

// tag::execution[]

// Using the Java API
println(System.getenv("ENVIRONMENTAL"))

// Using the Gradle API, provides a lazy Provider<String>

// Using the Java API
println System.getenv('ENVIRONMENTAL')

// Using the Gradle API, provides a lazy Provider<String>

    }
}

val pgpSigningKey: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY")
val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(
        project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,
        project.providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE").orNull
    )