dot-object 2.1.3 → 2.1.5

package/test/array_notation.js

@@ -1,176 +0,0 @@
-'use strict'
-
-/* jshint -W030 */
-
-require('should')
-var Dot = require('../index')
-
-describe('Dotted Array notation', function () {
-  var src
-
-  beforeEach(function () {
-    src = {
-      path: [{
-        longitude: 5.512482166290283,
-        latitude: 52.5006217956543
-      }, {
-        longitude: 5.512370586395264,
-        latitude: 52.50059509277344
-      }, {
-        longitude: 5.512370586395264,
-        latitude: 52.50059509277344
-      }]
-    }
-  })
-
-  function runVariant (type) {
-    var v = function (v) {
-      if (type === 'bracket') {
-        // rewrite some.prop.1 to some.prop[1]
-        return v.replace(/\.(-?\d+)/g, '[$1]')
-      } else {
-        return v
-      }
-    }
-
-    describe('can pick', function () {
-      it('index', function () {
-        Dot.pick(v('path.0'), src).should.eql(src.path[0])
-        Dot.pick(v('path.2'), src).should.eql(src.path[2])
-        ;(typeof Dot.pick(v('path.9'), src)).should.eql('undefined')
-      })
-
-      it('negative index', function () {
-        Dot.pick(v('path.-1'), src).should.eql(src.path[2])
-        Dot.pick(v('path.-2'), src).should.eql(src.path[1])
-        Dot.pick(v('path.-3'), src).should.eql(src.path[0])
-        ;(typeof Dot.pick(v('path.-9'), src)).should.eql('undefined')
-      })
-
-      it('non-array `-` prefixed properties', function () {
-        var src = {
-          path: {
-            '-1': 'test1',
-            '-2': 'test2',
-            '-3': 'test3',
-            '----key': 'test4'
-          }
-        }
-        Dot.pick(v('path.-1'), src).should.eql('test1')
-        Dot.pick(v('path.-2'), src).should.eql('test2')
-        Dot.pick(v('path.-3'), src).should.eql('test3')
-        Dot.pick(v('path.----key'), src).should.eql('test4')
-        ;(typeof Dot.pick(v('path.-9'), src)).should.eql('undefined')
-      })
-
-      it('multiple indexes', function () {
-        var src = {
-          I: [
-            { am: [{ nes: ['ted'] }] },
-            { me: 'too' }
-          ]
-        }
-
-        Dot.pick(v('I.0'), src).should.eql(src.I[0])
-        Dot.pick(v('I.0.am'), src).should.eql(src.I[0].am)
-        Dot.pick(v('I.0.am.0'), src).should.eql(src.I[0].am[0])
-        Dot.pick(v('I.0.am.0.nes'), src).should.eql(src.I[0].am[0].nes)
-        Dot.pick(v('I.0.am.0.nes.0'), src).should.eql('ted')
-        Dot.pick(v('I.1.me'), src).should.eql('too')
-      })
-    })
-
-    describe('can set', function () {
-      it('index at target', function () {
-        var obj = { path: [] }
-
-        Dot.set(v('path.0'), 'test', obj)
-        Dot.set(v('path.1'), 'test2', obj)
-
-        obj.path.should.be.instanceOf(Array)
-        obj.should.eql({ path: ['test', 'test2'] })
-      })
-
-      it('index and set undefined for empty indices', function () {
-        var obj = { path: [] }
-
-        Dot.set(v('path.0'), 'test', obj)
-        Dot.set(v('path.2'), 'test2', obj)
-
-        obj.path.should.be.instanceOf(Array)
-
-        // array will have an undefined index.
-        JSON.stringify(obj)
-          .should.eql(
-            JSON.stringify({ path: ['test', undefined, 'test2'] })
-          )
-
-        // to json will converted it to null
-        JSON.stringify(obj).should.eql('{"path":["test",null,"test2"]}')
-      })
-
-      it('index and overwrite existing values', function () {
-        var obj = { path: ['still', 'shall', 'be', 'gone', 'here'] }
-
-        Dot.set(v('path.1'), 'x', obj)
-        Dot.set(v('path.2'), 'xx', obj)
-        Dot.set(v('path.3'), 'xxx', obj)
-
-        obj.should.eql({ path: ['still', 'x', 'xx', 'xxx', 'here'] })
-      })
-    })
-
-    describe('can remove', function () {
-      it('indexes one by one leaving traces', function () {
-        var obj = { path: ['still', 'shall', 'really', 'be', 'gone', 'here'] }
-
-        Dot.remove(v('path.1'), obj)
-        Dot.remove(v('path.2'), obj)
-        Dot.del(v('path.3'), obj) // use alias
-        Dot.del(v('path.4'), obj)
-
-        // array will have an undefined index.
-        JSON.stringify(obj)
-          .should.eql(
-            JSON.stringify({
-              path: [
-                'still', undefined, undefined, undefined, undefined, 'here'
-              ]
-            })
-          )
-
-        // to json will converted it to null
-        JSON.stringify(obj).should.eql(
-          '{"path":["still",null,null,null,null,"here"]}'
-        )
-      })
-
-      it('array of indexes leaving no traces', function () {
-        var obj = { path: ['still', 'shall', 'really', 'be', 'gone', 'here'] }
-
-        Dot.remove([
-          v('path.1'),
-          v('path.2'),
-          v('path.3'),
-          v('path.4')], obj)
-
-        JSON.stringify(obj).should.eql('{"path":["still","here"]}')
-      })
-    })
-  }
-
-  describe('with dot notation', function () {
-    runVariant()
-  })
-
-  // extra logic no real benefit.
-  describe('with bracket notation', function () {
-    runVariant('bracket')
-  })
-
-  describe('Refuse to update __proto__', function () {
-    var obj = { path: [] }
-
-    ;(() => Dot.set('path[0].__proto__.toString', 'test', obj)).should.throw(/Refusing to update/)
-  })
-})

