gulp.run est obsolète. Comment rédiger des tâches?

Voici une tâche composée que je ne sais pas comment la remplacer par des dépendances de tâches.

...
gulp.task('watch', function () {
 var server = function(){
  gulp.run('jasmine');
  gulp.run('embed');
 };
 var client = function(){
  gulp.run('scripts');
  gulp.run('styles');
  gulp.run('copy');
  gulp.run('lint');
 };
 gulp.watch('app/*.js', server);
 gulp.watch('spec/nodejs/*.js', server);
 gulp.watch('app/backend/*.js', server);
 gulp.watch('src/admin/*.js', client);
 gulp.watch('src/admin/*.css', client);
 gulp.watch('src/geojson-index.json', function(){
  gulp.run('copygeojson');
 });
});

Le journal des modifications correspondant https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [deprecate gulp.run]

gulp.task('watch', function () {
  var server = ['jasmine', 'embed'];
  var client = ['scripts', 'styles', 'copy', 'lint'];
  gulp.watch('app/*.js', server);
  gulp.watch('spec/nodejs/*.js', server);
  gulp.watch('app/backend/*.js', server);
  gulp.watch('src/admin/*.js', client);
  gulp.watch('src/admin/*.css', client);
  gulp.watch('src/geojson-index.json', ['copygeojson']);
});

Vous n'avez plus besoin de passer une fonction (bien que vous le puissiez toujours) pour exécuter des tâches. Vous pouvez donner à watch un tableau de noms de tâches et il le fera pour vous.

Ou vous pouvez faire comme ceci:

gulp.start('task1', 'task2');

source: https://github.com/gulpjs/gulp/issues/755

gulp.start()n'a jamais été conçue pour être une API publique ni utilisée. Et comme indiqué plus haut dans les commentaires, la gestion des tâches est remplacée dans la prochaine version .... donc gulp.start()violeront.

La véritable intention de la conception de gulp est de créer des fonctions Javascript régulières et de ne faire que la tâche de les appeler.

Exemple:

function getJsFiles() {
    var sourcePaths = [
        './app/scripts/**/*.js',
        '!./app/scripts/**/*.spec.js',
        '!./app/scripts/app.js'
    ];

    var sources = gulp.src(sourcePaths, { read: false }).pipe(angularFilesort());

    return gulp.src('./app/index.html')
        .pipe(injector(sources, { ignorePath: 'app', addRootSlash: false }))
        .pipe(gulp.dest('./app'));
}  

gulp.task('js', function () {
    jsStream = getJsFiles();
});

Pardonnez-moi d'avoir ressuscité une vieille question. La réponse acceptée n'aborde pas le problème de l'exécution des tâches avant le réglage des montres. La réponse suivante utilise gulp.start qui disparaît. La troisième réponse souligne que les fonctions régulières devraient être utilisées mais l'exemple semble étrange. J'ai fait quelques recherches mais je n'ai pas trouvé d'exemple simple.

Voici ma solution. L'idée est de définir des fonctions js régulières puis de les enregistrer en tant que tâches. Les fonctions peuvent alors être appelées directement si nécessaire ou depuis une montre.

var 
  gulp     = require('gulp'),
  concat   = require('gulp-concat'),
  markdown = require('gulp-showdown')
;
var scriptFiles   = [ 'ang/app.js' ];
var markdownFiles = [ 'content/articles/*.md'];

var watchTask = function() 
{
  buildTask();

  gulp.watch(scriptFiles,  ['scripts' ]);
  gulp.watch(markdownFiles,['markdown']);
};
gulp.task('watch',watchTask);

var buildTask = function()
{
  scriptsTask();
  markdownTask();
};
gulp.task('build',buildTask);

var markdownTask = function() 
{
  gulp.src(markdownFiles)
    .pipe(markdown())
    .pipe(gulp.dest('web/articles'));
};
gulp.task('markdown',markdownTask);

var scriptsTask = function() 
{
  gulp.src(scriptFiles)
    .pipe(concat('app.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js',
      'bower_components/angular-route/angular-route.min.js'
    ])
    .pipe(concat('vendor.js'))
    .pipe(gulp.dest('web/js'));

  gulp.src(
    [
      'bower_components/angular/angular.min.js.map',
      'bower_components/angular-route/angular-route.min.js.map'
    ])
    .pipe(gulp.dest('web/js'));
};
gulp.task('scripts', scriptsTask);

Je suis nouveau à avaler. Veuillez me faire savoir si j'ai oublié quelque chose d'évident.

avaler 4

