spontaneous 0.1.0.alpha1

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

@@ -0,0 +1,58 @@
+if (JS.Proxy === undefined) JS.Proxy = {};
+
+JS.Proxy.Virtual = new JS.Class('Proxy.Virtual', {
+  initialize: function(klass) {
+    var bridge     = function() {},
+        proxy      = new JS.Class(),
+        delegators = {},
+        method, func;
+    
+    bridge.prototype = klass.prototype;
+    
+    for (method in klass.prototype) {
+      func = klass.prototype[method];
+      if (JS.isFn(func) && func !== klass) func = this.klass.forward(method);
+      delegators[method] = func;
+    }
+    
+    proxy.include({
+      initialize: function() {
+        var args    = arguments,
+            subject = null;
+        
+        this.__getSubject__ = function() {
+          subject = new bridge;
+          klass.apply(subject, args);
+          return (this.__getSubject__ = function() { return subject; })();
+        };
+      },
+      klass: klass,
+      constructor: klass
+    }, false);
+    
+    proxy.include(new JS.Module(delegators), false);
+    proxy.include(this.klass.InstanceMethods, true);
+    return proxy;
+  },
+  
+  extend: {
+    forward: function(name) {
+      return function() {
+        var subject = this.__getSubject__();
+        return subject[name].apply(subject, arguments);
+      };
+    },
+    
+    InstanceMethods: new JS.Module({
+      extend: function(source) {
+        this.__getSubject__().extend(source);
+        var method, func;
+        for (method in source) {
+          func = source[method];
+          if (JS.isFn(func)) func = JS.Proxy.Virtual.forward(method);
+          this[method] = func;
+        }
+      }
+    })
+  }
+});

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

@@ -0,0 +1,44 @@
+JS.Ruby = function(klass, define) {
+  define.call(new JS.Ruby.ClassBuilder(klass));
+};
+
+JS.extend(JS.Ruby, {
+  extendDSL: function(builder, source) {
+    for (var method in source) {
+      if (builder[method] || !JS.isFn(source[method])) continue;
+      this.addMethod(builder, source, method);
+    }
+  },
+  
+  addMethod: function(builder, source, method) {
+    builder[method] = function() {
+      var result = source[method].apply(source, arguments);
+      JS.Ruby.extendDSL(builder, source);
+      return result;
+    };
+  },
+  
+  alias: function(object, builder) {
+    return function(newName, oldName) {
+      var old = object[oldName];
+      if (old !== undefined) this.def(newName, old);
+      if (builder) JS.Ruby.extendDSL(builder, object);
+    };
+  },
+  
+  ClassBuilder: function(klass) {
+    this.def    = klass.method('define');
+    this.alias  = JS.Ruby.alias(klass.prototype);
+    
+    this.self = {
+      def: JS.bind(function(name, method) {
+        var def = {}; def[name] = method;
+        klass.extend(def);
+        JS.Ruby.extendDSL(this, klass);
+      }, this),
+      alias: JS.Ruby.alias(klass, this)
+    };
+    
+    JS.Ruby.extendDSL(this, klass);
+  }
+});

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

