gulp.run è deprecato. Come compongo le attività?

Ecco un'attività composta che non so come sostituirla con le dipendenze delle attività.

...
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');
 });
});

Il registro delle modifiche corrispondente 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']);
});

Non è più necessario passare una funzione (sebbene sia ancora possibile) per eseguire le attività. Puoi dare all'orologio una serie di nomi di attività e lo farà per te.

Oppure puoi fare così:

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

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

gulp.start()non è mai stato concepito per essere un'API pubblica né utilizzato. E come affermato sopra nei commenti, la gestione delle attività verrà sostituita nella prossima versione ... quindi gulp.start()sarà interrotta.

La vera intenzione del progetto gulp è quella di creare normali funzioni Javascript e fare solo il compito di chiamarle.

Esempio:

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();
});

Perdonami per aver resuscitato una vecchia domanda. La risposta accettata non affronta il problema dell'esecuzione di attività prima di impostare gli orologi. La prossima risposta usa gulp.start che sta andando via. La terza risposta indica che dovrebbero essere usate le funzioni regolari ma l'esempio sembra strano. Ho fatto qualche ricerca ma non ho trovato un semplice esempio.

Ecco la mia soluzione. L'idea è di definire funzioni js regolari e quindi registrarle come attività. Le funzioni possono quindi essere chiamate direttamente se necessario o dall'interno di un orologio.

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);

Sono nuovo da inghiottire. Per favore fatemi sapere se ho trascurato qualcosa di ovvio.

gulp 4

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

Mi piace gulp4!

Come menzionato da @dman, gulp.startverrà scartato nella prossima versione. Inoltre può essere visto in questo numero di gulp .

E nei commenti della risposta di @Pavel Evstigneev, @joemaller afferma che possiamo usare la sequenza di esecuzione in questo scenario.

Ma tieni presente che l'autore di run-sequence dice:

Questa è pensata come una soluzione temporanea fino al rilascio di gulp 4.0 che ha il supporto per la definizione delle dipendenze delle attività in serie o in parallelo.

Tieni presente che questa soluzione è un hack e potrebbe smettere di funzionare con un futuro aggiornamento per gulp.

Quindi, prima di gulp 4.0, possiamo usare run-sequence , dopo 4.0, possiamo semplicemente usare gulp.

Se è necessario mantenere l'ordine di esecuzione delle attività, è possibile definire le dipendenze come descritto qui : è sufficiente restituire il flusso dalla dipendenza:

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

Definisci l'attività che dipende da essa:

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

E usalo dall'orologio:

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

Ora l' dependecyattività verrà completata prima dependsdell'esecuzione (ad esempio le attività "jasmine" e "incorporamento" sarebbero dipendenze e avresti un altro "server" dell'attività che dipenderebbe da esse). Non c'è bisogno di alcun hack.

In Gulp 4 l'unica cosa che sembra funzionare per me è:

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

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

Per eseguire un'attività prima di iniziare a guardare, invece di usare gulp.run () o gulp.start (), esegui semplicemente il comando gulp.

Quindi invece di:

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

Basta fare:

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

Oppure puoi racchiudere quest'ultimo codice in una funzione "normale" e chiamarlo ogni volta che vuoi.

- Ispirato da questa risposta da un thread simile .

Ancora non vedo come questo risolva effettivamente la domanda a portata di mano.

Se ho 4 attività con dipendenze definite tra di loro

A, B, C, D

dove A dipende da B, ecc. come definito da gulp.task('A',['B'],function A(){}); e quindi ho definito una nuova attività usando gulp.watch eseguendo solo le funzioni duplicherebbe le dipendenze.

ad es. date queste attività (ciascuna funzione delle attività esposta tramite nome):

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);

posso scrivere 1)

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

che eseguirà A-> D ma se ad esempio il passaggio B fallisce non entrerebbe mai nell'attività (pensa all'errore di compilazione o di prova)

oppure posso scrivere 2)

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

che non avrebbe eseguito A-> D fino a quando qualcosa non fosse cambiato prima.

oppure posso scrivere 3)

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

che causerebbe la duplicazione (ed errori nel tempo) della gerarchia delle dipendenze.

PS: Nel caso in cui qualcuno si chieda perché vorrei che la mia attività di controllo venga eseguita se una delle attività dipendenti fallisce, di solito è perché utilizzo l'orologio per lo sviluppo live. per esempio. inizio la mia attività di orologio per iniziare a lavorare su test ecc. e può essere che il codice iniziale con cui inizio abbia già problemi, quindi errori.

Quindi spero che gulp run o qualcosa di equivalente rimanga per un po 'di tempo