ruby-wisp-source 0.7.0

data/vendor/node_modules/wisp/repl.js

@@ -0,0 +1,121 @@
+var repl = require("repl");
+
+var vm = require("vm");
+
+var transpile = (require("./engine/node")).transpile;;
+
+var pushBackReader = (require("./reader")).pushBackReader;
+var read = (require("./reader")).read;;
+
+var isEqual = (require("./runtime")).isEqual;
+var subs = (require("./runtime")).subs;;
+
+var list = (require("./sequence")).list;
+var count = (require("./sequence")).count;;
+
+var compileProgram = (require("./compiler")).compileProgram;
+var compile = (require("./compiler")).compile;;
+
+var prStr = (require("./ast")).prStr;;
+
+var evaluateCode = function evaluateCode(code, uri, context) {
+  context._debug_ ?
+    console.log("INPUT:", prStr(code)) :
+    void(0);
+  return (function() {
+    var reader = pushBackReader(code, uri);
+    return (function loop(lastOutput) {
+      var recur = loop;
+      while (recur === loop) {
+        recur = (function() {
+        var output = evaluateNextForm(reader, context);
+        var error = (output || 0)["error"];
+        return !((output || 0)["finished"]) ?
+          error ?
+            (function() {
+              context._e = error;
+              return output;
+            })() :
+            (lastOutput = output, loop) :
+          (function() {
+            context._3 = context._2;
+            context.__3 = context.__2;
+            context._2 = context._1;
+            context.__2 = context.__1;
+            context._1 = (lastOutput || 0)["value"];
+            context.__1 = (lastOutput || 0)["form"];
+            return lastOutput;
+          })();
+      })();
+      };
+      return recur;
+    })({
+      "finished": true
+    });
+  })();
+};
+exports.evaluateCode = evaluateCode;
+
+var evaluateNextForm = function evaluateNextForm(reader, context) {
+  return (function() {
+  try {
+    return (function() {
+      var uri = reader.uri;
+      var form = read(reader, false, "finished-reading");
+      return isEqual(form, "finished-reading") ?
+        {
+          "finished": true
+        } :
+        (function() {
+          var _ = context._debug_ ?
+            console.log("READ:", prStr(form)) :
+            void(0);
+          var body = form;
+          var code = compileProgram(list(body));
+          var _ = context._debug_ ?
+            console.log("EMITTED:", prStr(code)) :
+            void(0);
+          var value = vm.runInContext(code, context, uri);
+          return {
+            "value": value,
+            "js": code,
+            "form": form
+          };
+        })();
+    })();
+  } catch (error) {
+    return {
+      "error": error
+    };
+  }})();
+};
+exports.evaluateNextForm = evaluateNextForm;
+
+var evaluate = (function() {
+  var input = void(0);
+  var output = void(0);
+  return function evaluate(code, context, file, callback) {
+    return !(input === code) ?
+      (function() {
+        input = subs(code, 1, (count(code)) - 1);
+        output = evaluateCode(input, file, context);
+        return callback((output || 0)["error"], (output || 0)["value"]);
+      })() :
+      callback((output || 0)["error"]);
+  };
+})();
+exports.evaluate = evaluate;
+
+var start = function start() {
+  var session = repl.start({
+    "writer": prStr,
+    "prompt": "=> ",
+    "ignoreUndefined": true,
+    "useGlobal": false,
+    "eval": evaluate
+  });
+  var context = session.context;
+  context.exports = {};
+  return session;
+};
+exports.start = start

data/vendor/node_modules/wisp/runtime.js