@@ -0,0 +1,332 @@
+JS.Set = new JS.Class('Set', {
+  extend: {
+    forEach: function(list, block, context) {
+      if (!list || !block) return;
+      if (list.forEach) return list.forEach(block, context);
+      for (var i = 0, n = list.length; i < n; i++) {
+        if (list[i] !== undefined)
+          block.call(context || null, list[i], i);
+      }
+    }
+  },
+  
+  include: JS.Enumerable || {},
+  
+  initialize: function(list, block, context) {
+    this.clear();
+    if (block) this.klass.forEach(list, function(item) {
+      this.add(block.call(context || null, item));
+    }, this);
+    else this.merge(list);
+  },
+  
+  forEach: function(block, context) {
+    if (!block) return this.enumFor('forEach');
+    block = JS.Enumerable.toFn(block);
+    
+    this.klass.forEach(this._members, block, context);
+    return this;
+  },
+  
+  add: function(item) {
+    if (this.contains(item)) return false;
+    this._members.push(item);
+    this.length = this.size = this._members.length;
+    return true;
+  },
+  
+  classify: function(block, context) {
+    if (!block) return this.enumFor('classify');
+    block = JS.Enumerable.toFn(block);
+    
+    var classes = new JS.Hash();
+    this.forEach(function(item) {
+      var value = block.call(context || null, item);
+      if (!classes.hasKey(value)) classes.store(value, new this.klass);
+      classes.get(value).add(item);
+    }, this);
+    return classes;
+  },
+  
+  clear: function() {
+    this._members = [];
+    this.length = this.size = 0;
+  },
+  
+  complement: function(other) {
+    var set = new this.klass;
+    this.klass.forEach(other, function(item) {
+      if (!this.contains(item)) set.add(item);
+    }, this);
+    return set;
+  },
+  
+  contains: function(item) {
+    return this._indexOf(item) !== -1;
+  },
+  
+  difference: function(other) {
+    other = JS.isType(other, JS.Set) ? other : new JS.Set(other);
+    var set = new this.klass;
+    this.forEach(function(item) {
+      if (!other.contains(item)) set.add(item);
+    });
+    return set;
+  },
+  
+  divide: function(block, context) {
+    if (!block) return this.enumFor('divide');
+    block = JS.Enumerable.toFn(block);
+    
+    var classes = this.classify(block, context),
+        sets    = new this.klass;
+    
+    classes.forEachValue(sets.method('add'));
+    return sets;
+  },
+  
+  equals: function(other) {
+    if (this.length !== other.length || !JS.isType(other, JS.Set)) return false;
+    var result = true;
+    this.forEach(function(item) {
+      if (!result) return;
+      if (!other.contains(item)) result = false;
+    });
+    return result;
+  },
+  
+  hash: function() {
+    var hashes = [];
+    this.forEach(function(object) { hashes.push(JS.Hash.codeFor(object)) });
+    return hashes.sort().join('');
+  },
+  
+  flatten: function(set) {
+    var copy = new this.klass;
+    copy._members = this._members;
+    if (!set) { set = this; set.clear(); }
+    copy.forEach(function(item) {
+      if (JS.isType(item, JS.Set)) item.flatten(set);
+      else set.add(item);
+    });
+    return set;
+  },
+  
+  intersection: function(other) {
+    var set = new this.klass;
+    this.klass.forEach(other, function(item) {
+      if (this.contains(item)) set.add(item);
+    }, this);
+    return set;
+  },
+  
+  isEmpty: function() {
+    return this._members.length === 0;
+  },
+  
+  isProperSubset: function(other) {
+    return this._members.length < other._members.length && this.isSubset(other);
+  },
+  
+  isProperSuperset: function(other) {
+    return this._members.length > other._members.length && this.isSuperset(other);
+  },
+  
+  isSubset: function(other) {
+    var result = true;
+    this.forEach(function(item) {
+      if (!result) return;
+      if (!other.contains(item)) result = false;
+    });
+    return result;
+  },
+  
+  isSuperset: function(other) {
+    return other.isSubset(this);
+  },
+  
+  merge: function(list) {
+    this.klass.forEach(list, function(item) { this.add(item) }, this);
+  },
+  
+  product: function(other) {
+    var pairs = new JS.Set;
+    this.forEach(function(item) {
+      this.klass.forEach(other, function(partner) {
+        pairs.add([item, partner]);
+      });
+    }, this);
+    return pairs;
+  },
+  
+  rebuild: function() {
+    var members = this._members;
+    this.clear();
+    this.merge(members);
+  },
+  
+  remove: function(item) {
+    var index = this._indexOf(item);
+    if (index === -1) return;
+    this._members.splice(index, 1);
+    this.length = this.size = this._members.length;
+  },
+  
+  removeIf: function(block, context) {
+    if (!block) return this.enumFor('removeIf');
+    block = JS.Enumerable.toFn(block);
+    
+    var members = this._members,
+        i       = members.length;
+    
+    while (i--) {
+      if (block.call(context || null, members[i]))
+        this.remove(members[i]);
+    }
+    return this;
+  },
+  
+  replace: function(other) {
+    this.clear();
+    this.merge(other);
+  },
+  
+  subtract: function(list) {
+    this.klass.forEach(list, function(item) {
+      this.remove(item);
+    }, this);
+  },
+  
+  union: function(other) {
+    var set = new this.klass;
+    set.merge(this);
+    set.merge(other);
+    return set;
+  },
+  
+  xor: function(other) {
+    var set = new JS.Set(other);
+    this.forEach(function(item) {
+      set[set.contains(item) ? 'remove' : 'add'](item);
+    });
+    return set;
+  },
+  
+  _indexOf: function(item) {
+    var i     = this._members.length,
+        equal = JS.Enumerable.areEqual;
+    
+    while (i--) {
+      if (equal(item, this._members[i])) return i;
+    }
+    return -1;
+  }
+});
+
+JS.Set.include({
+  n:  JS.Set.instanceMethod('intersection'),
+  u:  JS.Set.instanceMethod('union'),
+  x:  JS.Set.instanceMethod('product')
+}, false);
+
+JS.SortedSet = new JS.Class('SortedSet', JS.Set, {
+  extend: {
+    compare: function(one, another) {
+      return JS.isType(one, Object)
+          ? one.compareTo(another)
+          : (one < another ? -1 : (one > another ? 1 : 0));
+    }
+  },
+  
+  add: function(item) {
+    var point = this._indexOf(item, true);
+    if (point === null) return;
+    this._members.splice(point, 0, item);
+    this.length = this.size = this._members.length;
+  },
+  
+  _indexOf: function(item, insertionPoint) {
+    var items   = this._members,
+        n       = items.length,
+        i       = 0,
+        d       = n,
+        compare = this.klass.compare,
+        equal   = JS.Enumerable.areEqual,
+        found;
+    
+    if (n === 0) return insertionPoint ? 0 : -1;
+    
+    if (compare(item, items[0]) < 1)   { d = 0; i = 0; }
+    if (compare(item, items[n-1]) > 0) { d = 0; i = n; }
+    
+    while (!equal(item, items[i]) && d > 0.5) {
+      d = d / 2;
+      i += (compare(item, items[i]) > 0 ? 1 : -1) * Math.round(d);
+      if (i > 0 && compare(item, items[i-1]) > 0 && compare(item, items[i]) < 1) d = 0;
+    }
+    
+    // The pointer will end up at the start of any homogenous section. Step
+    // through the section until we find the needle or until the section ends.
+    while (items[i] && !equal(item, items[i]) &&
+        compare(item, items[i]) === 0) i += 1;
+    
+    found = equal(item, items[i]);
+    return insertionPoint
+        ? (found ? null : i)
+        : (found ? i : -1);
+  }
+});
+
+JS.HashSet = new JS.Class('HashSet', JS.Set, {
+  forEach: function(block, context) {
+    if (!block) return this.enumFor('forEach');
+    block = JS.Enumerable.toFn(block);
+    
+    this._members.forEachKey(block, context);
+    return this;
+  },
+  
+  add: function(item) {
+    if (this.contains(item)) return false;
+    this._members.store(item, true);
+    this.length = this.size = this._members.length;
+    return true;
+  },
+  
+  clear: function() {
+    this._members = new JS.Hash();
+    this.size = this.length = 0;
+  },
+  
+  contains: function(item) {
+    return this._members.hasKey(item);
+  },
+  
+  rebuild: function() {
+    this._members.rehash();
+    this.length = this.size = this._members.length;
+  },
+  
+  remove: function(item) {
+    this._members.remove(item);
+    this.length = this.size = this._members.length;
+  },
+  
+  removeIf: function(block, context) {
+    if (!block) return this.enumFor('removeIf');
+    block = JS.Enumerable.toFn(block);
+    
+    this._members.removeIf(function(pair) {
+      return block.call(context || null, pair.key);
+    });
+    this.length = this.size = this._members.length;
+    return this;
+  }
+});
+
+JS.Enumerable.include({
+  toSet: function(klass, block, context) {
+    klass = klass || JS.Set;
+    return new klass(this, block, context);
+  }
+}, true);

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

