gulp.run jest przestarzały. Jak komponować zadania?

Oto złożone zadanie, którego nie wiem, jak go zastąpić zależnościami zadań.

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

Odpowiedni dziennik zmian 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']);
});

Nie musisz już przekazywać funkcji (choć nadal możesz), aby uruchamiać zadania. Możesz nadać zegarkowi szereg nazw zadań, a zrobi to za Ciebie.

Lub możesz to zrobić:

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

źródło: https://github.com/gulpjs/gulp/issues/755

gulp.start()nigdy nie miał być publicznym interfejsem API ani nie był używany. I jak wspomniano powyżej w komentarzach, zarządzanie zadaniami zostanie zastąpione w następnej wersji ... tak gulp.start()będzie zepsute.

Prawdziwym zamiarem projektu „Gulp” jest tworzenie zwykłych funkcji Javascript i tylko ich wywoływanie.

Przykład:

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

Wybacz mi, że wskrzeszę stare pytanie. Przyjęta odpowiedź nie dotyczy kwestii uruchamiania zadań przed ustawieniem zegarków. Następna odpowiedź używa gulp.start, który odchodzi. Trzecia odpowiedź wskazuje, że należy używać zwykłych funkcji, ale przykład wydaje się dziwny. Poszukałem trochę, ale nie znalazłem prostego przykładu.

Oto moje rozwiązanie. Pomysł polega na zdefiniowaniu zwykłych funkcji js, a następnie zarejestrowaniu ich jako zadań. W razie potrzeby funkcje można wywołać bezpośrednio lub z poziomu zegarka.

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

Jestem nowy, aby przełknąć. Daj mi znać, jeśli przeoczyłem coś oczywistego.

łyk 4

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

Lubię gulp4!

Jak wspomina @dman, gulp.startzostaną odrzucone w następnej wersji. Można to również zobaczyć w tym numerze łyku .

W komentarzach do odpowiedzi @Pavel Evstigneev @joemaller wspomina, że w tym scenariuszu możemy użyć sekwencji uruchamiania .

Ale proszę zauważyć, że autor sekwencji uruchamiania mówi:

Ma to być rozwiązanie tymczasowe do czasu wydania gulp 4.0, który obsługuje definiowanie zależności zadań szeregowo lub równolegle.

Należy pamiętać, że to rozwiązanie to hack i może przestać działać z przyszłą aktualizacją do gulp.

Tak więc przed łykiem 4.0 możemy użyć sekwencji run , po 4.0 możemy po prostu użyć łyka.

Jeśli chcesz zachować kolejność wykonywanych zadań, możesz zdefiniować zależności w sposób opisany tutaj - wystarczy, że zwróć strumień z zależności:

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

Zdefiniuj zadanie, które od tego zależy:

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

I używaj go z zegarka:

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

Teraz dependecyzadanie zakończy się przed dependsuruchomieniem (na przykład zadania „jasmine” i „embed” byłyby zależnościami i miałbyś inny „serwer” zadania, który byłby od nich zależny). Nie potrzeba żadnych hacków.

W Gulp 4 jedyne, co wydaje mi się działać, to:

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

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

Aby uruchomić zadanie przed rozpoczęciem oglądania, zamiast używać gulp.run () lub gulp.start (), po prostu uruchom polecenie gulp prosto do góry.

Więc zamiast:

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

Po prostu zrób:

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

Możesz też zawinąć ten ostatni kod w „normalną” funkcję i wywołać ją w dowolnym momencie.

- Zainspirowany tą odpowiedzią z podobnego wątku .

Nadal nie rozumiem, jak to właściwie rozwiązuje bieżące pytanie.

Jeśli mam 4 zadania ze zdefiniowanymi zależnościami między nimi

A, B, C, D

gdzie A zależy od B itd., jak zdefiniowano w, gulp.task('A',['B'],function A(){});a następnie zdefiniowałem nowe zadanie za pomocą gulp.watch, uruchamiając tylko funkcje, które zduplikowałyby zależności.

np. mając te zadania (każda funkcja zadań ujawniona przez nazwę):

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

mogę napisać 1)

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

który wykona A-> D, ale jeśli np. krok B zawiedzie, nigdy nie wejdzie do zadania (pomyśl o błędzie kompilacji lub testu)

czy mogę napisać 2)

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

który nie działałby A-> D dopóki coś nie zostało zmienione.

czy mogę napisać 3)

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

co spowodowałoby powielenie (i błędy w czasie) hierarchii zależności.

PS: W przypadku, gdy ktoś zastanawia się, dlaczego chciałbym, aby moje zadanie zegarka zostało wykonane, jeśli którekolwiek z zadań zależnych się nie powiedzie, jest to zwykle spowodowane tym, że używam zegarka do programowania na żywo. na przykład. Rozpoczynam zadanie zegarka, aby rozpocząć pracę nad testami itp. i może się zdarzyć, że początkowy kod, z którym zaczynam, ma już problemy, a zatem błędy.

Mam więc nadzieję, że łyk lub coś podobnego pozostanie na jakiś czas