acts_as_dashboard 0.1.0

data/generators/dashboard/templates/js.class-2.1.4/src/loader.js

@@ -0,0 +1,458 @@
+this.JS = this.JS || {};
+
+JS.Package = function(loader) {
+  var Set = JS.Package.OrderedSet;
+  JS.Package._index(this);
+  
+  this._loader    = loader;
+  this._names     = new Set();
+  this._deps      = new Set();
+  this._uses      = new Set();
+  this._observers = {};
+  this._events    = {};
+};
+
+(function(klass) {
+  //================================================================
+  // Ordered list of unique elements, for storing dependencies
+  
+  var Set = klass.OrderedSet = function(list, transform) {
+    this._members = this.list = [];
+    this._index = {};
+    if (!list) return;
+    
+    for (var i = 0, n = list.length; i < n; i++)
+      this.push(transform ? transform(list[i]) : list[i]);
+  };
+
+  Set.prototype.push = function(item) {
+    var key   = (item.id !== undefined) ? item.id : item,
+        index = this._index;
+    
+    if (index.hasOwnProperty(key)) return;
+    index[key] = this._members.length;
+    this._members.push(item);
+  };
+  
+  //================================================================
+  // Environment settings
+  
+  klass._env = this;
+  
+  if ((this.document || {}).getElementsByTagName) {
+    var script = document.getElementsByTagName('script')[0];
+    klass._isIE = (script.readyState !== undefined);
+  }
+  
+  
+  //================================================================
+  // Configuration methods, called by the DSL
+  
+  var instance = klass.prototype;
+  
+  instance.addDependency = function(pkg) {
+    this._deps.push(pkg);
+  };
+  
+  instance.addSoftDependency = function(pkg) {
+    this._uses.push(pkg);
+  };
+  
+  instance.addName = function(name) {
+    this._names.push(name);
+    klass.getFromCache(name).pkg = this;
+  };
+  
+  instance.onload = function(block) {
+    this._onload = block;
+  };
+  
+  //================================================================
+  // Event dispatchers, for communication between packages
+  
+  instance.on = function(eventType, block, scope) {
+    if (this._events[eventType]) return block.call(scope);
+    var list = this._observers[eventType] = this._observers[eventType] || [];
+    list.push([block, scope]);
+  };
+  
+  instance.fire = function(eventType) {
+    if (this._events[eventType]) return false;
+    this._events[eventType] = true;
+    
+    var list = this._observers[eventType];
+    if (!list) return true;
+    delete this._observers[eventType];
+    
+    for (var i = 0, n = list.length; i < n; i++)
+      list[i][0].call(list[i][1]);
+    
+    return true;
+  };
+  
+  //================================================================
+  // Loading frontend and other miscellany
+  
+  instance.isLoaded = function(withExceptions) {
+    if (!withExceptions && this._isLoaded !== undefined) return this._isLoaded;
+    
+    var names = this._names.list,
+        i     = names.length,
+        name, object;
+    
+    while (i--) { name = names[i];
+      object = klass.getObject(name);
+      if (object !== undefined) continue;
+      if (withExceptions)
+        throw new Error('Expected package at ' + this._loader + ' to define ' + name);
+      else
+        return this._isLoaded = false;
+    }
+    return this._isLoaded = true;
+  };
+  
+  instance.load = function() {
+    if (!this.fire('request')) return;
+    
+    var allDeps    = this._deps.list.concat(this._uses.list),
+        startEvent = 'load',  // could potentially use 'download' event in
+        listener   = {};      // browsers that guarantee execution order
+    
+    listener[startEvent] = this._deps.list;
+    
+    klass.when(listener, function() {
+      klass.when({complete: allDeps, load: [this]}, function() {
+        this.fire('complete');
+      }, this);
+      
+      var self = this, fireOnLoad = function() {
+        if (self._onload) self._onload();
+        self.isLoaded(true);
+        self.fire('load');
+      };
+      
+      if (this.isLoaded()) {
+        this.fire('download');
+        return this.fire('load');
+      }
+      
+      if (this._loader === undefined)
+        throw new Error('No load path found for ' + this._names.list[0]);
+      
+      typeof this._loader === 'function'
+            ? this._loader(fireOnLoad)
+            : klass.Loader.loadFile(this._loader, fireOnLoad);
+      
+      this.fire('download');
+    }, this);
+  };
+  
+  instance.toString = function() {
+    return 'Package:' + this._names.list.join(',');
+  };
+  
+  //================================================================
+  // Class-level event API, handles group listeners
+  
+  klass.when = function(eventTable, block, scope) {
+    var eventList = [], event, packages, i;
+    for (event in eventTable) {
+      if (!eventTable.hasOwnProperty(event)) continue;
+      packages = new klass.OrderedSet(eventTable[event], function(name) { return klass.getByName(name) });
+      i = packages.list.length;
+      while (i--) eventList.push([event, packages.list[i]]);
+    }
+    
+    var waiting = i = eventList.length;
+    if (waiting === 0) return block && block.call(scope);
+    
+    while (i--) {
+      eventList[i][1].on(eventList[i][0], function() {
+        waiting -= 1;
+        if (waiting === 0 && block) block.call(scope);
+      });
+      eventList[i][1].load();
+    }
+  };
+  
+  //================================================================
+  // Indexes for fast lookup by path and name, and assigning IDs
+  
+  klass._autoIncrement = 1;
+  klass._indexByPath = {};
+  klass._indexByName = {};
+  
+  klass._index = function(pkg) {
+    pkg.id = this._autoIncrement;
+    this._autoIncrement += 1;
+  };
+  
+  klass.getByPath = function(loader) {
+    var path = loader.toString();
+    return this._indexByPath[path] = this._indexByPath[path] || new this(loader);
+  };
+  
+  klass.getByName = function(name) {
+    if (typeof name !== 'string') return name;
+    var cached = this.getFromCache(name);
+    if (cached.pkg) return cached.pkg;
+    
+    var placeholder = new this();
+    placeholder.addName(name);
+    return placeholder;
+  };
+  
+  //================================================================
+  // Cache for named packages and runtime objects
+  
+  klass.getFromCache = function(name) {
+    return this._indexByName[name] = this._indexByName[name] || {};
+  };
+  
+  klass.getObject = function(name) {
+    var cached = this.getFromCache(name);
+    if (cached.obj !== undefined) return cached.obj;
+    
+    var object = this._env,
+        parts  = name.split('.'), part;
+    
+    while (part = parts.shift()) object = object && object[part];
+    
+    return this.getFromCache(name).obj = object;
+  };
+  
+})(JS.Package);
+
+
+JS.Package.DomLoader = {
+  usable: function() {
+    return !!JS.Package.getObject('window.document.getElementsByTagName');
+  },
+  
+  __FILE__: function() {
+    var scripts = document.getElementsByTagName('script');
+    return scripts[scripts.length - 1].src;
+  },
+  
+  loadFile: function(path, fireCallbacks) {
+    var self = this,
+        tag = document.createElement('script');
+    
+    tag.type = 'text/javascript';
+    tag.src = path;
+    
+    tag.onload = tag.onreadystatechange = function() {
+      var state = tag.readyState, status = tag.status;
+      if ( !state || state === 'loaded' || state === 'complete' || (state === 4 && status === 200) ) {
+        fireCallbacks();
+        tag.onload = tag.onreadystatechange = self._K;
+        tag = null;
+      }
+    };
+    
+    if (window.console && console.info)
+      console.info('Loading ' + path);
+    
+    document.getElementsByTagName('head')[0].appendChild(tag);
+  },
+  
+  _K: function() {}
+};
+
+JS.Package.ServerLoader = {
+  usable: function() {
+    return typeof JS.Package.getObject('load') === 'function' &&
+           typeof JS.Package.getObject('version') === 'function';
+  },
+  
+  setup: function() {
+    var self = this;
+    load = (function(origLoad) {
+      return function() {
+        self._currentPath = arguments[0];
+        return origLoad.apply(JS.Package._env, arguments);
+      };
+    })(load);
+  },
+  
+  __FILE__: function() {
+    return this._currentPath;
+  },
+  
+  loadFile: function(path, fireCallbacks) {
+    load(path);
+    fireCallbacks();
+  }
+};
+
+(function() {
+  var candidates = [  JS.Package.DomLoader,
+                      JS.Package.ServerLoader ],
+      
+      n = candidates.length,
+      i, candidate;
+  
+  for (i = 0; i < n; i++) {
+    candidate = candidates[i];
+    if (candidate.usable()) {
+      JS.Package.Loader = candidate;
+      if (candidate.setup) candidate.setup();
+      break;
+    }
+  }
+})();
+
+
+JS.Package.DSL = {
+  __FILE__: function() {
+    return JS.Package.Loader.__FILE__();
+  },
+  
+  pkg: function(name, path) {
+    var pkg = path
+        ? JS.Package.getByPath(path)
+        : JS.Package.getByName(name);
+    pkg.addName(name);
+    return new JS.Package.Description(pkg);
+  },
+  
+  file: function(path) {
+    var pkg = JS.Package.getByPath(path);
+    return new JS.Package.Description(pkg);
+  },
+  
+  load: function(path, fireCallbacks) {
+    JS.Package.Loader.loadFile(path, fireCallbacks);
+  }
+};
+
+JS.Package.Description = function(pkg) {
+  this._pkg = pkg;
+};
+
+(function(klass) {
+  
+  klass._batch = function(method, args) {
+    var n = args.length, method = this._pkg[method], i;
+    for (i = 0; i < n; i++) method.call(this._pkg, args[i]);
+    return this;
+  };
+  
+  klass.provides = function() {
+    return this._batch('addName', arguments);
+  };
+  
+  klass.requires = function() {
+    return this._batch('addDependency', arguments);
+  };
+  
+  klass.uses = function() {
+    return this._batch('addSoftDependency', arguments);
+  };
+  
+  klass.setup = function(block) {
+    this._pkg.onload(block);
+    return this;
+  };
+  
+})(JS.Package.Description.prototype);
+
+JS.Package.DSL.loader = JS.Package.DSL.file;
+
+JS.Packages = function(declaration) {
+  declaration.call(JS.Package.DSL);
+};
+ 
+JS.require = function() {
+  var requirements = [], i = 0;
+  
+  while (typeof arguments[i] === 'string'){
+    requirements.push(arguments[i]);
+    i += 1;
+  }
+  
+  JS.Package.when({complete: requirements}, arguments[i], arguments[i+1]);
+};
+
+require = JS.require;
+
+
+JS.Packages(function() { with(this) {
+    
+    var PATH = JS.Package._env.JSCLASS_PATH ||
+               __FILE__().replace(/[^\/]*$/g, '');
+    
+    if (!/\/$/.test(PATH)) PATH = PATH + '/';
+    
+    var module = function(name) { return file(PATH + name + '.js') };
+    
+    module('core')          .provides('JS.Module',
+                                      'JS.Class',
+                                      'JS.Kernel',
+                                      'JS.Singleton',
+                                      'JS.Interface');
+    
+    module('comparable')    .provides('JS.Comparable')
+                            .requires('JS.Module');
+    
+    module('constant_scope').provides('JS.ConstantScope')
+                            .requires('JS.Module');
+    
+    module('forwardable')   .provides('JS.Forwardable')
+                            .requires('JS.Module');
+    
+    module('enumerable')    .provides('JS.Enumerable')
+                            .requires('JS.Module',
+                                      'JS.Class');
+    
+    module('observable')    .provides('JS.Observable')
+                            .requires('JS.Module');
+    
+    module('hash')          .provides('JS.Hash')
+                            .requires('JS.Class',
+                                      'JS.Enumerable',
+                                      'JS.Comparable');
+    
+    module('set')           .provides('JS.Set',
+                                      'JS.HashSet',
+                                      'JS.SortedSet')
+                            .requires('JS.Class',
+                                      'JS.Enumerable')
+                            .uses(    'JS.Hash');
+    
+    module('linked_list')   .provides('JS.LinkedList',
+                                      'JS.LinkedList.Doubly',
+                                      'JS.LinkedList.Doubly.Circular')
+                            .requires('JS.Class',
+                                      'JS.Enumerable');
+    
+    module('command')       .provides('JS.Command',
+                                      'JS.Command.Stack')
+                            .requires('JS.Class',
+                                      'JS.Enumerable',
+                                      'JS.Observable');
+    
+    module('decorator')     .provides('JS.Decorator')
+                            .requires('JS.Module',
+                                      'JS.Class');
+    
+    module('method_chain')  .provides('JS.MethodChain')
+                            .requires('JS.Module',
+                                      'JS.Kernel');
+    
+    module('proxy')         .provides('JS.Proxy',
+                                      'JS.Proxy.Virtual')
+                            .requires('JS.Module',
+                                      'JS.Class');
+    
+    module('ruby')          .provides('JS.Ruby')
+                            .requires('JS.Class');
+    
+    module('stack_trace')   .provides('JS.StackTrace')
+                            .requires('JS.Module',
+                                      'JS.Singleton');
+    
+    module('state')         .provides('JS.State')
+                            .requires('JS.Module',
+                                      'JS.Class');
+}});

