From 424e505cda0093d6f88b4079875c7c8ebb17a79f Mon Sep 17 00:00:00 2001 From: tunnckoCore Date: Fri, 4 Mar 2016 12:26:37 +0200 Subject: [PATCH] use lazy-cache, add test --- .codeclimate.yml | 7 ---- index.js | 17 +++++---- package.json | 7 +++- test.js | 99 +++++++++++++++++++++++++++++------------------- utils.js | 50 ++++++++++++++++++++++++ 5 files changed, 125 insertions(+), 55 deletions(-) delete mode 100644 .codeclimate.yml create mode 100644 utils.js diff --git a/.codeclimate.yml b/.codeclimate.yml deleted file mode 100644 index 95aa3cc..0000000 --- a/.codeclimate.yml +++ /dev/null @@ -1,7 +0,0 @@ -languages: - JavaScript: true -exclude_paths: -- "dist/**/*" -- "dist/*.js" -- "dist/**/*.js" -- "dist/**.js" \ No newline at end of file diff --git a/index.js b/index.js index 31cfa00..83c2dd5 100644 --- a/index.js +++ b/index.js @@ -7,16 +7,17 @@ 'use strict' -var bindContext = require('bind-context') -var isObject = require('is-plain-object') -var useware = require('useware') -var map = require('arr-map') +var utils = require('./utils') module.exports = function usewareContext () { - var args = useware(arguments) - var ctx = isObject(arguments[0]) ? arguments[0] : (this || {}) + var args = utils.useware.apply(this, arguments) + var ctx = utils.isObject(arguments[0]) ? arguments[0] : (this || {}) - return map(args, function (fn) { - return bindContext(ctx, fn) + if (utils.isArguments(arguments[1])) { + args = utils.useware.apply(this, arguments[1]) + } + + return utils.arrMap(args, function (fn) { + return utils.bindContext(ctx, fn) }) } diff --git a/package.json b/package.json index 1201cdc..68c3288 100644 --- a/package.json +++ b/package.json @@ -13,7 +13,9 @@ "dependencies": { "arr-map": "^2.0.0", "bind-context": "^2.0.1", - "is-plain-object": "^2.0.1", + "is-arguments": "^1.0.2", + "isobject": "^2.0.0", + "lazy-cache": "^1.0.3", "useware": "^1.0.3" }, "devDependencies": { @@ -21,7 +23,8 @@ "pre-commit": "*" }, "files": [ - "index.js" + "index.js", + "utils.js" ], "keywords": [ "any", diff --git a/test.js b/test.js index 3f12504..e23483d 100644 --- a/test.js +++ b/test.js @@ -15,46 +15,69 @@ var usewareContext = require('./index') function fn1 () { return this.foo } + function fn2 () { return this.bar } -test('useware-context:', function () { - test('should work as `useware` package', function (done) { - var result = usewareContext(fn1, fn2) - var func1 = result[0] - var func2 = result[1] - var actual = [func1.name, func2.name] - var expected = ['fn1', 'fn2'] - - test.deepEqual(actual, expected) - test.deepEqual(typeof func1, 'function') - test.deepEqual(typeof func2, 'function') - test.deepEqual(func1(), undefined) - test.deepEqual(func2(), undefined) - done() - }) - test('should recognize 1st argument as context if object', function (done) { - var res = usewareContext({foo: 'baz', bar: 'qux'}, [1, 2, [fn1, 3]], 'arg', fn2) - var func1 = res[0] - var func2 = res[1] - - var names = [func1.name, func2.name] - var _names = ['fn1', 'fn2'] - - test.deepEqual(names, _names) - test.deepEqual(typeof func1, 'function') - test.deepEqual(typeof func2, 'function') - test.deepEqual(func1(), 'baz') - test.deepEqual(func2(), 'qux') - done() - }) - test('should accept this as context when `.call`, `.apply` etc', function (done) { - var res = usewareContext.call({foo: 'b', c: 'd'}, [fn1, 2, [3, fn2]], 1, fn1, fn2) - var func1 = res[0] - - test.equal(res.length, 4) - test.equal(func1(), 'b') - done() - }) +test('should work as `useware` package', function (done) { + var result = usewareContext(fn1, fn2) + var func1 = result[0] + var func2 = result[1] + var actual = [func1.name, func2.name] + var expected = ['fn1', 'fn2'] + + test.deepEqual(actual, expected) + test.deepEqual(typeof func1, 'function') + test.deepEqual(typeof func2, 'function') + test.deepEqual(func1(), undefined) + test.deepEqual(func2(), undefined) + done() +}) + +test('should recognize 1st argument as context if object', function (done) { + var res = usewareContext({foo: 'baz', bar: 'qux'}, [1, 2, [fn1, 3]], 'arg', fn2) + var func1 = res[0] + var func2 = res[1] + + var names = [func1.name, func2.name] + var _names = ['fn1', 'fn2'] + + test.deepEqual(names, _names) + test.deepEqual(typeof func1, 'function') + test.deepEqual(typeof func2, 'function') + test.deepEqual(func1(), 'baz') + test.deepEqual(func2(), 'qux') + done() +}) + +test('should accept context through `.call`, `.apply` etc', function (done) { + var fns1 = usewareContext.call({foo: 'bbb'}, [fn1, 2, [3, fn2]], 1, fn1, fn2) + var fns2 = usewareContext.apply({foo: 'ccc'}, [[fn1, 2, [3, fn2]], 1, fn1, fn2]) + + test.equal(fns1.length, 4) + test.equal(fns2.length, 4) + test.equal(fns1[0](), 'bbb') + test.equal(fns2[0](), 'ccc') + done() +}) + +test('should `useware(ctx, arguments)` work same way as `.call(ctx, arguments)`', function (done) { + function App () { + this.foo = 'bar' + this.fns = [] + } + App.prototype.use = function () { + this.fns = this.fns.concat(usewareContext(this, arguments)) + return this + } + var app = new App() + .use(fn1, fn2) + .use([fn1, [fn2, fn1], fn2]) + .use(1, 'foo', fn1, [fn2, 3, fn1], fn2) + + test.strictEqual(app.fns.length, 10) + test.strictEqual(app.fns[0](), 'bar') + test.strictEqual(app.fns[8](), 'bar') + done() }) diff --git a/utils.js b/utils.js new file mode 100644 index 0000000..dd622e0 --- /dev/null +++ b/utils.js @@ -0,0 +1,50 @@ +'use strict' + +/** + * Module dependencies + */ + +var utils = require('lazy-cache')(require) + +/** + * Temporarily re-assign `require` to trick browserify and + * webpack into reconizing lazy dependencies. + * + * This tiny bit of ugliness has the huge dual advantage of + * only loading modules that are actually called at some + * point in the lifecycle of the application, whilst also + * allowing browserify and webpack to find modules that + * are depended on but never actually called. + */ + +var fn = require +require = utils // eslint-disable-line no-undef, no-native-reassign + +/** + * Lazily required module dependencies + */ + +require('arr-map') +require('bind-context') +require('is-arguments') +require('isobject') +require('useware') + +/** + * Restore `require` + */ + +require = fn // eslint-disable-line no-undef, no-native-reassign + +utils.isObject = function isObject (val) { + if (!val) return false + if (utils.isArguments(val)) return false + if (utils.isobject(val)) return true + return false +} + +/** + * Expose `utils` modules + */ + +module.exports = utils