chimpanzee - npm Package Compare versions

Comparing version 0.0.1 to 0.0.2

dist/any.js

@@ -7,12 +7,26 @@ "use strict";
 exports.any = any;
+
+var _chimpanzee = require("./chimpanzee");
+
+var _wrap = require("./wrap");
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
 function any(list) {
-  return function* (obj, state, key) {
-    for (const gen of list) {
-      const result = yield* gen(obj, state, key);
-      if (result.type === "return") {
-        return result;
+  return function () {
+    var _ref = _asyncToGenerator(function* (obj, context, key, parentObj, parentContext) {
+      for (const gen of list) {
+        const result = yield (0, _chimpanzee.match)(gen(obj, context, key, parentObj, parentContext));
+        if (result && result.type === "return") {
+          return result;
+        }
       }
-    }
-  };
+      return (0, _wrap.skip)("None of the candidates matched.");
+    });
+
+    return function (_x, _x2, _x3, _x4, _x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 }
 //# sourceMappingURL=any.js.map

dist/capture.js

@@ -14,12 +14,25 @@ "use strict";
 
-function capture(name, schema, options) {
-  return function* (obj, state, key) {
-    const _options = _extends({}, options, { predicate: function predicate(obj) {
-        return typeof obj !== "undefined";
-      }, result: function result(state, obj) {
-        return { [name || key]: obj };
-      } });
-    const genFn = (0, _traverse.traverse)(schema || {}, _options);
-    return yield* genFn(obj, state, key);
-  };
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+function capture(name, schema, options = {}) {
+  return function () {
+    var _ref = _asyncToGenerator(function* (obj, context, key, parentObj, parentContext) {
+      const _options = _extends({
+        predicate: function predicate(obj) {
+          return typeof obj !== "undefined";
+        }
+      }, options, {
+        builders: (options.builders || []).concat({
+          get: function get(obj) {
+            return { [name || key]: obj };
+          }
+        })
+      });
+      return (0, _traverse.traverse)(schema || {}, _options)(obj, context, key, parentObj, parentContext);
+    });
+
+    return function (_x, _x2, _x3, _x4, _x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 }
@@ -26,0 +39,0 @@

dist/chimpanzee.js

@@ -7,2 +7,17 @@ "use strict";
 
+let match = exports.match = function () {
+  var _ref = _asyncToGenerator(function* (traverseResult) {
+    const result = yield traverseResult;
+    if (typeof result === "function") {
+      return yield match(result());
+    } else {
+      return result;
+    }
+  });
+
+  return function match(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
 var _traverse = require("./traverse");
@@ -49,11 +64,4 @@
 });
-exports.match = match;
-function match(generator) {
-  while (true) {
-    const result = generator.next();
-    if (result.done) {
-      return result.value;
-    }
-  }
-}
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
 //# sourceMappingURL=chimpanzee.js.map

dist/empty.js

@@ -10,7 +10,15 @@ "use strict";
 
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
 function empty() {
-  return function* (obj, state, key) {
-    return obj === undefined ? (0, _wrap.ret)({}) : (0, _wrap.skip)("Not empty.");
-  };
+  return function () {
+    var _ref = _asyncToGenerator(function* (obj, context, key, parentObj, parentContext) {
+      return obj === undefined ? (0, _wrap.ret)({}) : (0, _wrap.skip)("Not empty.");
+    });
+
+    return function (_x, _x2, _x3, _x4, _x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 }
 //# sourceMappingURL=empty.js.map

dist/traverse.js

@@ -13,104 +13,143 @@ "use strict";
 
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
 function traverse(schema, options = {}) {
-  if (!options.result) {
-    options.result = function (v) {
-      return v;
-    };
+  if (!options.builders) {
+    options.builders = [{ get: function get(obj, { state }) {
+        return state;
+      } }];
   }
 
-  function mismatch(message) {
-    if (options.mustMatch) {
-      throw new Error(message);
-    }
+  return function () {
+    var _ref = _asyncToGenerator(function* (obj, context = { state: {} }, key, parentObj, parentContext) {
 
-    if (options.logMismatch) {
-      options.logMismatch(message);
-    }
-    return (0, _wrap.skip)(message);
-  }
+      /*
+        Tasks must run only after childTasks are complete.
+      */
+      let run = function () {
+        var _ref3 = _asyncToGenerator(function* (childTasks, tasks) {
+          const runnables = childTasks.length ? childTasks : tasks;
 
-  return function* (obj, state = {}, key) {
-    obj = options.objectModifier ? options.objectModifier(obj) : obj;
+          let unfinished = [],
+              finished = [];
+          for (const gen of runnables) {
+            const val = yield gen;
+            if (typeof val === "function") {
+              unfinished.push(val());
+            } else {
+              finished.push(val);
+            }
+          }
 
-    if (options.predicate && !options.predicate(obj)) {
-      return mismatch(`Predicate returned false.`);
-    }
+          for (const item of finished) {
+            if (item.type === "skip" || item.type === "error") {
+              return item;
+            } else if (item.type === "return") {
+              context.state = _extends({}, context.state, item.value);
+            } else {
+              throw new Error(`Unknown result ${ item }.`);
+            }
+          }
 
-    let generators = [];
+          if (childTasks.length || unfinished.length) {
+            return _asyncToGenerator(function* () {
+              return childTasks.length ? run(unfinished, tasks) : run([], unfinished);
+            });
+          } else {
+            return (0, _wrap.ret)(context.state);
+          }
+        });
 
-    if (typeof schema === "object") {
-      for (const key in schema) {
-        const lhs = options.modifier ? options.modifier(obj, key) : obj[key];
-        const rhs = schema[key];
+        return function run(_x2, _x3) {
+          return _ref3.apply(this, arguments);
+        };
+      }();
 
-        if (["string", "number", "boolean"].includes(typeof rhs)) {
-          if (lhs !== rhs) {
-            return mismatch(`Expected ${ rhs } but got ${ lhs }.`);
-          }
-        } else if (typeof rhs === "object") {
-          generators.push(traverse(rhs, options)(lhs, state, key));
-        } else if (typeof rhs === "function") {
-          generators.push(rhs(lhs, { parent: state }, key));
-        }
-      }
-    } else if (Array.isArray(schema)) {
-      if (!Array.isArray(obj)) {
-        return mismatch(`Expected array but got ${ typeof obj }.`);
-      }
+      obj = options.objectModifier ? yield options.objectModifier(obj) : obj;
 
-      if (schema.length !== obj.length) {
-        return mismatch(`Expected array of length ${ schema.length } but got ${ obj.length }.`);
+      if (options.predicate && !(yield options.predicate(obj))) {
+        return (0, _wrap.skip)(`Predicate returned false.`);
       }
 
-      for (let i = 0; i < schema.length; i++) {
-        const lhs = obj[i];
-        const rhs = schema[i];
-        generators.push(traverse(rhs, options)(lhs, state, i));
-      }
-    }
+      function getTask(builder) {
+        return function () {
+          var _ref2 = _asyncToGenerator(function* () {
+            if (!builder.precondition || (yield builder.precondition(obj, context, key, parentObj, parentContext))) {
+              const predicates = (!builder.predicates ? [] : builder.predicates.map(function (p) {
+                return { fn: p.predicate, invalid: function invalid() {
+                    return (0, _wrap.skip)(`Predicate returned false.`);
+                  } };
+              })).concat(!builder.asserts ? [] : builder.asserts.map(function (a) {
+                return { fn: a.predicate, invalid: function invalid() {
+                    return (0, _wrap.error)(a.error);
+                  } };
+              }));
 
-    while (true) {
-      const iterated = generators.map(function (gen) {
-        return [gen, gen.next()];
-      });
-      const finished = iterated.filter(function (r) {
-        return r[1].done;
-      });
-      const unfinished = iterated.filter(function (r) {
-        return !r[1].done;
-      });
+              for (const predicate of predicates) {
+                if (!(yield predicate.fn(obj, context, key, parentObj, parentContext))) {
+                  return predicate.invalid();
+                }
+              }
 
-      for (const [gen, { value: genValue }] of finished) {
-        if (genValue.type === "return") {
-          state = _extends({}, state, genValue.value);
-        } else if (genValue.type === "skip") {
-          return mismatch(genValue.message);
-        } else if (genValue.type === "error") {
-          return (0, _wrap.error)(genValue.message);
-        }
+              return (0, _wrap.ret)((yield builder.get(obj, context, key, parentObj, parentContext)));
+            } else {
+              return fn;
+            }
+          });
+
+          function fn() {
+            return _ref2.apply(this, arguments);
+          }
+
+          return fn;
+        }();
       }
 
-      generators = unfinished.map(function (r) {
-        return r[0];
+      const tasks = options.builders.map(function (builder) {
+        return getTask(builder);
       });
 
-      const mustWait = generators.length || options.preconditions && options.preconditions.length && !options.preconditions.every(function (expr) {
-        return expr();
-      });
+      let childTasks = [];
 
-      if (mustWait) {
-        yield (0, _wrap.wait)();
-      } else {
-        if (options.asserts) {
-          for (const assert of options.asserts) {
-            if (assert[0]()) {
-              return (0, _wrap.error)(assert[1]);
+      if (typeof schema === "object") {
+        for (const key in schema) {
+          const lhs = options.modifier ? yield options.modifier(obj, key) : obj[key];
+          const rhs = schema[key];
+
+          if (["string", "number", "boolean"].includes(typeof rhs)) {
+            if (lhs !== rhs) {
+              return (0, _wrap.skip)(`Expected ${ rhs } but got ${ lhs }.`);
             }
+          } else if (typeof rhs === "object") {
+            childTasks.push(traverse(rhs, options)(lhs, context, key, parentObj, parentContext));
+          } else if (typeof rhs === "function") {
+            childTasks.push(rhs(lhs, undefined, key, obj, context));
           }
         }
-        return (0, _wrap.ret)(options.result(state, obj));
+      } else if (Array.isArray(schema)) {
+        if (!Array.isArray(obj)) {
+          return (0, _wrap.skip)(`Expected array but got ${ typeof obj }.`);
+        }
+
+        if (schema.length !== obj.length) {
+          return (0, _wrap.skip)(`Expected array of length ${ schema.length } but got ${ obj.length }.`);
+        }
+
+        for (let i = 0; i < schema.length; i++) {
+          const lhs = obj[i];
+          const rhs = schema[i];
+          childTasks.push(traverse(rhs, options)(lhs, context, i, parentObj, parentContext));
+        }
       }
-    }
-  };
+
+      return _asyncToGenerator(function* () {
+        return run(childTasks, tasks);
+      });
+    });
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
 }
 //# sourceMappingURL=traverse.js.map

dist/wrap.js

@@ -6,12 +6,7 @@ "use strict";
 });
-exports.wait = wait;
 exports.error = error;
 exports.skip = skip;
 exports.ret = ret;
-function wait() {
-  return { type: "wait" };
-}
-
 function error(message) {
-  return { type: "skip", message };
+  return { type: "error", message };
 }
@@ -18,0 +13,0 @@

package.json

 {
   "name": "chimpanzee",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "author": "Jeswin<[e-mail]>",
@@ -5,0 +5,0 @@ "scripts": {

No alert changes

Improved metrics

Total package byte prevSize

65328

increased by12.98%

Lines of code

279

increased by29.17%

No dependency changes