Extrait des méthodes communes de script de build Gradle

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

Maintenant, voici la situation:

Je suis entrain de créer un juste montant de créer des scripts qui contiennent des tâches différentes, mais utiliser les mêmes méthodes à partir du script d'origine. Donc, je voudrais extraire ces "méthodes communes" d'une certaine façon, donc je peux facilement les réutiliser au lieu de les copier pour chaque nouveau script que j'ai créer.

Si Gradle ont été PHP, quelque chose comme ce qui suit serait l'idéal:

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

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

De toute façon, comment puis-je arriver à ce résultat? Quelle est la meilleure méthode pour faire cela? J'ai lu à travers le Gradle documentation déjà, mais je n'arrive pas à déterminer quelle méthode est la plus simple et la mieux adaptée pour cela.

Merci d'avance!

Mise à JOUR:

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

(à l'aide de apply from: 'common-methods.gradle'),

ainsi, la structure est comme suit:

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

Après l'exécution d'une tâche à partir d' build.gradle, je suis tombé sur un nouveau problème: apparemment, les méthodes ne sont pas reconnus quand ils sont dans common-methods.gradle.

Des idées sur la façon de résoudre ce problème?

Êtes-vous sûr que vous devez écrire les méthodes à tous ? Vous manquez une de la Gradle goodies si vous écrivez vos scripts de génération en termes de méthodes, plus important encore, il va prendre un supplément de travail pour obtenir les différentiels de construire afin de fonctionner correctement. Le but de l'abstraction est d'utiliser et de réutiliser Tâches. Vous pouvez également créer des tâches personnalisées. Peut-être vous devriez envisager de mettre en œuvre, vous avez maintenant dans les méthodes de tâches.
et les autres, quelle est l'utilité de faire quelque chose comme un timestamp() ou currentWorkingDirectory() méthodes task-s (par exemple). Les fonctions de l'utilitaire et des choses semblables sont nominalement scalaire -- il ne serait pas de tâches, à l'exception qu'il y a des limitations sur de réutiliser le code dans-construit avec Gradle et la plupart des systèmes de construction. J'aime le monde asséché où je peux faire une chose UNE seule fois et de le réutiliser. En fait, l'extension @Pieter VDE l'exemple j'utilise aussi un "root.gradle" pour mes parents projet, Le construire.gradle fichier définit généralement un projet spécificités et puis juste apply ${ROOT} ...

InformationsquelleAutor Pieter VDE | 2013-09-10

build.gradle gradle

68

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 à la même chose. Par exemple, déclarer ext.foo = { ... } dans common-methods.gradle, utilisez apply from: à appliquer le script, et ensuite appeler la fermeture avec foo().
- Il fait le tour en effet! Mais j'ai une question à ce sujet: Comment sur les méthodes de retourner quelque chose? F. e. File foo(String f) deviendra ext.foo = { f -> ... }, puis-je simplement faire quelque chose comme: File f = foo(...)?
- Apparemment, la question dans mon commentaire précédent est possible. Alors, merci, Pierre, pour répondre à cette question!
- Pourquoi n'est-il pas possible? Gradle.org pense le contraire: docs.gradle.org/current/userguide/...
- merci pour le lien. Je me demande comment puis-je utiliser une valeur générée dans la construction séparé fichier dans le gradle.l'accumulation de cette façon, il serait très utile 🙂
- Comment le lien que vous avez partagé une aide dans le contexte de Pierre VDEs question?
- Recherchez le mot partagé
- hmmm, ok, on dirait que vous n'avez pas lu complètement la question de détails. Je pensais qu'il y avait une certaine spécialité, j'ai négligé dans les docs que vous avez associé. de construire "logique" != "des méthodes/fonctions", mais de "tâches". Les tâches sont partagées, mais les méthodes/fonctions pas. Par conséquent, les solutions de contournement décrite par Pierre et Matthias sont nécessaires. Merci quand même.
InformationsquelleAutor Peter Niederwieser

124

Bâtiment sur La réponse de pierre, c'est comment je peux exporter 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 c'est de cette façon-je utiliser 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)    
}

Voici plus d'informations sur la conversion des méthodes de fermetures dans Groovy: lien

est-il une raison particulière d'utiliser la fermeture de nom de poste?
Nous ajoutons les deux fermetures à Gradle extra propriétés. Ces propriétés supplémentaires sont regroupés dans un objet appelé ext.
c'est travaillé. merci

InformationsquelleAutor Matthias Braun

À l'aide de la Kotlin dsl il fonctionne comme ceci:

construire.gradle.kts:

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

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

externe.gradle.kts:

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

InformationsquelleAutor Simon L

Vous devez vous connecter pour publier un commentaire.