ruby-wisp-source 0.7.0

data/vendor/sequence.js

@@ -0,0 +1,555 @@
+var _ns_ = "wisp.sequence";
+module.namespace = _ns_;
+var isNil = (require("./runtime")).isNil;
+var isVector = (require("./runtime")).isVector;
+var isFn = (require("./runtime")).isFn;
+var isNumber = (require("./runtime")).isNumber;
+var isString = (require("./runtime")).isString;
+var isDictionary = (require("./runtime")).isDictionary;
+var keyValues = (require("./runtime")).keyValues;
+var str = (require("./runtime")).str;
+var dec = (require("./runtime")).dec;
+var inc = (require("./runtime")).inc;
+var merge = (require("./runtime")).merge;;
+
+var List = function List(head, tail) {
+  this.head = head;
+  this.tail = tail || (list());
+  this.length = inc(count(this.tail));
+  return this;
+};
+
+List.prototype.length = 0;
+
+List.type = "wisp.list";
+
+List.prototype.type = List.type;
+
+List.prototype.tail = Object.create(List.prototype);
+
+List.prototype.toString = function() {
+  return (function loop(result, list) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(list) ?
+      "" + "(" + (result.substr(1)) + ")" :
+      (result = "" + result + " " + (isVector(first(list)) ?
+        "" + "[" + (first(list).join(" ")) + "]" :
+      isNil(first(list)) ?
+        "nil" :
+      isString(first(list)) ?
+        JSON.stringify(first(list)) :
+      isNumber(first(list)) ?
+        JSON.stringify(first(list)) :
+        first(list)), list = rest(list), loop);
+    };
+    return recur;
+  })("", this);
+};
+
+var lazySeqValue = function lazySeqValue(lazySeq) {
+  return !(lazySeq.realized) ?
+    (lazySeq.realized = true) && (lazySeq.x = lazySeq.x()) :
+    lazySeq.x;
+};
+
+var LazySeq = function LazySeq(realized, x) {
+  this.realized = realized || false;
+  this.x = x;
+  return this;
+};
+
+LazySeq.type = "wisp.lazy.seq";
+
+LazySeq.prototype.type = LazySeq.type;
+
+var lazySeq = function lazySeq(realized, body) {
+  return new LazySeq(realized, body);
+};
+exports.lazySeq = lazySeq;
+
+var isLazySeq = function isLazySeq(value) {
+  return value && (LazySeq.type === value.type);
+};
+exports.isLazySeq = isLazySeq;
+
+undefined;
+
+var isList = function isList(value) {
+  return value && (List.type === value.type);
+};
+exports.isList = isList;
+
+var list = function list() {
+  return arguments.length === 0 ?
+    Object.create(List.prototype) :
+    Array.prototype.slice.call(arguments).reduceRight(function(tail, head) {
+      return cons(head, tail);
+    }, list());
+};
+exports.list = list;
+
+var cons = function cons(head, tail) {
+  return new List(head, tail);
+};
+exports.cons = cons;
+
+var reverseList = function reverseList(sequence) {
+  return (function loop(items, source) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(source) ?
+      list.apply(list, items) :
+      (items = [first(source)].concat(items), source = rest(source), loop);
+    };
+    return recur;
+  })([], sequence);
+};
+
+var isSequential = function isSequential(x) {
+  return (isList(x)) || (isVector(x)) || (isLazySeq(x)) || (isDictionary(x)) || (isString(x));
+};
+exports.isSequential = isSequential;
+
+var reverse = function reverse(sequence) {
+  return isList(sequence) ?
+    reverseList(sequence) :
+  isVector(sequence) ?
+    sequence.reverse() :
+  isNil(sequence) ?
+    list() :
+  "else" ?
+    reverse(seq(sequence)) :
+    void(0);
+};
+exports.reverse = reverse;
+
+var map = function map(f, sequence) {
+  return isVector(sequence) ?
+    sequence.map(f) :
+  isList(sequence) ?
+    mapList(f, sequence) :
+  isNil(sequence) ?
+    list() :
+  "else" ?
+    map(f, seq(sequence)) :
+    void(0);
+};
+exports.map = map;
+
+var mapList = function mapList(f, sequence) {
+  return (function loop(result, items) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(items) ?
+      reverse(result) :
+      (result = cons(f(first(items)), result), items = rest(items), loop);
+    };
+    return recur;
+  })(list(), sequence);
+};
+
+var filter = function filter(isF, sequence) {
+  return isVector(sequence) ?
+    sequence.filter(isF) :
+  isList(sequence) ?
+    filterList(isF, sequence) :
+  isNil(sequence) ?
+    list() :
+  "else" ?
+    filter(isF, seq(sequence)) :
+    void(0);
+};
+exports.filter = filter;
+
+var filterList = function filterList(isF, sequence) {
+  return (function loop(result, items) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(items) ?
+      reverse(result) :
+      (result = isF(first(items)) ?
+        cons(first(items), result) :
+        result, items = rest(items), loop);
+    };
+    return recur;
+  })(list(), sequence);
+};
+
+var reduce = function reduce(f) {
+  var params = Array.prototype.slice.call(arguments, 1);
+  return (function() {
+    var hasInitial = count(params) >= 2;
+    var initial = hasInitial ?
+      first(params) :
+      void(0);
+    var sequence = hasInitial ?
+      second(params) :
+      first(params);
+    return isNil(sequence) ?
+      initial :
+    isVector(sequence) ?
+      hasInitial ?
+        sequence.reduce(f, initial) :
+        sequence.reduce(f) :
+    isList(sequence) ?
+      hasInitial ?
+        reduceList(f, initial, sequence) :
+        reduceList(f, first(sequence), rest(sequence)) :
+    "else" ?
+      reduce(f, initial, seq(sequence)) :
+      void(0);
+  })();
+};
+exports.reduce = reduce;
+
+var reduceList = function reduceList(f, initial, sequence) {
+  return (function loop(result, items) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(items) ?
+      result :
+      (result = f(result, first(items)), items = rest(items), loop);
+    };
+    return recur;
+  })(initial, sequence);
+};
+
+var count = function count(sequence) {
+  return isNil(sequence) ?
+    0 :
+    (seq(sequence)).length;
+};
+exports.count = count;
+
+var isEmpty = function isEmpty(sequence) {
+  return count(sequence) === 0;
+};
+exports.isEmpty = isEmpty;
+
+var first = function first(sequence) {
+  return isNil(sequence) ?
+    void(0) :
+  isList(sequence) ?
+    sequence.head :
+  (isVector(sequence)) || (isString(sequence)) ?
+    (sequence || 0)[0] :
+  isLazySeq(sequence) ?
+    first(lazySeqValue(sequence)) :
+  "else" ?
+    first(seq(sequence)) :
+    void(0);
+};
+exports.first = first;
+
+var second = function second(sequence) {
+  return isNil(sequence) ?
+    void(0) :
+  isList(sequence) ?
+    first(rest(sequence)) :
+  (isVector(sequence)) || (isString(sequence)) ?
+    (sequence || 0)[1] :
+  isLazySeq(sequence) ?
+    second(lazySeqValue(sequence)) :
+  "else" ?
+    first(rest(seq(sequence))) :
+    void(0);
+};
+exports.second = second;
+
+var third = function third(sequence) {
+  return isNil(sequence) ?
+    void(0) :
+  isList(sequence) ?
+    first(rest(rest(sequence))) :
+  (isVector(sequence)) || (isString(sequence)) ?
+    (sequence || 0)[2] :
+  isLazySeq(sequence) ?
+    third(lazySeqValue(sequence)) :
+  "else" ?
+    second(rest(seq(sequence))) :
+    void(0);
+};
+exports.third = third;
+
+var rest = function rest(sequence) {
+  return isNil(sequence) ?
+    list() :
+  isList(sequence) ?
+    sequence.tail :
+  (isVector(sequence)) || (isString(sequence)) ?
+    sequence.slice(1) :
+  isLazySeq(sequence) ?
+    rest(lazySeqValue(sequence)) :
+  "else" ?
+    rest(seq(sequence)) :
+    void(0);
+};
+exports.rest = rest;
+
+var lastOfList = function lastOfList(list) {
+  return (function loop(item, items) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(items) ?
+      item :
+      (item = first(items), items = rest(items), loop);
+    };
+    return recur;
+  })(first(list), rest(list));
+};
+
+var last = function last(sequence) {
+  return (isVector(sequence)) || (isString(sequence)) ?
+    (sequence || 0)[dec(count(sequence))] :
+  isList(sequence) ?
+    lastOfList(sequence) :
+  isNil(sequence) ?
+    void(0) :
+  isLazySeq(sequence) ?
+    last(lazySeqValue(sequence)) :
+  "else" ?
+    last(seq(sequence)) :
+    void(0);
+};
+exports.last = last;
+
+var butlast = function butlast(sequence) {
+  var items = isNil(sequence) ?
+    void(0) :
+  isString(sequence) ?
+    subs(sequence, 0, dec(count(sequence))) :
+  isVector(sequence) ?
+    sequence.slice(0, dec(count(sequence))) :
+  isList(sequence) ?
+    list.apply(list, butlast(vec(sequence))) :
+  isLazySeq(sequence) ?
+    butlast(lazySeqValue(sequence)) :
+  "else" ?
+    butlast(seq(sequence)) :
+    void(0);
+  return !((isNil(items)) || (isEmpty(items))) ?
+    items :
+    void(0);
+};
+exports.butlast = butlast;
+
+var take = function take(n, sequence) {
+  return isNil(sequence) ?
+    list() :
+  isVector(sequence) ?
+    takeFromVector(n, sequence) :
+  isList(sequence) ?
+    takeFromList(n, sequence) :
+  isLazySeq(sequence) ?
+    take(n, lazySeqValue(sequence)) :
+  "else" ?
+    take(n, seq(sequence)) :
+    void(0);
+};
+exports.take = take;
+
+var takeVectorWhile = function takeVectorWhile(predicate, vector) {
+  return (function loop(result, tail, head) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = (!(isEmpty(tail))) && (predicate(head)) ?
+      (result = conj(result, head), tail = rest(tail), head = first(tail), loop) :
+      result;
+    };
+    return recur;
+  })([], vector, first(vector));
+};
+
+var takeListWhile = function takeListWhile(predicate, items) {
+  return (function loop(result, tail, head) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = (!(isEmpty(tail))) && (isPredicate(head)) ?
+      (result = conj(result, head), tail = rest(tail), head = first(tail), loop) :
+      list.apply(list, result);
+    };
+    return recur;
+  })([], items, first(items));
+};
+
+var takeWhile = function takeWhile(predicate, sequence) {
+  return isNil(sequence) ?
+    list() :
+  isVector(sequence) ?
+    takeVectorWhile(predicate, sequence) :
+  isList(sequence) ?
+    takeVectorWhile(predicate, sequence) :
+  "else" ?
+    takeWhile(predicate, lazySeqValue(sequence)) :
+    void(0);
+};
+exports.takeWhile = takeWhile;
+
+var takeFromVector = function takeFromVector(n, vector) {
+  return vector.slice(0, n);
+};
+
+var takeFromList = function takeFromList(n, sequence) {
+  return (function loop(taken, items, n) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = (n === 0) || (isEmpty(items)) ?
+      reverse(taken) :
+      (taken = cons(first(items), taken), items = rest(items), n = dec(n), loop);
+    };
+    return recur;
+  })(list(), sequence, n);
+};
+
+var dropFromList = function dropFromList(n, sequence) {
+  return (function loop(left, items) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = (left < 1) || (isEmpty(items)) ?
+      items :
+      (left = dec(left), items = rest(items), loop);
+    };
+    return recur;
+  })(n, sequence);
+};
+
+var drop = function drop(n, sequence) {
+  return n <= 0 ?
+    sequence :
+  isString(sequence) ?
+    sequence.substr(n) :
+  isVector(sequence) ?
+    sequence.slice(n) :
+  isList(sequence) ?
+    dropFromList(n, sequence) :
+  isNil(sequence) ?
+    list() :
+  isLazySeq(sequence) ?
+    drop(n, lazySeqValue(sequence)) :
+  "else" ?
+    drop(n, seq(sequence)) :
+    void(0);
+};
+exports.drop = drop;
+
+var conjList = function conjList(sequence, items) {
+  return reduce(function(result, item) {
+    return cons(item, result);
+  }, sequence, items);
+};
+
+var conj = function conj(sequence) {
+  var items = Array.prototype.slice.call(arguments, 1);
+  return isVector(sequence) ?
+    sequence.concat(items) :
+  isString(sequence) ?
+    "" + sequence + (str.apply(str, items)) :
+  isNil(sequence) ?
+    list.apply(list, reverse(items)) :
+  (isList(sequence)) || (isLazySeq()) ?
+    conjList(sequence, items) :
+  isDictionary(sequence) ?
+    merge(sequence, merge.apply(merge, items)) :
+  "else" ?
+    (function() { throw TypeError("" + "Type can't be conjoined " + sequence); })() :
+    void(0);
+};
+exports.conj = conj;
+
+var concat = function concat() {
+  var sequences = Array.prototype.slice.call(arguments, 0);
+  return reverse(reduce(function(result, sequence) {
+    return reduce(function(result, item) {
+      return cons(item, result);
+    }, result, seq(sequence));
+  }, list(), sequences));
+};
+exports.concat = concat;
+
+var seq = function seq(sequence) {
+  return isNil(sequence) ?
+    void(0) :
+  (isVector(sequence)) || (isList(sequence)) || (isLazySeq(sequence)) ?
+    sequence :
+  isString(sequence) ?
+    Array.prototype.slice.call(sequence) :
+  isDictionary(sequence) ?
+    keyValues(sequence) :
+  "default" ?
+    (function() { throw TypeError("" + "Can not seq " + sequence); })() :
+    void(0);
+};
+exports.seq = seq;
+
+var isSeq = function isSeq(sequence) {
+  return (isList(sequence)) || (isLazySeq(sequence));
+};
+exports.isSeq = isSeq;
+
+var listToVector = function listToVector(source) {
+  return (function loop(result, list) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = isEmpty(list) ?
+      result :
+      (result = (function() {
+        result.push(first(list));
+        return result;
+      })(), list = rest(list), loop);
+    };
+    return recur;
+  })([], source);
+};
+
+var vec = function vec(sequence) {
+  return isNil(sequence) ?
+    [] :
+  isVector(sequence) ?
+    sequence :
+  isList(sequence) ?
+    listToVector(sequence) :
+  "else" ?
+    vec(seq(sequence)) :
+    void(0);
+};
+exports.vec = vec;
+
+var sort = function sort(f, items) {
+  var hasComparator = isFn(f);
+  var items = (!(hasComparator)) && (isNil(items)) ?
+    f :
+    items;
+  var compare = hasComparator ?
+    function(a, b) {
+      return f(a, b) ?
+        0 :
+        1;
+    } :
+    void(0);
+  return isNil(items) ?
+    list() :
+  isVector(items) ?
+    items.sort(compare) :
+  isList(items) ?
+    list.apply(list, vec(items).sort(compare)) :
+  isDictionary(items) ?
+    seq(items).sort(compare) :
+  "else" ?
+    sort(f, seq(items)) :
+    void(0);
+};
+exports.sort = sort;
+
+var repeat = function repeat(n, x) {
+  return (function loop(n, result) {
+    var recur = loop;
+    while (recur === loop) {
+      recur = n <= 0 ?
+      result :
+      (n = dec(n), result = conj(result, x), loop);
+    };
+    return recur;
+  })(n, []);
+};
+exports.repeat = repeat

