gulp.run está obsoleto. Como faço para escrever tarefas?

Aqui está uma tarefa composta que não sei como substituí-la por dependências de tarefas.

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

O changelog correspondente 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']);
});

Você não precisa mais passar uma função (embora ainda possa) para executar tarefas. Você pode dar ao relógio uma série de nomes de tarefas e ele fará isso por você.

Ou você pode fazer assim:

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

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

gulp.start()nunca foi concebido para ser uma API pública nem usado. E, conforme declarado nos comentários acima, o gerenciamento de tarefas será substituído na próxima versão ... portanto gulp.start(), será interrompido.

A verdadeira intenção do design do gulp é fazer funções JavaScript regulares e apenas fazer a tarefa de chamá-las.

Exemplo:

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

Perdoe-me por ressuscitar uma velha questão. A resposta aceita não aborda a questão da execução de tarefas antes de definir os relógios. A próxima resposta usa gulp.start, que está indo embora. A terceira resposta aponta que funções regulares devem ser usadas, mas o exemplo parece estranho. Fiz algumas pesquisas, mas não encontrei um exemplo simples.

Aqui está minha solução. A ideia é definir funções js regulares e então registrá-las como tarefas. As funções podem então ser chamadas diretamente se necessário ou de dentro de um relógio.

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

Eu sou novo para engolir. Por favor, deixe-me saber se eu esqueci algo óbvio.

gole 4

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

Eu gosto de gulp4!

Como @dman menciona isso, gulp.startserão descartados na próxima versão. Também pode ser visto nesta edição do gole .

E nos comentários da resposta de @Pavel Evstigneev, @joemaller menciona que podemos usar a sequência de execução neste cenário.

Mas observe que o autor da sequência de execução diz:

Pretende-se que seja uma solução temporária até o lançamento do gulp 4.0, que tem suporte para definir dependências de tarefas em série ou em paralelo.

Esteja ciente de que esta solução é um hack e pode parar de funcionar com uma atualização futura para engolir.

Assim, antes gole 4.0, podemos usar run-seqüência , após 4.0, podemos usar apenas gole.

Se você precisa manter a ordem das tarefas em execução, pode definir dependências conforme descrito aqui - você só precisa retornar o fluxo da dependência:

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

Defina a tarefa que depende disso:

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

E use-o do relógio:

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

Agora a dependecytarefa será concluída antes de ser dependsexecutada (por exemplo, suas tarefas 'jasmim' e 'incorporar' seriam dependências e você teria outro 'servidor' de tarefas que dependeria delas). Não há necessidade de hacks.

No Gulp 4, a única coisa que parece estar funcionando para mim é:

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

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

Para executar uma tarefa antes de começar a assistir, em vez de usar gulp.run () ou gulp.start (), apenas execute o comando gulp diretamente.

Então, em vez de:

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

Apenas faça:

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

Ou você pode envolver esse último código em uma função "normal" e chamá-la sempre que quiser.

- Inspirado por esta resposta de um tópico semelhante .

Ainda não vejo como isso realmente resolve a questão em questão.

Se eu tiver 4 tarefas com dependências definidas entre elas

A, B, C, D

onde A depende de B, etc, conforme definido por gulp.task('A',['B'],function A(){});e então eu defini uma nova tarefa usando gulp.watch rodando apenas as funções que duplicariam as dependências.

por exemplo, dadas essas tarefas (cada função de tarefas exposta através do 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);

eu posso escrever 1)

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

que executaria A-> D, mas se, por exemplo, a Etapa B falhar, ela nunca entrará na tarefa (pense em erro de compilação ou teste)

ou posso escrever 2)

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

que não executaria A-> D até que algo fosse alterado primeiro.

ou posso escrever 3)

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

o que causaria duplicação (e erros ao longo do tempo) da hierarquia de dependência.

PS: Caso alguém esteja se perguntando por que eu gostaria que minha tarefa do relógio fosse executada se alguma das tarefas dependentes falhar, é geralmente porque eu uso o relógio para desenvolvimento ao vivo. por exemplo. Eu inicio minha tarefa de monitoramento para começar a trabalhar em testes etc. e pode ser que o código inicial com o qual eu inicio já tenha problemas, portanto, erros.

Espero que o gulp run ou algo equivalente permaneça por algum tempo