infinispan 0.13.0 → 0.15.0

package/lib/functional.js

@@ -2,9 +2,19 @@
 
   var _ = require('underscore');
 
-  function existy(x) { return x != null }
+  /**
+   * Checks whether a value exists (is not null or undefined).
+   * @param {*} x Value to check.
+   * @returns {boolean} True if the value is not null or undefined.
+   */
+  function existy(x) { return x != null; }
   exports.existy = existy;
 
+  /**
+   * Concatenates multiple arrays into a single array.
+   * @param {...Array} arguments Arrays to concatenate.
+   * @returns {Array} Concatenated array.
+   */
   function cat() {
     var head = _.first(arguments);
     if (existy(head))
@@ -14,6 +24,12 @@
   }
   exports.cat = cat;
 
+  /**
+   * Prepends a head element to a tail collection, returning a new array.
+   * @param {*} head Element to prepend.
+   * @param {Array|Arguments} tail Collection to append after head.
+   * @returns {Array} New array with head followed by tail elements.
+   */
   function construct(head, tail) {
     return cat([head], _.toArray(tail));
   }
@@ -64,8 +80,8 @@
     };
   };
 
-  exports.greaterThan = exports.curry2(function (lhs, rhs) { return lhs > rhs });
-  exports.lessThan = exports.curry2(function (lhs, rhs) { return lhs < rhs });
+  exports.greaterThan = exports.curry2(function (lhs, rhs) { return lhs > rhs; });
+  exports.lessThan = exports.curry2(function (lhs, rhs) { return lhs < rhs; });
 
   exports.lift = function lift(answerFun, stateFun) {
     return function(/* args */) {
@@ -101,6 +117,12 @@
     };
   };
 
+  /**
+   * Maps a function over a collection and concatenates the results.
+   * @param {Function} fun Mapping function returning arrays.
+   * @param {Array} coll Collection to map over.
+   * @returns {Array} Concatenated results.
+   */
   function mapcat(fun, coll) {
     return cat.apply(null, _.map(coll, fun));
   }
@@ -131,8 +153,19 @@
   };
 
   exports.truthy = truthy;
-  function truthy(x) { return (x !== false) && existy(x) }
-
+  /**
+   * Checks whether a value is truthy (not false, null, or undefined).
+   * @param {*} x Value to check.
+   * @returns {boolean} True if the value is truthy.
+   */
+  function truthy(x) { return (x !== false) && existy(x); }
+
+  /**
+   * Executes an action if the condition is truthy, otherwise returns undefined.
+   * @param {*} cond Condition to evaluate.
+   * @param {Function} action Function to invoke if condition is truthy.
+   * @returns {*} Result of action if condition is truthy, undefined otherwise.
+   */
   function doWhen(cond, action) {
     if(truthy(cond))
       return action();
@@ -160,6 +193,31 @@
     return _.extend.apply(null, construct({}, arguments));
   };
 
+  /**
+   * Deep merges multiple objects, with later arguments taking precedence.
+   * @returns {Object} A new merged object.
+   */
+  exports.deepMerge = function(/*args*/) {
+    var sources = _.toArray(arguments);
+    var result = {};
+    for (var i = 0; i < sources.length; i++) {
+      var src = sources[i];
+      if (!existy(src)) continue;
+      var keys = _.keys(src);
+      for (var k = 0; k < keys.length; k++) {
+        var key = keys[k];
+        var val = src[key];
+        if (!existy(val)) continue;
+        if (_.isObject(val) && !_.isArray(val) && _.isObject(result[key]) && !_.isArray(result[key])) {
+          result[key] = exports.deepMerge(result[key], val);
+        } else {
+          result[key] = val;
+        }
+      }
+    }
+    return result;
+  };
+
   exports.dispatch = function(/* funs */) {
     var funs = _.toArray(arguments);
     var size = funs.length;
@@ -183,7 +241,7 @@
     return function(obj) {
       if (type === obj)
         return action(obj);
-    }
-  }
+    };
+  };
 
 }.call(this));