@@ -0,0 +1,151 @@
+JS.StackTrace = new JS.Module('StackTrace', {
+  extend: {
+    included: function(base) {
+      var module = base.__mod__ || base,
+          self   = this,
+          method;
+      
+      module.extend({define: function(name, func) {
+        if (!JS.isFn(func)) return this.callSuper();
+        var wrapper = self.wrap(func, module, name);
+        return this.callSuper(name, wrapper);
+      } });
+      
+      for (method in module.__fns__)
+        module.define(method, module.__fns__[method], false);
+      module.resolve();
+      
+      if (!module.__nom__) setTimeout(function() {
+        module.__nom__ = self.nameOf(base);
+      }, 1);
+    },
+    
+    nameOf: function(object, root) {
+      var results = [], i, n, field, l;
+      
+      if (JS.isType(object, Array)) {
+        for (i = 0, n = object.length; i < n; i++)
+          results.push(this.nameOf(object[i]));
+        return results;
+      }
+      
+      if (object.__nom__) return object.__nom__;
+      
+      field = [{name: null, o: root || this.root}];
+      l = 0;
+      while (typeof field === 'object' && l < this.maxDepth) {
+        l += 1;
+        field = this.descend(field, object);
+      }
+      if (typeof field == 'string') {
+        field = field.replace(/\.prototype\./g, '#');
+        object.__nom__ = field;
+        if (object.__meta__) object.__meta__.__nom__ = field + '.__meta__';
+      }
+      return object.__nom__;
+    },
+    
+    descend: function(list, needle) {
+      var results = [],
+          n       = list.length,
+          i       = n,
+          key, item, name;
+      
+      while (i--) {
+        item = list[i];
+        if (n > 1 && JS.indexOf(this.excluded, item.o) !== -1) continue;
+        if (JS.isType(item.o, Array)) continue;
+        name = item.name ? item.name + '.' : '';
+        for (key in item.o) {
+          if (needle && item.o[key] === needle) return name + key;
+          results.push({name: name + key, o: item.o[key]});
+        }
+      }
+      return results;
+    },
+    
+    root:       this,
+    excluded:   [],
+    maxDepth:   8,
+    logLevel:   'full',
+    
+    stack: new JS.Singleton({
+      _list: [],
+      
+      indent: function() {
+        var indent = '',
+            n      = this._list.length;
+        
+        while (n--) indent += '|  ';
+        return indent;
+      },
+      
+      push: function(name, object, args) {
+        if (JS.StackTrace.logLevel === 'full') window.console &&
+            console.log(this.indent() + name + '(', args, ')');
+        this._list.push({name: name, object: object, args: args});
+      },
+      
+      pop: function(result) {
+        var name = this._list.pop().name;
+        if (JS.StackTrace.logLevel === 'full') window.console &&
+            console.log(this.indent() + name + '() --> ', result);
+        return name;
+      },
+      
+      top: function() {
+        return this._list[this._list.length - 1] || {};
+      },
+      
+      backtrace: function() {
+        var i = this._list.length, item;
+        while (i--) {
+          item = this._list[i];
+          window.console && console.log(item.name, 'in', item.object, '(', item.args, ')');
+        }
+      }
+    }),
+    
+    flush: function() {
+      this.stack._list = [];
+    },
+    
+    print: function() {
+      this.stack.backtrace();
+    },
+    
+    wrap: function(func, module, name) {
+      var self = JS.StackTrace;
+      var wrapper = function() {
+        var result, fullName = self.nameOf(module) + '#' + name;
+        self.stack.push(fullName, this, arguments);
+        
+        if (self.logLevel === 'errors') {
+          try { result = func.apply(this, arguments); }
+          catch (e) {
+            if (e.logged) throw e;
+            e.logged = true;
+            window.console && console.error(e, 'thrown by', self.stack.top().name + '. Backtrace:');
+            self.print();
+            self.flush();
+            throw e;
+          }
+        } else {
+          result = func.apply(this, arguments);
+        }
+        
+        self.stack.pop(result);
+        return result;
+      };
+      wrapper.toString = function() { return func.toString() };
+      return wrapper;
+    }
+  }
+});
+
+(function() {
+  var module = JS.StackTrace, key;
+  for (key in module.root) {
+    if (key !== 'JS') module.excluded.push(module.root[key]);
+  }
+})();

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

