gulp-notify

notification plugin for gulp

Information

Package	gulp-notify
Description	Send messages to Mac Notification Center, Linux notifications (using notify-send) or Windows >= 8 (using native toaster) or Growl as fallback, using the node-notifier module. Can also specify custom notifier.
Node Version	>= 0.8

Table of Contents

• Information
• Requirements
• Usage
• Notes/tip
• API
  • notify(String)
  • notify(Function)
  • notify(options)
    • options.onLast
    • options.emitError
    • options.message
    • options.title
    • options.templateOptions
    • options.notifier
  • notify.withReporter(Function)
  • notify.onError()
  • notify.logLevel(level)
• Disable gulp-notify
• Examples
  • As jshint reporter
• License

Requirements

• Mac OS X: No external installation needed (if Mac OS X 10.8 or higher).
• Linux: notify-send/notify-osd should be installed (On Ubuntu this is installed per default)
• Windows: Uses native toaster (if Windows 8 or higher).
• Fallback: Growl: Growl (for Mac, Windows or similar) should be installed.

See node-notifier for details.

Windows 10 Note: You might have to activate banner notification for the toast to show.

From #90 (comment)

You can make it work by going to System > Notifications & Actions. The 'toast' app needs to have Banners enabled. (You can activate banners by clicking on the 'toast' app and setting the 'Show notification banners' to On)

Usage

First, install gulp-notify as a development dependency:

1npm install --save-dev gulp-notify

Then, add it to your gulpfile.js:

1
2var notify = require("gulp-notify");
3gulp.src("./src/test.ext")
4  .pipe(notify("Hello Gulp!"));

Or with template

1
2var notify = require("gulp-notify");
3gulp.src("./src/test.ext")
4  .pipe(notify("Found file: <%= file.relative %>!"));

See examples for more or the API section for various inputs.

Notes/tip

gulp-notify passes on the vinyl files even on error. So if you are using gulp-plumber the run will not break if the notifier returns an error.

If you want to notify on errors gulp-plumber can be used to not break the run and force you to have to restart gulp.

You can use notify.onError() as the errorHandler for gulp-plumber like this:

1gulp.src("../test/fixtures/*")
2      .pipe(plumber({errorHandler: notify.onError("Error: <%= error.message %>")}))
3      .pipe(through(function () {
4        this.emit("error", new Error("Something happend: Error message!"))
5      }));

API

notify(String)

A message to notify per data on stream. The string can be a lodash template as it is passed through gulp-util.template.

notify(Function)

Type: function(VinylFile)

Vinyl File from gulp stream passed in as argument.

The result of the function can be a string used as the message or an options object (see below). If the returned value is a string, it can be a lodash template as it is passed through gulp-util.template.

If false is returned from the function the notification won't run.

notify(options)

*Options are passed onto the reporter, so on Windows, you can define Growl host, on Mac you can pass in contentImage, and so on.

See node-notifier for all options*

Default notification values:

• Gulp logo on regular notification
• Inverted Gulp logo on error
• Frog sound on error on Mac.

See also the advanced example.

options.onLast

Type: Boolean Default: false

If the notification should only happen on the last file of the stream. Per default a notification is triggered on each file.

options.emitError

Type: Boolean Default: false

If the returned stream should emit an error or not. If emitError is true, you have to handle .on('error') manually in case the notifier (gulp-notify) fails. If the default false is set, the error will not be emitted but simply printed to the console.

This means you can run the notifier on a CI system without opting it out but simply letting it fail gracefully.

options.message

Type: String Default: File path in stream

The message you wish to attach to file. The string can be a lodash template as it is passed through gulp-util.template.

Example: Created <%= file.relative %>.

as function

Type: Function(vinylFile)

See notify(Function).

options.title

Type: String Default: "Gulp Notification"

The title of the notification. The string can be a lodash template as it is passed through gulp-util.template.

Example: Created <%= file.relative %>.

as function

Type: Function(vinylFile)

See notify(Function).

options.templateOptions

Type: Object Default: {}

Object passed to the lodash template, for additional properties passed to the template.

Examples:

1gulp.src("../test/fixtures/*")
2    .pipe(notify({
3      message: "Generated file: <%= file.relative %> @ <%= options.date %>",
4      templateOptions: {
5        date: new Date()
6      }
7    }))

options.notifier

Type: Function(options, callback) Default: node-notifier module

Swap out the notifier by passing in an function. The function expects two arguments: options and callback.

The callback must be called when the notification is finished. Options will contain both title and message.

See notify.withReporter for syntactic sugar.

notify.on(event, function (notificationOptions)) - Events

If the wait option is set to true, the notifier will trigger events click or timeout, whether the user clicks the notification or it times out. You listen to these events on the main notify object, not the produces stream.

