Commit 899bdbee0824c6f1d64652cd691df1f985809a4c - node-has-binary

Import upstream version 0.1.7+git20170301.1.f9be9b3 Debian Janitor 2 years ago

5 changed file(s) with 74 addition(s) and 72 deletion(s). Raw diff Collapse all Expand all

-15

~~.gitignore~~ less more

0		lib-cov
1		*.seed
2		*.log
3		*.csv
4		*.dat
5		*.out
6		*.pid
7		*.gz
8
9		pids
10		logs
11		results
12
13		npm-debug.log
14		node_modules

-0

.travis.yml less more

	0	language: node_js
	1	sudo: false
	2	node_js:
	3	- "node"

+33

-34

index.js less more

	0	/* global Blob File */
0	1
1	2	/*
2	3	* Module requirements.

13	14	/**
14	15	* Checks for binary data.
15	16	*
16		* Right now only Buffer and ArrayBuffer are supported..
	17	* Supports Buffer, ArrayBuffer, Blob and File.
17	18	*
18	19	* @param {Object} anything
19	20	* @api public
20	21	*/
21	22
22		function hasBinary(data) {
23
24		function _hasBinary(obj) {
25		if (!obj) return false;
26
27		if ( (global.Buffer && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) \|\|
28		(global.ArrayBuffer && obj instanceof ArrayBuffer) \|\|
29		(global.Blob && obj instanceof Blob) \|\|
30		(global.File && obj instanceof File)
31		) {
32		return true;
33		}
34
35		if (isArray(obj)) {
36		for (var i = 0; i < obj.length; i++) {
37		if (_hasBinary(obj[i])) {
38		return true;
39		}
40		}
41		} else if (obj && 'object' == typeof obj) {
42		// see: https://github.com/Automattic/has-binary/pull/4
43		if (obj.toJSON && 'function' == typeof obj.toJSON) {
44		obj = obj.toJSON();
45		}
46
47		for (var key in obj) {
48		if (Object.prototype.hasOwnProperty.call(obj, key) && _hasBinary(obj[key])) {
49		return true;
50		}
51		}
52		}
53
	23	function hasBinary (obj) {
	24	if (!obj \|\| typeof obj !== 'object') {
54	25	return false;
55	26	}
56	27
57		return _hasBinary(data);
	28	if (isArray(obj)) {
	29	for (var i = 0, l = obj.length; i < l; i++) {
	30	if (hasBinary(obj[i])) {
	31	return true;
	32	}
	33	}
	34	return false;
	35	}
	36
	37	if ((typeof global.Buffer === 'function' && global.Buffer.isBuffer && global.Buffer.isBuffer(obj)) \|\|
	38	(typeof global.ArrayBuffer === 'function' && obj instanceof ArrayBuffer) \|\|
	39	(typeof global.Blob === 'function' && obj instanceof Blob) \|\|
	40	(typeof global.File === 'function' && obj instanceof File)
	41	) {
	42	return true;
	43	}
	44
	45	// see: https://github.com/Automattic/has-binary/pull/4
	46	if (obj.toJSON && typeof obj.toJSON === 'function') {
	47	return hasBinary(obj.toJSON());
	48	}
	49
	50	for (var key in obj) {
	51	if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
	52	return true;
	53	}
	54	}
	55
	56	return false;
58	57	}

-3

package.json less more

2	2	"version": "0.1.7",
3	3	"description": "A function that takes anything in javascript and returns true if its argument contains binary data.",
4	4	"dependencies": {
5		"isarray": "0.0.1"
	5	"isarray": "2.0.1"
6	6	},
7	7	"devDependencies": {
8		"better-assert": "1.0.0",
9		"mocha": "2.3.4"
	8	"better-assert": "^1.0.2",
	9	"mocha": "^3.2.0",
	10	"semistandard": "^9.2.1"
	11	},
	12	"scripts": {
	13	"checkstyle": "semistandard",
	14	"test": "npm run checkstyle && mocha --bail"
10	15	},
11	16	"author": "Kevin Roark",
12	17	"license": "MIT"

+29

-20

test.js less more

	0	/* global describe it Blob */
0	1
1	2	var hasBinary = require('./');
2	3	var assert = require('better-assert');
3	4	var fs = require('fs');
4	5
5		describe('has-binarydata', function(){
6
7		it('should work with buffer', function(){
	6	describe('has-binarydata', function () {
	7	it('should work with buffer', function () {
8	8	assert(hasBinary(fs.readFileSync('./test.js')));
9	9	});
10	10
11		it('should work with an array that does not contain binary', function() {
	11	it('should work with an array that does not contain binary', function () {
12	12	var arr = [1, 'cool', 2];
13	13	assert(!hasBinary(arr));
14	14	});
15	15
16		it('should work with an array that contains a buffer', function() {
	16	it('should work with an array that contains a buffer', function () {
17	17	var arr = [1, new Buffer('asdfasdf', 'utf8'), 2];
18	18	assert(hasBinary(arr));
19	19	});
20	20
21		it('should work with an object that does not contain binary', function() {
22		var ob = {a: 'a', b: [], c: 1234, toJSON: '{\"a\": \"a\"}'};
	21	it('should work with an object that does not contain binary', function () {
	22	var ob = {a: 'a', b: [], c: 1234, toJSON: '{"a": "a"}'};
23	23	assert(!hasBinary(ob));
24	24	});
25	25
26		it('should work with an object that contains a buffer', function() {
27		var ob = {a: 'a', b: new Buffer('abc'), c: 1234, toJSON: '{\"a\": \"a\"}'};
	26	it('should work with an object that contains a buffer', function () {
	27	var ob = {a: 'a', b: new Buffer('abc'), c: 1234, toJSON: '{"a": "a"}'};
28	28	assert(hasBinary(ob));
29	29	});
30	30
31		it('should work with null', function() {
	31	it('should work with an object whose toJSON() returns a buffer', function () {
	32	var ob = {a: 'a', b: [], c: 1234, toJSON: function () { return new Buffer('abc'); }};
	33	assert(hasBinary(ob));
	34	});
	35
	36	it('should work with null', function () {
32	37	assert(!hasBinary(null));
33	38	});
34	39
35		it('should work with undefined', function() {
	40	it('should work with undefined', function () {
36	41	assert(!hasBinary(undefined));
37	42	});
38	43
39		it('should work with a complex object that contains undefined and no binary', function() {
	44	it('should work with a complex object that contains undefined and no binary', function () {
40	45	var ob = {
41	46	x: ['a', 'b', 123],
42	47	y: undefined,

46	51	assert(!hasBinary(ob));
47	52	});
48	53
49		it('should work with a complex object that contains undefined and binary', function() {
	54	it('should work with a complex object that contains undefined and binary', function () {
50	55	var ob = {
51	56	x: ['a', 'b', 123],
52	57	y: undefined,

58	63	});
59	64
60	65	if (global.ArrayBuffer) {
61		it('should work with an ArrayBuffer', function() {
62		assert(hasBinary(new ArrayBuffer()));
63		});
	66	it('should work with an ArrayBuffer', function () {
	67	assert(hasBinary(new ArrayBuffer()));
	68	});
64	69	}
65	70
66	71	if (global.Blob) {
67		it('should work with a Blob', function() {
68		assert(hasBinary(new Blob()));
69		});
	72	it('should work with a Blob', function () {
	73	assert(hasBinary(new Blob()));
	74	});
	75	} else {
	76	it('should not crash if global Blob is not a function', function () {
	77	global.Blob = [ 1, 2, 3 ];
	78	assert(!hasBinary(global.Blob));
	79	});
70	80	}
71
72	81	});