gulp.run está obsoleto. ¿Cómo redacto tareas?

Aquí hay una tarea compuesta que no sé cómo reemplazarla con dependencias de tareas.

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

El registro de cambios correspondiente https://github.com/gulpjs/gulp/blob/master/CHANGELOG.md#35 [desaprobar 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']);
});

Ya no necesita pasar una función (aunque todavía puede) para ejecutar tareas. Puede darle al reloj una variedad de nombres de tareas y lo hará por usted.

O puedes hacer esto:

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

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

gulp.start()nunca tuvo la intención de ser una API pública ni se usó. Y como se indicó anteriormente en los comentarios, la administración de tareas se reemplazará en la próxima versión ... por gulp.start()lo que se romperá.

La verdadera intención del diseño de gulp es crear funciones regulares de Javascript y solo realizar la tarea de llamarlas.

Ejemplo:

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

Perdóname por resucitar una vieja pregunta. La respuesta aceptada no aborda el problema de ejecutar tareas antes de configurar los relojes. La siguiente respuesta usa gulp.start, que desaparece. La tercera respuesta señala que se deben usar funciones regulares, pero el ejemplo parece extraño. Hice algunas búsquedas pero no encontré un ejemplo simple.

Aquí está mi solución. La idea es definir funciones js regulares y luego registrarlas como tareas. Las funciones se pueden llamar directamente si es necesario o desde dentro de un reloj.

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

Soy nuevo en tragar. Por favor, avíseme si he pasado por alto algo obvio.

trago 4

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

¡Me gusta gulp4!

Como @dman menciona eso, gulp.startserá descartado en la próxima versión. También se puede ver en este número de gulp .

Y en los comentarios de la respuesta de @Pavel Evstigneev, @joemaller menciona que podemos usar run-sequence en este escenario.

Pero tenga en cuenta que, el autor de run-sequence dice:

Se pretende que sea una solución temporal hasta el lanzamiento de gulp 4.0, que tiene soporte para definir dependencias de tareas en serie o en paralelo.

Tenga en cuenta que esta solución es un truco y puede dejar de funcionar con una actualización futura de gulp.

Entonces, antes de gulp 4.0, podemos usar run-sequence , después de 4.0, simplemente podemos usar gulp.

Si necesita mantener el orden de las tareas en ejecución, puede definir las dependencias como se describe aquí ; solo necesita devolver el flujo de la dependencia:

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

Defina la tarea que depende de ella:

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

Y úsalo desde el reloj:

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

Ahora la dependecytarea se completará antes de dependsejecutarse (por ejemplo, sus tareas 'jazmín' e 'incrustación' serían dependencias y tendría otro 'servidor' de tareas que dependería de ellas). No es necesario ningún truco.

En Gulp 4, lo único que parece funcionar para mí es:

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

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

Para ejecutar una tarea antes de comenzar a mirar, en lugar de usar gulp.run () o gulp.start (), simplemente ejecute el comando gulp directamente.

Entonces en lugar de:

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

Solo haz:

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

O puede envolver ese último código en una función "normal" y llamarlo cuando lo desee.

- Inspirado por esta respuesta de un hilo similar .

Todavía no veo cómo esto realmente resuelve la pregunta en cuestión.

Si tengo 4 tareas con dependencias definidas entre ellas

A B C D

donde A depende de B, etc., según lo definido por gulp.task('A',['B'],function A(){}); y luego definí una nueva tarea usando gulp.watch ejecutando solo las funciones duplicaría las dependencias.

por ejemplo, dadas estas tareas (cada función de tareas expuesta a través del nombre):

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

puedo escribir 1)

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

que ejecutaría A-> D pero si, por ejemplo, el Paso B falla, nunca entraría en la tarea (piense en un error de compilación o prueba)

o puedo escribir 2)

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

que no ejecutaría A-> D hasta que se cambiara algo primero.

o puedo escribir 3)

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

lo que causaría duplicación (y errores a lo largo del tiempo) de la jerarquía de dependencias.

PD: En caso de que alguien se pregunte por qué querría que se ejecute mi tarea de vigilancia si alguna de las tareas dependientes falla, generalmente se debe a que uso la vigilancia para el desarrollo en vivo. p.ej. Comienzo mi tarea de reloj para comenzar a trabajar en pruebas, etc. y puede ser que el código inicial con el que comienzo ya tenga problemas, por lo tanto, errores.

Así que espero que gulp run o algo equivalente se quede por algún tiempo