web-dev-qa-db-fra.com

Comment passer des paramètres ou des arguments dans une tâche gradle

J'ai un script de construction gradle dans lequel j'essaie d'inclure le plugin css d'Eric Wendelin - http://eriwen.github.io/gradle-css-plugin/

Son assez facile à implémenter, et parce que je veux seulement la minification (plutôt que de combiner et de compresser), j'ai les parties pertinentes du script de construction qui ressemblent à ceci:

minifyCss {
    source = "src/main/webapp/css/brandA/styles.css"
    dest = "${buildDir}/brandA/styles.css"
    yuicompressor {
        lineBreakPos = -1
    }
}

war {
    baseName = 'ex-ren'
}

war.doFirst {
    tasks.myTask.minifyCss.execute()
}

C'est parfait - lorsque j'exécute la tâche gradle war, il appelle la tâche minifyCss, prend le fichier css source et crée une version minifiée dans le buildDir

Cependant, j'ai une poignée de fichiers css qui nécessitent une minification, mais ne se combinent pas en un seul fichier (donc je n'utilise pas la tâche combineCss)

Ce que j'aimerais pouvoir faire, c'est faire les propriétés source et dest (en supposant que c'est la bonne terminologie?) Des variables de référence de tâche minifyCss d'une certaine sorte - soit des variables passées dans la tâche dans la signature, soit des variables globales, ou quelque chose ...

Quelque chose comme ça, je suppose (qui ne fonctionne pas):

minifyCss(sourceFile, destFile) {
    source = sourceFile
    dest = destFile
    yuicompressor {
        lineBreakPos = -1
    }
}

war {
    baseName = 'ex-ren'
}

war.doFirst {
    tasks.myTask.minifyCss.execute("src/main/webapp/css/brandA/styles.css", "${buildDir}/brandA/styles.css")
    tasks.myTask.minifyCss.execute("src/main/webapp/css/brandB/styles.css", "${buildDir}/brandB/styles.css")
    tasks.myTask.minifyCss.execute("src/main/webapp/css/brandC/styles.css", "${buildDir}/brandC/styles.css")
}

Cela ne fonctionne pas non plus:

def sourceFile = null
def destFile = null

minifyCss {
    source = sourceFile
    dest = destFile
    yuicompressor {
        lineBreakPos = -1
    }
}

war {
    baseName = 'ex-ren'
}

war.doFirst {
    sourceFile = "src/main/webapp/css/brandA/styles.css"
    destFile = "${buildDir}/brandA/styles.css"
    tasks.myTask.minifyCss.execute()
}

Pour ma vie, je ne peux pas trouver comment appeler une tâche et transmettre des variables dans :(

Toute aide sera grandement appréciée;

variablesgroovyparametersgradle
45
Nathan Russell

Je pense que vous voulez probablement voir la minification de chaque ensemble de CSS comme une tâche distincte

task minifyBrandACss(type: com.eriwen.gradle.css.tasks.MinifyCssTask) {
     source = "src/main/webapp/css/brandA/styles.css"
     dest = "${buildDir}/brandA/styles.css"
}

etc etc

BTW exécuter vos tâches de minification dans une action de la tâche de guerre me semble étrange - ne serait-il pas plus logique d'en faire une dépendance de la tâche de guerre?

2
Perryn Fowler

Vous devriez envisager de passer l'argument -P en appelant Gradle.

De Documentation Gradle :

--project-prop Définit une propriété de projet du projet racine, par exemple -Pmyprop = myvalue. Voir Section 14.2, "Propriétés Gradle et propriétés système".

Compte tenu de ce build.gradle

task printProp << {
    println customProp
}

Appel de Gradle -PcustomProp=myProp donnera cette sortie:

$ gradle -PcustomProp=myProp printProp
:printProp
myProp

BUILD SUCCESSFUL

Total time: 3.722 secs

C'est ainsi que j'ai trouvé à passer des paramètres.

66
Bipi

Si la tâche à laquelle vous souhaitez transmettre des paramètres est de type JavaExec et que vous utilisez Gradle 5, par exemple la tâche run du plug-in d'application, alors vous pouvez passer vos paramètres via le --args=... option de ligne de commande . Par exemple gradle run --args="foo --bar=true".

Sinon, il n'y a pas de méthode intégrée pratique pour le faire, mais il existe 3 solutions.

1. Si peu de valeurs, fonction de création de tâche

Si les valeurs possibles sont peu nombreuses et connues à l'avance, vous pouvez créer par programme une tâche pour chacune d'entre elles:

void createTask(String platform) {
   String taskName = "myTask_" + platform;
   task (taskName) {
      ... do what you want
   }
}

String[] platforms = ["macosx", "linux32", "linux64"];
for(String platform : platforms) {
    createTask(platform);
}

Vous appelleriez alors vos tâches de la manière suivante:

./gradlew myTask_macosx

2. Hack d'entrée standard

Un hack pratique consiste à passer les arguments via une entrée standard et à lire votre tâche:

./gradlew myTask <<<"arg1 arg2 arg\ in\ several\ parts"

avec le code ci-dessous:

String[] splitIntoTokens(String commandLine) {
    String regex = "(([\"']).*?\\2|(?:[^\\\\ ]+\\\\\\s+)+[^\\\\ ]+|\\S+)";
    Matcher matcher = Pattern.compile(regex).matcher(commandLine);
    ArrayList<String> result = new ArrayList<>();
    while (matcher.find()) {
        result.add(matcher.group());
    }
    return result.toArray();   
}

task taskName, {
        doFirst {
            String typed = new Scanner(System.in).nextLine();
            String[] parsed = splitIntoTokens(typed);
            println ("Arguments received: " + parsed.join(" "))
            ... do what you want
        } 
 }

Vous devrez également ajouter les lignes suivantes en haut de votre script de génération:

import Java.util.regex.Matcher;
import Java.util.regex.Pattern;
import Java.util.Scanner;

3. -P paramètres

La dernière option consiste à passer un -P paramètre à Gradle:

./gradlew myTask -PmyArg=hello

Vous pouvez ensuite y accéder en tant que myArg dans votre script de génération:

task myTask {
    doFirst {
       println myArg
       ... do what you want
    }
}

Crédit à @ 789 pour sa réponse sur la division des arguments en jetons

43
Vic Seedoubleyew
task mathOnProperties << {
    println Integer.parseInt(a)+Integer.parseInt(b)
    println new Integer(a) * new Integer(b)
}

$ gradle -Pa=3 -Pb=4 mathOnProperties
:mathOnProperties
7
12

BUILD SUCCESSFUL
6
user3877963

Je suggérerais la méthode présentée sur le forum Gradle :

def createMinifyCssTask(def brand, def sourceFile, def destFile) {
    return tasks.create("minify${brand}Css", com.eriwen.gradle.css.tasks.MinifyCssTask) {
        source = sourceFile
        dest = destFile
    }
}

J'ai moi-même utilisé cette méthode pour créer des tâches personnalisées, et cela fonctionne très bien.

5
AutonomousApps