Comment faire pour copier vers de multiples destinations, avec Gradle tâche de copie?

Je suis en train de copier un fichier vers plusieurs destinations à travers un Gradle tâche. J'ai trouvé ce qui suit dans d'autres sites, mais j'obtiens une ERREUR lors de l'exécution de cette tâche.

def filesToCopy = copySpec{
    from 'somefile.jar'
    rename {String fileName -> 'anotherfile.jar'}
}

task copyFile(type:Copy) {
    with filesToCopy  {
      into 'dest1/'
    }
    with filesToCopy  {
      into 'dest2/'
    }
}

ERREUR

Pas de signature de la méthode: org.gradle.l'api.interne.fichier.copie.CopySpecImpl.call() est applicable pour les types d'argument

Est-il un moyen pour copier plusieurs destinations dans un Gradle tâche?

InformationsquelleAutor Venkatesh Nannan | 2012-11-20

gradle

40

Si vous voulez vraiment dans une tâche, vous faites quelque chose comme cela:
```
def filesToCopy = copySpec {
  from 'someFile.jar'
  rename { 'anotherfile.jar' }
}

task copyFiles << {
  ['dest1', 'dest2'].each { dest ->
    copy {
      with filesToCopy
      into dest
    }
  }
}
```
- C'est une méthode pratique. Un inconvénient cependant, c'est que quand je mets une extension variable dans la liste: ext.dispersalList = [ 'dest1', 'dest2', ... ]; la Tâche utilise la définition de la valeur de temps (vide) et non pas le "au moment de la construction" de la valeur. Cela signifie que je dois à plusieurs reprises définir la même tâche dans le sous-projet build.gradle fichiers. Est-il un moyen de paramétrer tâches ainsi construit peut être plus SEC.
InformationsquelleAutor ajoberstar

une autre façon

task myCustomTask << {

    copy {
        from 'sourcePath/folderA'
        into 'targetPath/folderA'
    }

    copy {
        from 'sourcePath/folderB'
        into 'targetPath/folderB'
    }

    copy {
        from 'sourcePath/fileA.java','sourcePath/fileB.java'
        into 'targetPath/folderC'
    }
}

InformationsquelleAutor bhdrk

12

pas il n'y a pas un moyen de faire de l'atm. Je voudrais créer séparée gradle tâches pour chaque répertoire cible
```
def filesToCopy = copySpec{
    from 'somefile.jar'
    rename {String fileName -> 'anotherfile.jar'}
}

task copyFileDest1(type:Copy) {
    with filesToCopy
    into 'dest1/'
}

task filesToCopyDest2(type:Copy)  {
    with filesToCopy
    into 'dest2/'
}
```
- +1 de Cette façon, vous conservez le bénéfice de la mise À JOUR des contrôles (qui serait perdue en appelant directement la copie() la méthode suggérée par certains autres réponses)
- Je havn'pas mentionné, mais certainement un bon point.
- c'est le gradle façon +1, doit être accepté de répondre à
- Où est utilisé filesToCopyDest2?
- filesToCopyDest2 est une tâche
InformationsquelleAutor Rene Groeschke
11

Avec une Destination Commune Chemin d'accès de Base

Si votre destination chemins de partager un chemin commun préfixe (dest_base), alors vous pouvez utiliser quelque chose comme ceci:
```
def filesToCopy = copySpec {
    from 'somefile.jar'
    rename { String fileName -> 'anotherfile.jar' }
}

task copyFile(type: Copy) {
    into 'dest_base'
    into('dest1') {
      with filesToCopy
    }
    into('dest2') {
      with filesToCopy
    }
}
```
Par rapport à d'autres réponses qui utilisent le copy, cette approche conserve également Gradle est-À-JOUR des vérifications.

L'extrait ci-dessus aurait pour résultat de sortie comme ceci:
```
dest_base/
├── dest1
│   └── anotherfile.jar
└── dest2
    └── anotherfile.jar
```
- Wow, je ne savais pas que des destinations multiples avec différentsCopySpecs sont possibles. Je ne sais pas si c'est une nouvelle Gradle, mais il est en fait la meilleure solution, car il fournit à la fois À la DATE des vérifications de et ne pas créer de multiples tâches (ce qui peut être gênant pour un montant élevé de sous-répertoires).
InformationsquelleAutor Chriki

Ici est un général extrait sans copySpec pour Gradle 4.1. Comme l'a souligné l'astuce est d'utiliser une base et d'utilisation par rapport à l'intérieur de la fermeture (par exemple, de la fermeture).

task multiIntoCopy(type: Copy){
    into(projectDir) //copy into relative to this

    from("foo"){
        into("copied/foo") //will be projectDir/copied/foo
        //just standard copy stuff
        rename("a.txt", "x.txt")
    }

    from("bar"){
        into("copied/aswell/bar") // projectDir/copied/copied/aswell/bar
    }

    from("baz") //baz folder content will get copied into projectDir

    //from("/bar"){ //this will mess things up, be very careful with the paths
    //   into("copied/aswell/bar")
    //}
}

Cela ne répond pas à la question posée. L'objectif est de les copier vers DE multiples destinations, pas DE multiples destinations

InformationsquelleAutor Alen Vrečko

Vous devez vous connecter pour publier un commentaire.

ERREUR

Avec une Destination Commune Chemin d'accès de Base