deku 0.1.0

data/deps/node_modules/deku/node_modules/object-path/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "object-path",
+  "description": "Access deep properties using a path",
+  "version": "0.8.1",
+  "author": {
+    "name": "Mario Casciaro"
+  },
+  "homepage": "https://github.com/mariocasciaro/object-path",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mariocasciaro/object-path.git"
+  },
+  "engines": {
+    "node": ">=0.8.0"
+  },
+  "devDependencies": {
+    "mocha": "~1.20.1",
+    "chai": "~1.9.1",
+    "mocha-lcov-reporter": "~0.0.1",
+    "coveralls": "~2.11.1",
+    "istanbul": "~0.3.0"
+  },
+  "scripts": {
+    "test": "node ./node_modules/istanbul/lib/cli.js cover ./node_modules/mocha/bin/_mocha test.js --report html -- -R spec"
+  },
+  "testling": {
+    "browsers": {
+      "ie": [
+        8,
+        9
+      ],
+      "firefox": [
+        10,
+        24
+      ],
+      "chrome": [
+        30,
+        22
+      ],
+      "safari": [
+        5,
+        6
+      ],
+      "opera": [
+        15
+      ],
+      "iphone": [
+        6
+      ],
+      "android-browser": [
+        4.2
+      ]
+    },
+    "harness": "mocha",
+    "files": "test.js"
+  },
+  "keywords": [
+    "deep",
+    "path",
+    "access",
+    "bean"
+  ],
+  "license": "MIT",
+  "gitHead": "57e379d14a32cd04c597f63182e7d54b695f9415",
+  "bugs": {
+    "url": "https://github.com/mariocasciaro/object-path/issues"
+  },
+  "_id": "object-path@0.8.1",
+  "_shasum": "40691756e154372e55eef0f15f005e317e855c8c",
+  "_from": "object-path@>=0.8.1 <0.9.0",
+  "_npmVersion": "1.4.28",
+  "_npmUser": {
+    "name": "mariocasciaro",
+    "email": "contact@mariocasciaro.me"
+  },
+  "maintainers": [
+    {
+      "name": "mariocasciaro",
+      "email": "mariocasciaro@gmail.com"
+    }
+  ],
+  "dist": {
+    "shasum": "40691756e154372e55eef0f15f005e317e855c8c",
+    "tarball": "http://registry.npmjs.org/object-path/-/object-path-0.8.1.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/object-path/-/object-path-0.8.1.tgz",
+  "readme": "ERROR: No README data found!"
+}

data/deps/node_modules/deku/node_modules/object-path/test.js

