Merge pull request #23 from tjmehta/keys

keys, keysIn, values, valuesIn

Author: tjmehta

README.md

@@ -23,6 +23,10 @@ Functional methods like forEach, map, filter, and other Array methods for Object
 
 [forEach](https://github.com/tjmehta/object-loops#forEach)
 
+[keys](https://github.com/tjmehta/object-loops#keys)
+
+[keysIn](https://github.com/tjmehta/object-loops#keysIn)
+
 [mapKeys](https://github.com/tjmehta/object-loops#mapKeys)
 
 [map](https://github.com/tjmehta/object-loops#map)
@@ -31,6 +35,10 @@ Functional methods like forEach, map, filter, and other Array methods for Object
 
 [some](https://github.com/tjmehta/object-loops#some)
 
+[values](https://github.com/tjmehta/object-loops#values)
+
+[valuesIn](https://github.com/tjmehta/object-loops#valuesIn)
+
 # Usage
 
 #### You can require each method individually `object-loops/<loop>`
@@ -238,6 +246,44 @@ keyConcat // = 'foobarbaz'
 valSum    // = 60
 ```
 
+## keys
+
+Equivalent to `Object.keys`. Implemented specifically for chain.
+
+```js
+var chain = require('object-loops/chain')
+
+var obj = {
+  foo: 10,
+  bar: 20,
+  baz: 30
+}
+chain(obj)
+  .keys()
+  .toJSON()
+// ['foo', 'bar', 'baz']
+```
+
+## keysIn
+
+Like to `keys`, but includes enumerable keys from the prototype chain.
+
+```js
+var keysIn = require('object-loops/keys-in')
+
+function Person (name) {
+  this.name = name
+}
+Person.prototype.getName = function () {
+  return this.name
+}
+
+var person = new Person('foo')
+keysIn(obj)
+// ['name', 'getName']
+// for comparison, `keys` would return ['name']
+```
+
 ## mapKeys
 
 Creates a new object with the results of calling a provided function on every key in the object.
@@ -345,6 +391,45 @@ anyGreaterThan25 // true
 */
 ```
 
+## values
+
+Like to `keys`, but returns direct enumerable values.
+
+```js
+var values = require('object-loops/values')
+
+function Person (name) {
+  this.name = name
+}
+Person.prototype.getName = function () {
+  return this.name
+}
+
+var person = new Person('foo')
+values(obj)
+// ['foo']
+// for comparison, `valuesIn` would return ['foo', Person.prototype.getName]
+```
+
+## valuesIn
+
+Like to `keys`, but returns direct enumerable values including prototype chain.
+
+```js
+var valuesIn = require('object-loops/values-in')
+
+function Person (name) {
+  this.name = name
+}
+Person.prototype.getName = function () {
+  return this.name
+}
+
+var person = new Person('foo')
+valuesIn(obj)
+// ['foo', Person.prototype.getName]
+```
+
 ## License
 
 MIT

chain.js

@@ -36,10 +36,14 @@ function extendChainPrototype (hideWarnings) {
     'findKey',
     'find',
     'forEach',
+    'keys',
+    'keysIn',
     'mapKeys',
     'map',
     'reduce',
-    'some'
+    'some',
+    'values',
+    'valuesIn'
   ].forEach(function (methodName) {
     var filename = dasherize(methodName)
     var filepath = path.join(__dirname, filename)
@@ -58,8 +62,7 @@ function extendChainPrototype (hideWarnings) {
 
         return this
       },
-      enumerable: false,
-      configurable: envIs('test') // hack for tests
+      enumerable: false
     })
   })
 }

index.js

@@ -21,10 +21,14 @@ function extendObjectPrototype (hideWarnings) {
     'findKey',
     'find',
     'forEach',
+    'keys',
+    'keysIn',
     'mapKeys',
     'map',
     'reduce',
-    'some'
+    'some',
+    'values',
+    'valuesIn'
   ].forEach(function (methodName) {
     var filename = dasherize(methodName)
     var filepath = path.join(__dirname, filename)

keys-in.js

@@ -0,0 +1,11 @@
+/**
+ * @module object-loops/keys-in
+ */
+
+/**
+ * Like to `keys`, but includes enumerable keys from the prototype chain.
+ * @function module:object-loops/keys-in
+ * @param {object} [obj] - object to get enumerable keys from
+ * @returns {array} keys
+ */
+module.exports = require('101/keys-in')

keys.js

@@ -0,0 +1,15 @@
+/**
+ * @module object-loops/keys
+ */
+
+/**
+ * Equivalent to `Object.keys`. Implemented specifically for chain.
+ * @function module:object-loops/keys
+ * @param {object} [obj] - object to get hasOwnProperty enumerable keys from
+ * @returns {array} keys
+ */
+module.exports = keys
+
+function keys (obj) {
+  return Object.keys(obj)
+}

map-keys.js

@@ -18,14 +18,16 @@ function mapKeys (obj, callback, thisArg) {
     throw new TypeError(callback + ' must be a function')
   }
   var objIsArray = Array.isArray(obj)
+  var mapped = objIsArray ? [] : {}
   if (objIsArray) {
-    forEach = Array.prototype.forEach.call.bind(Array.prototype.forEach)
+    obj.forEach(eachCallback)
+  } else {
+    forEach(obj, eachCallback)
   }
-  var mapped = objIsArray ? [] : {}
-  forEach(obj, function (val, key, obj) {
+  function eachCallback (val, key, obj) {
     var newKey = callback.call(thisArg, key, val, obj)
     mapped[newKey] = val
-  })
+  }
   return mapped
 }
 /**

test/fixtures/reset-object-prototype.js

@@ -1,15 +1,4 @@
-var methodNames = [
-  'every',
-  'inverse',
-  'filter',
-  'find',
-  'findKey',
-  'forEach',
-  'map',
-  'mapKeys',
-  'reduce',
-  'some'
-]
+var methodNames = require('./all-method-names.js')
 
 module.exports = resetObjectPrototype
 

test/test-chain.js

@@ -23,8 +23,12 @@ describe('chain', function () {
       .map(mapCb)
       .mapKeys(mapKeysCb)
       .reduce(reduceCb)
+      .keys()
+      .map(mapCb)
+      .mapKeys(mapKeysCb)
+      .reduce(reduceCb)
       .toJSON()
-    expect(output).to.deep.equal({ x: 1, y: 1 })
+    expect(output).to.deep.equal(['x', 'y'])
     done()
   })
   it('should have all methods', function (done) {

test/test-keys-in.js

@@ -0,0 +1,43 @@
+var Code = require('code')
+var Lab = require('lab')
+var lab = exports.lab = Lab.script()
+
+var describe = lab.describe
+var it = lab.it
+var before = lab.before
+var after = lab.after
+var expect = Code.expect
+
+var keysIn = require('../keys-in')
+
+describe('keysIn', function () {
+  function Person (name) {
+    this.name = name
+  }
+  Person.prototype.getName = function () {
+    return this.name
+  }
+
+  describe('prototype', function () {
+    before(function (done) {
+      require('../index')()
+      done()
+    })
+    after(require('./fixtures/reset-object-prototype'))
+    it('should get all direct enumerables keys from object', function (done) {
+      var objKeys = new Person('hey').keysIn()
+      // assertions
+      expect(objKeys).to.deep.equal(['name', 'getName'])
+      done()
+    })
+  })
+
+  describe('require', function () {
+    it('should get all direct enumerables keys from object', function (done) {
+      var objKeys = keysIn(new Person('hey'))
+      // assertions
+      expect(objKeys).to.deep.equal(['name', 'getName'])
+      done()
+    })
+  })
+})

test/test-keys.js

@@ -0,0 +1,43 @@
+var Code = require('code')
+var Lab = require('lab')
+var lab = exports.lab = Lab.script()
+
+var describe = lab.describe
+var it = lab.it
+var before = lab.before
+var after = lab.after
+var expect = Code.expect
+
+var keys = require('../keys')
+
+describe('keys', function () {
+  function Person (name) {
+    this.name = name
+  }
+  Person.prototype.getName = function () {
+    return this.name
+  }
+
+  describe('prototype', function () {
+    before(function (done) {
+      require('../index')()
+      done()
+    })
+    after(require('./fixtures/reset-object-prototype'))
+    it('should get all direct enumerables keys from object', function (done) {
+      var objKeys = new Person('hey').keys()
+      // assertions
+      expect(objKeys).to.deep.equal(['name'])
+      done()
+    })
+  })
+
+  describe('require', function () {
+    it('should get all direct enumerables keys from object', function (done) {
+      var objKeys = keys(new Person('hey'))
+      // assertions
+      expect(objKeys).to.deep.equal(['name'])
+      done()
+    })
+  })
+})