Socket
Socket
Sign inDemoInstall

empower

Package Overview
Dependencies
Maintainers
1
Versions
37
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

empower - npm Package Compare versions

Comparing version 0.7.1 to 0.7.2

build/empower.js
gulpfile.js
test/not_espowered_case_test.js

15

bower.json
{
"name": "empower",
"version": "0.7.1",
"version": "0.7.2",
"main": "lib/empower.js",
"ignore": [
"**/.*",
"Gruntfile.js",
"gulpfile.js",
"node_modules",

@@ -14,13 +14,8 @@ "package.json",

"devDependencies": {
"espower": "~0.7.0",
"esprima": "~1.2.1",
"escodegen": "1.3.0",
"mocha": "~1.18.2",
"requirejs": "~2.1.11",
"espower-source": "~0.7.3",
"mocha": "~1.20.0",
"requirejs": "~2.1.13",
"assert": "Jxck/assert",
"buster.js": "~0.7.0"
},
"resolutions": {
"esprima": "~1.2.1"
}
}

402

lib/empower.js

@@ -8,188 +8,193 @@ /**

* Licensed under the MIT license.
* https://raw.github.com/twada/empower/master/MIT-LICENSE.txt
*
* A part of extend function is:
* Copyright 2012 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
* https://github.com/twada/empower/blob/master/MIT-LICENSE.txt
*/
(function (root, factory) {
'use strict';
'use strict';
// using returnExports UMD pattern
if (typeof define === 'function' && define.amd) {
define(factory);
} else if (typeof exports === 'object') {
module.exports = factory();
} else {
root.empower = factory();
}
}(this, function () {
'use strict';
var extend = require('node.extend'),
isPhantom = typeof window !== 'undefined' && typeof window.callPhantom === 'function';
var isPhantom = typeof window !== 'undefined' && typeof window.callPhantom === 'function';
function defaultOptions () {
return {
destructive: false,
modifyMessageOnFail: false,
saveContextOnFail: false,
targetMethods: {
oneArg: [
'ok'
],
twoArgs: [
'equal',
'notEqual',
'strictEqual',
'notStrictEqual',
'deepEqual',
'notDeepEqual'
]
}
};
}
function defaultOptions () {
return {
destructive: false,
modifyMessageOnFail: false,
saveContextOnFail: false,
targetMethods: {
oneArg: [
'ok'
],
twoArgs: [
'equal',
'notEqual',
'strictEqual',
'notStrictEqual',
'deepEqual',
'notDeepEqual'
]
}
};
}
/**
* Enhance Power Assert feature to assert function/object.
* @param assert target assert function or object to enhance
* @param formatter power assert format function
* @param options enhancement options
* @return enhanced assert function/object
*/
function empower (assert, formatter, options) {
var typeOfAssert = (typeof assert),
config;
if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
throw new TypeError('empower argument should be a function or object.');
}
if (isEmpowered(assert)) {
return assert;
}
config = extend(defaultOptions(), (options || {}));
switch (typeOfAssert) {
case 'function':
return empowerAssertFunction(assert, formatter, config);
case 'object':
return empowerAssertObject(assert, formatter, config);
default:
throw new Error('Cannot be here');
}
/**
* Enhance Power Assert feature to assert function/object.
* @param assert target assert function or object to enhance
* @param formatter power assert format function
* @param options enhancement options
* @return enhanced assert function/object
*/
function empower (assert, formatter, options) {
var typeOfAssert = (typeof assert),
config;
if ((typeOfAssert !== 'object' && typeOfAssert !== 'function') || assert === null) {
throw new TypeError('empower argument should be a function or object.');
}
if (isEmpowered(assert)) {
return assert;
}
config = extend(defaultOptions(), (options || {}));
switch (typeOfAssert) {
case 'function':
return empowerAssertFunction(assert, formatter, config);
case 'object':
return empowerAssertObject(assert, formatter, config);
default:
throw new Error('Cannot be here');
}
}
function isEmpowered (assertObjectOrFunction) {
return (typeof assertObjectOrFunction._capt === 'function') && (typeof assertObjectOrFunction._expr === 'function');
}
function isEmpowered (assertObjectOrFunction) {
return (typeof assertObjectOrFunction._capt === 'function') && (typeof assertObjectOrFunction._expr === 'function');
}
function empowerAssertObject (assertObject, formatter, config) {
var enhancement = enhance(assertObject, formatter, config),
target = config.destructive ? assertObject : Object.create(assertObject);
return extend(target, enhancement);
}
function empowerAssertObject (assertObject, formatter, config) {
var enhancement = enhance(assertObject, formatter, config),
target = config.destructive ? assertObject : Object.create(assertObject);
return extend(target, enhancement);
}
function empowerAssertFunction (assertFunction, formatter, config) {
if (config.destructive) {
throw new Error('cannot use destructive:true to function.');
}
var enhancement = enhance(assertFunction, formatter, config),
powerAssert = function powerAssert (context, message) {
enhancement(context, message);
};
extend(powerAssert, assertFunction);
return extend(powerAssert, enhancement);
function empowerAssertFunction (assertFunction, formatter, config) {
if (config.destructive) {
throw new Error('cannot use destructive:true to function.');
}
var enhancement = enhance(assertFunction, formatter, config),
powerAssert = function powerAssert (context, message) {
enhancement(context, message);
};
extend(powerAssert, assertFunction);
return extend(powerAssert, enhancement);
}
function enhance (target, formatter, config) {
var eagerEvaluation = !(config.modifyMessageOnFail || config.saveContextOnFail),
doPowerAssert = function (baseAssert, args, message, context) {
var f;
if (eagerEvaluation) {
args.push(buildPowerAssertText(message, context));
return baseAssert.apply(target, args);
function enhance (target, formatter, config) {
var eagerEvaluation = !(config.modifyMessageOnFail || config.saveContextOnFail),
doPowerAssert = function (baseAssert, args, message, context) {
var f;
if (eagerEvaluation) {
args.push(buildPowerAssertText(message, context));
return baseAssert.apply(target, args);
}
try {
args.push(message);
return baseAssert.apply(target, args);
} catch (e) {
if (e.name !== 'AssertionError') {
throw e;
}
try {
args.push(message);
return baseAssert.apply(target, args);
} catch (e) {
if (e.name !== 'AssertionError') {
throw e;
if (typeof target.AssertionError !== 'function') {
throw e;
}
if (isPhantom) {
f = new target.AssertionError({
actual: e.actual,
expected: e.expected,
operator: e.operator,
message: e.message
});
} else {
f = e;
}
if (config.modifyMessageOnFail) {
f.message = buildPowerAssertText(message, context);
if (typeof e.generatedMessage !== 'undefined') {
f.generatedMessage = false;
}
if (typeof target.AssertionError !== 'function') {
throw e;
}
if (isPhantom) {
f = new target.AssertionError({
actual: e.actual,
expected: e.expected,
operator: e.operator,
message: e.message
});
} else {
f = e;
}
if (config.modifyMessageOnFail) {
f.message = buildPowerAssertText(message, context);
if (typeof e.generatedMessage !== 'undefined') {
f.generatedMessage = false;
}
}
if (config.saveContextOnFail) {
f.powerAssertContext = context;
}
throw f;
}
},
enhancement = (typeof target === 'function') ? decorateOneArg(target, target, doPowerAssert) : {},
events = [];
if (config.saveContextOnFail) {
f.powerAssertContext = context;
}
throw f;
}
},
enhancement = (typeof target === 'function') ? decorateOneArg(target, target, doPowerAssert) : {},
events = [];
function buildPowerAssertText (message, context) {
var powerAssertText = formatter(context);
return message ? message + ' ' + powerAssertText : powerAssertText;
}
function buildPowerAssertText (message, context) {
var powerAssertText = formatter(context);
return message ? message + ' ' + powerAssertText : powerAssertText;
}
function _capt (value, espath) {
events.push({value: value, espath: espath});
return value;
}
function _capt (value, espath) {
events.push({value: value, espath: espath});
return value;
}
function _expr (value, args) {
var captured = events;
events = [];
return { powerAssertContext: {value: value, events: captured}, source: {content: args.content, filepath: args.filepath, line: args.line} };
function _expr (value, args) {
var captured = events;
events = [];
return { powerAssertContext: {value: value, events: captured}, source: {content: args.content, filepath: args.filepath, line: args.line} };
}
config.targetMethods.oneArg.forEach(function (methodName) {
if (typeof target[methodName] === 'function') {
enhancement[methodName] = decorateOneArg(target, target[methodName], doPowerAssert);
}
});
config.targetMethods.twoArgs.forEach(function (methodName) {
if (typeof target[methodName] === 'function') {
enhancement[methodName] = decorateTwoArgs(target, target[methodName], doPowerAssert);
}
});
config.targetMethods.oneArg.forEach(function (methodName) {
if (typeof target[methodName] === 'function') {
enhancement[methodName] = decorateOneArg(target, target[methodName], doPowerAssert);
}
});
config.targetMethods.twoArgs.forEach(function (methodName) {
if (typeof target[methodName] === 'function') {
enhancement[methodName] = decorateTwoArgs(target, target[methodName], doPowerAssert);
}
});
enhancement._capt = _capt;
enhancement._expr = _expr;
return enhancement;
}
enhancement._capt = _capt;
enhancement._expr = _expr;
return enhancement;
}
function isEspoweredValue (value) {
return (typeof value === 'object') && (value !== null) && (typeof value.powerAssertContext !== 'undefined');
}
function isEspoweredValue (value) {
return (typeof value === 'object') && (value !== null) && (typeof value.powerAssertContext !== 'undefined');
}
function decorateOneArg (target, baseAssert, doPowerAssert) {
return function (arg1, message) {
var context, val1;
if (! isEspoweredValue(arg1)) {
return baseAssert.apply(target, [arg1, message]);
}
val1 = arg1.powerAssertContext.value;
context = {
source: arg1.source,
args: []
};
context.args.push({
value: val1,
events: arg1.powerAssertContext.events
});
return doPowerAssert(baseAssert, [val1], message, context);
};
}
function decorateOneArg (target, baseAssert, doPowerAssert) {
return function (arg1, message) {
var context, val1;
if (! isEspoweredValue(arg1)) {
return baseAssert.apply(target, [arg1, message]);
}
val1 = arg1.powerAssertContext.value;
function decorateTwoArgs (target, baseAssert, doPowerAssert) {
return function (arg1, arg2, message) {
var context, val1, val2;
if (!(isEspoweredValue(arg1) || isEspoweredValue(arg2))) {
return baseAssert.apply(target, [arg1, arg2, message]);
}
if (isEspoweredValue(arg1)) {
context = {

@@ -200,71 +205,32 @@ source: arg1.source,

context.args.push({
value: val1,
value: arg1.powerAssertContext.value,
events: arg1.powerAssertContext.events
});
return doPowerAssert(baseAssert, [val1], message, context);
};
}
val1 = arg1.powerAssertContext.value;
} else {
val1 = arg1;
}
function decorateTwoArgs (target, baseAssert, doPowerAssert) {
return function (arg1, arg2, message) {
var context, val1, val2;
if (!(isEspoweredValue(arg1) || isEspoweredValue(arg2))) {
return baseAssert.apply(target, [arg1, arg2, message]);
}
if (isEspoweredValue(arg1)) {
if (isEspoweredValue(arg2)) {
if (!isEspoweredValue(arg1)) {
context = {
source: arg1.source,
source: arg2.source,
args: []
};
context.args.push({
value: arg1.powerAssertContext.value,
events: arg1.powerAssertContext.events
});
val1 = arg1.powerAssertContext.value;
} else {
val1 = arg1;
}
context.args.push({
value: arg2.powerAssertContext.value,
events: arg2.powerAssertContext.events
});
val2 = arg2.powerAssertContext.value;
} else {
val2 = arg2;
}
if (isEspoweredValue(arg2)) {
if (!isEspoweredValue(arg1)) {
context = {
source: arg2.source,
args: []
};
}
context.args.push({
value: arg2.powerAssertContext.value,
events: arg2.powerAssertContext.events
});
val2 = arg2.powerAssertContext.value;
} else {
val2 = arg2;
}
return doPowerAssert(baseAssert, [val1, val2], message, context);
};
}
return doPowerAssert(baseAssert, [val1, val2], message, context);
};
}
// borrowed from qunit.js
function extend (a, b) {
var prop;
for (prop in b) {
if (b.hasOwnProperty(prop)) {
if (typeof b[prop] === 'undefined') {
delete a[prop];
} else {
a[prop] = b[prop];
}
}
}
return a;
}
// using returnExports UMD pattern with substack pattern
empower.defaultOptions = defaultOptions;
return empower;
}));
empower.defaultOptions = defaultOptions;
module.exports = empower;

43

package.json
{
"name": "empower",
"description": "Power Assert feature enhancer for assert function/object",
"version": "0.7.1",
"version": "0.7.2",
"keywords": [

@@ -18,5 +18,5 @@ "power-assert",

"scripts": {
"bower": "./node_modules/bower/bin/bower install --config.interactive=false",
"test": "grunt test",
"coveralls": "grunt coverage && cat ./coverage.lcov | ./node_modules/coveralls/bin/coveralls.js"
"bower": "bower install --config.interactive=false",
"test": "gulp test",
"coveralls": "gulp coverage && cat ./coverage.lcov | coveralls"
},

@@ -31,20 +31,23 @@ "main": "./lib/empower",

},
"dependencies": {
"node.extend": "~1.0.10"
},
"devDependencies": {
"blanket": "~1.1.6",
"bower": "~1.3.3",
"browserify": "~4.1.6",
"buster-assertions": "~0.10.4",
"coveralls": "~2.10.0",
"escodegen": "~1.3.2",
"espower": "~0.7.0",
"esprima": "~1.2.0",
"grunt": "~0.4.2",
"grunt-bower-requirejs": "~0.9.2",
"grunt-bump": "~0.0.13",
"grunt-contrib-connect": "~0.7.1",
"grunt-contrib-jshint": "~0.10.0",
"grunt-contrib-watch": "~0.6.1",
"grunt-mocha": "~0.4.10",
"grunt-mocha-test": "~0.10.2",
"jit-grunt": "~0.5.0",
"mocha-lcov-reporter": "~0.0.1"
"espower-source": "~0.7.3",
"gulp": "~3.6.2",
"gulp-bump": "~0.1.8",
"gulp-clean": "~0.3.0",
"gulp-connect": "~2.0.5",
"gulp-git": "~0.4.2",
"gulp-mocha": "~0.4.1",
"gulp-mocha-phantomjs": "~0.2.1",
"gulp-util": "~2.2.14",
"mocha": "~1.20.0",
"mocha-lcov-reporter": "~0.0.1",
"run-sequence": "~0.3.6",
"through2": "~0.4.2",
"vinyl-source-stream": "~0.1.1"
},

@@ -54,3 +57,3 @@ "licenses": [

"type": "MIT",
"url": "https://raw.github.com/twada/empower/master/MIT-LICENSE.txt"
"url": "https://github.com/twada/empower/blob/master/MIT-LICENSE.txt"
}

@@ -57,0 +60,0 @@ ],

3

README.md

@@ -8,3 +8,2 @@ empower

[![Coverage Status](https://coveralls.io/repos/twada/empower/badge.png?branch=master)](https://coveralls.io/r/twada/empower?branch=master)
[![Built with Grunt](https://cdn.gruntjs.com/builtwith.png)](http://gruntjs.com/)

@@ -45,2 +44,2 @@ Power Assert feature enhancer for assert function/object.

---------------------------------------
Licensed under the [MIT](https://raw.github.com/twada/empower/master/MIT-LICENSE.txt) license.
Licensed under the [MIT](https://github.com/twada/empower/blob/master/MIT-LICENSE.txt) license.

61

test/buster_assertions_test.js
(function (root, factory) {
'use strict';
var dependencies = [
'../lib/empower',
'espower',
'esprima',
'escodegen',
'assert',
'buster-assertions'
];
if (typeof define === 'function' && define.amd) {
define(dependencies, factory);
define(['empower', 'espower-source', 'assert', 'buster-assertions'], factory);
} else if (typeof exports === 'object') {
factory.apply(root, dependencies.map(function (path) { return require(path); }));
factory(require('../lib/empower'), require('espower-source'), require('assert'), require('buster-assertions'));
} else {
factory.apply(root, dependencies.map(function (path) {
var tokens = path.split('/'),
basename = tokens[tokens.length - 1],
subnames = basename.split('-');
return root[subnames[0]];
}));
factory(root.empower, root.espowerSource, root.assert, root.buster);
}
}(this, function (
empower,
espower,
esprima,
escodegen,
espowerSource,
baseAssert,
busterAssertions
) {
// see: https://github.com/Constellation/escodegen/issues/115
if (typeof define === 'function' && define.amd) {
escodegen = window.escodegen;
}
var weave = function () {
function applyEspower (line, options) {
options = options || {
destructive: false,
source: line,
path: '/path/to/some_test.js',
powerAssertVariableName: 'assert',
targetMethods: {
oneArg: ['isNull'],
twoArgs: ['same']
}
};
var tree = esprima.parse(line, {tolerant: true, loc: true, tokens: true, raw: true});
return espower(tree, options);
}
return function (line, options) {
return escodegen.generate(applyEspower(line, options), {format: {compact: true}});
var weave = function (line) {
var options = {
destructive: false,
source: line,
path: '/path/to/some_test.js',
powerAssertVariableName: 'assert',
targetMethods: {
oneArg: ['isNull'],
twoArgs: ['same']
}
};
}(),
return espowerSource(line, '/path/to/some_test.js', options);
},
fakeFormatter = function (context) {

@@ -59,0 +30,0 @@ var events = context.args.reduce(function (accum, arg) {

20

test/empower_option_test.js
(function (root, factory) {
'use strict';
var dependencies = [
'../lib/empower',
'assert'
];
if (typeof define === 'function' && define.amd) {
define(dependencies, factory);
define(['empower', 'assert'], factory);
} else if (typeof exports === 'object') {
factory.apply(root, dependencies.map(function (path) { return require(path); }));
factory(require('../lib/empower'), require('assert'));
} else {
factory.apply(root, dependencies.map(function (path) {
var tokens = path.split('/');
return root[tokens[tokens.length - 1]];
}));
factory(root.empower, root.assert);
}
}(this, function (empower, assert) {
}(this, function (
empower,
assert
) {

@@ -21,0 +15,0 @@ var fakeFormatter = function (context) {

41

test/empower_test.js
(function (root, factory) {
'use strict';
var dependencies = [
'../lib/empower',
'espower',
'esprima',
'escodegen',
'assert'
];
if (typeof define === 'function' && define.amd) {
define(dependencies, factory);
define(['empower', 'espower-source', 'assert'], factory);
} else if (typeof exports === 'object') {
factory.apply(root, dependencies.map(function (path) { return require(path); }));
factory(require('../lib/empower'), require('espower-source'), require('assert'));
} else {
factory.apply(root, dependencies.map(function (path) {
var tokens = path.split('/');
return root[tokens[tokens.length - 1]];
}));
factory(root.empower, root.espowerSource, root.assert);
}
}(this, function (
empower,
espower,
esprima,
escodegen,
espowerSource,
baseAssert
) {
// see: https://github.com/Constellation/escodegen/issues/115
if (typeof define === 'function' && define.amd) {
escodegen = window.escodegen;
}
var weave = function () {
function applyEspower (line, options) {
options = options || {destructive: false, source: line, path: '/path/to/some_test.js', powerAssertVariableName: 'assert'};
var tree = esprima.parse(line, {tolerant: true, loc: true, tokens: true, raw: true});
return espower(tree, options);
}
return function (line, options) {
return escodegen.generate(applyEspower(line, options), {format: {compact: true}});
};
}(),
var weave = function (line) {
return espowerSource(line, '/path/to/some_test.js');
},
fakeFormatter = function (context) {

@@ -46,0 +19,0 @@ var events = context.args.reduce(function (accum, arg) {

9

test/rjsconfig.js
var require = {
paths: {
empower: "../build/empower",
"espower-source": "../bower_components/espower-source/build/espower-source",
assert: "../bower_components/assert/assert",
escodegen: "../bower_components/escodegen/escodegen.browser",
esprima: "../bower_components/esprima/esprima",
estraverse: "../bower_components/estraverse/estraverse",
espower: "../bower_components/espower/lib/espower",
mocha: "../bower_components/mocha/mocha",

@@ -16,5 +14,2 @@ requirejs: "../bower_components/requirejs/require",

},
escodegen: {
exports: "escodegen"
},
"buster-assertions": {

@@ -21,0 +16,0 @@ exports: "buster"

Gruntfile.js
test/test-amd.html

Sorry, the diff of this file is not supported yet

test/test-browser.html

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc