✨ Add lang.and and lang.or for booleans (#220)

* ✨ Add lang.and

* ✨ add lang.or

Author: nlepage

packages/immutadot/src/lang/and.js

@@ -0,0 +1,17 @@
+import { convert } from 'core/convert'
+
+/**
+ * Applies <code>&&</code> between the former value and <code>args</code>
+ * @function
+ * @memberof lang
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {...*} [args] Other operands.
+ * @return {Object} Returns the updated object.
+ * @example and({ nested: { prop: true } }, 'nested.prop', true) // { nested: { prop: true } }
+ * @example and({ nested: { prop: true } }, 'nested.prop', true, false) // { nested: { prop: false } }
+ * @since 1.0.0
+ */
+const and = convert((v, ...args) => args.reduce((acc, arg) => acc && arg, v))
+
+export { and }

packages/immutadot/src/lang/and.spec.js

@@ -0,0 +1,63 @@
+/* eslint-env jest */
+import { and } from 'lang'
+import { immutaTest } from 'test.utils'
+
+describe('lang.and', () => {
+
+  const withTrue = {
+    nested: { prop: true },
+    other: {},
+  }
+  const withFalse = {
+    nested: { prop: false },
+    other: {},
+  }
+
+  it('should stay true', () => {
+    immutaTest(input => {
+      const output = and(input, 'nested.prop')
+      expect(output).toEqual(withTrue)
+      return output
+    }, withTrue, 'nested')
+  })
+
+  it('should stay true', () => {
+    immutaTest(input => {
+      const output = and(input, 'nested.prop', true)
+      expect(output).toEqual(withTrue)
+      return output
+    }, withTrue, 'nested')
+  })
+
+  it('should set deep undefined to undefined', () => {
+    immutaTest((input, path) => {
+      const output = and(input, path)
+      expect(output).toEqual({ nested: { prop: undefined } })
+      return output
+    }, undefined, 'nested.prop')
+  })
+
+  it('should set to false', () => {
+    immutaTest((input, path) => {
+      const output = and(input, path, false)
+      expect(output).toEqual(withFalse)
+      return output
+    }, withTrue, 'nested.prop')
+  })
+
+  it('should stay false', () => {
+    immutaTest(input => {
+      const output = and(input, 'nested.prop', true)
+      expect(output).toEqual(withFalse)
+      return output
+    }, withFalse, 'nested')
+  })
+
+  it('should set to false', () => {
+    immutaTest((input, path) => {
+      const output = and(input, path, true, false)
+      expect(output).toEqual(withFalse)
+      return output
+    }, withTrue, 'nested.prop')
+  })
+})

packages/immutadot/src/lang/index.js

@@ -5,7 +5,9 @@
  */
 
 export { add } from './add'
+export { and } from './and'
 export { divide } from './divide'
 export { multiply } from './multiply'
+export { or } from './or'
 export { subtract } from './subtract'
 export { toggle } from './toggle'

packages/immutadot/src/lang/or.js

@@ -0,0 +1,17 @@
+import { convert } from 'core/convert'
+
+/**
+ * Applies <code>||</code> between the former value and <code>args</code>
+ * @function
+ * @memberof lang
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {...*} [args] Other operands.
+ * @return {Object} Returns the updated object.
+ * @example or({ nested: { prop: false } }, 'nested.prop', true) // { nested: { prop: true } }
+ * @example or({ nested: { prop: true } }, 'nested.prop', false, false) // { nested: { prop: true } }
+ * @since 1.0.0
+ */
+const or = convert((v, ...args) => args.reduce((acc, arg) => acc || arg, v))
+
+export { or }

packages/immutadot/src/lang/or.spec.js

@@ -0,0 +1,63 @@
+/* eslint-env jest */
+import { immutaTest } from 'test.utils'
+import { or } from 'lang'
+
+describe('lang.or', () => {
+
+  const withTrue = {
+    nested: { prop: true },
+    other: {},
+  }
+  const withFalse = {
+    nested: { prop: false },
+    other: {},
+  }
+
+  it('should stay true', () => {
+    immutaTest(input => {
+      const output = or(input, 'nested.prop')
+      expect(output).toEqual(withTrue)
+      return output
+    }, withTrue, 'nested')
+  })
+
+  it('should stay true', () => {
+    immutaTest(input => {
+      const output = or(input, 'nested.prop', true)
+      expect(output).toEqual(withTrue)
+      return output
+    }, withTrue, 'nested')
+  })
+
+  it('should set deep undefined to undefined', () => {
+    immutaTest((input, path) => {
+      const output = or(input, path)
+      expect(output).toEqual({ nested: { prop: undefined } })
+      return output
+    }, undefined, 'nested.prop')
+  })
+
+  it('should stay true', () => {
+    immutaTest(input => {
+      const output = or(input, 'nested.prop', false)
+      expect(output).toEqual(withTrue)
+      return output
+    }, withTrue, 'nested')
+  })
+
+  it('should set to true', () => {
+    immutaTest((input, path) => {
+      const output = or(input, path, true)
+      expect(output).toEqual(withTrue)
+      return output
+    }, withFalse, 'nested.prop')
+  })
+
+  it('should set to false', () => {
+    immutaTest((input, path) => {
+      const output = or(input, path, true, false)
+      expect(output).toEqual(withTrue)
+      return output
+    }, withFalse, 'nested.prop')
+  })
+})