initial commit

Author: skratchdot

.gitignore

@@ -0,0 +1,5 @@
+_ignore/
+node_modules/
+.DS_Store
+.npm-debug.log
+.project

.jshintrc

@@ -0,0 +1,21 @@
+{
+  "curly": false,
+  "noempty": true,
+  "newcap": false,
+  "eqeqeq": true,
+  "eqnull": true,
+  "undef": true,
+  "devel": true,
+  "node": true,
+  "browser": true,
+  "evil": false,
+  "latedef": true,
+  "nonew": true,
+  "trailing": true,
+  "immed": true,
+  "smarttabs": true,
+  "strict": true,
+  "globals": {
+    "define": true
+  }
+}

.npmignore

@@ -0,0 +1,7 @@
+.git*
+_ignore/
+.DS_Store
+.gitignore
+.npm-debug.log
+.project
+.travis.yml

.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - '0.10'
+before_script:
+  - npm install -g gulp

LICENSE-MIT

@@ -0,0 +1,22 @@
+Copyright (c) 2014 skratchdot
+
+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.

README.md

@@ -0,0 +1,39 @@
+# object-path-set
+
+[![NPM version](https://badge.fury.io/js/object-path-set.svg)](http://badge.fury.io/js/object-path-set)
+[![Build Status](https://travis-ci.org/skratchdot/object-path-set.png?branch=master)](https://travis-ci.org/skratchdot/object-path-set)
+[![devDependency Status](https://david-dm.org/skratchdot/object-path-set/dev-status.svg)](https://david-dm.org/skratchdot/object-path-set#info=devDependencies)
+
+[![NPM](https://nodei.co/npm/object-path-set.svg)](https://npmjs.org/package/object-path-set)
+
+
+## Description
+
+set values in javascript objects by specifying a path.
+
+if the path doesn't exist yet, it will be created.
+
+by using this library, you can help prevent the following error from occurring:
+```
+Cannot set property 'foo' of undefined
+```
+
+NOTE: I've re-written / used this function so many different times, I decided to publish it
+as a module.
+
+## Getting Started
+
+Install the module with: `npm install object-path-set`
+
+```javascript
+var setPath = require('object-path-set');
+var obj = {foo:{bar:'baz'}};
+obj = setPath(obj, 'foo.bar', 'newValue'); // result: {foo:{bar:'newValue'}}
+obj = setPath(obj, 'foo.invalidKey', 'cool'); // result: {foo:{bar:'newValue',invalidKey: 'cool'}}
+obj = setPath(obj, 'foo|bar', 'again', '|'); // result: {foo:{bar:'again',invalidKey: 'cool'}}
+```
+
+## License
+
+Copyright (c) 2014 skratchdot  
+Licensed under the MIT license.

gulpfile.js

@@ -0,0 +1,27 @@
+'use strict';
+var gulp = require('gulp');
+var jshint = require('gulp-jshint');
+var nodeunit = require('gulp-nodeunit');
+
+gulp.task('jshint', function () {
+	gulp.src('*.js')
+		.pipe(jshint())
+		.pipe(jshint.reporter('default'));
+});
+
+gulp.task('test', function () {
+	gulp.src('test.js')
+		.pipe(nodeunit());
+});
+
+gulp.task('watch', function () {
+	gulp.watch(['*.js'], ['jshint', 'test']);
+});
+
+// setup default task
+gulp.task('default', ['jshint', 'test', 'watch']);
+
+// handle errors
+process.on('uncaughtException', function (e) {
+	console.error(e);
+});

index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var setPath = function (obj, path, value, delimiter) {
+	var arr, key;
+	if (!obj || typeof obj !== 'object') {
+		obj = {};
+	}
+	if (typeof path === 'string') {
+		arr = path.split(delimiter || '.');
+		key = arr[0];
+		if (arr.length > 1) {
+			arr.shift();
+			obj[key] = setPath(obj[key], arr.join(delimiter || '.'), value, delimiter);
+		} else {
+			obj[key] = value;
+		}
+	}
+	return obj;
+};
+
+module.exports = exports = setPath;

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "object-path-set",
+  "version": "0.0.1",
+  "description": "set values in javascript objects by specifying a path",
+  "main": "index.js",
+  "scripts": {
+    "test": "gulp test"
+  },
+  "author": "skratchdot",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/skratchdot/object-path-set/issues"
+  },
+  "homepage": "https://github.com/skratchdot/object-path-set",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/skratchdot/object-path-set"
+  },
+  "devDependencies": {
+    "gulp": "^3.8.1",
+    "gulp-jshint": "^1.6.3",
+    "gulp-nodeunit": "0.0.5"
+  },
+  "keywords": [
+    "object",
+    "path",
+    "helper",
+    "deep"
+  ]
+}

test.js

@@ -0,0 +1,96 @@
+'use strict';
+/*
+======== A Handy Little Nodeunit Reference ========
+https://github.com/caolan/nodeunit
+
+Test methods:
+	test.expect(numAssertions)
+	test.done()
+Test assertions:
+	test.ok(value, [message])
+	test.equal(actual, expected, [message])
+	test.notEqual(actual, expected, [message])
+	test.deepEqual(actual, expected, [message])
+	test.notDeepEqual(actual, expected, [message])
+	test.strictEqual(actual, expected, [message])
+	test.notStrictEqual(actual, expected, [message])
+	test.throws(block, [error], [message])
+	test.doesNotThrow(block, [error], [message])
+	test.ifError(value)
+*/
+var setPath = require('./index.js');
+var now = new Date();
+var getDefaultObject = function () {
+	return {
+		nested: {
+			thing: {
+				foo: 'bar'
+			},
+			is: {
+				cool: true
+			}
+		},
+		dataUndefined: undefined,
+		dataDate: now,
+		dataNumber: 42,
+		dataString: 'foo',
+		dataNull: null,
+		dataBoolean: true
+	};
+};
+
+exports['object-path-set'] = {
+	setUp: function (done) {
+		// setup here
+		done();
+	},
+	'types': function (test) {
+		var obj = getDefaultObject();
+		test.expect(5);
+		obj = setPath(obj, 'dataUndefined', 'newValue');
+		test.equal(typeof obj.dataUndefined, 'string', 'typeof dataUndefined is wrong');
+		obj = setPath(obj, 'dataDate', 'newValue');
+		test.equal(typeof obj.dataDate, 'string', 'typeof dataDate is wrong');
+		obj = setPath(obj, 'nested', 'newValue');
+		test.equal(typeof obj.nested, 'string', 'typeof nested is wrong');
+		obj = setPath(obj, 'nested.foo', 'newValue');
+		test.equal(typeof obj.nested, 'object', 'typeof nested is wrong');
+		test.equal(typeof obj.nested.foo, 'string', 'typeof nested.foo is wrong');
+		test.done();
+	},
+	'convert to object': function (test) {
+		test.expect(5);
+		test.deepEqual(setPath(1234, 'a', 42), {a: 42}, '1234 should have been converted to an object');
+		test.deepEqual(setPath(null, 'a', 42), {a: 42}, 'null should have been converted to an object');
+		test.deepEqual(setPath(true, 'a', 42), {a: 42}, 'true should have been converted to an object');
+		test.deepEqual(setPath({a: 123}, 'a.b', 42), {a: {b: 42}}, '{a: 123} should have been converted to an object');
+		test.deepEqual(setPath(null, 'a.b.c.d', null), {a:{b:{c:{d:null}}}}, 'null should have been converted to an object with a.b.c.d');
+		test.done();
+	},
+	'delimiter': function (test) {
+		test.expect(3);
+		test.deepEqual(setPath({}, 'a|b|c|d', 42), {"a|b|c|d": 42}, 'should not have used my custom delimiter');
+		test.deepEqual(setPath({}, 'a|b|c|d', 42, '|'), {a:{b:{c:{d:42}}}}, 'should have used my custom delimiter');
+		test.deepEqual(setPath({}, 'a.b.c.d', 42, '|'), {"a.b.c.d": 42}, 'should have used my custom delimiter');
+		test.done();
+	},
+	'values': function (test) {
+		test.expect(4);
+		test.deepEqual(setPath({}, 'a.b', 42), {a:{b: 42}}, 'expecting a number');
+		test.deepEqual(setPath({}, 'a.b', undefined), {a:{b: undefined}}, 'expecting undefined');
+		test.deepEqual(setPath({}, 'a.b', true), {a:{b: true}}, 'expecting a boolean');
+		test.deepEqual(setPath({}, 'a.b', 'wow'), {a:{b: 'wow'}}, 'expecting a string');
+		test.done();
+	},
+	'multiple sets': function (test) {
+		var obj;
+		test.expect(1);
+		obj = setPath(obj, 'a', 42);
+		obj = setPath(obj, 'b', true);
+		obj = setPath(obj, 'c.d', {});
+		obj = setPath(obj, 'c.d.e', {});
+		obj = setPath(obj, 'c.d.f', 'foo');
+		test.deepEqual(obj, {a: 42, b: true, c:{d:{e:{}, f:'foo'}}}, 'should have created a deep nested object');
+		test.done();
+	}
+};