@@ -0,0 +1,95 @@
+JS.State = new JS.Module('State', {
+  __getState__: function(state) {
+    return  (typeof state === 'object' && state) ||
+            (typeof state === 'string' && ((this.states || {})[state] || {})) ||
+            {};
+  },
+  
+  setState: function(state) {
+    this.__state__ = this.__getState__(state);
+    JS.State.addMethods(this.__state__, this.klass);
+  },
+  
+  inState: function() {
+    var i = arguments.length;
+    while (i--) {
+      if (this.__state__ === this.__getState__(arguments[i])) return true;
+    }
+    return false;
+  },
+  
+  extend: {
+    stub: function() { return this; },
+    
+    buildStubs: function(stubs, collection, states) {
+      var state, method;
+      for (state in states) {
+        collection[state] = {};
+        for (method in states[state]) stubs[method] = this.stub;
+    } },
+    
+    findStates: function(collections, name) {
+      var i = collections.length, results = [];
+      while (i--) {
+        if (collections[i].hasOwnProperty(name))
+          results.push(collections[i][name]);
+      }
+      return results;
+    },
+    
+    buildCollection: function(module, states) {
+      var stubs       = {},
+          collection  = {},
+          superstates = module.lookup('states'),
+          state, klass, methods, name, mixins, i, n;
+      
+      this.buildStubs(stubs, collection, states);
+      
+      for (i = 0, n = superstates.length; i < n;  i++)
+        this.buildStubs(stubs, collection, superstates[i]);
+      
+      for (state in collection) {
+        klass  = new JS.Class(states[state]);
+        mixins = this.findStates(superstates, state);
+        
+        i = mixins.length;
+        while (i--) klass.include(mixins[i].klass);
+        
+        methods = {};
+        for (name in stubs) { if (!klass.prototype[name]) methods[name] = stubs[name]; }
+        klass.include(methods);
+        collection[state] = new klass;
+      }
+      if (module.__res__) this.addMethods(stubs, module.__res__.klass);
+      return collection;
+    },
+    
+    addMethods: function(state, klass) {
+      if (!klass) return;
+      
+      var methods = {},
+          p       = klass.prototype,
+          method;
+      
+      for (method in state) {
+        if (p[method]) continue;
+        p[method] = klass.__mod__.__fns__[method] = this.wrapped(method);
+      }
+    },
+    
+    wrapped: function(method) {
+      return function() {
+        var func = (this.__state__ || {})[method];
+        return func ? func.apply(this, arguments): this;
+      };
+    }
+  }
+});
+
+JS.Module.include({define: (function(wrapped) {
+  return function(name, block) {
+    if (name === 'states' && typeof block === 'object')
+      arguments[1] = JS.State.buildCollection(this, block);
+    return wrapped.apply(this, arguments);
+  };
+})(JS.Module.prototype.define)}, true);