Each "scope" is just a string (without spaces).

They are normally used to declare specific security permissions, for example:

* `users:read` or `users:write` are common examples.
* `instagram_basic` is used by Facebook / Instagram.
* `https://www.googleapis.com/auth/drive` is used by Google.

!!! info
    In OAuth2 a "scope" is just a string that declares a specific permission required.

                warnings.addUnsupported(String.format("%s:%s:%s declared as a dependency constraint", constraint.getGroup(), constraint.getName(), constraint.getVersion()));
            }
        }
        if (!variant.getCapabilities().isEmpty()) {
            for (Capability capability : variant.getCapabilities()) {

        'excluding group of declared module'               | [group: 'org.gradle']                     | ['test-1.45.jar', 'company-4.0.jar', 'other-company-4.0.jar', 'enterprise-5.0.jar']

It is the de-facto public artifact store for Java and is used by many build systems.

*Dependencies* - Dependencies declared via configuration types -> https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter-api[`libs.junit.jupiter`] and https://mvnrepository.com/artifact/com.google.guava/guava[`libs.guava`] +

        then:
        failure.assertHasCause "Could not find group:moduleA:."
        failure.assertNotOutput("parse")
    }

    def 'a BOM dependencyManagement entry preserves exclusions declared in build file'() {
        def modB = mavenHttpRepo.module("group", "moduleB", "1.0").allowAll().publish()
        moduleA.dependsOn(modB).publish()
        bomDependency('moduleA').publish()

        buildFile << """

Le système d'injection de dépendances exige le pré-enregistrement des dépendances et les dépendances sont résolues sur la base des types déclarés. Ainsi, il n'est pas possible de déclarer plus d'un "composant" qui fournit un certain type.

Les routes sont déclarées à un seul endroit, en utilisant des fonctions déclarées à d'autres endroits (au lieu
d'utiliser des décorateurs qui peuvent être placés juste au-dessus de la fonction qui gère l'endpoint). Cette

 * Some of your transitive dependencies are declared as optional
 * You want to declare some of your direct dependencies as optional in your project's published POM

For the first scenario, Gradle behaves the same way as Maven and simply ignores any transitive dependencies that are declared as optional.

//            String message = "Cannot publish dependency on " + project.getDisplayName() + " since it does not declare any publications. " +
//                "Publishing a component that depends on another project without publications";
//            DeprecationLogger.deprecate(message)
//                .withAdvice("Ensure " + project.getDisplayName() + " declares at least one publication.")
//                .willBecomeAnErrorInGradle9()

image::dependency-management-dynamic-dependency-build-scan.png[]

By default, Gradle caches dynamic versions of dependencies for 24 hours. Within this time frame, Gradle does not try to resolve newer versions from the declared repositories.
The <<#sec:controlling-dynamic-version-caching,threshold can be configured>> as needed for example if you want to resolve new versions earlier.

[[sub:declaring_dependency_with_changing_version]]

[NOTE]
====
Strict dependencies are to some extent similar to Maven's _nearest first_ strategy, but there are subtle differences:

- _strict dependencies_ don't suffer an ordering problem: they are applied transitively to the subgraph, and it doesn't matter in which order dependencies are declared.