dot-object 0.3.0

package/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Rob Halff
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,219 @@
+[![Build Status](https://travis-ci.org/rhalff/dot-object.png)](https://travis-ci.org/rhalff/dot-object)
+
+Dot-Object
+========
+
+Dot-Object makes it possible to transform javascript objects using dot notation.
+
+
+#### Move a property within one object to another location
+```javascript
+var DJ = require('dot-object');
+
+var dj = new DJ();
+
+var obj = {
+  'first_name': 'John',
+  'last_name': 'Doe'
+};
+
+dj.move('first_name', 'contact.firstname', obj);
+dj.move('last_name', 'contact.lastname', obj);
+
+console.log(obj);
+
+{
+  contact: {
+    firstname: 'John',
+    lastname: 'Doe'
+  }
+}
+
+```
+
+#### Transform an object
+
+```javascript
+var DJ = require('dot-object');
+
+var dj = new DJ();
+
+var row = {
+  'id': 2,
+  'contact.name.first': 'John',
+  'contact.name.last': 'Doe',
+  'contact.email': 'example@gmail.com',
+  'contact.info.about.me': 'classified'
+};
+
+dj.object(row);
+
+console.log(row);
+
+{
+  "id": 2,
+  "contact": {
+    "name": {
+      "first": "John",
+      "last": "Doe"
+    },
+    "email": "example@gmail.com",
+    "info": {
+      "about": {
+      "me": "classified"
+      }
+    }
+  }
+}
+```
+
+To convert manually per string use:
+```javascript
+var DJ = require('dot-object');
+
+var dj = new DJ();
+
+var obj = { val: 'test' };
+dj.str('this.is.my.string', 'value', obj);
+
+console.log(obj);
+
+{
+  "val": "test",
+  "this": {
+    "is": {
+      "my": {
+        "string": "value"
+      }
+    }
+  }
+}
+```
+
+#### Pick a value using dot notation:
+```
+var obj = {
+ some: {
+   nested: {
+     value: 'Hi there!'
+   }
+ }
+};
+
+var val = dj.pick('some.nested.key', obj);
+console.log(val);
+
+Hi there!
+```
+
+### Using modifiers
+
+You can use modifiers to translate values on the fly.
+
+This example uses the [underscore.string](https://github.com/epeli/underscore.string) library.
+
+
+
+```javascript
+var DJ = require('dot-object');
+
+var dj = new DJ();
+
+var _s = require('underscore.string');
+
+var row = {
+  'nr': 200,
+  'doc.name': '    My Document   '
+};
+
+var mods = {
+  "doc.name": [_s.trim, _s.underscored],
+};
+
+dj.object(row, mods);
+
+console.log(row);
+```
+
+```
+{
+  "nr": 200,
+  "doc": {
+    "name": "my_document"
+  }
+}
+```
+
+Or using .str() directy:
+
+```javascript
+
+var DJ = require('dot-object');
+var _s = require('underscore.string');
+var obj = { id: 100 };
+
+var dj = new DJ();
+
+// use one modifier
+dj.str('my.title', 'this is my title', obj, _s.slugify);
+
+// multiple modifiers
+dj.str('my.title', '   this is my title  ', obj, [_s.trim, _s.slugify]);
+
+console.log(obj);
+```
+Result:
+```json
+{
+  "id": 100,
+  "my": {
+    "title": "this-is-my-title"
+  }
+}
+```
+
+## Using a different seperator
+
+If you do not like dot notation, you are free to specify a different seperator.
+
+```javascript
+var DJ = require('dot-object');
+
+var dj = new DJ('->');
+
+var _s = require('underscore.string');
+
+var row = {
+  'nr': 200,
+  'doc->name': '    My Document   '
+};
+
+var mods = {
+  "doc->name": [_s.trim, _s.underscored],
+};
+
+dj.object(row, mods);
+
+console.log(row);
+```
+
+```
+{
+  "nr": 200,
+  "doc": {
+    "name": "my_document"
+  }
+}
+```
+
+## Transforming SQL results to JSON
+
+SQL translation on the fly:
+
+```javascript
+ // TODO
+
+```
+
+
+> Copyright © 2013 Rob Halff, released under the MIT license

package/index.js

@@ -0,0 +1,189 @@
+'use strict';
+
+function DotObject(seperator, override) {
+
+  if(!(this instanceof DotObject)) return new DotObject(seperator, override);
+
+  if (typeof seperator === 'undefined') { seperator = '.'; }
+  if (typeof override === 'undefined') { override = false; }
+  this.seperator = seperator;
+  this.override = override;
+}
+
+DotObject.prototype._fill = function (a, obj, v, mod) {
+  var k = a.shift();
+
+  if (a.length > 0) {
+    obj[k] = obj[k] || {};
+
+    if (obj[k] !== Object(obj[k])) {
+      if (this.override) {
+        obj[k] = {};
+      } else {
+        throw new Error('Trying to redefine \'' + k + '\' which is a ' + typeof obj[k]);
+      }
+    }
+
+    this._fill(a, obj[k], v, mod);
+  } else {
+    if (obj[k] === Object(obj[k]) && Object.keys(obj[k]).length) {
+      throw new Error('Trying to redefine non-empty obj[\'' + k + '\']');
+    }
+
+    obj[k] = this.process(v, mod);
+  }
+};
+
+DotObject.prototype.process = function (v, mod) {
+  var i;
+
+  if (typeof mod === 'function') {
+    v = mod(v);
+  } else if (mod instanceof Array) {
+    for (i = 0; i < mod.length; i++) {
+      v = mod[i](v);
+    }
+  }
+
+  return v;
+};
+
+DotObject.prototype.object = function (obj, mods) {
+  var self = this;
+
+  Object.keys(obj).forEach(function (k, i) {
+    var mod = mods === undefined ? null : mods[k];
+
+    if (k.indexOf(self.seperator) !== -1) {
+      self._fill(k.split(self.seperator), obj, obj[k], mod);
+      delete obj[k];
+    } else if (self.override) {
+      obj[k] = self.process(obj[k], mod);
+    }
+  });
+};
+
+DotObject.prototype.str = function (str, v, obj, mod) {
+  if (str.indexOf(this.seperator) !== -1) {
+    this._fill(str.split(this.seperator), obj, v, mod);
+  } else if (this.override) {
+    obj[str] = this.process(v, mod);
+  }
+};
+
+/**
+ *
+ * Pick a value from an object using dot notation.
+ *
+ * Optionally remove the value
+ *
+ * @param {String} path
+ * @param {Object} obj
+ * @param {Boolean} remove
+ */
+DotObject.prototype.pick = function (path, obj, remove) {
+  var i, keys, val;
+
+  if (path.indexOf(this.seperator) !== -1) {
+    keys = path.split(this.seperator);
+    for (i = 0; i < keys.length; i++) {
+      if(obj.hasOwnProperty(keys[i])) {
+        if(i === (keys.length - 1)) {
+          if(remove) {
+            val = obj[keys[i]];
+            delete obj[keys[i]];
+            return val;
+          } else {
+            return obj[keys[i]];
+          }
+        } else {
+          obj = obj[keys[i]];
+        }
+      } else {
+        return undefined;
+      }
+    }
+    return obj;
+  } else {
+    if(remove) {
+      val = obj[path];
+      delete obj[path];
+      return val;
+    } else {
+      return obj[path];
+    }
+  }
+};
+
+/**
+ *
+ * Move a property from one place to the other.
+ *
+ * If the source path does not exist (undefined)
+ * the target property will not be set.
+ *
+ * @param {String} source
+ * @param {String} target
+ * @param {Object} obj
+ *
+ */
+DotObject.prototype.move = function (source, target, obj) {
+
+  this.set(target, this.pick(source, obj, true), obj);
+
+  return obj;
+
+};
+
+/**
+ *
+ * Transfer a property from one object to another object.
+ *
+ * If the source path does not exist (undefined)
+ * the property on the other object will not be set.
+ *
+ * @param {String} source
+ * @param {String} target
+ * @param {Object} obj
+ *
+ */
+DotObject.prototype.transfer = function (source, target, obj1, obj2) {
+
+  this.set(target, this.pick(source, obj1, true), obj2);
+
+  return obj2;
+
+};
+
+/**
+ *
+ * Set a property on an object using dot notation.
+ *
+ */
+DotObject.prototype.set = function (path, val, obj) {
+  var i, keys;
+
+  // Do not operate if the value is undefined.
+  if(typeof val === 'undefined') return obj;
+
+  if (path.indexOf(this.seperator) !== -1) {
+    keys = path.split(this.seperator);
+    for (i = 0; i < keys.length; i++) {
+      if(i === (keys.length - 1)) {
+        obj[keys[i]] = val;
+      } else if(
+        // force the value to be an object
+        !obj.hasOwnProperty(keys[i]) ||
+        Object.prototype.toString.call(obj[keys[i]]) !== '[object Object]') {
+        obj[keys[i]] = {};
+      }
+      obj = obj[keys[i]];
+    }
+    return obj;
+  } else {
+    obj[path] = val;
+    return obj;
+  }
+};
+
+module.exports = DotObject;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "dot-object",
+  "description": "dot-object makes it possible to transform and read (JSON) objects using dot notation.",
+  "version": "0.3.0",
+  "author": {
+    "name": "Rob Halff",
+    "email": "rob.halff@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/rhalff/dot-object.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rhalff/dot-object/issues"
+  },
+  "main": "index",
+  "scripts": {
+    "test": "mocha"
+  },
+  "devDependencies": {
+    "underscore.string": "latest",
+    "mocha": "1.x.x",
+    "should": "1.x.x",
+    "grunt": "0.x.x",
+    "grunt-release": "0.x.x",
+    "grunt-contrib-watch": "0.x.x",
+    "grunt-shell": "0.x.x"
+  },
+  "keywords": [
+    "json",
+    "filter",
+    "transform",
+    "dot notation",
+    "dot"
+  ]
+}

package/test/dot-json.js

@@ -0,0 +1,222 @@
+require('should');
+var _s = require('underscore.string');
+var DJ = require('../index.js');
+
+describe("Dot Object test:", function () {
+
+  it("Should Dot object keys", function (done) {
+
+    var dj = new DJ();
+
+    var row = {
+      'id': 2,
+      'contact.name.first': 'John',
+      'contact.name.last': 'Doe',
+      'contact.email': 'example@gmail.com',
+      'contact.info.about.me': 'classified'
+    };
+
+    dj.object(row);
+
+    row.should.eql({
+      "id": 2,
+      "contact": {
+        "name": {
+          "first": "John",
+          "last": "Doe"
+        },
+        "email": "example@gmail.com",
+        "info": {
+          "about": {
+            "me": "classified"
+          }
+        }
+      }
+    });
+
+    done();
+
+  });
+
+  it("Should Dot Object a string", function (done) {
+
+    var obj = {};
+
+    var dj = new DJ();
+
+    dj.str('this.is.my.string', 'value', obj);
+
+    obj.should.eql({
+      "this": {
+        "is": {
+          "my": {
+            "string": "value"
+          }
+        }
+      }
+    });
+
+    done();
+
+  });
+
+  it("DJ.str Redefinition should fail", function (done) {
+
+    var obj = {
+      'already': 'set'
+    };
+
+    (function () {
+
+      var dj = new DJ();
+
+      dj.str('already.new', 'value', obj);
+
+    }).should.throw("Trying to redefine 'already' which is a string");
+
+    done();
+
+  });
+
+  it("DJ.str should process a modifier", function (done) {
+
+    var obj = {};
+
+    var dj = new DJ();
+
+    dj.str('this.is.my.string', 'value', obj, _s.capitalize);
+
+    obj.should.eql({
+      "this": {
+        "is": {
+          "my": {
+            "string": "Value"
+          }
+        }
+      }
+    });
+
+    done();
+
+  });
+
+  it("DOT.str should process multiple modifiers", function (done) {
+
+    var obj = {};
+
+    var dj = new DJ();
+
+    dj.str('this.is.my.string', '  this is a test   ', obj, [_s.trim, _s.underscored]);
+
+    obj.should.eql({
+      "this": {
+        "is": {
+          "my": {
+            "string": "this_is_a_test"
+          }
+        }
+      }
+    });
+
+    done();
+
+  });
+
+  it("DJ.object should process a modifier", function (done) {
+
+    var row = {
+      'page.title': 'my page',
+      'page.slug': 'My Page'
+    };
+
+    var mods = {
+      "page.title": _s.titleize,
+      "page.slug": _s.slugify
+    };
+
+    var dj = new DJ();
+
+    dj.object(row, mods);
+
+    row.should.eql({
+      "page": {
+        "title": "My Page",
+        "slug": "my-page"
+      }
+    });
+
+    done();
+
+  });
+
+  it("DJ.object should not process non dot notation value with modifier when DJ.override is false", function (done) {
+
+    var row = {
+      'title': 'my page',
+      'slug': 'My Page'
+    };
+
+    var mods = {
+      "title": _s.titleize,
+      "slug": _s.slugify
+    };
+
+    var dj = new DJ();
+    dj.object(row, mods);
+
+    row.should.eql({
+      "title": "my page",
+      "slug": "My Page"
+    });
+
+    done();
+
+  });
+
+  it("DJ.object should process multiple modifiers", function (done) {
+
+    var row = {
+      'page.name': '    My Page    '
+    };
+
+    var mods = {
+      "page.name": [_s.trim, _s.underscored]
+    };
+
+    var dj = new DJ();
+    dj.object(row, mods);
+
+    row.should.eql({
+      "page": {
+        "name": "my_page"
+      }
+    });
+
+    done();
+
+  });
+
+  it("DJ.object should work with a different seperator", function (done) {
+
+    var row = {
+      'page=>name': '    My Page    '
+    };
+
+    var mods = {
+      "page=>name": [_s.trim, _s.underscored]
+    };
+
+    var dj = new DJ("=>", false);
+    dj.object(row, mods);
+
+    row.should.eql({
+      "page": {
+        "name": "my_page"
+      }
+    });
+
+    done();
+
+  });
+
+});

package/test/move.js

@@ -0,0 +1,60 @@
+require('should');
+var _s = require('underscore.string');
+var dj = require('../index.js')();
+
+describe("DJ value picker:", function () {
+
+  it("Should be able to move properties", function (done) {
+
+    var link = {
+      id: '527423a65e380f0000588e47',
+      source: '526dd5c6b4c4aa8770000001',
+      target: '527402d6b15d1800008755cf',
+      out: 'github',
+      in: 'in'
+    };
+
+    var expected = {
+     id: '527423a65e380f0000588e47',
+     source: { id: '526dd5c6b4c4aa8770000001', port: 'github' },
+     target: { id: '527402d6b15d1800008755cf', port: 'in' }
+    };
+
+    dj.move('source', 'source.id', link);
+    dj.move('out',  'source.port', link);
+    dj.move('target', 'target.id', link);
+    dj.move('in',   'target.port', link);
+
+    link.should.eql(expected);
+
+    done();
+
+  });
+
+  it("Undefined properties should be ignored", function (done) {
+
+    var link = {
+      source: '526dd5c6b4c4aa8770000001',
+      target: '527402d6b15d1800008755cf',
+      out: 'github',
+      in: 'in'
+    };
+
+    var expected = {
+     source: { id: '526dd5c6b4c4aa8770000001' },
+     target: { port: 'in' },
+     out: 'github'
+    };
+
+    dj.move('source', 'source.id', link);
+    dj.move('out.er.nope',  'source.port', link);
+    dj.move('target.bla.di.bla', 'target.id', link);
+    dj.move('in',   'target.port', link);
+
+    link.should.eql(expected);
+
+    done();
+
+  });
+
+});

package/test/override.js

@@ -0,0 +1,74 @@
+require('should');
+var _s = require('underscore.string');
+var DJ = require('../index.js');
+
+describe("DJ test:", function () {
+
+
+  it("Redefinition should _not_ fail if override is true", function (done) {
+
+    var dj = new DJ('.', true);
+
+    var obj = {
+      'some': 'value',
+      'already': 'set'
+    };
+
+    dj.str('already.new', 'value', obj);
+
+    obj.should.eql({
+      "some": "value",
+      "already": { "new": "value" }
+    });
+
+    done();
+
+  });
+
+  it("Redefinition should _not_ fail if override is true", function (done) {
+
+    var dj = new DJ('.', true);
+
+    var obj = {
+      'some': 'value',
+      'already': 'set'
+    };
+
+    dj.str('already.new', 'value', obj);
+    dj.str('some', 'new_value', obj);
+
+    obj.should.eql({
+      "some": "new_value",
+      "already": { "new": "value" }
+    });
+
+    done();
+
+  });
+
+  it("DJ.object _should_ process non dot notation value with modifier when DJ.override is true", function (done) {
+
+    var dj = new DJ('.', true);
+
+    var row = {
+      'title': 'my page',
+      'slug': 'My Page'
+    };
+
+    var mods = {
+      "title": _s.titleize,
+      "slug": _s.slugify
+    };
+
+    dj.object(row, mods);
+
+    row.should.eql({
+      "title": "My Page",
+      "slug": "my-page"
+    });
+
+    done();
+
+  });
+
+});

package/test/pick.js

@@ -0,0 +1,42 @@
+require('should');
+var _s = require('underscore.string');
+var DJ = require('../index.js');
+
+describe("DJ value picker:", function () {
+
+  it("Should be able to pick a value", function (done) {
+
+    var dj = new DJ('.', true);
+
+    var obj = {
+      'some': 'value',
+      'already': 'set'
+    };
+
+    var val = dj.pick('some', obj);
+
+    val.should.eql('value');
+
+    done();
+
+  });
+
+  it("Should be able to pick dotted value", function (done) {
+
+    var dj = new DJ();
+
+    var obj = {
+      'some': {
+        'other': 'value'
+      }
+    };
+
+    var val = dj.pick('some.other', obj);
+
+    val.should.eql('value');
+
+    done();
+
+  });
+
+});