package/test/copy.js

@@ -1,86 +0,0 @@
-'use strict'
-
-require('should')
-var Dot = require('../index')
-
-describe('Copy:', function () {
-  it('Should be able to copy properties', function () {
-    var src = {
-      name: 'John',
-      stuff: {
-        phone: {
-          brand: 'iphone',
-          version: 6
-        }
-      }
-    }
-
-    var tgt = {
-      name: 'Brandon'
-    }
-
-    var srcExpected = JSON.parse(JSON.stringify(src))
-
-    var tgtExpected = {
-      name: 'Brandon',
-      copied: 'John',
-      wanna: {
-        haves: {
-          phone: {
-            brand: 'iphone',
-            version: 6
-          }
-        }
-      }
-    }
-
-    // copy object
-    Dot.copy('stuff.phone', 'wanna.haves.phone', src, tgt)
-
-    // copy string
-    Dot.copy('name', 'copied', src, tgt)
-
-    src.should.eql(srcExpected)
-    tgt.should.eql(tgtExpected)
-  })
-
-  it('Should process modifiers', function () {
-    function up (val) {
-      val.brand = val.brand.toUpperCase()
-      return val
-    }
-
-    var src = {
-      name: 'John',
-      stuff: {
-        phone: {
-          brand: 'iphone',
-          version: 6
-        }
-      }
-    }
-
-    var tgt = {
-      name: 'Brandon'
-    }
-
-    var srcExpected = JSON.parse(JSON.stringify(src))
-
-    var tgtExpected = {
-      name: 'Brandon',
-      wanna: {
-        haves: {
-          phone: {
-            brand: 'IPHONE',
-            version: 6
-          }
-        }
-      }
-    }
-
-    Dot.copy('stuff.phone', 'wanna.haves.phone', src, tgt, up)
-
-    src.should.eql(srcExpected)
-    tgt.should.eql(tgtExpected)
-  })
-})

package/test/data/array_deep_bug.json

@@ -1,30 +0,0 @@
-{
-  "name": "array deep bug #10",
-  "options": {
-    "useArray": true
-  },
-  "input": {
-    "a[0]": "A0",
-    "a[1]": "A1",
-    "a[2]": "A2",
-    "a[3].b[0].c[0]": "A3B0C0",
-    "a[3].b[0].c[1]": "A3B0C1"
-  },
-  "expected": {
-    "a": [
-      "A0",
-      "A1",
-      "A2",
-      {
-        "b": [
-          {
-            "c": [
-              "A3B0C0",
-              "A3B0C1"
-            ]
-          }
-        ]
-      }
-    ]
-  }
-}