gulp.parallel('taskName1', 'taskName2')()
gulp.series('taskName1', 'taskName2')()

J'aime gulp4!

Comme @dman le mentionne, gulp.startsera supprimé dans la prochaine version. On peut également le voir dans ce numéro de gulp .

Et dans les commentaires de la réponse de @Pavel Evstigneev, @joemaller mentionne que nous pouvons utiliser run-sequence dans ce scénario.

Mais s'il vous plaît noter que, l'auteur de run-sequence dit:

Ceci est destiné à être une solution temporaire jusqu'à la sortie de gulp 4.0 qui prend en charge la définition des dépendances de tâches en série ou en parallèle.

Sachez que cette solution est un hack et peut cesser de fonctionner avec une future mise à jour de gulp.

Donc, avant gulp 4.0, nous pouvons utiliser run-sequence , après 4.0, nous pouvons simplement utiliser gulp.

Si vous avez besoin de maintenir l'ordre d'exécution des tâches, vous pouvez définir les dépendances comme décrit ici - il vous suffit de renvoyer le flux depuis la dépendance:

gulp.task('dependency', function () {
  return gulp.src('glob')
    .pipe(plumber())
    .pipe(otherPlugin())
    .pipe(gulp.dest('destination'));
});

Définissez la tâche qui en dépend:

gulp.task('depends', [ 'dependency' ], function () {
  // do work
});

Et utilisez-le depuis la montre:

gulp.task('watch', function () {
  watch('glob', [ 'depends' ]);
});

Maintenant, la dependecytâche se terminera avant l' dependsexécution (par exemple, vos tâches 'jasmine' et 'embed' seraient des dépendances et vous auriez une autre tâche 'serveur' qui en dépendrait). Pas besoin de hacks.

Dans Gulp 4, la seule chose qui semble fonctionner pour moi est:

gulp.task('watch', function() {
    gulp.watch(['my-files/**/*'], gulp.series('my-func'));
});

gulp.task('my-func', function() {
    return gulp.src('[...]').pipe(gulp.dest('...'));
});

Pour exécuter une tâche avant de commencer à regarder, au lieu d'utiliser gulp.run () ou gulp.start (), exécutez simplement la commande gulp directement.

Donc au lieu de:

var compress = function () {
    return gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));
};

Faites simplement:

gulp.src('js/vendor/*.js')
        .pipe(concat('vendor.js'))
        .pipe(gulp.dest('./build/js/'));

Ou vous pouvez envelopper ce dernier code dans une fonction "normale" et l'appeler quand vous le souhaitez.

- Inspiré par cette réponse à partir d'un fil similaire .

Je ne vois toujours pas comment cela résout réellement la question à portée de main.

Si j'ai 4 tâches avec des dépendances définies entre elles

A B C D

où A dépend de B, etc. tel que défini par gulp.task('A',['B'],function A(){});, puis j'ai défini une nouvelle tâche en utilisant gulp.watch en exécutant uniquement les fonctions dupliquerait les dépendances.

Par exemple, étant donné ces tâches (chaque fonction de tâches exposée via le nom):

function A(){}
gulp.task('A',['B'],A);

function A(){}
gulp.task('A',['B'],A);

function B(){}
gulp.task('B',['C'],B);

function C(){}
gulp.task('C',['D'],C);

function D(){}
gulp.task('D',[],D);

je peux écrire 1)

gulp.task('WATCHER', ['A'], function(){
   ...
}

qui exécuterait A-> D mais si, par exemple, l'étape B échoue, elle n'entrerait jamais dans la tâche (pensez à une erreur de compilation ou de test)

ou je peux écrire 2)

gulp.task('WATCHER', [], function(){
   gulp.watch(...,['A'])
}

qui n'exécuterait pas A-> D tant que quelque chose n'a pas été modifié en premier.

ou je peux écrire 3)

gulp.task('WATCHER', [], function(){
   D();
   C();
   B();
   A();
   gulp.watch(...,['A'])
}

ce qui entraînerait une duplication (et des erreurs au fil du temps) de la hiérarchie de dépendances.

PS: Au cas où quelqu'un se demanderait pourquoi je voudrais que ma tâche de surveillance s'exécute si l'une des tâches dépendantes échoue, c'est généralement parce que j'utilise watch pour le développement en direct. par exemple. Je commence ma tâche de surveillance pour commencer à travailler sur des tests, etc. et il se peut que le code initial avec lequel je commence ait déjà des problèmes, donc des erreurs.

J'espère donc que gulp run ou un équivalent reste pendant un certain temps