reintroduce some utility functions

jlmakes · jlmakes · commit e503d997cfa6 · 2018-01-04T19:40:33.000+01:00
A few utilities were extracted into the `tealight` package, since
they proved reusable and relevant to front-end development...

However, rather than creating an opinionated utility library, the
`tealight` package has been pruned to focus on DOM queries; alas,
the rejected utilities make their back into the source (for now).
diff --git a/src/utils/deep-assign.js b/src/utils/deep-assign.js
@@ -0,0 +1,22 @@
+import isObject from './is-object'
+import each from './each'
+
+export default function deepAssign (target, ...sources) {
+	if (isObject(target)) {
+		each(sources, source => {
+			each(source, (data, key) => {
+				if (isObject(data)) {
+					if (!target[key] || !isObject(target[key])) {
+						target[key] = {}
+					}
+					deepAssign(target[key], data)
+				} else {
+					target[key] = data
+				}
+			})
+		})
+		return target
+	} else {
+		throw new TypeError('Target must be an object literal.')
+	}
+}
diff --git a/src/utils/each.js b/src/utils/each.js
@@ -0,0 +1,12 @@
+import isObject from './is-object'
+
+export default function each (collection, callback) {
+	if (isObject(collection)) {
+		const keys = Object.keys(collection)
+		return keys.forEach(key => callback(collection[key], key, collection))
+	}
+	if (collection instanceof Array) {
+		return collection.forEach((item, i) => callback(item, i, collection))
+	}
+	throw new TypeError('Expected either an array or object literal.')
+}
diff --git a/src/utils/is-object.js b/src/utils/is-object.js
@@ -0,0 +1,7 @@
+export default function isObject (x) {
+	return (
+		x !== null &&
+		x instanceof Object &&
+		(x.constructor === Object || Object.prototype.toString.call(x) === '[object Object]')
+	)
+}
diff --git a/test/utils/deep-assign.spec.js b/test/utils/deep-assign.spec.js
@@ -0,0 +1,58 @@
+import deepAssign from '../../src/utils/deep-assign'
+
+describe('Utilities', () => {
+	describe('deepAssign()', () => {
+		it('should assign source values to target object', () => {
+			const target = { foo: 'bar', bun: 'baz' }
+			const source = { foo: 'bonk!', bif: 'baff' }
+			const goal = { foo: 'bonk!', bun: 'baz', bif: 'baff' }
+			deepAssign(target, source)
+			expect(target).to.deep.equal(goal)
+		})
+
+		it('should assign nested source values to target object', () => {
+			// each property tests a
+			// different execution path
+			const target = {
+				foo: 'initial',
+				bar: 'initial',
+				kel: { pow: 'pop' },
+				zad: null,
+			}
+			const source = {
+				foo: 'bonk!',
+				bar: { baz: 'baff' },
+				kel: { pow: 'lol' },
+				zad: { min: 'max' },
+			}
+			const goal = {
+				foo: 'bonk!',
+				bar: { baz: 'baff' },
+				kel: { pow: 'lol' },
+				zad: { min: 'max' },
+			}
+			deepAssign(target, source)
+			expect(target).to.deep.equal(goal)
+		})
+
+		it('should accept multiple sources', () => {
+			const target = { foo: 'bar', bun: 'baz' }
+			const source1 = { foo: 'bonk!', bif: 'baff' }
+			const source2 = { foo: 'pow!' }
+			const goal = { foo: 'pow!', bun: 'baz', bif: 'baff' }
+			deepAssign(target, source1, source2)
+			expect(target).to.deep.equal(goal)
+		})
+
+		it('should throw a type error when not passed an object literal', () => {
+			let caught
+			try {
+				deepAssign(null, null)
+			} catch (error) {
+				caught = error
+			}
+			expect(caught).to.exist
+			expect(caught).to.be.an.instanceof(TypeError)
+		})
+	})
+})
diff --git a/test/utils/each.spec.js b/test/utils/each.spec.js
@@ -0,0 +1,75 @@
+import each from '../../src/utils/each'
+
+describe('Utilities', () => {
+	describe('each()', () => {
+		function Fixture () {
+			this.foo = 'bar'
+			this.baz = 'bun'
+		}
+
+		describe('if passed an object literal...', () => {
+			it('should invoke callback for each property', () => {
+				const fixture = new Fixture()
+				const spy = sinon.spy()
+				each(fixture, spy)
+				expect(spy).to.have.been.calledTwice
+			})
+
+			it('should ignore properties on the prototype chain', () => {
+				Fixture.prototype.biff = 'baff'
+				const fixture = new Fixture()
+				const spy = sinon.spy()
+				each(fixture, spy)
+				expect(spy).to.have.been.calledTwice
+			})
+
+			it('should pass the value, key and collection to the callback', () => {
+				const fixture = new Fixture()
+				let _value, _key, _collection
+				each(fixture, (value, key, collection) => {
+					_value = value
+					_key = key
+					_collection = collection
+				})
+				expect(_value).to.equal('bun')
+				expect(_key).to.equal('baz')
+				expect(_collection).to.deep.equal(fixture)
+			})
+		})
+
+		describe('if passed an array...', () => {
+			const fixture = ['apple', 'orange', 'banana']
+
+			it('should invoke callback for each value', () => {
+				const spy = sinon.spy()
+				each(fixture, spy)
+				expect(spy).to.have.been.calledThrice
+			})
+
+			it('should pass the value, index and collection to the callback', () => {
+				let _value, _index, _collection
+				each(fixture, (value, index, collection) => {
+					_value = value
+					_index = index
+					_collection = collection
+				})
+				expect(_value).to.equal('banana')
+				expect(_index).to.equal(2)
+				expect(_collection).to.deep.equal(fixture)
+			})
+		})
+
+		describe('else', () => {
+			it('should throw a type error when passed an invalid collection', () => {
+				let caught
+				try {
+					each(null, () => {})
+				} catch (error) {
+					caught = error
+				}
+				expect(caught).to.exist
+				expect(caught).to.be.an.instanceof(TypeError)
+			})
+		})
+	})
+})
diff --git a/test/utils/is-object.spec.js b/test/utils/is-object.spec.js
@@ -0,0 +1,30 @@
+import isObject from '../../src/utils/is-object'
+
+describe('Utilities', () => {
+	describe('isObject()', () => {
+		it('should return true when passed an object literal', () => {
+			const result = isObject({})
+			expect(result).to.be.true
+		})
+
+		it('should return false when passed a function', () => {
+			const result = isObject(() => {})
+			expect(result).to.be.false
+		})
+
+		it('should return false when passed an array', () => {
+			const result = isObject([])
+			expect(result).to.be.false
+		})
+
+		it('should return false when passed null', () => {
+			const result = isObject(null)
+			expect(result).to.be.false
+		})
+
+		it('should return false when passed undefined', () => {
+			const result = isObject(undefined)
+			expect(result).to.be.false
+		})
+	})
+})
