Extraire les méthodes communes de Gradle build script.

Question

J'ai une construction Gradle script ( build.gradle ), dans lequel j'ai créé quelques tâches. Ces tâches consistent principalement en des appels de méthodes. Les méthodes appelées sont également dans le build script.

Maintenant, voici la situation :

Je crée un bon nombre de scripts de construction, qui contiennent différentes tâches, mais utilisent les mêmes méthodes que le scripts original. Ainsi, je voudrais extraire ces "méthodes communes" d'une manière ou d'une autre, de sorte que je puisse facilement les réutiliser au lieu de les copier pour chaque nouveau scripts que je crée.

Si Gradle était PHP, quelque chose comme ce qui suit serait idéal :

//script content
...
require("common-methods.gradle");
...
//more script content

Mais bien sûr, ce n'est pas possible. Ou bien l'est-ce ?

Bref, comment puis-je obtenir ce résultat ? Quelle est la meilleure méthode possible pour y parvenir ? J'ai déjà lu la documentation de Gradle, mais je n'arrive pas à déterminer quelle méthode sera la plus facile et la mieux adaptée pour cela.

Merci d'avance !

---

UPDATE :

J'ai réussi à extraire les méthodes dans un autre fichier

(en utilisant apply from: 'common-methods.gradle' ),

La structure est donc la suivante :

parent/
      /build.gradle              // The original build script
      /common-methods.gradle     // The extracted methods
      /gradle.properties         // Properties used by the build script

Après avoir exécuté une tâche de build.gradle j'ai rencontré un nouveau problème : apparemment, les méthodes ne sont pas reconnues lorsqu'elles sont dans des fichiers de type common-methods.gradle .

Des idées sur la façon de réparer cela ?

Answer 1

Construire sur La réponse de Pierre c'est ainsi que j'exporte mes méthodes :

Contenu de helpers/common-methods.gradle :

// Define methods as usual
def commonMethod1(param) {
    return true
}
def commonMethod2(param) {
    return true
}

// Export methods by turning them into closures
ext {
    commonMethod1 = this.&commonMethod1
    otherNameForMethod2 = this.&commonMethod2
}

Et voici comment j'utilise ces méthodes dans un autre script :

// Use double-quotes, otherwise $ won't work
apply from: "$rootDir/helpers/common-methods.gradle"

// You can also use URLs
//apply from: "https://bitbucket.org/mb/build_scripts/raw/master/common-methods.gradle"

task myBuildTask {
    def myVar = commonMethod1("parameter1")
    otherNameForMethod2(myVar)
}

En savoir plus sur la conversion des méthodes en fermetures dans Groovy.

Answer 2

Il n'est pas possible de partager des méthodes, mais vous pouvez partager des propriétés supplémentaires contenant une fermeture, ce qui revient au même. Par exemple, déclarez ext.foo = { ... } en common-methods.gradle utiliser apply from: pour appliquer le script, et ensuite appeler la fermeture avec foo() .

Answer 3

Utilisation de la Kotlin DSL ça marche comme ça :

build.gradle.kts :

apply {
  from("external.gradle.kts")
}

val foo = extra["foo"] as () -> Unit
foo()

external.gradle.kts :

extra["foo"] = fun() {
  println("Hello world!")
}

Answer 4

Une autre approche pour Kotlin DSL pourrait être :

mon-plugin.gradle.kts

extra["sum"] = { x: Int, y: Int -> x + y }

paramètres.gradle.kts

@Suppress("unchecked_cast", "nothing_to_inline")
inline fun <T> uncheckedCast(target: Any?): T = target as T

apply("my-plugin.gradle.kts")

val sum = uncheckedCast<(Int, Int) -> Int>(extra["sum"])

println(sum(1, 2))

Answer 5

Je suggérerais un léger ajustement à La réponse de Matthias Braun , en ce sens qu'au lieu d'écrire deux fois le même nom de méthode et d'avoir encore claire et concise, pourquoi ne pas simplement faire ce qui suit :

ext.commonMethod1 = (param) -> {
    return true
} as Closure<boolean>

L'utilisation de la as -L'opérateur "t" le dit simplement de manière explicite, que cette fonction retournera une valeur de boolean -type.

Parce qu'après tout, c'est toujours de la bonté Groovy. Pas mal, hein ?