Gulps gulp.watch nie został uruchomiony dla nowych lub usuniętych plików?

Następujące zadanie Gulpjs działa dobrze podczas edycji plików w dopasowaniu globalnym:

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

Jednak to nie działa (nie jest wyzwalane) dla nowych lub usuniętych plików. Czy jest coś, czego mi brakuje?

EDYCJA : nawet przy użyciu wtyczki grunt-watch wydaje się nie działać:

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

EDYCJA : rozwiązany, to był ten problem . Globy zaczynające się od ./(taka była wartość src) wydaje się nie działać ATM.

Edycja: Najwyraźniej gulp.watchdziała teraz z nowymi lub usuniętymi plikami. Tak się nie stało, gdy zadano pytanie.

Reszta mojej odpowiedzi jest nadal aktualna: gulp-watchjest zwykle lepszym rozwiązaniem, ponieważ pozwala wykonywać określone czynności tylko na zmodyfikowanych plikach, a jednocześnie gulp.watchpozwala wykonywać tylko kompletne zadania. W przypadku projektu o rozsądnych rozmiarach szybko stanie się to zbyt wolne, aby było przydatne.

Niczego nie brakuje. gulp.watchnie działa z nowymi lub usuniętymi plikami. To proste rozwiązanie przeznaczone do prostych projektów.

Aby uzyskać plik oglądanie że mogą szukać nowych plików, korzystania z gulp-watchwtyczki , która jest o wiele bardziej wydajny. Sposób użycia wygląda następująco:

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

Osobiście polecam pierwszą opcję. Pozwala to na znacznie szybsze procesy na plik. Działa świetnie podczas programowania z livereload, o ile nie łączysz żadnych plików.

Możesz podsumować swoje strumienie za pomocą mojej lazypipebiblioteki lub po prostu używając funkcji i stream-combinertak:

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

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

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

AKTUALIZACJA 15 października 2014 r

Jak wskazał @pkyeck poniżej, najwyraźniej wersja 1.0 gulp-watchnieznacznie zmieniła format, więc powyższe przykłady powinny teraz wyglądać tak:

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

i

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

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

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

Oba gulp.watch()i require('gulp-watch')()będą wyzwalane dla nowych / usuniętych plików, jednak nie, jeśli używasz katalogów bezwzględnych. W moich testach nie "./"używałem przy okazji katalogów względnych.

Oba nie zostaną wyzwolone, jeśli zostaną usunięte całe katalogi.

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

Jeśli srcjest to ścieżka bezwzględna (zaczynająca się od /), kod nie wykryje nowych ani usuniętych plików. Jednak wciąż jest sposób:

Zamiast:

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

pisać:

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

i będzie działać!

Globy muszą mieć określony oddzielny katalog podstawowy, a tej lokalizacji podstawowej nie można określać w samym globie.

Jeśli tak lib/*.js, będzie wyglądał pod bieżącym katalogiem roboczym, którym jestprocess.cwd()

Gulp używa Gaze do oglądania plików, aw dokumencie API Gulp widzimy, że możemy przekazać określone opcje Gaze do funkcji watch:gulp.watch(glob[, opts], tasks)

Teraz w dokumencie Gaze możemy znaleźć, że bieżący katalog roboczy (glob base dir) jest cwdopcją.

Co prowadzi nas do odpowiedzi Alexka: gulp.watch('js/**/*.js', {cwd: src}, ['scripts']);

Wiem, że to starsze pytanie, ale pomyślałem, że rzucę rozwiązanie, które wymyśliłem. Żadna z wtyczek gulp, które znalazłem, nie powiadamia mnie o nowych lub zmienionych nazwach plików. Skończyło się na tym, że owijałem monokl w wygodną funkcję.

Oto przykład użycia tej funkcji:

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

Powinienem zauważyć, że gulpStart to również funkcja wygody, którą stworzyłem.

A oto rzeczywisty moduł zegarka.

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

Całkiem proste, co? Całość można znaleźć w moim zestawie startowym z łykiem: https://github.com/chrisdavies/gulp_starter_kit

Ważne jest, aby pamiętać, że wygląda jak gulp.watch zgłasza tylko zmienione i usunięte pliki w systemie Windows, ale domyślnie nasłuchuje nowych i usuniętych plików w systemie OSX:

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

Powinieneś używać „gulp-watch” dla nowych / zmienionych nazw / usuniętych plików zamiast 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));
    });
});