spontaneous 0.1.0.alpha1

data/application/js/vendor/JS.Class-2.1.5/src/hash.js

@@ -0,0 +1,334 @@
+JS.Hash = new JS.Class('Hash', {
+  include: JS.Enumerable || {},
+  
+  extend: {
+    Pair: new JS.Class({
+      include: JS.Comparable || {},
+      
+      setKey: function(key) {
+        this[0] = this.key = key;
+      },
+      
+      hasKey: function(key) {
+        var my = this.key;
+        return my.equals ? my.equals(key) : my === key;
+      },
+      
+      setValue: function(value) {
+        this[1] = this.value = value;
+      },
+      
+      hasValue: function(value) {
+        var my = this.value;
+        return my.equals ? my.equals(value) : my === value;
+      },
+      
+      compareTo: function(other) {
+        return this.key.compareTo
+            ? this.key.compareTo(other.key)
+            : (this.key < other.key ? -1 : (this.key > other.key ? 1 : 0));
+      },
+      
+      hash: function() {
+        var key   = JS.Hash.codeFor(this.key),
+            value = JS.Hash.codeFor(this.value);
+        
+        return [key, value].sort().join('');
+      }
+    }),
+    
+    codeFor: function(object) {
+      if (typeof object !== 'object') return String(object);
+      return JS.isFn(object.hash)
+          ? object.hash()
+          : object.toString();
+    }
+  },
+  
+  initialize: function(object) {
+    this.clear();
+    if (!JS.isType(object, Array)) return this.setDefault(object);
+    for (var i = 0, n = object.length; i < n; i += 2)
+      this.store(object[i], object[i+1]);
+  },
+  
+  forEach: function(block, context) {
+    if (!block) return this.enumFor('forEach');
+    block = JS.Enumerable.toFn(block);
+    
+    var hash, bucket, i;
+    
+    for (hash in this._buckets) {
+      if (!this._buckets.hasOwnProperty(hash)) continue;
+      bucket = this._buckets[hash];
+      i = bucket.length;
+      while (i--) block.call(context || null, bucket[i]);
+    }
+    return this;
+  },
+  
+  _bucketForKey: function(key, createIfAbsent) {
+    var hash   = this.klass.codeFor(key),
+        bucket = this._buckets[hash];
+    
+    if (!bucket && createIfAbsent)
+      bucket = this._buckets[hash] = [];
+    
+    return bucket;
+  },
+  
+  _indexInBucket: function(bucket, key) {
+    var i     = bucket.length,
+        ident = !!this._compareByIdentity;
+        
+    while (i--) {
+      if (ident ? (bucket[i].key === key) : bucket[i].hasKey(key))
+        return i;
+    }
+    return -1;
+  },
+  
+  assoc: function(key, createIfAbsent) {
+    var bucket, index, pair;
+    
+    bucket = this._bucketForKey(key, createIfAbsent);
+    if (!bucket) return null;
+    
+    index = this._indexInBucket(bucket, key);
+    if (index > -1) return bucket[index];
+    if (!createIfAbsent) return null;
+    
+    this.size += 1; this.length += 1;
+    pair = new this.klass.Pair;
+    pair.setKey(key);
+    bucket.push(pair);
+    return pair;
+  },
+  
+  rassoc: function(value) {
+    var key = this.key(value);
+    return key ? this.assoc(key) : null;
+  },
+  
+  clear: function() {
+    this._buckets = {};
+    this.length = this.size = 0;
+  },
+  
+  compareByIdentity: function() {
+    this._compareByIdentity = true;
+  },
+  
+  comparesByIdentity: function() {
+    return !!this._compareByIdentity;
+  },
+  
+  setDefault: function(value) {
+    this._default = value;
+    return this;
+  },
+  
+  getDefault: function(key) {
+    return JS.isFn(this._default)
+        ? this._default(this, key)
+        : (this._default || null);
+  },
+  
+  equals: function(other) {
+    if (!JS.isType(other, JS.Hash) || this.length !== other.length)
+      return false;
+    var result = true;
+    this.forEach(function(pair) {
+      if (!result) return;
+      var otherPair = other.assoc(pair.key);
+      if (otherPair === null || !otherPair.hasValue(pair.value)) result = false;
+    });
+    return result;
+  },
+  
+  hash: function() {
+    var hashes = [];
+    this.forEach(function(pair) { hashes.push(pair.hash()) });
+    return hashes.sort().join('');
+  },
+  
+  fetch: function(key, defaultValue) {
+    var pair = this.assoc(key);
+    if (pair) return pair.value;
+    
+    if (defaultValue === undefined) throw new Error('key not found');
+    if (JS.isFn(defaultValue)) return defaultValue(key);
+    return defaultValue;
+  },
+  
+  forEachKey: function(block, context) {
+    if (!block) return this.enumFor('forEachKey');
+    block = JS.Enumerable.toFn(block);
+    
+    this.forEach(function(pair) {
+      block.call(context || null, pair.key);
+    });
+    return this;
+  },
+  
+  forEachPair: function(block, context) {
+    if (!block) return this.enumFor('forEachPair');
+    block = JS.Enumerable.toFn(block);
+    
+    this.forEach(function(pair) {
+      block.call(context || null, pair.key, pair.value);
+    });
+    return this;
+  },
+  
+  forEachValue: function(block, context) {
+    if (!block) return this.enumFor('forEachValue');
+    block = JS.Enumerable.toFn(block);
+    
+    this.forEach(function(pair) {
+      block.call(context || null, pair.value);
+    });
+    return this;
+  },
+  
+  get: function(key) {
+    var pair = this.assoc(key);
+    return pair ? pair.value : this.getDefault(key);
+  },
+  
+  hasKey: function(key) {
+    return !!this.assoc(key);
+  },
+  
+  hasValue: function(value) {
+    var has = false, ident = !!this._compareByIdentity;
+    this.forEach(function(pair) {
+      if ((value.equals && !ident) ? value.equals(pair.value) : value === pair.value)
+        has = true;
+    });
+    return has;
+  },
+  
+  invert: function() {
+    var hash = new this.klass;
+    this.forEach(function(pair) {
+      hash.store(pair.value, pair.key);
+    });
+    return hash;
+  },
+  
+  isEmpty: function() {
+    for (var hash in this._buckets) {
+      if (this._buckets.hasOwnProperty(hash) && this._buckets[hash].length > 0)
+        return false;
+    }
+    return true;
+  },
+  
+  key: function(value) {
+    var result = null;
+    this.forEach(function(pair) {
+      if (value.equals ? value.equals(pair.value) : (value === pair.value))
+        result = pair.key;
+    });
+    return result;
+  },
+  
+  keys: function() {
+    var keys = [];
+    this.forEach(function(pair) { keys.push(pair.key) });
+    return keys;
+  },
+  
+  merge: function(hash, block, context) {
+    var newHash = new this.klass;
+    newHash.update(this);
+    newHash.update(hash, block, context);
+    return newHash;
+  },
+  
+  rehash: function() {
+    var temp = new this.klass;
+    temp._buckets = this._buckets;
+    this.clear();
+    this.update(temp);
+  },
+  
+  remove: function(key, block) {
+    if (block === undefined) block = null;
+    var bucket, index, result;
+    
+    bucket = this._bucketForKey(key);
+    if (!bucket) return JS.isFn(block) ? this.fetch(key, block) : this.getDefault(key);
+    
+    index = this._indexInBucket(bucket, key);
+    if (index < 0) return JS.isFn(block) ? this.fetch(key, block) : this.getDefault(key);
+    
+    result = bucket[index].value;
+    bucket.splice(index, 1);
+    this.size -= 1;
+    this.length -= 1;
+    
+    if (bucket.length === 0)
+      delete this._buckets[this.klass.codeFor(key)];
+    
+    return result;
+  },
+  
+  removeIf: function(block, context) {
+    if (!block) return this.enumFor('removeIf');
+    block = JS.Enumerable.toFn(block);
+    
+    this.forEach(function(pair) {
+      if (block.call(context || null, pair))
+        this.remove(pair.key);
+    }, this);
+    return this;
+  },
+  
+  replace: function(hash) {
+    this.clear();
+    this.update(hash);
+  },
+  
+  shift: function() {
+    var keys = this.keys();
+    if (keys.length === 0) return this.getDefault();
+    var pair = this.assoc(keys[0]);
+    this.remove(pair.key);
+    return pair;
+  },
+  
+  store: function(key, value) {
+    this.assoc(key, true).setValue(value);
+    return value;
+  },
+  
+  update: function(hash, block, context) {
+    var blockGiven = JS.isFn(block);
+    hash.forEach(function(pair) {
+      var key = pair.key, value = pair.value;
+      if (blockGiven && this.hasKey(key))
+        value = block.call(context || null, key, this.get(key), value);
+      this.store(key, value);
+    }, this);
+  },
+  
+  values: function() {
+    var values = [];
+    this.forEach(function(pair) { values.push(pair.value) });
+    return values;
+  },
+  
+  valuesAt: function() {
+    var i = arguments.length, results = [];
+    while (i--) results.push(this.get(arguments[i]));
+    return results;
+  }
+});
+
+JS.Hash.include({
+  includes: JS.Hash.instanceMethod('hasKey'),
+  index:    JS.Hash.instanceMethod('key'),
+  put:      JS.Hash.instanceMethod('store')
+}, true);

