.npmignore

@@ -0,0 +1,2 @@
+# .npmignore file
+test/

example.js

@@ -4,7 +4,7 @@ var object = {
   a: {
     b: {
       c: 1,
-      d: [1,2,3],
+      d: [1, 2, 3],
       e: 'remy'
     }
   }

lib/undefsafe.js

@@ -1,7 +1,6 @@
 'use strict';
 
-function undefsafe(obj, path, value) {
-
+function undefsafe(obj, path, value, __res) {
   // I'm not super keen on this private function, but it's because
   // it'll also be use in the browser and I wont *one* function exposed
   function split(path) {
@@ -19,7 +18,8 @@ function undefsafe(obj, path, value) {
           c = path.substr(i, 1);
         }
 
-        if (key) { // the first value could be a string
+        if (key) {
+          // the first value could be a string
           res.push(key);
         }
         key = '';
@@ -40,15 +40,23 @@ function undefsafe(obj, path, value) {
     return res;
   }
 
+  // bail if there's nothing
+  if (obj === undefined || obj === null) {
+    return undefined;
+  }
+
   var parts = split(path);
   var key = null;
   var type = typeof obj;
   var root = obj;
   var parent = obj;
 
-  var star = parts.filter(function (_) { return _ === '*' }).length > 0;
+  var star =
+    parts.filter(function(_) {
+      return _ === '*';
+    }).length > 0;
 
-  // we're dealing with a primative
+  // we're dealing with a primitive
   if (type !== 'object' && type !== 'function') {
     return obj;
   } else if (path.trim() === '') {
@@ -64,17 +72,35 @@ function undefsafe(obj, path, value) {
     if (key === '*') {
       // loop through each property
       var prop = '';
+      var res = __res || [];
 
       for (prop in parent) {
-        var shallowObj = undefsafe(obj[prop], parts.slice(i + 1).join('.'), value);
-        if (shallowObj) {
-          if ((value && shallowObj === value) || (!value)) {
-            return shallowObj;
+        var shallowObj = undefsafe(
+          obj[prop],
+          parts.slice(i + 1).join('.'),
+          value,
+          res
+        );
+        if (shallowObj && shallowObj !== res) {
+          if ((value && shallowObj === value) || value === undefined) {
+            if (value !== undefined) {
+              return shallowObj;
+            }
+
+            res.push(shallowObj);
           }
         }
       }
+
+      if (res.length === 0) {
+        return undefined;
+      }
+
+      return res;
+    }
+
+    if (Object.getOwnPropertyNames(obj).indexOf(key) == -1) {
       return undefined;
-      key = prop;
     }
 
     obj = obj[key];

package.json

@@ -11,6 +11,10 @@
     "cover": "tap test/*.test.js --cov --coverage-report=lcov",
     "semantic-release": "semantic-release pre && npm publish && semantic-release post"
   },
+  "prettier": {
+    "trailingComma": "none",
+    "singleQuote": true
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/remy/undefsafe.git"

test/array.test.js

@@ -2,23 +2,22 @@
 var test = require('tap').test;
 var undefsafe = require('../lib/undefsafe');
 
-test('get specific array index', function (t) {
+test('get specific array index', function(t) {
   var fixture = {
-    a: [1,2,3,4]
+    a: [1, 2, 3, 4]
   };
 
   var res = undefsafe(fixture, 'a.2');
   t.equal(res, 3);
   t.end();
 });
 
-test('set specific array index', function (t) {
+test('set specific array index', function(t) {
   var fixture = {
-    a: [1,2,3,4]
+    a: [1, 2, 3, 4]
   };
 
   undefsafe(fixture, 'a.2', 30);
-  t.deepEqual(fixture, { a: [1,2,30,4] });
+  t.deepEqual(fixture, { a: [1, 2, 30, 4] });
   t.end();
 });
-

test/misc.test.js

@@ -0,0 +1,11 @@
+var test = require('tap').test;
+var undefsafe = require('../lib/undefsafe');
+
+test('cannot modify prototype chain', function(t) {
+  const pre = {}.__proto__.toString;
+  var payload = '__proto__.toString';
+  undefsafe({ a: 'b' }, payload, 'JHU');
+  t.notEqual({}.toString, 'JHU');
+  ({}.__proto__.toString = pre); // restore
+  t.end();
+});

test/set.test.js

@@ -2,7 +2,7 @@
 var test = require('tap').test;
 var undefsafe = require('../lib/undefsafe');
 
-test('setting deep object values', function (t) {
+test('setting deep object values', function(t) {
   var fixture = {
     a: {
       b: {
@@ -14,11 +14,11 @@ test('setting deep object values', function (t) {
   };
 
   undefsafe(fixture, 'a.b.c.d', 20);
-  t.equal(fixture.a.b.c.d, 20, 'deep primative changed');
+  t.equal(fixture.a.b.c.d, 20, 'deep primitive changed');
   t.end();
 });
 
-test('setting shallow object values', function (t) {
+test('setting shallow object values', function(t) {
   var fixture = {
     a: {
       b: {
@@ -34,7 +34,7 @@ test('setting shallow object values', function (t) {
   t.end();
 });
 
-test('undef value', function (t) {
+test('undef value', function(t) {
   var fixture = {
     a: {
       b: {
@@ -50,7 +50,7 @@ test('undef value', function (t) {
   t.end();
 });
 
-test('missing value', function (t) {
+test('missing value', function(t) {
   var fixture = {
     a: {
       b: {

test/star-rule.test.js

@@ -2,49 +2,54 @@
 var test = require('tap-only');
 var undefsafe = require('../lib/undefsafe');
 var fixture = {
-  "commits": [
+  commits: [
     {
-      "modified": [
-        "one",
-        "two"
-      ]
+      modified: ['one', 'two']
     },
     {
-      "modified": [
-        "two",
-        "four"
-      ]
+      modified: ['two', 'four']
     }
   ]
 };
 
-test('get value on first * selector', function (t) {
-  var res = undefsafe(fixture, 'commits.*.modified.*');
-  t.equal(res, 'one');
+test('2.0.0: match all.*', function(t) {
+  var res = undefsafe(fixture, '*.*.*.1');
+  t.deepEqual(res, ['two', 'four']);
+  t.end();
+});
+
+test('2.0.0: match all.*', function(t) {
+  var res = undefsafe(fixture, 'commits.*.modified.*.b');
+  t.deepEqual(res, ['one', 'two', 'two', 'four']);
   t.end();
 });
 
-test('walking multiple routes', function (t) {
+test('get value on first * selector', function(t) {
+  var res = undefsafe(fixture, 'commits.*.modified.0');
+  t.deepEqual(res, ['one', 'two']);
+  t.end();
+});
+
+test('walking multiple routes', function(t) {
   var res = undefsafe(fixture, 'commits.*.modified.*', 'four');
   t.equal(res, 'four');
   t.end();
 });
 
-
-test('get specific match * selector', function (t) {
+test('get specific match * selector', function(t) {
   var res = undefsafe(fixture, 'commits.*.modified.*', 'two');
   t.equal(res, 'two');
   t.end();
 });
 
-test('match * selector returns undefined', function (t) {
+test('match * selector returns undefined', function(t) {
   var res = undefsafe(fixture, 'commits.*.modified.*', 'three');
   t.equal(res, undefined);
   t.end();
 });
 
-test('match * selector works on objects', function (t) {
-  var res = undefsafe(fixture, '*.*.modified.*');
+test('match * selector works on objects', function(t) {
+  var res = undefsafe(fixture, '*.*.modified.*', 'one');
   t.equal(res, 'one');
   t.end();
 });

test/undefsafe.test.js

@@ -2,13 +2,19 @@
 var test = require('tap-only');
 var undefsafe = require('../lib/undefsafe');
 
-test('should handle primatives', function (t) {
+test('should handle primatives', function(t) {
   var r = undefsafe(1, '');
   t.equal(r, 1, 'undefsafe is 1: ' + r);
   t.end();
 });
 
-test('should handle empty objects', function (t) {
+test('should handle null', function(t) {
+  var r = undefsafe(null, 'foo');
+  t.equal(r, undefined, 'undefsafe works with null');
+  t.end();
+});
+
+test('should handle empty objects', function(t) {
   var value = {};
   var r;
 
@@ -24,11 +30,11 @@ test('should handle empty objects', function (t) {
   t.end();
 });
 
-test('should handle null properties', function (t) {
+test('should handle null properties', function(t) {
   var value = {
     a: {
-      b: null,
-    },
+      b: null
+    }
   };
   var r;
 
@@ -41,7 +47,7 @@ test('should handle null properties', function (t) {
   t.end();
 });
 
-test('should find properties with periods in them', function (t) {
+test('should find properties with periods in them', function(t) {
   var value = {
     a: { 'one.two': true }
   };
@@ -57,10 +63,7 @@ test('should find properties with periods in them', function (t) {
   t.equal(r, true, 'weird: ' + r);
 
   value = {
-    a: { 'one.two.and\three': [
-      false,
-      true,
-    ] }
+    a: { 'one.two.and\three': [false, true] }
   };
 
   r = undefsafe(value, `a['one.two.and\three'].1`);
@@ -76,23 +79,22 @@ test('should find properties with periods in them', function (t) {
   t.end();
 });
 
-
-test('should find deep object properties', function (t) {
+test('should find deep object properties', function(t) {
   var value = {
     a: {
       b: {
         c: {
           d: 10,
           e: {
-            f: 20,
+            f: 20
           },
           g: true,
           h: false,
           i: undefined,
-          j: null,
-        },
-      },
-    },
+          j: null
+        }
+      }
+    }
   };
   var r;