use lazy-cache, add test

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)
   })
 }

package.json

@@ -13,15 +13,18 @@
   "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": {
     "assertit": "^0.1.0",
     "pre-commit": "*"
   },
   "files": [
-    "index.js"
+    "index.js",
+    "utils.js"
   ],
   "keywords": [
     "any",

test.js

@@ -15,46 +15,66 @@ 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()
+  app.use(fn1, fn2)
+
+  test.strictEqual(app.fns.length, 2)
+  test.strictEqual(app.fns[0](), 'bar')
+  done()
 })

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