gulp-watch
Watch, that actually is an endless stream
This is implementation of gulp.watch
with endless stream approach. If gulp.watch
is working for you - stick with it, otherwise you can try gulp-watch
plugin.
Main reasons of gulp-watch
existance is that it can easly (with a little help of gulp-plumber
achieve per-file rebuilding on file change:
This is close to bundled gulp.watch
, but with some tweaks. First - files will be grouped by timeout of 200
and passed into stream inside callback (this will keep git checkout
commands do rebuilding only once). Second - callbacks will never run parallel (unless you remove return
), until one stream ends working.
var gulp = require('gulp'),
watch = require('gulp-watch');
gulp.task('default', function () {
gulp.src('scss/**/*.scss')
.pipe(watch(function(files) {
return files.pipe(sass())
.pipe(gulp.dest('./dist/'));
}));
});
If you want to watch all directories, include those, which will be created after:
var gulp = require('gulp'),
watch = require('gulp-watch');
gulp.task('default', function () {
watch({glob: 'scss/**/*.scss'}, function(files) {
return files.pipe(sass())
.pipe(gulp.dest('./dist/'));
});
});
This is usefull, when you want blazingly fast rebuilding per-file.
Be aware: end
event is never happens in this mode, so plugins dependent on it will never print or do whatever they should do on end
task.
// npm i gulp gulp-watch gulp-sass
var gulp = require('gulp'),
watch = require('gulp-watch'),
plumber = require('gulp-plumber'),
sass = require('gulp-sass');
gulp.task('default', function () {
gulp.src('scss/**', { read: false })
.pipe(watch())
.pipe(plumber()) // This will keeps pipes working after error event
.pipe(sass())
.pipe(gulp.dest('./dist/'));
});
If you want to watch all directories, include those, which will be created after:
gulp.task('default', function () {
watch({ glob: 'sass/**/*.scss' })
.pipe(plumber())
.pipe(sass())
.pipe(gulp.dest('./dist/'));
});
Problem with gulp.watch
is that will run your test suit on every changed file per once. To avoid this gulp-batch
was written first, but after some time it became clear, that gulp.watch
should be a plugin with event batching abilities.
var grep = require('gulp-grep-stream');
var mocha = require('gulp-mocha');
var plumber = require('gulp-plumber');
gulp.task('watch', function() {
gulp.src(['lib/**', 'test/**'], { read: false })
.pipe(watch({ emit: 'all' }, function(files) {
files
.pipe(grep('*/test/*.js'))
.pipe(mocha({ reporter: 'spec' }))
.on('error', function() {
if (!/tests? failed/.test(err.stack)) {
console.log(err.stack);
}
})
}));
});
gulp.task('default', function () {
gulp.run('watch');
});
// run `gulp watch` or just `gulp` for watching and rerunning tests
This function creates have two different modes, that are depends on have you provice callback function, or not. If you do - you get batched mode, if you not - you get stream.
events
- isStream
of incoming events.done
- is callback for your function signal to batch, that you are done. This allows to run your callback as soon as previous end.
This object passed to gaze
options directly, so see documentation there. For batched mode we are using gulp-batch
, so options from there are available. And of course options for gulp.src
used too. If you do not want content from watch, then add read: false
to options object.
Type: String
Default: one
This options defines emit strategy:
one
- emit only changed fileall
- emit all watched files (and folders), when one changes
Type: Boolean
Default: true
This options will pass vinyl objects, that was piped into watch
to next Stream in pipeline.
Type: String
Default: undefined
If you want to detect new files, then you have to use this option. When gulp-watch
gets files from gulp.src
it looses the information about pattern of matching - therefore it can not detect new files.
Type: Boolean
Default: true
If options.glob
is used, gulp-watch, by default, will emit files when beginning to watch them -- much like gulp.src()
. Otherwise, disable this option.
Example:
// gulp-watch will not emit like gulp.src(...)
watch({glob:'./src/**/*.md', emitOnGlob: false})
.pipe(plumber())
.pipe(anotherPlugin(opts))
.pipe(gulp.dest('./html'))
Type: String
Default: undefined
Name of the watcher. If it present in options, you will get more readable output:
Notes:
- you cannot pipe to watcher, that got this option (writable stream will be closed).
- you will receive vinyl File object only on changes.
Returned Stream from constructor have some useful methods:
close()
- callinggaze.close
and emittingend
, aftergaze.close
is done.
end
- all files are stop being watched.ready
- just re-emitted event fromgaze
.error
- when something happened inside callback, you will get notified.
gaze
- instance ofgaze
in case you want to call it methods (for exampleremove
). Be aware no one guarantee you nothing after you hacked ongaze
.
Stream, that handles gulp.src
piping.
MIT (c) 2013 Vsevolod Strukchinsky ([email protected])