data/application/js/vendor/JS.Class-2.1.5/src/linked_list.js

@@ -0,0 +1,114 @@
+JS.LinkedList = new JS.Class('LinkedList', {
+  include: JS.Enumerable || {},
+  
+  initialize: function(array, useNodes) {
+    this.length = 0;
+    this.first = this.last = null;
+    if (!array) return;
+    for (var i = 0, n = array.length; i < n; i++)
+      this.push( useNodes ? new this.klass.Node(array[i]) : array[i] );
+  },
+  
+  forEach: function(block, context) {
+    if (!block) return this.enumFor('forEach');
+    block = JS.Enumerable.toFn(block);
+    
+    var node   = this.first,
+        next, i, n;
+    
+    for (i = 0, n = this.length; i < n; i++) {
+      next = node.next;
+      block.call(context || null, node, i);
+      if (node === this.last) break;
+      node = next;
+    }
+    return this;
+  },
+  
+  at: function(n) {
+    if (n < 0 || n >= this.length) return undefined;
+    var node = this.first;
+    while (n--) node = node.next;
+    return node;
+  },
+  
+  pop: function() {
+    return this.length ? this.remove(this.last) : undefined;
+  },
+  
+  shift: function() {
+    return this.length ? this.remove(this.first) : undefined;
+  },
+  
+  // stubs - should be implemented by concrete list types
+  insertAfter:  function() {},
+  push:         function() {},
+  remove:       function() {},
+  
+  extend: {
+    Node: new JS.Class({
+      initialize: function(data) {
+        this.data = data;
+        this.prev = this.next = this.list = null;
+      }
+    })
+  }
+});
+
+JS.LinkedList.Doubly = new JS.Class('LinkedList.Doubly', JS.LinkedList, {
+  insertAt: function(n, newNode) {
+    if (n < 0 || n >= this.length) return;
+    this.insertBefore(this.at(n), newNode);
+  },
+  
+  unshift: function(newNode) {
+    this.length > 0
+        ? this.insertBefore(this.first, newNode)
+        : this.push(newNode);
+  },
+  
+  insertBefore: function() {}
+});
+
+JS.LinkedList.insertTemplate = function(prev, next, pos) {
+  return function(node, newNode) {
+    if (node.list !== this) return;
+    newNode[prev] = node;
+    newNode[next] = node[next];
+    node[next] = (node[next][prev] = newNode);
+    if (newNode[prev] === this[pos]) this[pos] = newNode;
+    newNode.list = this;
+    this.length++;
+  };
+};
+
+JS.LinkedList.Doubly.Circular = new JS.Class('LinkedList.Doubly.Circular', JS.LinkedList.Doubly, {
+  insertAfter: JS.LinkedList.insertTemplate('prev', 'next', 'last'),
+  insertBefore: JS.LinkedList.insertTemplate('next', 'prev', 'first'),
+  
+  push: function(newNode) {
+    if (this.length)
+      return this.insertAfter(this.last, newNode);
+    
+    this.first = this.last =
+        newNode.prev = newNode.next = newNode;
+    
+    newNode.list = this;
+    this.length = 1;
+  },
+  
+  remove: function(removed) {
+    if (removed.list !== this || this.length === 0) return null;
+    if (this.length > 1) {
+      removed.prev.next = removed.next;
+      removed.next.prev = removed.prev;
+      if (removed === this.first) this.first = removed.next;
+      if (removed === this.last) this.last = removed.prev;
+    } else {
+      this.first = this.last = null;
+    }
+    removed.prev = removed.next = removed.list = null;
+    this.length--;
+    return removed;
+  }
+});