@@ -0,0 +1,609 @@
+var identity = function identity(x) {
+  return x;
+};
+exports.identity = identity;
+
+var isOdd = function isOdd(n) {
+  return n % 2 === 1;
+};
+exports.isOdd = isOdd;
+
+var isEven = function isEven(n) {
+  return n % 2 === 0;
+};
+exports.isEven = isEven;
+
+var isDictionary = function isDictionary(form) {
+  return (isObject(form)) && (isObject(Object.getPrototypeOf(form))) && (isNil(Object.getPrototypeOf(Object.getPrototypeOf(form))));
+};
+exports.isDictionary = isDictionary;
+
+var dictionary = function dictionary() {
+  return (function loop(keyValues, result) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = keyValues.length ?
+      (function() {
+        (result || 0)[(keyValues || 0)[0]] = (keyValues || 0)[1];
+        return (keyValues = keyValues.slice(2), result = result, loop);
+      })() :
+      result;
+    };
+    return recur;
+  })(Array.prototype.slice.call(arguments), {});
+};
+exports.dictionary = dictionary;
+
+var keys = function keys(dictionary) {
+  return Object.keys(dictionary);
+};
+exports.keys = keys;
+
+var vals = function vals(dictionary) {
+  return keys(dictionary).map(function(key) {
+    return (dictionary || 0)[key];
+  });
+};
+exports.vals = vals;
+
+var keyValues = function keyValues(dictionary) {
+  return keys(dictionary).map(function(key) {
+    return [key, (dictionary || 0)[key]];
+  });
+};
+exports.keyValues = keyValues;
+
+var merge = function merge() {
+  return Object.create(Object.prototype, Array.prototype.slice.call(arguments).reduce(function(descriptor, dictionary) {
+    isObject(dictionary) ?
+      Object.keys(dictionary).forEach(function(key) {
+        return (descriptor || 0)[key] = Object.getOwnPropertyDescriptor(dictionary, key);
+      }) :
+      void(0);
+    return descriptor;
+  }, Object.create(Object.prototype)));
+};
+exports.merge = merge;
+
+var isContainsVector = function isContainsVector(vector, element) {
+  return vector.indexOf(element) >= 0;
+};
+exports.isContainsVector = isContainsVector;
+
+var mapDictionary = function mapDictionary(source, f) {
+  return Object.keys(source).reduce(function(target, key) {
+    (target || 0)[key] = f((source || 0)[key]);
+    return target;
+  }, {});
+};
+exports.mapDictionary = mapDictionary;
+
+var toString = Object.prototype.toString;
+exports.toString = toString;
+
+var isFn = typeof(/./) === "function" ?
+  function isFn(x) {
+    return toString.call(x) === "[object Function]";
+  } :
+  function isFn(x) {
+    return typeof(x) === "function";
+  };
+exports.isFn = isFn;
+
+var isString = function isString(x) {
+  return (typeof(x) === "string") || (toString.call(x) === "[object String]");
+};
+exports.isString = isString;
+
+var isNumber = function isNumber(x) {
+  return (typeof(x) === "number") || (toString.call(x) === "[object Number]");
+};
+exports.isNumber = isNumber;
+
+var isVector = isFn(Array.isArray) ?
+  Array.isArray :
+  function isVector(x) {
+    return toString.call(x) === "[object Array]";
+  };
+exports.isVector = isVector;
+
+var isDate = function isDate(x) {
+  return toString.call(x) === "[object Date]";
+};
+exports.isDate = isDate;
+
+var isBoolean = function isBoolean(x) {
+  return (x === true) || (x === false) || (toString.call(x) === "[object Boolean]");
+};
+exports.isBoolean = isBoolean;
+
+var isRePattern = function isRePattern(x) {
+  return toString.call(x) === "[object RegExp]";
+};
+exports.isRePattern = isRePattern;
+
+var isObject = function isObject(x) {
+  return x && (typeof(x) === "object");
+};
+exports.isObject = isObject;
+
+var isNil = function isNil(x) {
+  return (x === void(0)) || (x === null);
+};
+exports.isNil = isNil;
+
+var isTrue = function isTrue(x) {
+  return x === true;
+};
+exports.isTrue = isTrue;
+
+var isFalse = function isFalse(x) {
+  return x === true;
+};
+exports.isFalse = isFalse;
+
+var reFind = function reFind(re, s) {
+  var matches = re.exec(s);
+  return !(isNil(matches)) ?
+    matches.length === 1 ?
+      (matches || 0)[0] :
+      matches :
+    void(0);
+};
+exports.reFind = reFind;
+
+var reMatches = function reMatches(pattern, source) {
+  var matches = pattern.exec(source);
+  return (!(isNil(matches))) && ((matches || 0)[0] === source) ?
+    matches.length === 1 ?
+      (matches || 0)[0] :
+      matches :
+    void(0);
+};
+exports.reMatches = reMatches;
+
+var rePattern = function rePattern(s) {
+  var match = reFind(/^(?:\(\?([idmsux]*)\))?(.*)/, s);
+  return new RegExp((match || 0)[2], (match || 0)[1]);
+};
+exports.rePattern = rePattern;
+
+var inc = function inc(x) {
+  return x + 1;
+};
+exports.inc = inc;
+
+var dec = function dec(x) {
+  return x - 1;
+};
+exports.dec = dec;
+
+var str = function str() {
+  return String.prototype.concat.apply("", arguments);
+};
+exports.str = str;
+
+var char = function char(code) {
+  return String.fromCharCode(code);
+};
+exports.char = char;
+
+var int = function int(x) {
+  return isNumber(x) ?
+    x >= 0 ?
+      Math.floor(x) :
+      Math.floor(x) :
+    x.charCodeAt(0);
+};
+exports.int = int;
+
+var subs = function subs(string, start, end) {
+  return string.substring(start, end);
+};
+exports.subs = subs;
+
+var isPatternEqual = function isPatternEqual(x, y) {
+  return (isRePattern(x)) && (isRePattern(y)) && (x.source === y.source) && (x.global === y.global) && (x.multiline === y.multiline) && (x.ignoreCase === y.ignoreCase);
+};
+
+var isDateEqual = function isDateEqual(x, y) {
+  return (isDate(x)) && (isDate(y)) && (Number(x) === Number(y));
+};
+
+var isDictionaryEqual = function isDictionaryEqual(x, y) {
+  return (isObject(x)) && (isObject(y)) && ((function() {
+    var xKeys = keys(x);
+    var yKeys = keys(y);
+    var xCount = xKeys.length;
+    var yCount = yKeys.length;
+    return (xCount === yCount) && ((function loop(index, count, keys) {
+      var recur = loop;
+      while (recur === loop) {
+        recur = index < count ?
+        isEquivalent((x || 0)[(keys || 0)[index]], (y || 0)[(keys || 0)[index]]) ?
+          (index = inc(index), count = count, keys = keys, loop) :
+          false :
+        true;
+      };
+      return recur;
+    })(0, xCount, xKeys));
+  })());
+};
+
+var isVectorEqual = function isVectorEqual(x, y) {
+  return (isVector(x)) && (isVector(y)) && (x.length === y.length) && ((function loop(xs, ys, index, count) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = index < count ?
+      isEquivalent((xs || 0)[index], (ys || 0)[index]) ?
+        (xs = xs, ys = ys, index = inc(index), count = count, loop) :
+        false :
+      true;
+    };
+    return recur;
+  })(x, y, 0, x.length));
+};
+
+var isEquivalent = function isEquivalent(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return (x === y) || (isNil(x) ?
+        isNil(y) :
+      isNil(y) ?
+        isNil(x) :
+      isString(x) ?
+        false :
+      isNumber(x) ?
+        false :
+      isFn(x) ?
+        false :
+      isBoolean(x) ?
+        false :
+      isDate(x) ?
+        isDateEqual(x, y) :
+      isVector(x) ?
+        isVectorEqual(x, y, [], []) :
+      isRePattern(x) ?
+        isPatternEqual(x, y) :
+      "else" ?
+        isDictionaryEqual(x, y) :
+        void(0));
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (isEquivalent(previous, current)) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+
+var isEqual = isEquivalent;
+exports.isEqual = isEqual;
+
+var isStrictEqual = function isStrictEqual(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return x === y;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (previous === current) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+exports.isStrictEqual = isStrictEqual;
+
+var greaterThan = function greaterThan(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return x > y;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (previous > current) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+exports.greaterThan = greaterThan;
+
+var notLessThan = function notLessThan(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return x >= y;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (previous >= current) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+exports.notLessThan = notLessThan;
+
+var lessThan = function lessThan(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return x < y;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (previous < current) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+exports.lessThan = lessThan;
+
+var notGreaterThan = function notGreaterThan(x, y) {
+  switch (arguments.length) {
+    case 1:
+      return true;
+    case 2:
+      return x <= y;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 2);
+      return (function loop(previous, current, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = (previous <= current) && (index < count ?
+          (previous = current, current = (more || 0)[index], index = inc(index), count = count, loop) :
+          true);
+        };
+        return recur;
+      })(x, y, 0, more.length);
+  };
+  return void(0);
+};
+exports.notGreaterThan = notGreaterThan;
+
+var sum = function sum(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return 0;
+    case 1:
+      return a;
+    case 2:
+      return a + b;
+    case 3:
+      return a + b + c;
+    case 4:
+      return a + b + c + d;
+    case 5:
+      return a + b + c + d + e;
+    case 6:
+      return a + b + c + d + e + f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value + ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a + b + c + d + e + f, 0, more.length);
+  };
+  return void(0);
+};
+exports.sum = sum;
+
+var subtract = function subtract(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return (function() { throw TypeError("Wrong number of args passed to: -"); })();
+    case 1:
+      return 0 - a;
+    case 2:
+      return a - b;
+    case 3:
+      return a - b - c;
+    case 4:
+      return a - b - c - d;
+    case 5:
+      return a - b - c - d - e;
+    case 6:
+      return a - b - c - d - e - f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value - ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a - b - c - d - e - f, 0, more.length);
+  };
+  return void(0);
+};
+exports.subtract = subtract;
+
+var divide = function divide(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return (function() { throw TypeError("Wrong number of args passed to: /"); })();
+    case 1:
+      return 1 / a;
+    case 2:
+      return a / b;
+    case 3:
+      return a / b / c;
+    case 4:
+      return a / b / c / d;
+    case 5:
+      return a / b / c / d / e;
+    case 6:
+      return a / b / c / d / e / f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value / ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a / b / c / d / e / f, 0, more.length);
+  };
+  return void(0);
+};
+exports.divide = divide;
+
+var multiply = function multiply(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return 1;
+    case 1:
+      return a;
+    case 2:
+      return a * b;
+    case 3:
+      return a * b * c;
+    case 4:
+      return a * b * c * d;
+    case 5:
+      return a * b * c * d * e;
+    case 6:
+      return a * b * c * d * e * f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value * ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a * b * c * d * e * f, 0, more.length);
+  };
+  return void(0);
+};
+exports.multiply = multiply;
+
+var and = function and(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return true;
+    case 1:
+      return a;
+    case 2:
+      return a && b;
+    case 3:
+      return a && b && c;
+    case 4:
+      return a && b && c && d;
+    case 5:
+      return a && b && c && d && e;
+    case 6:
+      return a && b && c && d && e && f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value && ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a && b && c && d && e && f, 0, more.length);
+  };
+  return void(0);
+};
+exports.and = and;
+
+var or = function or(a, b, c, d, e, f) {
+  switch (arguments.length) {
+    case 0:
+      return void(0);
+    case 1:
+      return a;
+    case 2:
+      return a || b;
+    case 3:
+      return a || b || c;
+    case 4:
+      return a || b || c || d;
+    case 5:
+      return a || b || c || d || e;
+    case 6:
+      return a || b || c || d || e || f;
+
+    default:
+      var more = Array.prototype.slice.call(arguments, 6);
+      return (function loop(value, index, count) {
+        var recur = loop;
+        while (recur === loop) {
+          recur = index < count ?
+          (value = value || ((more || 0)[index]), index = inc(index), count = count, loop) :
+          value;
+        };
+        return recur;
+      })(a || b || c || d || e || f, 0, more.length);
+  };
+  return void(0);
+};
+exports.or = or;
+
+var print = function print() {
+  var more = Array.prototype.slice.call(arguments, 0);
+  return console.log.apply(console.log, more);
+};
+exports.print = print