package/test/data/array_deep_bug2.json

@@ -1,19 +0,0 @@
-{
-  "name": "array deep bug2 #10",
-  "options": {
-    "useArray": true
-  },
-  "input": {
-    "b.0.c.1": "b0c1",
-    "b.0.c.2": "b0c2"
-  },
-  "expected": {
-    "b" : [ {
-      "c" : [
-        null,
-        "b0c1",
-        "b0c2"
-      ]
-    }]
-  }
-}

package/test/data/empty_array.json

@@ -1,43 +0,0 @@
-{
-  "name": "empty array",
-  "input": [
-    {
-      "a": []
-    },
-    {
-      "a.0": 1,
-      "a": []
-    },
-    {
-      "a": [],
-      "a.0": 2
-    },
-    {
-      "a.0.b": []
-    },
-    {
-      "b.a.0": "b",
-      "b.a": [],
-      "b.a.1": "c"
-    }
-  ],
-  "expected": [
-    {
-      "a": []
-    },
-    {
-      "a": [1]
-    },
-    {
-      "a": [2]
-    },
-    {
-      "a" : [ {"b" : [] } ]
-    },
-    {
-      "b" : {
-        "a": [ "b", "c" ]
-      }
-    }
-  ]
-}

package/test/data/empty_object.json

@@ -1,23 +0,0 @@
-{
-  "name": "empty object",
-  "input": [
-    {
-      "a.b": {}
-    },
-    {
-      "a.b.c": 1,
-      "a.b": {} ,
-      "a.b.d": 2
-    }
-  ],
-  "expected": [
-    {
-      "a" : {"b" : {} }
-    },
-    {
-      "a" : {
-        "b": { "c": 1, "d": 2 }
-      }
-    }
-  ]
-}

package/test/data/index.js

@@ -1,8 +0,0 @@
-module.exports = [
-  require('./array_deep_bug'),
-  require('./array_deep_bug2'),
-  require('./empty_array'),
-  require('./empty_object'),
-  require('./object_deep_numeric_keys'),
-  require('./object_deep_numeric_keys2')
-]

package/test/data/object_deep_numeric_keys.json

