feat(presence): implemented presence function

src/index.js

@@ -92,7 +92,7 @@ export { default as isNaturalNumber } from './isNaturalNumber';
 export { default as isPrimitive } from './isPrimitive';
 export { default as isNotPrimitive } from './isNotPrimitive';
 export { default as isSentinelValue } from './isSentinelValue';
-export { default as isBlank } from './isBlank';
+export { default as isBlank } from './internal/isBlank';
 // Function
 export { default as stubUndefined } from './stubUndefined';
 export { default as stubNull } from './stubNull';
@@ -197,6 +197,7 @@ export { default as inRange } from './inRange';
 export { default as notEqual } from './notEqual';
 export { default as overlaps } from './overlaps';
 // Logic
+export { default as presence } from './presence';
 export { default as isNotEmpty } from './isNotEmpty';
 export { default as defaultWhen } from './defaultWhen';
 export { default as notBoth } from './notBoth';

src/isBlank.js → src/internal/isBlank.js

@@ -1,6 +1,6 @@
 import { isEmpty, isNil, anyPass, test } from 'ramda';
 
-import isFalse from './isFalse';
+import isFalse from '../isFalse';
 /**
  * Returns `true` if the given value is its type's empty value, `false`, `undefined`
  * as well as strings containing only whitespace characters; `false` otherwise.

src/presence.js

@@ -0,0 +1,41 @@
+import * as R from 'ramda';
+
+import isBlank from './internal/isBlank';
+
+/**
+ * Returns the receiver if it’s present, otherwise returns `null`.
+ *
+ * @func presence
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/3.2.0|v3.2.0}
+ * @category Logic
+ * @sig a -> a | null
+ * @see {@link http://ramdajs.com/docs/#isEmpty|R.isEmpty}
+ * @param {*} val The value to test
+ * @return {*}
+ * @example
+ *
+ * RA.presence({ foo: 'foo' }) // => { foo: 'foo' }
+ * RA.presence({}) // => null
+ * RA.presence(false) // => null
+ * RA.presence(true) // => true
+ * RA.presence('') // => null
+ * RA.presence('  ') // => null
+ * RA.presence('\t\n') // => null
+ * RA.presence('foo') // => foo
+ * RA.presence([]) // => null
+ * RA.presence([1, 2, 3]) // => [1, 2, 3]
+ * RA.presence(undefined) // => null
+ * RA.presence(0) // => 0
+ * RA.presence(null) // => null
+ */
+
+const presence = R.cond([
+  [R.equals(false), R.always(null)],
+  [isBlank, R.always(null)],
+  [R.isEmpty, R.always(null)],
+  [R.isNil, R.always(null)],
+  [R.T, R.identity],
+]);
+
+export default presence;

test/internal/isBlank.js

@@ -0,0 +1,28 @@
+import { assert } from 'chai';
+import * as R from 'ramda';
+
+import { isBlank } from '../../src';
+
+describe('isBlank', function () {
+  it('should test value for a `Blank`', function () {
+    assert.isTrue(isBlank(''));
+    assert.isTrue(isBlank('   '));
+    assert.isTrue(isBlank('\t\n'));
+    assert.isTrue(isBlank({}));
+    assert.isTrue(isBlank(null));
+    assert.isTrue(isBlank(undefined));
+    assert.isTrue(isBlank([]));
+    assert.isTrue(isBlank(false));
+
+    assert.isFalse(isBlank('value'));
+    assert.isFalse(isBlank({ foo: 'foo' }));
+    assert.isFalse(isBlank([1, 2, 3]));
+    assert.isFalse(isBlank(true));
+  });
+
+  it('should support placeholder to specify "gaps"', function () {
+    const _isBlank = isBlank(R.__);
+
+    assert.isTrue(_isBlank(''));
+  });
+});

test/presence.js

@@ -0,0 +1,93 @@
+import { assert } from 'chai';
+
+import * as RA from '../src';
+
+describe('presence', function () {
+  context('given an object', function () {
+    specify('should return the object', function () {
+      const val = { foo: 'foo' };
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty object', function () {
+    specify('should return null', function () {
+      const val = {};
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a boolean with value false', function () {
+    specify('should return null', function () {
+      const val = false;
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a boolean with value true', function () {
+    specify('should return boolean true', function () {
+      const val = true;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty string', function () {
+    specify('should return null', function () {
+      assert.strictEqual(RA.presence(''), null);
+      assert.strictEqual(RA.presence('   '), null);
+      assert.strictEqual(RA.presence('\t\n'), null);
+    });
+  });
+
+  context('given a string', function () {
+    specify('should return the correct string', function () {
+      const val = 'val';
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty array', function () {
+    specify('should return null', function () {
+      const val = [];
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given an array with values', function () {
+    specify('should return the array', function () {
+      const val = [1, 2, 3];
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an undefined', function () {
+    specify('should return null', function () {
+      const val = undefined;
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a number', function () {
+    specify('should return number', function () {
+      const val = 0;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given a null', function () {
+    specify('should return null', function () {
+      const val = null;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+});