dry-underscore
Advanced tools
dry-underscore - npm Package Compare versions
Comparing version 0.21.7 to 0.21.8
@@ -14,2 +14,3 @@ | ||
| _.sha256 = require('../lib/sha256.js').library(_); | ||
| _.inspect = require('../lib/inspect.js').library(_); | ||
| _.format = require('../lib/format.js').library(_); | ||
@@ -16,0 +17,0 @@ _.test = require('../lib/test.js').library(_); |
| function library(_){ | ||
| function isString(arg) { | ||
| return typeof arg === 'string'; | ||
| } | ||
| function isObject(arg) { | ||
| return typeof arg === 'object' && arg !== null; | ||
| } | ||
| function isNull(arg) { | ||
| return arg === null; | ||
| } | ||
| // taken from the nodejs source | ||
| var format = (function(){ | ||
| var formatRegExp = /%[sdj%]/g; | ||
| return(function(f) { | ||
| var format_f = function(f) { | ||
| if (!isString(f)) { | ||
| var objects = []; | ||
| for (var i = 0; i < arguments.length; i++) { | ||
| objects.push(inspect(arguments[i])); | ||
| objects.push(_.inspect(arguments[i])); | ||
| } | ||
@@ -39,508 +50,9 @@ return objects.join(' '); | ||
| } else { | ||
| str += ' ' + inspect(x); | ||
| str += ' ' + _.inspect(x); | ||
| } | ||
| } | ||
| return str; | ||
| }); | ||
| /** | ||
| * Echos the value of a value. Trys to print the value out | ||
| * in the best way possible given the different types. | ||
| * | ||
| * @param {Object} obj The object to print out. | ||
| * @param {Object} opts Optional options object that alters the output. | ||
| */ | ||
| /* legacy: obj, showHidden, depth, colors*/ | ||
| function inspect(obj, opts) { | ||
| // default options | ||
| var ctx = { | ||
| seen: [], | ||
| stylize: stylizeNoColor | ||
| }; | ||
| // legacy... | ||
| if (arguments.length >= 3) ctx.depth = arguments[2]; | ||
| if (arguments.length >= 4) ctx.colors = arguments[3]; | ||
| if (isBoolean(opts)) { | ||
| // legacy... | ||
| ctx.showHidden = opts; | ||
| } else if (opts) { | ||
| // got an "options" object | ||
| _extend(ctx, opts); | ||
| } | ||
| // set default options | ||
| if (isUndefined(ctx.showHidden)) ctx.showHidden = false; | ||
| if (isUndefined(ctx.depth)) ctx.depth = 4; | ||
| if (isUndefined(ctx.colors)) ctx.colors = false; | ||
| if (isUndefined(ctx.customInspect)) ctx.customInspect = true; | ||
| if (ctx.colors) ctx.stylize = stylizeWithColor; | ||
| return formatValue(ctx, obj, ctx.depth); | ||
| } | ||
| // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics | ||
| inspect.colors = { | ||
| 'bold' : [1, 22], | ||
| 'italic' : [3, 23], | ||
| 'underline' : [4, 24], | ||
| 'inverse' : [7, 27], | ||
| 'white' : [37, 39], | ||
| 'grey' : [90, 39], | ||
| 'black' : [30, 39], | ||
| 'blue' : [34, 39], | ||
| 'cyan' : [36, 39], | ||
| 'green' : [32, 39], | ||
| 'magenta' : [35, 39], | ||
| 'red' : [31, 39], | ||
| 'yellow' : [33, 39] | ||
| }; | ||
| // Don't use 'blue' not visible on cmd.exe | ||
| inspect.styles = { | ||
| 'special': 'cyan', | ||
| 'number': 'yellow', | ||
| 'boolean': 'yellow', | ||
| 'undefined': 'grey', | ||
| 'null': 'bold', | ||
| 'string': 'green', | ||
| 'date': 'magenta', | ||
| // "name": intentionally not styling | ||
| 'regexp': 'red' | ||
| }; | ||
| function stylizeWithColor(str, styleType) { | ||
| var style = inspect.styles[styleType]; | ||
| if (style) { | ||
| return '\u001b[' + inspect.colors[style][0] + 'm' + str + | ||
| '\u001b[' + inspect.colors[style][1] + 'm'; | ||
| } else { | ||
| return str; | ||
| } | ||
| } | ||
| function stylizeNoColor(str, styleType) { | ||
| return str; | ||
| } | ||
| function arrayToHash(array) { | ||
| var hash = {}; | ||
| array.forEach(function(val, idx) { | ||
| hash[val] = true; | ||
| }); | ||
| return hash; | ||
| } | ||
| function formatValue(ctx, value, recurseTimes) { | ||
| // Provide a hook for user-specified inspect functions. | ||
| // Check that value is an object with an inspect function on it | ||
| if (ctx.customInspect && | ||
| value && | ||
| isFunction(value.inspect) && | ||
| // Filter out the util module, it's inspect function is special | ||
| value.inspect !== exports.inspect && | ||
| // Also filter out any prototype objects using the circular check. | ||
| !(value.constructor && value.constructor.prototype === value)) { | ||
| var ret = value.inspect(recurseTimes, ctx); | ||
| if (!isString(ret)) { | ||
| ret = formatValue(ctx, ret, recurseTimes); | ||
| } | ||
| return ret; | ||
| } | ||
| // Primitive types cannot have properties | ||
| var primitive = formatPrimitive(ctx, value); | ||
| if (primitive) { | ||
| return primitive; | ||
| } | ||
| // Look up the keys of the object. | ||
| var keys = Object.keys(value); | ||
| var visibleKeys = arrayToHash(keys); | ||
| if (ctx.showHidden) { | ||
| keys = Object.getOwnPropertyNames(value); | ||
| } | ||
| // This could be a boxed primitive (new String(), etc.), check valueOf() | ||
| // NOTE: Avoid calling `valueOf` on `Date` instance because it will return | ||
| // a number which, when object has some additional user-stored `keys`, | ||
| // will be printed out. | ||
| var formatted; | ||
| var raw = value; | ||
| try { | ||
| // the .valueOf() call can fail for a multitude of reasons | ||
| if (!isDate(value)) | ||
| raw = value.valueOf(); | ||
| } catch (e) { | ||
| // ignore... | ||
| } | ||
| if (isString(raw)) { | ||
| // for boxed Strings, we have to remove the 0-n indexed entries, | ||
| // since they just noisey up the output and are redundant | ||
| keys = keys.filter(function(key) { | ||
| return !(key >= 0 && key < raw.length); | ||
| }); | ||
| } | ||
| // Some type of object without properties can be shortcutted. | ||
| if (keys.length === 0) { | ||
| if (isFunction(value)) { | ||
| var name = value.name ? ': ' + value.name : ''; | ||
| return ctx.stylize('[Function' + name + ']', 'special'); | ||
| } | ||
| if (isRegExp(value)) { | ||
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | ||
| } | ||
| if (isDate(value)) { | ||
| return ctx.stylize(Date.prototype.toString.call(value), 'date'); | ||
| } | ||
| if (isError(value)) { | ||
| return formatError(value); | ||
| } | ||
| // now check the `raw` value to handle boxed primitives | ||
| if (isString(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| return ctx.stylize('[String: ' + formatted + ']', 'string'); | ||
| } | ||
| if (isNumber(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| return ctx.stylize('[Number: ' + formatted + ']', 'number'); | ||
| } | ||
| if (isBoolean(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| return ctx.stylize('[Boolean: ' + formatted + ']', 'boolean'); | ||
| } | ||
| } | ||
| var base = '', array = false, braces = ['{', '}']; | ||
| // Make Array say that they are Array | ||
| if (isArray(value)) { | ||
| array = true; | ||
| braces = ['[', ']']; | ||
| } | ||
| // Make functions say that they are functions | ||
| if (isFunction(value)) { | ||
| var n = value.name ? ': ' + value.name : ''; | ||
| base = ' [Function' + n + ']'; | ||
| } | ||
| // Make RegExps say that they are RegExps | ||
| if (isRegExp(value)) { | ||
| base = ' ' + RegExp.prototype.toString.call(value); | ||
| } | ||
| // Make dates with properties first say the date | ||
| if (isDate(value)) { | ||
| base = ' ' + Date.prototype.toUTCString.call(value); | ||
| } | ||
| // Make error with message first say the error | ||
| if (isError(value)) { | ||
| base = ' ' + formatError(value); | ||
| } | ||
| // Make boxed primitive Strings look like such | ||
| if (isString(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| base = ' ' + '[String: ' + formatted + ']'; | ||
| } | ||
| // Make boxed primitive Numbers look like such | ||
| if (isNumber(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| base = ' ' + '[Number: ' + formatted + ']'; | ||
| } | ||
| // Make boxed primitive Booleans look like such | ||
| if (isBoolean(raw)) { | ||
| formatted = formatPrimitiveNoColor(ctx, raw); | ||
| base = ' ' + '[Boolean: ' + formatted + ']'; | ||
| } | ||
| if (keys.length === 0 && (!array || value.length == 0)) { | ||
| return braces[0] + base + braces[1]; | ||
| } | ||
| if (recurseTimes < 0) { | ||
| if (isRegExp(value)) { | ||
| return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); | ||
| } else { | ||
| return ctx.stylize('[Object]', 'special'); | ||
| } | ||
| } | ||
| ctx.seen.push(value); | ||
| var output; | ||
| if (array) { | ||
| output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); | ||
| } else { | ||
| output = keys.map(function(key) { | ||
| return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); | ||
| }); | ||
| } | ||
| ctx.seen.pop(); | ||
| return reduceToSingleString(output, base, braces); | ||
| } | ||
| function formatPrimitive(ctx, value) { | ||
| if (isUndefined(value)) | ||
| return ctx.stylize('undefined', 'undefined'); | ||
| if (isString(value)) { | ||
| var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') | ||
| .replace(/'/g, "\\'") | ||
| .replace(/\\"/g, '"') + '\''; | ||
| return ctx.stylize(simple, 'string'); | ||
| } | ||
| if (isNumber(value)) { | ||
| // Format -0 as '-0'. Strict equality won't distinguish 0 from -0, | ||
| // so instead we use the fact that 1 / -0 < 0 whereas 1 / 0 > 0 . | ||
| if (value === 0 && 1 / value < 0) | ||
| return ctx.stylize('-0', 'number'); | ||
| return ctx.stylize('' + value, 'number'); | ||
| } | ||
| if (isBoolean(value)) | ||
| return ctx.stylize('' + value, 'boolean'); | ||
| // For some reason typeof null is "object", so special case here. | ||
| if (isNull(value)) | ||
| return ctx.stylize('null', 'null'); | ||
| } | ||
| function formatPrimitiveNoColor(ctx, value) { | ||
| var stylize = ctx.stylize; | ||
| ctx.stylize = stylizeNoColor; | ||
| var str = formatPrimitive(ctx, value); | ||
| ctx.stylize = stylize; | ||
| return str; | ||
| } | ||
| function formatError(value) { | ||
| return '[' + Error.prototype.toString.call(value) + ']'; | ||
| } | ||
| function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { | ||
| var output = []; | ||
| for (var i = 0, l = value.length; i < l; ++i) { | ||
| if (hasOwnProperty(value, String(i))) { | ||
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | ||
| String(i), true)); | ||
| } else { | ||
| output.push(''); | ||
| } | ||
| } | ||
| keys.forEach(function(key) { | ||
| if (!key.match(/^\d+$/)) { | ||
| output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, | ||
| key, true)); | ||
| } | ||
| }); | ||
| return output; | ||
| } | ||
| function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { | ||
| var name, str, desc; | ||
| desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; | ||
| if (desc.get) { | ||
| if (desc.set) { | ||
| str = ctx.stylize('[Getter/Setter]', 'special'); | ||
| } else { | ||
| str = ctx.stylize('[Getter]', 'special'); | ||
| } | ||
| } else { | ||
| if (desc.set) { | ||
| str = ctx.stylize('[Setter]', 'special'); | ||
| } | ||
| } | ||
| if (!hasOwnProperty(visibleKeys, key)) { | ||
| name = '[' + key + ']'; | ||
| } | ||
| if (!str) { | ||
| if (ctx.seen.indexOf(desc.value) < 0) { | ||
| if (isNull(recurseTimes)) { | ||
| str = formatValue(ctx, desc.value, null); | ||
| } else { | ||
| str = formatValue(ctx, desc.value, recurseTimes - 1); | ||
| } | ||
| if (str.indexOf('\n') > -1) { | ||
| if (array) { | ||
| str = str.split('\n').map(function(line) { | ||
| return ' ' + line; | ||
| }).join('\n').substr(2); | ||
| } else { | ||
| str = '\n' + str.split('\n').map(function(line) { | ||
| return ' ' + line; | ||
| }).join('\n'); | ||
| } | ||
| } | ||
| } else { | ||
| str = ctx.stylize('[Circular]', 'special'); | ||
| } | ||
| } | ||
| if (isUndefined(name)) { | ||
| if (array && key.match(/^\d+$/)) { | ||
| return str; | ||
| } | ||
| name = JSON.stringify('' + key); | ||
| if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { | ||
| name = name.substr(1, name.length - 2); | ||
| name = ctx.stylize(name, 'name'); | ||
| } else { | ||
| name = name.replace(/'/g, "\\'") | ||
| .replace(/\\"/g, '"') | ||
| .replace(/(^"|"$)/g, "'") | ||
| .replace(/\\\\/g, '\\'); | ||
| name = ctx.stylize(name, 'string'); | ||
| } | ||
| } | ||
| return name + ': ' + str; | ||
| } | ||
| function reduceToSingleString(output, base, braces) { | ||
| var length = output.reduce(function(prev, cur) { | ||
| return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; | ||
| }, 0); | ||
| if (length > 60) { | ||
| return braces[0] + | ||
| (base === '' ? '' : base + '\n ') + | ||
| ' ' + | ||
| output.join(',\n ') + | ||
| ' ' + | ||
| braces[1]; | ||
| } | ||
| return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; | ||
| } | ||
| // NOTE: These type checking functions intentionally don't use `instanceof` | ||
| // because it is fragile and can be easily faked with `Object.create()`. | ||
| function isArray(ar) { | ||
| return Array.isArray(ar); | ||
| } | ||
| function isBoolean(arg) { | ||
| return typeof arg === 'boolean'; | ||
| } | ||
| function isNull(arg) { | ||
| return arg === null; | ||
| } | ||
| function isNullOrUndefined(arg) { | ||
| return arg == null; | ||
| } | ||
| function isNumber(arg) { | ||
| return typeof arg === 'number'; | ||
| } | ||
| function isString(arg) { | ||
| return typeof arg === 'string'; | ||
| } | ||
| function isSymbol(arg) { | ||
| return typeof arg === 'symbol'; | ||
| } | ||
| function isUndefined(arg) { | ||
| return arg === void 0; | ||
| } | ||
| function isRegExp(re) { | ||
| return isObject(re) && objectToString(re) === '[object RegExp]'; | ||
| } | ||
| function isObject(arg) { | ||
| return typeof arg === 'object' && arg !== null; | ||
| } | ||
| function isDate(d) { | ||
| return isObject(d) && objectToString(d) === '[object Date]'; | ||
| } | ||
| function isError(e) { | ||
| return isObject(e) && | ||
| (objectToString(e) === '[object Error]' || e instanceof Error); | ||
| } | ||
| function isFunction(arg) { | ||
| return typeof arg === 'function'; | ||
| } | ||
| function isPrimitive(arg) { | ||
| return arg === null || | ||
| typeof arg === 'boolean' || | ||
| typeof arg === 'number' || | ||
| typeof arg === 'string' || | ||
| typeof arg === 'symbol' || // ES6 symbol | ||
| typeof arg === 'undefined'; | ||
| } | ||
| function isBuffer(arg) { | ||
| return arg instanceof Buffer; | ||
| } | ||
| function objectToString(o) { | ||
| return Object.prototype.toString.call(o); | ||
| } | ||
| function pad(n) { | ||
| return n < 10 ? '0' + n.toString(10) : n.toString(10); | ||
| } | ||
| var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']; | ||
| // 26 Feb 16:19:34 | ||
| function timestamp() { | ||
| var d = new Date(); | ||
| var time = [pad(d.getHours()), | ||
| pad(d.getMinutes()), | ||
| pad(d.getSeconds())].join(':'); | ||
| return [d.getDate(), months[d.getMonth()], time].join(' '); | ||
| } | ||
| // log is just a thin wrapper to console.log that prepends a timestamp | ||
| /* | ||
| exports.log = function() { | ||
| console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); | ||
| }; | ||
| */ | ||
| var _extend = function(origin, add) { | ||
| // Don't do anything if add isn't an object | ||
| if (!add || !isObject(add)) return origin; | ||
| var keys = Object.keys(add); | ||
| var i = keys.length; | ||
| while (i--) { | ||
| origin[keys[i]] = add[keys[i]]; | ||
| } | ||
| return origin; | ||
| }; | ||
| function hasOwnProperty(obj, prop) { | ||
| return Object.prototype.hasOwnProperty.call(obj, prop); | ||
| } | ||
| return(format_f); | ||
| })(); | ||
@@ -547,0 +59,0 @@ |
@@ -18,2 +18,11 @@ "use strict"; | ||
| test("inspect", function(){ | ||
| eq(_.inspect({ test: "hello" }), "{ test: 'hello' }"); | ||
| }); | ||
| test("inspect", function(){ | ||
| eq(_.inspect({ test: "hello", obj: { a: {} } }, { depth: 0 }), "{ test: 'hello', obj: [Object] }"); | ||
| eq(_.inspect({ test: "hello", obj: { a: {} } }, { depth: 1 }), "{ test: 'hello', obj: { a: {} } }"); | ||
| }); | ||
| test("phone_number", function(){ | ||
@@ -20,0 +29,0 @@ eq(_.format.phone_number(null), null); |
| { | ||
| "name": "dry-underscore", | ||
| "version": "0.21.7", | ||
| "version": "0.21.8", | ||
| "dependencies": { | ||
@@ -5,0 +5,0 @@ "deep-diff": { |
| { | ||
| "name": "dry-underscore", | ||
| "version": "0.21.7", | ||
| "version": "0.21.8", | ||
| "main": "./index/node.index.js", | ||
@@ -5,0 +5,0 @@ "description": "The DRY Undescore Library", |
Sorry, the diff of this file is not supported yet
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Number of package files
- increased by0.75%
134
- Lines of code
- increased by0.17%
23313
Worsened metrics
- Total package byte prevSize
- decreased by-0.11%
1920771
No dependency changes