@@ -1,30 +0,0 @@
-{
-  "name": "object deep numeric keys",
-  "options": {
-    "useArray": false
-  },
-  "input": {
-    "a[0]": "A0",
-    "a[1]": "A1",
-    "a[2]": "A2",
-    "a[3].b[0].c[0]": "A3B0C0",
-    "a[3].b[0].c[1]": "A3B0C1"
-  },
-  "expected": {
-    "a": {
-      "0": "A0",
-      "1": "A1",
-      "2": "A2",
-      "3": {
-        "b": {
-          "0": {
-            "c": {
-              "0": "A3B0C0",
-              "1": "A3B0C1"
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/test/data/object_deep_numeric_keys2.json

@@ -1,20 +0,0 @@
-{
-  "name": "object deep numeric keys 2 #10",
-  "options": {
-    "useArray": false
-  },
-  "input": {
-    "b.0.c.1": "b0c1",
-    "b.0.c.2": "b0c2"
-  },
-  "expected": {
-    "b": {
-      "0": {
-        "c": {
-          "1": "b0c1",
-          "2": "b0c2"
-        }
-      }
-    }
-  }
-}

package/test/dot-json.js

@@ -1,215 +0,0 @@
-'use strict'
-
-require('should')
-var _s = require('underscore.string')
-var Dot = require('../index')
-
-describe('Object test:', function () {
-  it('Should expand dotted keys', function () {
-    var row = {
-      id: 2,
-      'contact.name.first': 'John',
-      'contact.name.last': 'Doe',
-      'contact.email': 'example@gmail.com',
-      'contact.info.about.me': 'classified'
-    }
-
-    Dot.object(row)
-
-    row.should.eql({
-      id: 2,
-      contact: {
-        name: {
-          first: 'John',
-          last: 'Doe'
-        },
-        email: 'example@gmail.com',
-        info: {
-          about: {
-            me: 'classified'
-          }
-        }
-      }
-    })
-  })
-
-  it('Should expand dotted keys with array notation', function () {
-    var row = {
-      id: 2,
-      'my.arr.0': 'one',
-      'my.arr.1': 'two',
-      'my.arr.2': 'three',
-      'my.arr2[0]': 'one',
-      'my.arr2[1]': 'two',
-      'my.arr2[2]': 'three'
-    }
-
-    Dot.object(row)
-
-    row.should.eql({
-      id: 2,
-      my: {
-        arr: ['one', 'two', 'three'],
-        arr2: ['one', 'two', 'three']
-      }
-    })
-  })
-
-  it('Should allow keys with numbers', function () {
-    var row = {
-      id: 2,
-      '0A': 'a',
-      '0A9': 'b',
-      '0B.1AB.A34C9': 'c'
-    }
-
-    Dot.object(row)
-
-    row.should.eql({
-      id: 2,
-      '0A': 'a',
-      '0A9': 'b',
-      '0B': {
-        '1AB': {
-          A34C9: 'c'
-        }
-      }
-    })
-  })
-
-  it('Should expand dotted string', function () {
-    var tgt = {}
-
-    Dot.str('this.is.my.string', 'value', tgt)
-
-    tgt.should.eql({
-      this: {
-        is: {
-          my: {
-            string: 'value'
-          }
-        }
-      }
-    })
-  })
-
-  it('Dot.str Redefinition should fail', function () {
-    var tgt = {
-      already: 'set'
-    }
-
-    ;(function () {
-      Dot.str('already.new', 'value', tgt)
-    }).should.throw('Trying to redefine `already` which is a string')
-  })
-
-  it('Dot.str should process a modifier', function () {
-    var tgt = {}
-
-    Dot.str('this.is.my.string', 'value', tgt, _s.capitalize)
-
-    tgt.should.eql({
-      this: {
-        is: {
-          my: {
-            string: 'Value'
-          }
-        }
-      }
-    })
-  })
-
-  it('Dot.str should process multiple modifiers', function () {
-    var tgt = {}
-
-    Dot.str(
-      'this.is.my.string',
-      '  this is a test   ',
-      tgt, [_s.trim, _s.underscored]
-    )
-
-    tgt.should.eql({
-      this: {
-        is: {
-          my: {
-            string: 'this_is_a_test'
-          }
-        }
-      }
-    })
-  })
-
-  it('Dot.object should process a modifier', function () {
-    var row = {
-      'page.title': 'my page',
-      'page.slug': 'My Page'
-    }
-
-    var mods = {
-      'page.title': _s.titleize,
-      'page.slug': _s.slugify
-    }
-
-    Dot.object(row, mods)
-
-    row.should.eql({ page: { title: 'My Page', slug: 'my-page' } })
-  })
-
-  it('should process root properties',
-    function () {
-      var row = {
-        nr: 200,
-        'nested.nr': 200
-      }
-
-      var mods = {
-        nr: [val => val * 2],
-        'nested.nr': [val => val * 2]
-      }
-
-      Dot.object(row, mods)
-
-      row.should.eql({ nr: 400, nested: { nr: 400 } })
-    }
-  )
-
-  it('should process non dot value with modifier when override is false',
-    function () {
-      var row = { title: 'my page', slug: 'My Page' }
-
-      var mods = { title: _s.titleize, slug: _s.slugify }
-
-      Dot.object(row, mods)
-
-      row.should.eql({ title: 'My Page', slug: 'my-page' })
-    }
-  )
-
-  it('Dot.object should process multiple modifiers', function () {
-    var row = { 'page.name': '    My Page    ' }
-
-    var mods = { 'page.name': [_s.trim, _s.underscored] }
-
-    Dot.object(row, mods)
-
-    row.should.eql({ page: { name: 'my_page' } })
-  })
-
-  it('Dot.object should work with a different separator', function () {
-    var row = { 'page=>name': '    My Page    ' }
-
-    var mods = { 'page=>name': [_s.trim, _s.underscored] }
-
-    var dot = new Dot('=>', false)
-    dot.object(row, mods)
-
-    row.should.eql({ page: { name: 'my_page' } })
-  })
-
-  it('Dot.object should disallow to set __proto__', function () {
-    var row = { '__proto__.toString': 'hi' }
-
-    var dot = new Dot()
-    ;(() => dot.object(row)).should.throw(/Refusing to update/)
-  })
-})