data/vendor/src/ast.wisp

@@ -0,0 +1,162 @@
+(ns wisp.ast
+  (:use [wisp.sequence :only [list? sequential? first second count last map
+                              vec]]
+        [wisp.string :only [split join]]
+        [wisp.runtime :only [nil? vector? number? string? boolean? object?
+                             date? re-pattern? dictionary? str inc subs =]]))
+
+(defn with-meta
+  "Returns identical value with given metadata associated to it."
+  [value metadata]
+  (.defineProperty Object value "metadata" {:value metadata :configurable true})
+  value)
+
+(defn meta
+  "Returns the metadata of the given value or nil if there is no metadata."
+  [value]
+  (if (object? value) (.-metadata value)))
+
+(def **ns-separator** "\u2044")
+
+(defn- Symbol
+  "Type for the symbols"
+  [namespace name]
+  (set! (.-namespace this) namespace)
+  (set! (.-name this) name)
+  this)
+(set! Symbol.type "wisp.symbol")
+(set! Symbol.prototype.type Symbol.type)
+(set! Symbol.prototype.to-string
+      (fn []
+        (let [ns (namespace this)]
+          (if ns
+            (str ns "/" (name this))
+            (str (name this))))))
+
+(defn symbol
+  "Returns a Symbol with the given namespace and name."
+  [ns id]
+  (cond
+   (symbol? ns) ns
+   (keyword? ns) (Symbol. (namespace ns) (name ns))
+   (nil? id) (Symbol. nil ns)
+   :else (Symbol. ns id)))
+
+(defn ^boolean symbol? [x]
+  (and x (identical? Symbol.type x.type)))
+
+(defn ^boolean keyword? [x]
+  (and (string? x)
+       (> (count x) 1)
+       (identical? (first x) "\uA789")))
+
+(defn keyword
+  "Returns a Keyword with the given namespace and name. Do not use :
+  in the keyword strings, it will be added automatically."
+  [ns id]
+  (cond (keyword? ns) ns
+        (symbol? ns) (str "\uA789" (name ns))
+        (nil? id) (str "\uA789" ns)
+        (nil? ns) (str "\uA789" id)
+        :else (str "\uA789" ns **ns-separator** id)))
+
+(defn- keyword-name
+  [value]
+  (last (split (subs value 1) **ns-separator**)))
+
+(defn name
+  "Returns the name String of a string, symbol or keyword."
+  [value]
+  (cond (symbol? value) (.-name value)
+        (keyword? value) (keyword-name value)
+        (string? value) value
+        :else (throw (TypeError. (str "Doesn't support name: " value)))))
+
+(defn- keyword-namespace
+  [x]
+  (let [parts (split (subs x 1) **ns-separator**)]
+    (if (> (count parts) 1) (get parts 0))))
+
+(defn namespace
+  "Returns the namespace String of a symbol or keyword, or nil if not present."
+  [x]
+  (cond (symbol? x) (.-namespace x)
+        (keyword? x) (keyword-namespace x)
+        :else (throw (TypeError. (str "Doesn't supports namespace: " x)))))
+
+(defn gensym
+  "Returns a new symbol with a unique name. If a prefix string is
+  supplied, the name is prefix# where # is some unique number. If
+  prefix is not supplied, the prefix is 'G__'."
+  [prefix]
+  (symbol (str (if (nil? prefix) "G__" prefix)
+               (set! gensym.base (+ gensym.base 1)))))
+(set! gensym.base 0)
+
+
+(defn ^boolean unquote?
+  "Returns true if it's unquote form: ~foo"
+  [form]
+  (and (list? form) (= (first form) 'unquote)))
+
+(defn ^boolean unquote-splicing?
+  "Returns true if it's unquote-splicing form: ~@foo"
+  [form]
+  (and (list? form) (= (first form) 'unquote-splicing)))
+
+(defn ^boolean quote?
+  "Returns true if it's quote form: 'foo '(foo)"
+  [form]
+  (and (list? form) (= (first form) 'quote)))
+
+(defn ^boolean syntax-quote?
+  "Returns true if it's syntax quote form: `foo `(foo)"
+  [form]
+  (and (list? form) (= (first form) 'syntax-quote)))
+
+(defn- normalize [n len]
+  (loop [ns (str n)]
+    (if (< (count ns) len)
+      (recur (str "0" ns))
+      ns)))
+
+(defn quote-string
+  [s]
+  (set! s (join "\\\"" (split s "\"")))
+  (set! s (join "\\\\" (split s "\\")))
+  (set! s (join "\\b" (split s "\b")))
+  (set! s (join "\\f" (split s "\f")))
+  (set! s (join "\\n" (split s "\n")))
+  (set! s (join "\\r" (split s "\r")))
+  (set! s (join "\\t" (split s "\t")))
+  (str "\"" s "\""))
+
+(defn ^string pr-str
+  [x]
+  (cond (nil? x) "nil"
+        (keyword? x) (if (namespace x)
+                        (str ":" (namespace x) "/" (name x))
+                        (str ":" (name x)))
+        (string? x) (quote-string x)
+        (date? x) (str "#inst \""
+                       (.getUTCFullYear x) "-"
+                       (normalize (inc (.getUTCMonth x)) 2) "-"
+                       (normalize (.getUTCDate x) 2) "T"
+                       (normalize (.getUTCHours x) 2) ":"
+                       (normalize (.getUTCMinutes x) 2) ":"
+                       (normalize (.getUTCSeconds x) 2) "."
+                       (normalize (.getUTCMilliseconds x) 3) "-"
+                       "00:00\"")
+        (vector? x) (str "[" (join " " (map pr-str (vec x))) "]")
+        (dictionary? x) (str "{"
+                             (join ", "
+                                   (map (fn [pair]
+                                          (str
+                                           (pr-str (first pair))
+                                           " "
+                                           (pr-str (second pair))))
+                                        x))
+                             "}")
+        (sequential? x) (str "(" (join " " (map pr-str (vec x))) ")")
+        (re-pattern? x) (str "#\"" (join "\\/" (split (.-source x) "/")) "\"")
+        :else (str x)))