data/generators/dashboard/templates/js.class-2.1.4/src/method_chain.js

@@ -0,0 +1,172 @@
+JS.MethodChain = function(base) {
+  var queue      = [],
+      baseObject = base || {};
+  
+  this.____ = function(method, args) {
+    queue.push({func: method, args: args});
+  };
+  
+  this.fire = function(base) {
+    return JS.MethodChain.fire(queue, base || baseObject);
+  };
+};
+
+JS.MethodChain.fire = function(queue, object) {
+  var method, property, i, n;
+  loop: for (i = 0, n = queue.length; i < n; i++) {
+    method = queue[i];
+    if (object instanceof JS.MethodChain) {
+      object.____(method.func, method.args);
+      continue;
+    }
+    switch (typeof method.func) {
+      case 'string':    property = object[method.func];       break;
+      case 'function':  property = method.func;               break;
+      case 'object':    object = method.func; continue loop;  break;
+    }
+    object = (typeof property === 'function')
+        ? property.apply(object, method.args)
+        : property;
+  }
+  return object;
+};
+
+JS.MethodChain.prototype = {
+  _: function() {
+    var base = arguments[0],
+        args, i, n;
+    
+    switch (typeof base) {
+      case 'object': case 'function':
+        args = [];
+        for (i = 1, n = arguments.length; i < n; i++) args.push(arguments[i]);
+        this.____(base, args);
+    }
+    return this;
+  },
+  
+  toFunction: function() {
+    var chain = this;
+    return function(object) { return chain.fire(object); };
+  }
+};
+
+JS.MethodChain.reserved = (function() {
+  var names = [], key;
+  for (key in new JS.MethodChain) names.push(key);
+  return new RegExp('^(?:' + names.join('|') + ')$');
+})();
+
+JS.MethodChain.addMethod = function(name) {
+  if (this.reserved.test(name)) return;
+  var func = this.prototype[name] = function() {
+    this.____(name, arguments);
+    return this;
+  };
+  func.displayName = 'MethodChain#' + name;
+};
+
+JS.MethodChain.displayName = 'MethodChain';
+
+JS.MethodChain.addMethods = function(object) {
+  var methods = [], property, i;
+  
+  for (property in object)
+    Number(property) !== property && methods.push(property);
+  
+  if (object instanceof Array) {
+    i = object.length;
+    while (i--)
+      typeof object[i] === 'string' && methods.push(object[i]);
+  }
+  i = methods.length;
+  while (i--) this.addMethod(methods[i]);
+  
+  object.__fns__ && this.addMethods(object.__fns__);
+  object.prototype && this.addMethods(object.prototype);
+};
+
+it = its = function() { return new JS.MethodChain; };
+
+JS.Module.methodAdded(function(name) {
+  JS.MethodChain.addMethod(name);
+});
+
+JS.Kernel.include({
+  wait: function(time) {
+    var chain = new JS.MethodChain;
+    
+    typeof time === 'number' &&
+      setTimeout(chain.fire.bind(chain, this), time * 1000);
+    
+    this.forEach && typeof time === 'function' &&
+      this.forEach(function() {
+        setTimeout(chain.fire.bind(chain, arguments[0]), time.apply(this, arguments) * 1000);
+      });
+    
+    return chain;
+  },
+  
+  _: function() {
+    var base = arguments[0],
+        args = [],
+        i, n;
+    
+    for (i = 1, n = arguments.length; i < n; i++) args.push(arguments[i]);
+    return  (typeof base === 'object' && base) ||
+            (typeof base === 'function' && base.apply(this, args)) ||
+            this;
+  }
+}, true);
+
+(function() {
+  var queue = JS.Module.__chainq__,
+      n     = queue.length;
+  
+  while (n--) JS.MethodChain.addMethods(queue[n]);
+  JS.Module.__chainq__ = null;
+})();
+
+JS.MethodChain.addMethods([
+  "abbr", "abs", "accept", "acceptCharset", "accesskey", "acos", "action", "addEventListener", 
+  "adjacentNode", "align", "alignWithTop", "alink", "alt", "anchor", "appendChild", "appendedNode", 
+  "apply", "archive", "arguments", "arity", "asin", "atan", "atan2", "attrNode", "attributes", 
+  "axis", "background", "bgcolor", "big", "blink", "blur", "bold", "border", "call", "caller", 
+  "ceil", "cellpadding", "cellspacing", "char", "charAt", "charCodeAt", "charoff", "charset", 
+  "checked", "childNodes", "cite", "className", "classid", "clear", "click", "clientHeight", 
+  "clientLeft", "clientTop", "clientWidth", "cloneNode", "code", "codebase", "codetype", "color", 
+  "cols", "colspan", "compact", "concat", "content", "coords", "cos", "data", "datetime", "declare", 
+  "deep", "defer", "dir", "disabled", "dispatchEvent", "enctype", "event", "every", "exec", "exp", 
+  "face", "filter", "firstChild", "fixed", "floor", "focus", "fontcolor", "fontsize", "forEach", 
+  "frame", "frameborder", "fromCharCode", "getAttribute", "getAttributeNS", "getAttributeNode", 
+  "getAttributeNodeNS", "getDate", "getDay", "getElementsByTagName", "getElementsByTagNameNS", 
+  "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getTime", 
+  "getTimezoneOffset", "getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", 
+  "getUTCMilliseconds", "getUTCMinutes", "getUTCMonth", "getUTCSeconds", "getYear", "global", 
+  "handler", "hasAttribute", "hasAttributeNS", "hasAttributes", "hasChildNodes", "hasOwnProperty", 
+  "headers", "height", "href", "hreflang", "hspace", "htmlFor", "httpEquiv", "id", "ignoreCase", 
+  "index", "indexOf", "innerHTML", "input", "insertBefore", "insertedNode", "isPrototypeOf", "ismap", 
+  "italics", "join", "label", "lang", "language", "lastChild", "lastIndex", "lastIndexOf", "length", 
+  "link", "listener", "localName", "log", "longdesc", "map", "marginheight", "marginwidth", "match", 
+  "max", "maxlength", "media", "method", "min", "multiline", "multiple", "name", "namespace", 
+  "namespaceURI", "nextSibling", "node", "nodeName", "nodeType", "nodeValue", "nohref", "noresize", 
+  "normalize", "noshade", "now", "nowrap", "object", "offsetHeight", "offsetLeft", "offsetParent", 
+  "offsetTop", "offsetWidth", "onblur", "onchange", "onclick", "ondblclick", "onfocus", "onkeydown", 
+  "onkeypress", "onkeyup", "onload", "onmousedown", "onmousemove", "onmouseout", "onmouseover", 
+  "onmouseup", "onreset", "onselect", "onsubmit", "onunload", "ownerDocument", "parentNode", "parse", 
+  "pop", "pow", "prefix", "previousSibling", "profile", "prompt", "propertyIsEnumerable", "push", 
+  "random", "readonly", "reduce", "reduceRight", "rel", "removeAttribute", "removeAttributeNS", 
+  "removeAttributeNode", "removeChild", "removeEventListener", "removedNode", "replace", 
+  "replaceChild", "replacedNode", "rev", "reverse", "round", "rows", "rowspan", "rules", "scheme", 
+  "scope", "scrollHeight", "scrollIntoView", "scrollLeft", "scrollTop", "scrollWidth", "scrolling", 
+  "search", "selected", "setAttribute", "setAttributeNS", "setAttributeNode", "setAttributeNodeNS", 
+  "setDate", "setFullYear", "setHours", "setMilliseconds", "setMinutes", "setMonth", "setSeconds", 
+  "setTime", "setUTCDate", "setUTCFullYear", "setUTCHours", "setUTCMilliseconds", "setUTCMinutes", 
+  "setUTCMonth", "setUTCSeconds", "setYear", "shape", "shift", "sin", "size", "slice", "small", 
+  "some", "sort", "source", "span", "splice", "split", "sqrt", "src", "standby", "start", "strike", 
+  "style", "sub", "substr", "substring", "summary", "sup", "tabIndex", "tabindex", "tagName", "tan", 
+  "target", "test", "text", "textContent", "title", "toArray", "toFunction", "toGMTString", 
+  "toLocaleDateString", "toLocaleFormat", "toLocaleString", "toLocaleTimeString", "toLowerCase", 
+  "toSource", "toString", "toUTCString", "toUpperCase", "type", "unshift", "unwatch", "useCapture", 
+  "usemap", "valign", "value", "valueOf", "valuetype", "version", "vlink", "vspace", "watch", "width"
+]);

