Gulps gulp.watch non attivato per file nuovi o eliminati?

La seguente attività Gulpjs funziona bene quando si modificano i file nella corrispondenza glob:

// watch task.
gulp.task('watch', ['build'], function () {
    gulp.watch(src + '/js/**/*.js', ['scripts']);
    gulp.watch(src + '/img//**/*.{jpg,jpeg,png,gif}', ['copy:images']);
    gulp.watch(src + '/less/*.less', ['styles']);
    gulp.watch(src + '/templates/**/*.{swig,json}', ['html']);
});

// build task.
gulp.task('build', ['clean'], function() {
    return gulp.start('copy', 'scripts', 'less', 'htmlmin');
});

Tuttavia non funziona (non è attivato) per i file nuovi o eliminati. C'è qualcosa che mi manca?

EDIT : anche usando il plugin grunt-watch sembra non funzionare:

gulp.task('scripts', function() {
    return streamqueue(
        { objectMode: true },
        gulp.src([
            vendor + '/jquery/dist/jquery.min.js',
            vendor + '/bootstrap/dist/js/bootstrap.min.js'
        ]),
        gulp.src([
            src + '/js/**/*.js'
        ]).pipe(plugins.uglify())
    )
    .pipe(plugins.concat(pkg.name + '.min.js'))
    .pipe(gulp.dest(dest + '/js/'));
});

gulp.task('watch', ['build'], function () {
    plugins.watch({glob: src + '/js/**/*.js'}, function () {
        gulp.start('scripts');
    });
});

EDIT : risolto, era questo problema . I globi che iniziano con ./(che era il valore di src) sembrano non funzionare ATM.

Modifica: a quanto pare gulp.watchfunziona ora con file nuovi o eliminati. Non è stato quando è stata posta la domanda.

Il resto della mia risposta è ancora valido: di gulp-watchsolito è una soluzione migliore perché ti consente di eseguire azioni specifiche solo sui file che sono stati modificati, mentre gulp.watchti consente solo di eseguire attività complete. Per un progetto di dimensioni ragionevoli, questo diventerà rapidamente troppo lento per essere utile.

Non ti stai perdendo nulla. gulp.watchnon funziona con file nuovi o eliminati. È una soluzione semplice progettata per progetti semplici.

Per ottenere la visione di file in grado di cercare nuovi file, utilizzare il gulp-watchplug-in , che è molto più potente. L'utilizzo è simile al seguente:

var watch = require('gulp-watch');

// in a task
watch({glob: <<glob or array of globs>> })
        .pipe( << add per-file tasks here>> );

// if you'd rather rerun the whole task, you can do this:
watch({glob: <<glob or array of globs>>}, function() {
    gulp.start( <<task name>> );
});

Personalmente, raccomando la prima opzione. Ciò consente processi per file molto più veloci. Funziona benissimo durante lo sviluppo con livereload fintanto che non stai concatenando alcun file.

Puoi concludere i tuoi flussi utilizzando la mia lazypipelibreria o semplicemente usando una funzione e in stream-combinerquesto modo:

var combine = require('stream-combiner');

function scriptsPipeline() {
    return combine(coffeeescript(), uglify(), gulp.dest('/path/to/dest'));
}

watch({glob: 'src/scripts/**/*.js' })
        .pipe(scriptsPipeline());

AGGIORNAMENTO 15 ottobre 2014

Come sottolineato da @pkyeck di seguito, apparentemente la versione 1.0 di ha gulp-watchcambiato leggermente il formato, quindi gli esempi sopra dovrebbero ora essere:

var watch = require('gulp-watch');

// in a task
watch(<<glob or array of globs>>)
        .pipe( << add per-file tasks here>> );

// if you'd rather rerun the whole task, you can do this:
watch(<<glob or array of globs>>, function() {
    gulp.start( <<task name>> );
});

e

var combine = require('stream-combiner');

function scriptsPipeline() {
    return combine(coffeeescript(), uglify(), gulp.dest('/path/to/dest'));
}

watch('src/scripts/**/*.js')
        .pipe(scriptsPipeline());

