├── .gitignore
├── .travis.yml
├── CHANGELOG.md
├── CONTRIBUTING.md
├── IMPLEMENTATION-EXAMPLE.md
├── IMPLEMENTATIONS.md
├── LICENSE
├── README.md
├── index.js
├── package.json
└── test
    └── main.js


/.gitignore:
--------------------------------------------------------------------------------
1 | coverage/
2 | node_modules/
3 | npm-debug.log
4 | *.sublime-*
5 | .idea/
6 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "4.1"
4 |   - "0.12"
5 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | ## 1.0.0 The Promised Hashing
 4 | 
 5 | ### Breaking changes
 6 | 
 7 | - The `config` method has been removed, you can now pass a configuration options object in the `bust()` call. See the [docs](https://github.com/UltCombo/gulp-buster/#syntax) for details.
 8 | - Removed the undocumented experimental `mode` option, use the new `transform` option instead.
 9 | - Removed the undocumented `hashes` method.
10 | 
11 | ### New features
12 | 
13 | - Configuration options: added new `formatter` and `transform` options, added support for `algo` as a function and negative `length`. See the [docs](https://github.com/UltCombo/gulp-buster/#parameters) for details.
14 | - All of the configuration options which accept a function can be run asynchronously by returning a promise.
15 | - Added type validation for configuration options.
16 | 
17 | ## 0.2.0 Multidimensional Configurable Hashing Abyss
18 | 
19 | - `fileName` parameter is now optional and defaults to `busters.json`.
20 | - Allow multiple different output files in the same script (hashes are grouped by output filename).
21 | - Added `.config()` method to allow customizing the hashing algorithm, hash length and default output filename.
22 | 
23 | ### Patch releases
24 | 
25 | - **0.2.1**: Readme: Fixed miscellaneous typos, including config sample.
26 | - **0.2.2**: Fixed crash when piping an empty buffer stream into gulp-buster. Many documentation improvements: added cache busting explanation, improved syntax and architecture documentation, added 3rd-party implementations listing and contributing guide.
27 | 
28 | ## 0.1.0 Bustering Gulpness
29 | 
30 | - Initial release.
31 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | See [Ult Foundation Contributor's Guide](https://github.com/UltFoundation/Ultiomatic.js/blob/master/CONTRIBUTING.md).
2 | 


--------------------------------------------------------------------------------
/IMPLEMENTATION-EXAMPLE.md:
--------------------------------------------------------------------------------
 1 | # Implementation examples
 2 | 
 3 | **This document taken from [gulp-buster](https://github.com/UltCombo/gulp-buster) the same ideas apply here **
 4 | 
 5 | These examples explain the basic logic necessary to implement gulp-buster into your application.
 6 | 
 7 | ## Node.js + Jade
 8 | 
 9 | **asset-loader.js**
10 | ```js
11 | var busters = require('path/to/busters.json');
12 | module.exports = function(path) {
13 | 	return path + (busters[path] ? '?' + busters[path] : '');
14 | };
15 | ```
16 | 
17 | Then when outputting cache-busted file paths, simply call the asset loader passing the (relative to project root) file path. Example with Express and Jade:
18 | 
19 | ```jade
20 | script(src=fooSrc)
21 | ```
22 | 
23 | ```js
24 | var asset = require('./asset-loader.js');
25 | res.render('view', { fooSrc: '/' + asset('js/min/foo.min.js') }, function(err, html) {
26 | 	// ...
27 | });
28 | ```
29 | 
30 | As you can see, the gulp-buster `busters.json`'s paths are relative to project root without the leading slash, so we manually prepend a `/` to the cache-busted URL. This works nicely if your project root corresponds to the web server root. Otherwise, you will have to prepend the correct base URL. The optimal way would be to dynamically retrieve your app's base URL, specially as the project path relative to the web server root may differ between production and local development environments (e.g. it is a common scenario to have the project run at `/` in the production server and at `/myProject/` in local development).
31 | 
32 | ## Client-side
33 | 
34 | There are many ways to implement this in the front-end as well. If your project uses an AMD loader such as Require.js, you can map the modules to their cache-busted URLs in the config. Even without any loader, it is possible to `document.write` the scripts as follows:
35 | 
36 | ```js
37 | ['app', 'services', 'controllers', 'filters', 'directives'].forEach(function(s) {
38 | 	document.write('<script src="/' + asset('js/' + s + '.js') + '"><\/script>');
39 | });
40 | ```
41 | 
42 | **Note:** If implementing this in the front-end, make sure to load the fresh (non-cached) `busters.json` file. That is, retrieving it through an Ajax request may return a cached version of it depending on the server configurations. Append a timestamp to the request URL's querystring to prevent caching issues. You may also output the JSON file's contents inside of a dynamic page's `<script>` tag assigning it to a variable. JSON (JavaScript Object Notation) is a subset of the JS object/array literals syntax, so this is perfectly valid as well.
43 | 
44 | ## Closing words
45 | 
46 | As the asset loader implementation is up to you, you may make it the way which better fits your application. A more robust implementation could check the file extension (js/css/png) and return the full HTML tag for it, accept string/array of strings overloading for the path argument, and also take the base path as an optional argument.
47 | 


--------------------------------------------------------------------------------
/IMPLEMENTATIONS.md:
--------------------------------------------------------------------------------
 1 | # Implementations
 2 | 
 3 | **This document taken from [gulp-buster](https://github.com/UltCombo/gulp-buster) the same ideas apply here **
 4 | 
 5 | First off, if you are planning to make your own gulp-buster implementation, check the [implementation examples](https://github.com/mathisonian/gulp-sri/blob/master/IMPLEMENTATION-EXAMPLE.md) which explain the basic implementation logic and provide some tips.
 6 | 
 7 | ## Available implementations per language
 8 | 
 9 | 
10 | ## Submit your own implementation
11 | 
12 | Have you made a new implementation and would like it listed here? Just send a PR! `=]`
13 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Matthew Conlen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # [gulp](https://github.com/gulpjs/gulp/)-sri
 2 | [![npm version](http://img.shields.io/npm/v/gulp-sri.svg)](https://npmjs.org/package/gulp-sri)
 3 | [![Build Status](https://travis-ci.org/mathisonian/gulp-sri.svg?branch=master)](https://travis-ci.org/mathisonian/gulp-sri)
 4 | 
 5 | [SubResource Integrity](http://www.w3.org/TR/SRI/) hashes generator for gulp. Code heavily borrowed from [gulp-buster](https://github.com/UltCombo/gulp-buster).
 6 | 
 7 | ## What is subresource integrity?
 8 | 
 9 | A way to verify the contents of files after they have been delivered to the browser. There is a good blog post here: https://blog.cloudflare.com/an-introduction-to-javascript-based-ddos/
10 | 
11 | 
12 | ## Install
13 | 
14 | First off, [install gulp](https://github.com/gulpjs/gulp/blob/master/docs/getting-started.md).
15 | 
16 | Then install gulp-sri as a development dependency:
17 | 
18 | ```
19 | npm install --save-dev gulp-sri
20 | ```
21 | 
22 | ## How to use
23 | 
24 | gulp-sri can be used standalone as part of a build task, or in conjunction with [gulp-watch](https://npmjs.org/package/gulp-watch) to update the hashes as the files are modified.
25 | 
26 | Example with gulp-watch `^1.0.5` and gulp-ruby-sass `^0.7.1` (compile, bust and watch for changes):
27 | 
28 | ```js
29 | var gulp = require('gulp'),
30 | 	watch = require('gulp-watch'),
31 | 	sass = require('gulp-ruby-sass'),
32 | 	sri = require('gulp-sri');
33 | 
34 | gulp.task('default', function() {
35 | 	var srcGlob = 'scss/*.scss';
36 | 	return gulp.src(srcGlob)
37 | 		.pipe(watch(srcGlob, function(files) {
38 | 			return files
39 | 				.pipe(sass())
40 | 				.pipe(gulp.dest('css'))
41 | 				.pipe(sri())           // pipe generated files into gulp-sri
42 | 				.pipe(gulp.dest('.'));  // output sri.json to project root
43 | 	}));
44 | });
45 | ```
46 | 
47 | ## Syntax
48 | 
49 | ```none
50 | <through stream> sri([options])
51 | ```
52 | 
53 | ### Parameters
54 | 
55 | - `options` (object|string, optional): the configuration options object. Passing `options` as a string is treated as `{ fileName: options }`.
56 | 
57 | - `options.fileName` (string, optional): the output filename. Defaults to `'sri.json'`.
58 | 
59 | - `options.algorithms` (string|function, optional): the hashing algorithms to be used. Defaults to `['sha256']`. This option is passed directly to the [sri-toolbox](https://github.com/neftaly/npm-sri-toolbox).
60 | 
61 | - `options.type` (string, optional): Content type string to be included in the output hash. This option is passed directly to the [sri-toolbox](https://github.com/neftaly/npm-sri-toolbox).
62 | 
63 | - `options.transform` (function, optional): allows mutating the hashes object, or even creating a completely new data structure, before passing it to the `formatter`. It takes a copy of the hashes object (a plain object in the `filePath: hash` format) as the first argument and must return a value compatible with the `formatter` option. Defaults to passing through the hashes object.
64 | 
65 | - `options.formatter` (function, optional): the function responsible for serializing the hashes data structure into the string content of the output file. It takes the value returned from the `transform` function as the first argument and must return a string. Defaults to `JSON.stringify`.
66 | 
67 | **Note:** all of the options which accept a function can be run asynchronously by returning a promise (or *thenable*). If the given option has a return value constraint, the constraint will still be applied to the promise's fulfillment value.
68 | 
69 | ## Integrating with Web applications
70 | 
71 | gulp-sri is language-agnostic, thus this part relies on you and your specific use case. By default, gulp-sri generates a JSON file in the following format:
72 | 
73 | ```js
74 | {
75 | 	"path/to/file/relative/to/project/root/filename.ext": "srihash",
76 | 	//other entries
77 | }
78 | ```
79 | 
80 | Integration can be easily achieved on any language which supports JSON parsing, in either back-end or front-end. See the [Implementations page](https://github.com/UltCombo/gulp-buster/blob/master/IMPLEMENTATIONS.md) for examples and existing solutions for your language of choice.
81 | 
82 | **Note:** The output file contents' data structure and format can be customized through the [configuration options](#parameters). This enables gulp-sri to output the cache buster hashes file in a suitable native data structure for your target language, as well as allowing to mutate the paths and hashes to suit your specific needs.
83 | 
84 | ## Architecture
85 | 
86 | When gulp-sri is initialized, it creates an empty object which serves as a cache for the generated hashes. Generated hashes are then grouped by the `options.fileName` parameter. That means, piping two different streams into `sri('foo.json')` will merge both of those streams' files' hashes into the same output file. This approach's main pros are:
87 | 
88 | - Allows piping only modified files into gulp-sri, the other hashes are retrieved from the cache when generating the output file;
89 | - Deleted files' hashes are automatically cleaned on startup, as the hashes cache object starts empty on every startup;
90 | - Although this feature is very similar to [gulp-remember](https://github.com/ahaurw01/gulp-remember), gulp-sri's hashes cache is much more efficient. Using gulp-remember would cause all of the files that have ever went through the stream to be re-hashed whenever piping any new file, unlike gulp-sri's hashes cache which allows hashing only the files that are piped into gulp-buster.
91 | 
92 | There are close to no cons, the only notable drawback is that all the to-be-hashed files must be piped into gulp-sri (preferably at startup) before it generates the output file with all hashes that you'd expect. A feature to allow inputting an already-generated hashes file was considered in order to avoid having to pipe all the to-be-hashed files at startup, but that seems to bring more cons than pros -- the auto-cleanup of deleted files' hashes would no longer happen, outdated hashes could stay in the output hashes file if the to-be-hashed files were edited while gulp was not running, and finally it'd also be incompatible with the `transform` and `formatter` features.
93 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var crypto = require('crypto'),
  4 | 	path = require('path'),
  5 | 	sriToolbox = require('sri-toolbox'),
  6 | 	through = require('through'),
  7 | 	assign = require('object-assign'),
  8 | 	defaults = require('lodash.defaults'),
  9 | 	gutil = require('gulp-util'),
 10 | 	Promise = require('bluebird'),
 11 | 	DEFAULT_OPTIONS = {
 12 | 		fileName: 'sri.json',
 13 | 		transform: Object,
 14 | 		formatter: JSON.stringify,
 15 | 	},
 16 | 	OPTION_TYPES = {
 17 | 		fileName: ['String'],
 18 | 		algorithms: ['Array'],
 19 | 		transform: ['Function'],
 20 | 		formatter: ['Function'],
 21 | 	},
 22 | 	hashesStore = {}; // options.fileName: { relativePath: hash }
 23 | 
 24 | function error(msg) {
 25 | 	return new gutil.PluginError('gulp-sri', msg);
 26 | }
 27 | 
 28 | function hash(file, options) {
 29 | 	return sriToolbox.generate({
 30 | 		algorithms: options.algorithms
 31 | 	}, file.contents);
 32 | }
 33 | 
 34 | function sliceHash(hash, options) {
 35 | 	// positive length = leading characters; negative = trailing
 36 | 	return options.length
 37 | 		? options.length > 0
 38 | 			? hash.slice(0, options.length)
 39 | 			: hash.slice(options.length)
 40 | 		: hash;
 41 | }
 42 | 
 43 | function relativePath(projectPath, filePath) {
 44 | 	return path.relative(projectPath, filePath).replace(/\\/g, '/');
 45 | }
 46 | 
 47 | function getType(value) {
 48 | 	return {}.toString.call(value).slice(8, -1);
 49 | }
 50 | 
 51 | function assignOptions(options) {
 52 | 	if (typeof options === 'string') options = { fileName: options };
 53 | 	options = options || {};
 54 | 
 55 | 	Object.keys(options).forEach(function(option) {
 56 | 		if (!OPTION_TYPES.hasOwnProperty(option)) throw error('Unsupported option: ' + option);
 57 | 		if (options[option] !== undefined && !~OPTION_TYPES[option].indexOf(getType(options[option]))) throw error('`options.' + option + '` must be of type ' + OPTION_TYPES[option].join(' or '));
 58 | 	});
 59 | 
 60 | 	return defaults({}, options, DEFAULT_OPTIONS);
 61 | }
 62 | 
 63 | module.exports = exports = function(options) {
 64 | 	options = assignOptions(options);
 65 | 	var hashes = hashesStore[options.fileName] = hashesStore[options.fileName] || {},
 66 | 		hashingPromises = [];
 67 | 
 68 | 	function hashFile(file) {
 69 | 		if (file.isNull()) return; // ignore
 70 | 		if (file.isStream()) return this.emit('error', error('Streaming not supported'));
 71 | 
 72 | 		// start hashing files as soon as they are received for maximum concurrency
 73 | 		hashingPromises.push(
 74 | 			Promise.try(hash.bind(undefined, file, options)).then(function(hashed) {
 75 | 				if (typeof hashed !== 'string') throw error('Return/fulfill value must be a string');
 76 | 				hashes[relativePath(file.cwd, file.path)] = sliceHash(hashed, options);
 77 | 			})
 78 | 		);
 79 | 	}
 80 | 
 81 | 	function endStream() {
 82 | 		Promise.all(hashingPromises).bind(this).then(function() {
 83 | 			return options.transform.call(undefined, assign({}, hashes));
 84 | 		}).then(function(transformed) {
 85 | 			return options.formatter.call(undefined, transformed);
 86 | 		}).then(function(formatted) {
 87 | 			if (typeof formatted !== 'string') throw error('Return/fulfill value of `options.formatter` must be a string');
 88 | 
 89 | 			this.emit('data', new gutil.File({
 90 | 				path: path.join(process.cwd(), options.fileName),
 91 | 				contents: new Buffer(formatted),
 92 | 			}));
 93 | 			this.emit('end');
 94 | 		}).catch(function(err) {
 95 | 			this.emit('error', err instanceof gutil.PluginError ? err : error(err));
 96 | 		});
 97 | 	}
 98 | 
 99 | 	return through(hashFile, endStream);
100 | };
101 | 
102 | // for testing. Don't use, may be removed or changed at anytime
103 | assign(exports, {
104 | 	_Promise: Promise,
105 | 	_DEFAULT_OPTIONS: DEFAULT_OPTIONS,
106 | 	_error: error,
107 | 	_hash: hash,
108 | 	_relativePath: relativePath,
109 | 	_getType: getType,
110 | 	_assignOptions: assignOptions,
111 | 	_reset: function() {
112 | 		hashesStore = {};
113 | 	},
114 | });
115 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "gulp-sri",
 3 |   "description": "SRI integrety hash generator for gulp. Based on gulp-buster.",
 4 |   "version": "0.3.1",
 5 |   "author": {
 6 |     "name": "Matthew Conlen",
 7 |     "email": "code@mathisonian.com"
 8 |   },
 9 |   "main": "./index.js",
10 |   "keywords": [
11 |     "gulpplugin",
12 |     "sri",
13 |     "sri hash",
14 |     "cache",
15 |     "fingerprint",
16 |     "fingerprinting",
17 |     "revision",
18 |     "revisioning",
19 |     "workflow",
20 |     "webdev",
21 |     "web development"
22 |   ],
23 |   "repository": {
24 |     "type": "git",
25 |     "url": "https://github.com/mathisonian/gulp-sri.git"
26 |   },
27 |   "dependencies": {
28 |     "bluebird": "^2.3.2",
29 |     "gulp-util": "^3.0.1",
30 |     "lodash.defaults": "^2.4.1",
31 |     "object-assign": "^1.0.0",
32 |     "sri-toolbox": "0.2.0",
33 |     "through": "^2.3.4"
34 |   },
35 |   "engines": {
36 |     "node": ">= 0.10"
37 |   },
38 |   "license": "MIT",
39 |   "bugs": {
40 |     "url": "https://github.com/mathisonian/gulp-sri/issues"
41 |   },
42 |   "devDependencies": {
43 |     "istanbul": "^0.3.2",
44 |     "mocha": "^2.0.0",
45 |     "should": "^4.0"
46 |   },
47 |   "scripts": {
48 |     "test": "mocha",
49 |     "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- -R dot",
50 |     "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly"
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/test/main.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var bust = require('..'),
  4 | 	assign = require('object-assign'),
  5 | 	gutil = require('gulp-util'),
  6 | 	fileContentStr = 'foo',
  7 | 	file2ContentStr = [ // Transparent.gif
  8 | 		0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
  9 | 		0xff, 0xff, 0xff, 0x21, 0xf9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00,
 10 | 		0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x01, 0x44, 0x00, 0x3b
 11 | 	],
 12 | 	file = new gutil.File({
 13 | 		cwd: 'C:/users/ult/',
 14 | 		base: 'C:/users/ult/test',
 15 | 		path: 'C:/users/ult/test/file.js',
 16 | 		contents: new Buffer(fileContentStr),
 17 | 	}),
 18 | 	file2 = new gutil.File({
 19 | 		cwd: 'C:/users/ult/',
 20 | 		base: 'C:/users/ult/test',
 21 | 		path: 'C:/users/ult/test/file2.js',
 22 | 		contents: new Buffer(file2ContentStr),
 23 | 	}),
 24 | 	fileBustPath = bust._relativePath(file.cwd, file.path),
 25 | 	file2BustPath = bust._relativePath(file2.cwd, file2.path),
 26 | 	fileHash = bust._hash(file, bust._DEFAULT_OPTIONS),
 27 | 	file2Hash = bust._hash(file2, bust._DEFAULT_OPTIONS);
 28 | 
 29 | require('should');
 30 | 
 31 | beforeEach(bust._reset);
 32 | 
 33 | describe('Configuration-independent internal methods', function() {
 34 | 	describe('_error()', function() {
 35 | 		it('should return an instance of PluginError', function() {
 36 | 			bust._error('err').should.be.an.instanceOf(gutil.PluginError);
 37 | 		});
 38 | 	});
 39 | 
 40 | 	describe('_relativePath()', function() {
 41 | 		it('should return a path relative to project root', function() {
 42 | 			bust._relativePath('/projectRoot/', '/projectRoot/folder/file.ext').should.equal('folder/file.ext');
 43 | 		});
 44 | 	});
 45 | 
 46 | 	describe('_getType()', function() {
 47 | 		it('should return the correct type for all native values', function() {
 48 | 			bust._getType('').should.equal('String');
 49 | 			bust._getType(0).should.equal('Number');
 50 | 			bust._getType({}).should.equal('Object');
 51 | 			bust._getType([]).should.equal('Array');
 52 | 			bust._getType(null).should.equal('Null');
 53 | 			bust._getType(undefined).should.equal('Undefined');
 54 | 			bust._getType(false).should.equal('Boolean');
 55 | 			bust._getType(function() {}).should.equal('Function');
 56 | 			bust._getType(/(?:)/).should.equal('RegExp');
 57 | 			bust._getType(new Date()).should.equal('Date');
 58 | 			bust._getType(new Error()).should.equal('Error');
 59 | 		});
 60 | 	});
 61 | 
 62 | 	describe('_assignOptions()', function() {
 63 | 		it('should assign options', function() {
 64 | 			var options = { algorithms: ['sha256'] };
 65 | 			bust._assignOptions(options).should.eql(assign({}, bust._DEFAULT_OPTIONS, options));
 66 | 		});
 67 | 
 68 | 		it('should return the default options when no options are passed', function() {
 69 | 			bust._assignOptions().should.eql(bust._DEFAULT_OPTIONS);
 70 | 		});
 71 | 
 72 | 		it('should treat `options` string as `options.fileName`', function() {
 73 | 			var fileName = 'customName.ext';
 74 | 			bust._assignOptions(fileName).fileName.should.equal(fileName);
 75 | 		});
 76 | 
 77 | 		it('should set options whose value evaluate to `undefined` to their default value', function() {
 78 | 			bust._assignOptions({ fileName: undefined }).should.eql(bust._DEFAULT_OPTIONS);
 79 | 		});
 80 | 
 81 | 		it('should not mutate the `options` argument', function() {
 82 | 			var options = {};
 83 | 			bust._assignOptions(options);
 84 | 			options.should.eql({});
 85 | 		});
 86 | 
 87 | 		it('should throw on unsupported options', function() {
 88 | 			bust._assignOptions.bind(undefined, { foo: 0 }).should.throw();
 89 | 		});
 90 | 
 91 | 		it('should throw on invalid option value', function() {
 92 | 			bust._assignOptions.bind(undefined, { transform: null }).should.throw();
 93 | 		});
 94 | 	});
 95 | });
 96 | 
 97 | describe('Core', function() {
 98 | 	it('should bust two files into the same output file in the same stream', function(done) {
 99 | 		var stream = bust();
100 | 		stream.on('data', function(newFile) {
101 | 			newFile.should.be.an.instanceOf(gutil.File);
102 | 			newFile.should.have.property('path');
103 | 			newFile.should.have.property('relative');
104 | 			newFile.should.have.property('contents');
105 | 
106 | 			newFile.relative.should.equal('sri.json');
107 | 			var expectedObj = {};
108 | 			expectedObj[fileBustPath] = fileHash;
109 | 			expectedObj[file2BustPath] = file2Hash;
110 | 
111 | 			JSON.parse(newFile.contents.toString()).should.eql(expectedObj);
112 | 			Buffer.isBuffer(newFile.contents).should.be.true;
113 | 			done();
114 | 		});
115 | 		stream.write(file);
116 | 		stream.end(file2);
117 | 	});
118 | 
119 | 	it('should bust two files into different output files in different streams', function(done) {
120 | 		var stream = bust('output1.json'),
121 | 			stream2 = bust('output2.json'),
122 | 			testedOutputs = 0;
123 | 
124 | 		stream.on('data', function(newFile) {
125 | 			var obj = JSON.parse(newFile.contents.toString());
126 | 			obj.should.have.property(fileBustPath);
127 | 			obj.should.not.have.property(file2BustPath);
128 | 			if (++testedOutputs === 2) done();
129 | 		});
130 | 		stream2.on('data', function(newFile) {
131 | 			var obj = JSON.parse(newFile.contents.toString());
132 | 			obj.should.not.have.property(fileBustPath);
133 | 			obj.should.have.property(file2BustPath);
134 | 			if (++testedOutputs === 2) done();
135 | 		});
136 | 		stream.end(file);
137 | 		stream2.end(file2);
138 | 	});
139 | 
140 | 	it('should bust two files into the same output file in different streams', function(done) {
141 | 		var stream = bust('output.json'),
142 | 			stream2 = bust('output.json'),
143 | 			testedOutputs = 0;
144 | 
145 | 		function runAssertion(newFile) {
146 | 			var obj = JSON.parse(newFile.contents.toString());
147 | 			obj.should.have.property(fileBustPath);
148 | 			obj.should.have.property(file2BustPath);
149 | 			done();
150 | 		}
151 | 		function onData() {
152 | 			if (++testedOutputs === 2) runAssertion.apply(this, arguments);
153 | 		}
154 | 		stream.on('data', onData);
155 | 		stream2.on('data', onData);
156 | 		stream.end(file);
157 | 		stream2.end(file2);
158 | 	});
159 | 
160 | 	it('should return an empty hashes object file when receiving an empty buffers stream', function(done) {
161 | 		var stream = bust();
162 | 		stream.on('data', function(newFile) {
163 | 			JSON.parse(newFile.contents.toString()).should.eql({});
164 | 			done();
165 | 		});
166 | 		stream.end();
167 | 	});
168 | });
169 | 
170 | describe('Configuration options', function() {
171 | 	describe('fileName', function() {
172 | 		it('should allow setting the output file name', function(done) {
173 | 			var fileName = 'customName.ext';
174 | 
175 | 			var stream = bust({ fileName: fileName });
176 | 			stream.on('data', function(newFile) {
177 | 				newFile.relative.should.equal(fileName);
178 | 				done();
179 | 			});
180 | 			stream.end(file);
181 | 		});
182 | 	});
183 | 
184 | 	describe('algo', function() {
185 | 		it('should accept an array of algorithms', function(done) {
186 | 			var stream = bust({ algorithms: ['sha256'] });
187 | 			stream.on('data', function(newFile) {
188 | 				JSON.parse(newFile.contents.toString())[fileBustPath].should.be.exactly('sha256-LCa0a2j/xo/5m0U8HTBBNBNCLXBkg7+g+YpeiGJm564=');
189 | 				done();
190 | 			});
191 | 			stream.end(file);
192 | 		});
193 | 
194 | 		it('should emit an error when the hashing algorithm is not supported', function(done) {
195 | 			var stream = bust({ algorithms: ['UltHasher9000'] });
196 | 			stream.on('error', function() {
197 | 				done();
198 | 			});
199 | 			stream.end(file);
200 | 		});
201 | 
202 | 		it('should correctly generate the hash for a binary file', function(done) {
203 | 			var stream = bust({ algorithms: ['sha256'] });
204 | 			stream.on('data', function(newFile) {
205 | 				JSON.parse(newFile.contents.toString())[file2BustPath].should.be.exactly('sha256-7xlVrnV8i5ZsgySDUDMb06MPZYztEfOH+OvwWrM2hik=');
206 | 				done();
207 | 			});
208 | 			stream.end(file2);
209 | 		});
210 | 	});
211 | 
212 | 	describe('transform', function() {
213 | 		it('should accept a synchronous function', function(done) {
214 | 			var suffix = '_suffix',
215 | 				options = {
216 | 					transform: function(hashes) {
217 | 						(this === undefined).should.be.true;
218 | 						return [hashes[fileBustPath] + suffix];
219 | 					},
220 | 				},
221 | 				stream = bust(options);
222 | 			stream.on('data', function(newFile) {
223 | 				JSON.parse(newFile.contents.toString())[0].should.equal(fileHash + suffix);
224 | 				done();
225 | 			});
226 | 			stream.end(file);
227 | 		});
228 | 
229 | 		it('should accept an asynchronous function', function(done) {
230 | 			var suffix = '_suffix',
231 | 				options = {
232 | 					transform: function(hashes) {
233 | 						(this === undefined).should.be.true;
234 | 						return new bust._Promise(function(fulfill) {
235 | 							setTimeout(function() {
236 | 								fulfill([hashes[fileBustPath] + suffix]);
237 | 							}, 0);
238 | 						});
239 | 					},
240 | 				},
241 | 				stream = bust(options);
242 | 			stream.on('data', function(newFile) {
243 | 				JSON.parse(newFile.contents.toString())[0].should.equal(fileHash + suffix);
244 | 				done();
245 | 			});
246 | 			stream.end(file);
247 | 		});
248 | 	});
249 | 
250 | 	describe('formatter', function() {
251 | 		it('should accept a synchronous function', function(done) {
252 | 			var options = {
253 | 					formatter: function(hashes) {
254 | 						(this === undefined).should.be.true;
255 | 						return hashes[fileBustPath];
256 | 					},
257 | 				},
258 | 				stream = bust(options);
259 | 			stream.on('data', function(newFile) {
260 | 				newFile.contents.toString().should.equal(fileHash);
261 | 				done();
262 | 			});
263 | 			stream.end(file);
264 | 		});
265 | 
266 | 		it('should accept an asynchronous function', function(done) {
267 | 			var options = {
268 | 					formatter: function(hashes) {
269 | 						(this === undefined).should.be.true;
270 | 						return new bust._Promise(function(fulfill) {
271 | 							setTimeout(function() {
272 | 								fulfill(hashes[fileBustPath]);
273 | 							}, 0);
274 | 						});
275 | 					},
276 | 				},
277 | 				stream = bust(options);
278 | 			stream.on('data', function(newFile) {
279 | 				newFile.contents.toString().should.equal(fileHash);
280 | 				done();
281 | 			});
282 | 			stream.end(file);
283 | 		});
284 | 
285 | 		it('should emit an error when function does not return a string or promise', function(done) {
286 | 			var stream = bust({ formatter: function() {} });
287 | 			stream.on('error', function(err) {
288 | 				err.should.be.an.instanceOf(gutil.PluginError);
289 | 				done();
290 | 			});
291 | 			stream.end(file);
292 | 		});
293 | 
294 | 		it('should emit an error when promise is not fulfilled with a string', function(done) {
295 | 			var stream = bust({
296 | 					formatter: function() {
297 | 						return new bust._Promise.resolve();
298 | 					},
299 | 				});
300 | 			stream.on('error', function(err) {
301 | 				err.should.be.an.instanceOf(gutil.PluginError);
302 | 				done();
303 | 			});
304 | 			stream.end(file);
305 | 		});
306 | 	});
307 | });
308 | 


--------------------------------------------------------------------------------