data/generators/dashboard/templates/js.class-2.1.4/src/observable.js

@@ -0,0 +1,55 @@
+JS.Observable = new JS.Module('Observable', {
+  extend: {
+    DEFAULT_METHOD: 'update'
+  },
+  
+  addObserver: function(observer, context) {
+    (this.__observers__ = this.__observers__ || []).push({_block: observer, _context: context || null});
+  },
+  
+  removeObserver: function(observer, context) {
+    this.__observers__ = this.__observers__ || [];
+    context = context || null;
+    var i = this.countObservers();
+    while (i--) {
+      if (this.__observers__[i]._block === observer && this.__observers__[i]._context === context) {
+        this.__observers__.splice(i,1);
+        return;
+      }
+    }
+  },
+  
+  removeObservers: function() {
+    this.__observers__ = [];
+  },
+  
+  countObservers: function() {
+    return (this.__observers__ = this.__observers__ || []).length;
+  },
+  
+  notifyObservers: function() {
+    if (!this.isChanged()) return;
+    var i = this.countObservers(), observer, block, context;
+    while (i--) {
+      observer = this.__observers__[i];
+      block    = observer._block;
+      context  = observer._context;
+      if (JS.isFn(block)) block.apply(context || null, arguments);
+      else block[context || JS.Observable.DEFAULT_METHOD].apply(block, arguments);
+    }
+  },
+  
+  setChanged: function(state) {
+    this.__changed__ = !(state === false);
+  },
+  
+  isChanged: function() {
+    if (this.__changed__ === undefined) this.__changed__ = true;
+    return !!this.__changed__;
+  }
+});
+
+JS.Observable.include({
+  subscribe:    JS.Observable.instanceMethod('addObserver'),
+  unsubscribe:  JS.Observable.instanceMethod('removeObserver')
+}, true);