Entrambi gulp.watch()e require('gulp-watch')()attiveranno i file nuovi / eliminati, tuttavia non se si utilizzano directory assolute. Nei miei test non ho usato "./"per le relative directory BTW.

Entrambi però non si attivano se vengono eliminate intere directory.

   var watch = require('gulp-watch');
   //Wont work for new files until gaze is fixed if using absolute dirs. It  won't trigger if whole directories are deleted though.
   //gulp.watch(config.localDeploy.path + '/reports/**/*', function (event) {

   //gulp.watch('src/app1/reports/**/*', function (event) {
   // console.log('*************************** Event received in gulp.watch');
   // console.log(event);
   // gulp.start('localDeployApp');
   });

   //Won't work for new files until gaze is fixed if using absolute dirs. It  won't trigger if whole directories are deleted though. See https://github.com/floatdrop/gulp-watch/issues/104
   //watch(config.localDeploy.path + '/reports/**/*', function() {

   watch('src/krfs-app/reports/**/*', function(event) {
      console.log("watch triggered");
      console.log(event);
      gulp.start('localDeployApp');
   //});

Se srcè un percorso assoluto (a partire da /), il codice non rileverà i file nuovi o eliminati. Tuttavia c'è ancora un modo:

Invece di:

gulp.watch(src + '/js/**/*.js', ['scripts']);

Scrivi:

gulp.watch('js/**/*.js', {cwd: src}, ['scripts']);

e funzionerà!

I globi devono avere una directory di base separata specificata e tale posizione di base non deve essere specificata nel glob stesso.

Se lo hai lib/*.js, guarderà sotto la directory di lavoro corrente che èprocess.cwd()

Gulp usa Gaze per guardare i file e nel documento API di Gulp vediamo che possiamo passare le opzioni specifiche di Gaze alla funzione watch:gulp.watch(glob[, opts], tasks)

Ora nel documento Gaze possiamo scoprire che l'attuale directory di lavoro (glob base dir) è l' cwdopzione.

Il che ci porta alla risposta di alexk: gulp.watch('js/**/*.js', {cwd: src}, ['scripts']);

So che questa è una domanda più vecchia, ma ho pensato di gettare la soluzione che mi è venuta in mente. Nessuno dei plugin gulp che ho trovato mi avrebbe notificato file nuovi o rinominati. Così ho finito per avvolgere il monocolo in una funzione di convenienza.

Ecco un esempio di come viene utilizzata quella funzione:

watch({
    root: config.src.root,
    match: [{
      when: 'js/**',
      then: gulpStart('js')
    }, {
      when: '+(scss|css)/**',
      then: gulpStart('css')
    }, {
      when: '+(fonts|img)/**',
      then: gulpStart('assets')
    }, {
      when: '*.+(html|ejs)',
      then: gulpStart('html')
    }]
  });

Devo notare che gulpStart è anche una funzione di convenienza che ho creato.

Ed ecco il vero modulo dell'orologio.

module.exports = function (options) {
  var path = require('path'),
      monocle = require('monocle'),
      minimatch = require('minimatch');

  var fullRoot = path.resolve(options.root);

  function onFileChange (e) {
    var relativePath = path.relative(fullRoot, e.fullPath);

    options.match.some(function (match) {
      var isMatch = minimatch(relativePath, match.when);
      isMatch && match.then();
      return isMatch;
    });
  }

  monocle().watchDirectory({
    root: options.root,
    listener: onFileChange
  });
};

Abbastanza semplice, eh? Il tutto può essere trovato sul mio kit di avvio gulp: https://github.com/chrisdavies/gulp_starter_kit

È importante notare che sembra che gulp.watch riporta solo i file modificati ed eliminati su Windows ma ascolta i file nuovi ed eliminati per impostazione predefinita su OSX:

https://github.com/gulpjs/gulp/issues/675

Dovresti usare 'gulp-watch' per i file nuovi / rinominati / eliminati invece di gulp.watch

var gulpwatch = require('gulp-watch');
var source = './assets',  
destination = './dest';
gulp.task('copy-changed-assets', function() {
    gulpwatch(source+'/**/*', function(obj){
        gulp.src( obj.path, { "base": source})
        .pipe(gulp.dest(destination));
    });
});