1var notify = require('gulp-notify');
2
3notify.on('click', function (options) {
4  console.log('I clicked something!', options);
5});
6
7notify.on('timeout', function (options) {
8  console.log('The notification timed out', options);
9});
10
11gulp.task("click", function () {
12  return gulp.src("some/glob/**")
13    .pipe(notify({ message: 'Click or wait', wait: true }));
14});

notify.withReporter(Function)

Type: Reporter

Wraps options.notifier to return a new notify-function only using the passed in reporter.

Example:

1var custom = notify.withReporter(function (options, callback) {
2  console.log("Title:", options.title);
3  console.log("Message:", options.message);
4  callback();
5});
6
7gulp.src("../test/fixtures/1.txt")
8    .pipe(custom("This is a message."));
9

This will be the same as

1
2gulp.src("../test/fixtures/1.txt")
3    .pipe(notify({
4      message: "This is a message."
5      notifier: function (options, callback) {
6        console.log("Title:", options.title);
7        console.log("Message:", options.message);
8        callback();
9      }
10    }));

But much, much prettier.

notify.onError()

The exact same API as using notify(), but where a vinyl File is passed, the error object is passed instead.

Example:

1gulp.src("../test/fixtures/*")
2      .pipe(through(function () {
3        this.emit("error", new Error("Something happend: Error message!"))
4      }))
5      .on("error", notify.onError(function (error) {
6        return "Message to the notifier: " + error.message;
7      }));

Or simply:

1gulp.src("../test/fixtures/*")
2      .pipe(through(function () {
3        this.emit("error", new Error("Something happend: Error message!"))
4      }))
5      .on("error", notify.onError("Error: <%= error.message %>"));

1gulp.src("../test/fixtures/*")
2      .pipe(through(function () {
3        this.emit("error", new Error("Something happend: Error message!"))
4      }))
5      .on("error", notify.onError({
6        message: "Error: <%= error.message %>",
7        title: "Error running something"
8      }));

The onError() end point does support lodash.template.

onError() will automatically end the stream for you. Making it easer for watching.

notify.logLevel(level)

Type: Integer Default: 2

Set if logger should be used or not. If log level is set to 0, no logging will be used. If no new log level is passed, the current log level is returned.

• 0: No logging
• 1: Log on error
• 2: Log both on error and regular notification.

If logging is set to > 0, the title and message passed to gulp-notify will be logged like so:

1➜  gulp-notify git:(master) ✗ gulp --gulpfile examples/gulpfile.js one
2[gulp] Using file /Users/example/gulp-notify/examples/gulpfile.js
3[gulp] Working directory changed to /Users/example/repos/gulp-notify/examples
4[gulp] Running 'one'...
5[gulp] Finished 'one' in 4.08 ms
6[gulp] gulp-notify: [Gulp notification] /Users/example/gulp-notify/test/fixtures/1.txt

Disable gulp-notify

If you are running on a system that handles notifications poorly or you simply do not wish to use gulp-notify but your project does? You can disable gulp-notify by using enviroment variable DISABLE_NOTIFIER.

export DISABLE_NOTIFIER=true;

This will disable all methods; notify(), notify.onError and notify.withReporter.

Examples

To see all examples run from root:

1$ gulp --gulpfile examples/gulpfile.js --tasks
2[gulp] Using file /Users/example/gulp-notify/examples/gulpfile.js
3[gulp] Working directory changed to /Users/example/gulp-notify/examples
4[gulp] Tasks for /Users/example/gulp-notify/examples/gulpfile.js
5[gulp] ├── multiple
6[gulp] ├── one
7[gulp] ├── message
8[gulp] ├── customReporter
9[gulp] ├── template
10[gulp] ├── templateadv
11[gulp] ├── function
12[gulp] ├── onlast
13[gulp] ├── advanceMac
14[gulp] ├── error
15[gulp] ├── forceGrowl
16[gulp] └── customError

To run an example:

1$ gulp --gulpfile examples/gulpfile.js multiple
2[gulp] Using file /Users/example/gulp-notify/examples/gulpfile.js
3[gulp] Working directory changed to /Users/example/gulp-notify/examples
4[gulp] Running 'multiple'...
5[gulp] Finished 'multiple' in 3.75 ms

As jshint reporter

gulp-notify can easily be used as jshint reporter. As jshint exposes the result on the vinyl file we can use them in a function like so:

1gulp.task('lint', function() {
2  gulp.src('/src/**/*.js')
3    .pipe(jshint())
4    // Use gulp-notify as jshint reporter
5    .pipe(notify(function (file) {
6      if (file.jshint.success) {
7        // Don't show something if success
8        return false;
9      }
10
11      var errors = file.jshint.results.map(function (data) {
12        if (data.error) {
13          return "(" + data.error.line + ':' + data.error.character + ') ' + data.error.reason;
14        }
15      }).join("\n");
16      return file.relative + " (" + file.jshint.results.length + " errors)\n" + errors;
17    }));
18});

If you use a function for message in gulp-notify, the message won't be shown. This is true for both direct use of function and { message: function () {}}.

License

MIT License