@@ -0,0 +1,510 @@
+var expect = require('chai').expect,
+  objectPath = require('./index.js');
+
+
+function getTestObj() {
+  return {
+    a: 'b',
+    b: {
+      c: [],
+      d: ['a', 'b'],
+      e: [{},{f: 'g'}],
+      f: 'i'
+    }
+  };
+}
+
+describe('get', function() {
+  it('should return the value under shallow object', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'a')).to.be.equal('b');
+    expect(objectPath.get(obj, ['a'])).to.be.equal('b');
+  });
+
+  it('should work with number path', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj.b.d, 0)).to.be.equal('a');
+    expect(objectPath.get(obj.b, 0)).to.be.equal(void 0);
+  });
+
+  it('should return the value under deep object', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'b.f')).to.be.equal('i');
+    expect(objectPath.get(obj, ['b','f'])).to.be.equal('i');
+  });
+
+  it('should return the value under array', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'b.d.0')).to.be.equal('a');
+    expect(objectPath.get(obj, ['b','d',0])).to.be.equal('a');
+  });
+
+  it('should return the value under array deep', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'b.e.1.f')).to.be.equal('g');
+    expect(objectPath.get(obj, ['b','e',1,'f'])).to.be.equal('g');
+  });
+
+  it('should return undefined for missing values under object', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'a.b')).to.not.exist;
+    expect(objectPath.get(obj, ['a','b'])).to.not.exist;
+  });
+
+  it('should return undefined for missing values under array', function() {
+    var obj = getTestObj();
+    expect(objectPath.get(obj, 'b.d.5')).to.not.exist;
+    expect(objectPath.get(obj, ['b','d','5'])).to.not.exist;
+  });
+
+  it('should return the value under integer-like key', function() {
+    var obj = { '1a': 'foo' };
+    expect(objectPath.get(obj, '1a')).to.be.equal('foo');
+    expect(objectPath.get(obj, ['1a'])).to.be.equal('foo');
+  });
+
+  it('should return the default value when the key doesnt exist', function() {
+    var obj = { '1a': 'foo' };
+    expect(objectPath.get(obj, '1b', null)).to.be.equal(null);
+    expect(objectPath.get(obj, ['1b'], null)).to.be.equal(null);
+  });
+
+  it('should return the default value when path is empty', function() {
+    var obj = { '1a': 'foo' };
+    expect(objectPath.get(obj, '', null)).to.be.deep.equal({ '1a': 'foo' });
+    expect(objectPath.get(obj, [])).to.be.deep.equal({ '1a': 'foo' });
+    expect(objectPath.get({  }, ['1'])).to.be.equal(undefined);
+  });
+
+  it('should skip non own properties with isEmpty', function(){
+    var Base = function(enabled){ };
+    Base.prototype = {
+      one: {
+        two: true
+      }
+    };
+    var Extended = function(){
+      Base.call(this,  true);
+    };
+    Extended.prototype = Object.create(Base.prototype);
+
+    var extended = new Extended();
+
+    expect(objectPath.get(extended, ['one','two'])).to.be.equal(undefined);
+    extended.enabled = true;
+
+    expect(objectPath.get(extended, 'enabled')).to.be.equal(true);
+  });
+});
+
+
+describe('set', function() {
+  it('should set value under shallow object', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, 'c', {m: 'o'});
+    expect(obj).to.have.deep.property('c.m', 'o');
+    obj = getTestObj();
+    objectPath.set(obj, ['c'], {m: 'o'});
+    expect(obj).to.have.deep.property('c.m', 'o');
+  });
+
+  it('should set value using number path', function() {
+    var obj = getTestObj();
+    objectPath.set(obj.b.d, 0, 'o');
+    expect(obj).to.have.deep.property('b.d.0', 'o');
+  });
+
+  it('should set value under deep object', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, 'b.c', 'o');
+    expect(obj).to.have.deep.property('b.c', 'o');
+    obj = getTestObj();
+    objectPath.set(obj, ['b','c'], 'o');
+    expect(obj).to.have.deep.property('b.c', 'o');
+  });
+
+  it('should set value under array', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, 'b.e.1.g', 'f');
+    expect(obj).to.have.deep.property('b.e.1.g', 'f');
+    obj = getTestObj();
+    objectPath.set(obj, ['b','e',1,'g'], 'f');
+    expect(obj).to.have.deep.property('b.e.1.g', 'f');
+  });
+
+  it('should create intermediate objects', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, 'c.d.e.f', 'l');
+    expect(obj).to.have.deep.property('c.d.e.f', 'l');
+    obj = getTestObj();
+    objectPath.set(obj, ['c','d','e','f'], 'l');
+    expect(obj).to.have.deep.property('c.d.e.f', 'l');
+  });
+
+  it('should create intermediate arrays', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, 'c.0.1.m', 'l');
+    expect(obj.c).to.be.an('array');
+    expect(obj.c[0]).to.be.an('array');
+    expect(obj).to.have.deep.property('c.0.1.m', 'l');
+    obj = getTestObj();
+    objectPath.set(obj, ['c','0', 1,'m'], 'l');
+    expect(obj.c).to.be.an('object');
+    expect(obj.c[0]).to.be.an('array');
+    expect(obj).to.have.deep.property('c.0.1.m', 'l');
+  });
+
+  it('should set value under integer-like key', function() {
+    var obj = getTestObj();
+    objectPath.set(obj, '1a', 'foo');
+    expect(obj).to.have.deep.property('1a', 'foo');
+    obj = getTestObj();
+    objectPath.set(obj, ['1a'], 'foo');
+    expect(obj).to.have.deep.property('1a', 'foo');
+  });
+
+  it('should set value under empty array', function() {
+    var obj = [];
+    objectPath.set(obj, [0], 'foo');
+    expect(obj[0]).to.be.equal('foo');
+    obj = [];
+    objectPath.set(obj, '0', 'foo');
+    expect(obj[0]).to.be.equal('foo');
+  });
+});
+
+
+describe('push', function() {
+  it('should push value to existing array', function() {
+    var obj = getTestObj();
+    objectPath.push(obj, 'b.c', 'l');
+    expect(obj).to.have.deep.property('b.c.0', 'l');
+    obj = getTestObj();
+    objectPath.push(obj, ['b','c'], 'l');
+    expect(obj).to.have.deep.property('b.c.0', 'l');
+  });
+
+  it('should push value to new array', function() {
+    var obj = getTestObj();
+    objectPath.push(obj, 'b.h', 'l');
+    expect(obj).to.have.deep.property('b.h.0', 'l');
+    obj = getTestObj();
+    objectPath.push(obj, ['b','h'], 'l');
+    expect(obj).to.have.deep.property('b.h.0', 'l');
+  });
+
+  it('should push value to existing array using number path', function() {
+    var obj = getTestObj();
+    objectPath.push(obj.b.e, 0, 'l');
+    expect(obj).to.have.deep.property('b.e.0.0', 'l');
+  });
+
+});
+
+
+describe('ensureExists', function() {
+  it('should create the path if it does not exists', function() {
+    var obj = getTestObj();
+    var oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test');
+    expect(oldVal).to.not.exist;
+    expect(obj).to.have.deep.property('b.g.1.l', 'test');
+    oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test1');
+    expect(oldVal).to.be.equal('test');
+    expect(obj).to.have.deep.property('b.g.1.l', 'test');
+  });
+
+
+  it('should return the object if path is empty', function() {
+    var obj = getTestObj();
+    expect(objectPath.ensureExists(obj, [], 'test')).to.have.property('a', 'b');
+  });
+
+  it('Issue #26', function() {
+    var any = {};
+    objectPath.ensureExists(any, ['1','1'], {});
+    expect(any).to.be.an('object');
+    expect(any[1]).to.be.an('object');
+    expect(any[1][1]).to.be.an('object');
+  });
+});
+
+describe('coalesce', function(){
+  it('should return the first non-undefined value', function(){
+    var obj = {
+      should: {have: 'prop'}
+    };
+
+    expect(objectPath.coalesce(obj, [
+      'doesnt.exist',
+      ['might','not','exist'],
+      'should.have'
+    ])).to.equal('prop');
+  });
+
+  it('should work with falsy values (null, 0, \'\', false)', function(){
+    var obj = {
+      is: {
+        false: false,
+        null: null,
+        empty: '',
+        zero: 0
+      }
+    };
+
+    expect(objectPath.coalesce(obj, [
+      'doesnt.exist',
+      'is.zero'
+    ])).to.equal(0);
+
+    expect(objectPath.coalesce(obj, [
+      'doesnt.exist',
+      'is.false'
+    ])).to.equal(false);
+
+    expect(objectPath.coalesce(obj, [
+      'doesnt.exist',
+      'is.null'
+    ])).to.equal(null);
+
+    expect(objectPath.coalesce(obj, [
+      'doesnt.exist',
+      'is.empty'
+    ])).to.equal('');
+  });
+
+  it('returns defaultValue if no paths found', function(){
+    var obj = {
+      doesnt: 'matter'
+    };
+
+    expect(objectPath.coalesce(obj, ['some.inexistant','path',['on','object']], 'false')).to.equal('false');
+  });
+});
+
+describe('empty', function(){
+  it('should ignore invalid arguments safely', function(){
+    var obj = {};
+    expect(objectPath.empty()).to.equal(void 0);
+    expect(objectPath.empty(obj, 'path')).to.equal(void 0);
+    expect(objectPath.empty(obj, '')).to.equal(obj);
+
+    obj.path = true;
+
+    expect(objectPath.empty(obj, 'inexistant')).to.equal(obj);
+  });
+
+  it('should empty each path according to their types', function(){
+    function Instance(){
+      this.notOwn = true;
+    }
+
+    /*istanbul ignore next: not part of code */
+    Instance.prototype.test = function(){};
+    /*istanbul ignore next: not part of code */
+    Instance.prototype.arr = [];
+
+    var
+      obj = {
+        string: 'some string',
+        array: ['some','array',[1,2,3]],
+        number: 21,
+        boolean: true,
+        object: {
+          some:'property',
+          sub: {
+            'property': true
+          }
+        },
+        instance: new Instance()
+      };
+
+    /*istanbul ignore next: not part of code */
+    obj['function'] = function(){};
+
+    objectPath.empty(obj, ['array','2']);
+    expect(obj.array[2]).to.deep.equal([]);
+
+    objectPath.empty(obj, 'object.sub');
+    expect(obj.object.sub).to.deep.equal({});
+
+    objectPath.empty(obj, 'instance.test');
+    expect(obj.instance.test).to.equal(null);
+    expect(Instance.prototype.test).to.be.a('function');
+
+    objectPath.empty(obj, 'string');
+    objectPath.empty(obj, 'number');
+    objectPath.empty(obj, 'boolean');
+    objectPath.empty(obj, 'function');
+    objectPath.empty(obj, 'array');
+    objectPath.empty(obj, 'object');
+    objectPath.empty(obj, 'instance');
+
+    expect(obj.string).to.equal('');
+    expect(obj.array).to.deep.equal([]);
+    expect(obj.number).to.equal(0);
+    expect(obj.boolean).to.equal(false);
+    expect(obj.object).to.deep.equal({});
+    expect(obj.instance.notOwn).to.be.an('undefined');
+    expect(obj.instance.arr).to.be.an('array');
+    expect(obj['function']).to.equal(null);
+  });
+});
+
+describe('del', function(){
+  it('should return undefined on empty object', function(){
+    expect(objectPath.del({}, 'a')).to.equal(void 0);
+  });
+
+  it('should work with number path', function(){
+    var obj = getTestObj();
+    objectPath.del(obj.b.d, 1);
+    expect(obj.b.d).to.deep.equal(['a']);
+  });
+
+  it('should delete deep paths', function(){
+    var obj = getTestObj();
+
+    expect(objectPath.del(obj)).to.be.equal(obj);
+
+    objectPath.set(obj, 'b.g.1.0', 'test');
+    objectPath.set(obj, 'b.g.1.1', 'test');
+    objectPath.set(obj, 'b.h.az', 'test');
+
+    expect(obj).to.have.deep.property('b.g.1.0','test');
+    expect(obj).to.have.deep.property('b.g.1.1','test');
+    expect(obj).to.have.deep.property('b.h.az','test');
+
+    objectPath.del(obj, 'b.h.az');
+    expect(obj).to.not.have.deep.property('b.h.az');
+    expect(obj).to.have.deep.property('b.h');
+
+    objectPath.del(obj, 'b.g.1.1');
+    expect(obj).to.not.have.deep.property('b.g.1.1');
+    expect(obj).to.have.deep.property('b.g.1.0','test');
+
+    objectPath.del(obj, ['b','g','1','0']);
+    expect(obj).to.not.have.deep.property('b.g.1.0');
+    expect(obj).to.have.deep.property('b.g.1');
+
+    expect(objectPath.del(obj, ['b'])).to.not.have.deep.property('b.g');
+    expect(obj).to.be.deep.equal({'a':'b'});
+  });
+
+  it('should remove items from existing array', function(){
+    var obj = getTestObj();
+
+    objectPath.del(obj, 'b.d.0');
+    expect(obj.b.d).to.have.length(1);
+    expect(obj.b.d).to.be.deep.equal(['b']);
+
+    objectPath.del(obj, 'b.d.0');
+    expect(obj.b.d).to.have.length(0);
+    expect(obj.b.d).to.be.deep.equal([]);
+  });
+
+  it('should skip undefined paths', function(){
+    var obj = getTestObj();
+
+    expect(objectPath.del(obj, 'do.not.exist')).to.be.equal(obj);
+    expect(objectPath.del(obj, 'a.c')).to.be.equal('b');
+  });
+});
+
+describe('insert', function(){
+  it('should insert value into existing array', function(){
+    var obj = getTestObj();
+
+    objectPath.insert(obj, 'b.c', 'asdf');
+    expect(obj).to.have.deep.property('b.c.0', 'asdf');
+    expect(obj).to.not.have.deep.property('b.c.1');
+  });
+
+  it('should create intermediary array', function(){
+    var obj = getTestObj();
+
+    objectPath.insert(obj, 'b.c.0', 'asdf');
+    expect(obj).to.have.deep.property('b.c.0.0', 'asdf');
+  });
+
+  it('should insert in another index', function(){
+    var obj = getTestObj();
+
+    objectPath.insert(obj, 'b.d', 'asdf', 1);
+    expect(obj).to.have.deep.property('b.d.1', 'asdf');
+    expect(obj).to.have.deep.property('b.d.0', 'a');
+    expect(obj).to.have.deep.property('b.d.2', 'b');
+  });
+
+  it('should handle sparse array', function(){
+    var obj = getTestObj();
+    obj.b.d = new Array(4);
+    obj.b.d[0] = 'a';
+    obj.b.d[1] = 'b';
+
+    objectPath.insert(obj, 'b.d', 'asdf', 3);
+    expect(obj.b.d).to.have.members([
+      'a',
+      'b',
+      ,
+      ,
+      'asdf'
+    ]);
+  });
+});
+
+describe('has', function () {
+  it('should return false for empty object', function () {
+    expect(objectPath.has({}, 'a')).to.be.false;
+  });
+
+  it('should return false for empty path', function () {
+    var obj = getTestObj();
+    expect(objectPath.has(obj, '')).to.be.false;
+    expect(objectPath.has(obj, [])).to.be.false;
+    expect(objectPath.has(obj, [''])).to.be.false;
+  });
+
+  it('should test under shallow object', function() {
+    var obj = getTestObj();
+    expect(objectPath.has(obj, 'a')).to.be.true;
+    expect(objectPath.has(obj, ['a'])).to.be.true;
+    expect(objectPath.has(obj, 'z')).to.be.false;
+    expect(objectPath.has(obj, ['z'])).to.be.false;
+  });
+
+  it('should work with number path', function() {
+    var obj = getTestObj();
+    expect(objectPath.has(obj.b.d, 0)).to.be.true;
+    expect(objectPath.has(obj.b, 0)).to.be.false;
+    expect(objectPath.has(obj.b.d, 10)).to.be.false;
+    expect(objectPath.has(obj.b, 10)).to.be.false;
+  });
+
+  it('should test under deep object', function() {
+    var obj = getTestObj();
+    expect(objectPath.has(obj, 'b.f')).to.be.true;
+    expect(objectPath.has(obj, ['b','f'])).to.be.true;
+    expect(objectPath.has(obj, 'b.g')).to.be.false;
+    expect(objectPath.has(obj, ['b','g'])).to.be.false;
+  });
+
+  it('should test value under array', function() {
+    var obj = getTestObj();
+    expect(objectPath.has(obj, 'b.d.0')).to.be.true;
+    expect(objectPath.has(obj, ['b','d',0])).to.be.true;
+  });
+
+  it('should test the value under array deep', function() {
+    var obj = getTestObj();
+    expect(objectPath.has(obj, 'b.e.1.f')).to.be.true;
+    expect(objectPath.has(obj, ['b','e',1,'f'])).to.be.true;
+    expect(objectPath.has(obj, 'b.e.1.f.g.h.i')).to.be.false;
+    expect(objectPath.has(obj, ['b','e',1,'f','g','h','i'])).to.be.false;
+  });
+
+  it('should test the value under integer-like key', function() {
+    var obj = { '1a': 'foo' };
+    expect(objectPath.has(obj, '1a')).to.be.true;
+    expect(objectPath.has(obj, ['1a'])).to.be.true;
+  });
+});