grandstand 0.2.1

data/public/admin/javascripts/mustache.js

@@ -0,0 +1,324 @@
+/*
+  mustache.js — Logic-less templates in JavaScript
+
+  See http://mustache.github.com/ for more info.
+*/
+
+var Mustache = function() {
+  var Renderer = function() {};
+
+  Renderer.prototype = {
+    otag: "{{",
+    ctag: "}}",
+    pragmas: {},
+    buffer: [],
+    pragmas_implemented: {
+      "IMPLICIT-ITERATOR": true
+    },
+    context: {},
+
+    render: function(template, context, partials, in_recursion) {
+      // reset buffer & set context
+      if(!in_recursion) {
+        this.context = context;
+        this.buffer = []; // TODO: make this non-lazy
+      }
+
+      // fail fast
+      if(!this.includes("", template)) {
+        if(in_recursion) {
+          return template;
+        } else {
+          this.send(template);
+          return;
+        }
+      }
+
+      template = this.render_pragmas(template);
+      var html = this.render_section(template, context, partials);
+      if(in_recursion) {
+        return this.render_tags(html, context, partials, in_recursion);
+      }
+
+      this.render_tags(html, context, partials, in_recursion);
+    },
+
+    /*
+      Sends parsed lines
+    */
+    send: function(line) {
+      if(line != "") {
+        this.buffer.push(line);
+      }
+    },
+
+    /*
+      Looks for %PRAGMAS
+    */
+    render_pragmas: function(template) {
+      // no pragmas
+      if(!this.includes("%", template)) {
+        return template;
+      }
+
+      var that = this;
+      var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
+            this.ctag);
+      return template.replace(regex, function(match, pragma, options) {
+        if(!that.pragmas_implemented[pragma]) {
+          throw({message: 
+            "This implementation of mustache doesn't understand the '" +
+            pragma + "' pragma"});
+        }
+        that.pragmas[pragma] = {};
+        if(options) {
+          var opts = options.split("=");
+          that.pragmas[pragma][opts[0]] = opts[1];
+        }
+        return "";
+        // ignore unknown pragmas silently
+      });
+    },
+
+    /*
+      Tries to find a partial in the curent scope and render it
+    */
+    render_partial: function(name, context, partials) {
+      name = this.trim(name);
+      if(!partials || partials[name] === undefined) {
+        throw({message: "unknown_partial '" + name + "'"});
+      }
+      if(typeof(context[name]) != "object") {
+        return this.render(partials[name], context, partials, true);
+      }
+      return this.render(partials[name], context[name], partials, true);
+    },
+
+    /*
+      Renders inverted (^) and normal (#) sections
+    */
+    render_section: function(template, context, partials) {
+      if(!this.includes("#", template) && !this.includes("^", template)) {
+        return template;
+      }
+
+      var that = this;
+      // CSW - Added "+?" so it finds the tighest bound, not the widest
+      var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
+              "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
+              "\\s*", "mg");
+
+      // for each {{#foo}}{{/foo}} section do...
+      return template.replace(regex, function(match, type, name, content) {
+        var value = that.find(name, context);
+        if(type == "^") { // inverted section
+          if(!value || that.is_array(value) && value.length === 0) {
+            // false or empty list, render it
+            return that.render(content, context, partials, true);
+          } else {
+            return "";
+          }
+        } else if(type == "#") { // normal section
+          if(that.is_array(value)) { // Enumerable, Let's loop!
+            return that.map(value, function(row) {
+              return that.render(content, that.create_context(row),
+                partials, true);
+            }).join("");
+          } else if(that.is_object(value)) { // Object, Use it as subcontext!
+            return that.render(content, that.create_context(value),
+              partials, true);
+          } else if(typeof value === "function") {
+            // higher order section
+            return value.call(context, content, function(text) {
+              return that.render(text, context, partials, true);
+            });
+          } else if(value) { // boolean section
+            return that.render(content, context, partials, true);
+          } else {
+            return "";
+          }
+        }
+      });
+    },
+
+    /*
+      Replace {{foo}} and friends with values from our view
+    */
+    render_tags: function(template, context, partials, in_recursion) {
+      // tit for tat
+      var that = this;
+
+      var new_regex = function() {
+        return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
+          that.ctag + "+", "g");
+      };
+
+      var regex = new_regex();
+      var tag_replace_callback = function(match, operator, name) {
+        switch(operator) {
+        case "!": // ignore comments
+          return "";
+        case "=": // set new delimiters, rebuild the replace regexp
+          that.set_delimiters(name);
+          regex = new_regex();
+          return "";
+        case ">": // render partial
+          return that.render_partial(name, context, partials);
+        case "{": // the triple mustache is unescaped
+          return that.find(name, context);
+        default: // escape the value
+          return that.escape(that.find(name, context));
+        }
+      };
+      var lines = template.split("\n");
+      for(var i = 0; i < lines.length; i++) {
+        lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+        if(!in_recursion) {
+          this.send(lines[i]);
+        }
+      }
+
+      if(in_recursion) {
+        return lines.join("\n");
+      }
+    },
+
+    set_delimiters: function(delimiters) {
+      var dels = delimiters.split(" ");
+      this.otag = this.escape_regex(dels[0]);
+      this.ctag = this.escape_regex(dels[1]);
+    },
+
+    escape_regex: function(text) {
+      // thank you Simon Willison
+      if(!arguments.callee.sRE) {
+        var specials = [
+          '/', '.', '*', '+', '?', '|',
+          '(', ')', '[', ']', '{', '}', '\\'
+        ];
+        arguments.callee.sRE = new RegExp(
+          '(\\' + specials.join('|\\') + ')', 'g'
+        );
+      }
+      return text.replace(arguments.callee.sRE, '\\$1');
+    },
+
+    /*
+      find `name` in current `context`. That is find me a value
+      from the view object
+    */
+    find: function(name, context) {
+      name = this.trim(name);
+
+      // Checks whether a value is thruthy or false or 0
+      function is_kinda_truthy(bool) {
+        return bool === false || bool === 0 || bool;
+      }
+
+      var value;
+      if(is_kinda_truthy(context[name])) {
+        value = context[name];
+      } else if(is_kinda_truthy(this.context[name])) {
+        value = this.context[name];
+      }
+
+      if(typeof value === "function") {
+        return value.apply(context);
+      }
+      if(value !== undefined) {
+        return value;
+      }
+      // silently ignore unkown variables
+      return "";
+    },
+
+    // Utility methods
+
+    /* includes tag */
+    includes: function(needle, haystack) {
+      return haystack.indexOf(this.otag + needle) != -1;
+    },
+
+    /*
+      Does away with nasty characters
+    */
+    escape: function(s) {
+      s = String(s === null ? "" : s);
+      return s.replace(/&(?!\w+;)|["<>\\]/g, function(s) {
+        switch(s) {
+        case "&": return "&amp;";
+        case "\\": return "\\\\";
+        case '"': return '\"';
+        case "<": return "&lt;";
+        case ">": return "&gt;";
+        default: return s;
+        }
+      });
+    },
+
+    // by @langalex, support for arrays of strings
+    create_context: function(_context) {
+      if(this.is_object(_context)) {
+        return _context;
+      } else {
+        var iterator = ".";
+        if(this.pragmas["IMPLICIT-ITERATOR"]) {
+          iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+        }
+        var ctx = {};
+        ctx[iterator] = _context;
+        return ctx;
+      }
+    },
+
+    is_object: function(a) {
+      return a && typeof a == "object";
+    },
+
+    is_array: function(a) {
+      return Object.prototype.toString.call(a) === '[object Array]';
+    },
+
+    /*
+      Gets rid of leading and trailing whitespace
+    */
+    trim: function(s) {
+      return s.replace(/^\s*|\s*$/g, "");
+    },
+
+    /*
+      Why, why, why? Because IE. Cry, cry cry.
+    */
+    map: function(array, fn) {
+      if (typeof array.map == "function") {
+        return array.map(fn);
+      } else {
+        var r = [];
+        var l = array.length;
+        for(var i = 0; i < l; i++) {
+          r.push(fn(array[i]));
+        }
+        return r;
+      }
+    }
+  };
+
+  return({
+    name: "mustache.js",
+    version: "0.3.0-dev",
+
+    /*
+      Turns a template and view into HTML
+    */
+    to_html: function(template, view, partials, send_fun) {
+      var renderer = new Renderer();
+      if(send_fun) {
+        renderer.send = send_fun;
+      }
+      renderer.render(template, view, partials);
+      if(!send_fun) {
+        return renderer.buffer.join("\n");
+      }
+    }
+  });
+}();

data/public/admin/javascripts/selection.js

@@ -0,0 +1,280 @@
+/*  
+*  Selection.js
+*  Copyright (c) 2010 Flip Sasser, All Rights Reserved
+*  Use to manipulate a text selection object using jQuery. Fun!
+*
+*/
+
+require('string');
+
+$.extend($.expr[':'], {
+  block: function(a) {
+    return $(a).css('display') === 'block';
+  },
+  textnode: function(a) {
+    return a.nodeType == 3;
+  }
+});
+
+jQuery.fn.selection = function(rootSelector) {
+  return new Selection(this[0], rootSelector);
+};
+
+// The selection class will provide some basic range finding methods, such as:
+// * Find text before and after the selection, inside of current block
+// * Move the caret to a block if it's in a Textnode directly under body
+// The selection class can be used to move after() to a new adjacent
+// block without much overhead or trouble. It can also be used to wrap,
+// unwrap, and detect wrapping tags in, HTML content. Example:
+// 
+// var selection = $(window).selection();
+// var before = selection.before();
+// var after = selection.after();
+// // Splits the `before` and `after` into
+// // two new blocks; the default block type is
+// // paragraph but that can be changed:
+// var newParagraph = selection.split('p');
+// selection.wrap('strong');
+// selection.unwrap('strong');
+// selection.wrappedIn('strong'); //=> true if the selection is inside <strong>
+// selection.insert('<img alt="Image!" src="/images/foo.gif" />');
+
+var Selection = function(element, rootSelector) {
+  this.window = element;
+  this.document = element.document;
+  this.rootSelector = rootSelector || 'body';
+  this.root = $(this.document).find(this.rootSelector + ':first');
+};
+
+Selection.prototype = {
+  // `after` and `before` return the strings before and after the current selection,
+  // inside of the current block (or an automatically-created paragraph block).
+  after: function() {
+    return this.afterRange().toString();
+  },
+  afterAll: function() {
+    var range = this.range();
+    var afterAllRange = this.document.createRange();
+    afterAllRange.selectNodeContents(this.root[0]);
+    afterAllRange.setStart(range.endContainer, range.endOffset);
+    return afterAllRange.cloneContents();
+  },
+  before: function() {
+    return this.beforeRange().toString();
+  },
+  beforeAll: function() {
+    var range = this.range();
+    var beforeAllRange = this.document.createRange();
+    beforeAllRange.setStart(this.root[0], 0);
+    beforeAllRange.setEnd(range.startContainer, range.startOffset);
+    return beforeAllRange.cloneContents();
+  },
+  // Inserts some content into the selection. Really, it just replaces the
+  // current selection with the content. Coolness.
+  insert: function(content) {
+    this.replace(content);
+  },
+  normalize: function() {
+    if (this.startBlock().length > 0) {
+      this.startBlock()[0].normalize();
+    }
+    if (this.endBlock().length > 0) {
+      this.endBlock()[0].normalize();
+    }
+  },
+  // Returns the before or after range of the current selection, scoped to the
+  // containing block. If no containing block is found, it automatically
+  // creates one and set the range inside of it.
+  range: function(name) {
+    return this._data('range', function() {
+      var range;
+      if (this.selection.getRangeAt) {
+        range = this.selection.getRangeAt(0);
+      } else if (this.document.selection) {
+        range = this.document.createRange();
+        range.setStart(this.selection.anchorNode, this.selection.anchorOffset);
+        range.setEnd(this.selection.focusNode, this.selection.focusOffset);
+      }
+      return range;
+    });
+  },
+  // Replaces the selection with the passed-in content. Primarily used internally
+  // for `insert` and `wrap`.
+  replace: function(content) {
+    this.range().deleteContents();
+    var startNode = this.startNode();
+    startNode.append(content);
+    this.select(startNode);
+  },
+  // Sets the caret position inside the first element that matches the selector.
+  // You can also pass in an element and an offset if you're feeling extra-aggressive,
+  // but be forewarned: the element MUST appear inside the `root` element of the
+  // selection, or you can go to hell, sir.
+  select: function(selector, offset) {
+    this.root.focus();
+    var element;
+    if (typeof(selector) == 'object') {
+      element = $(selector);
+    } else {
+      element = this.root.find(selector + ':first');
+    }
+    if (!offset) {
+      offset = 0;
+    }
+    element = element[0];
+    if (element) {
+      if (!this.selection) {
+        this.selection = this.window.getSelection ? this.window.getSelection() : this.document.selection;
+      }
+      var range = this.document.createRange();
+      range.selectNodeContents(element);
+      range.collapse(true);
+      this.selection.removeAllRanges();
+      this.selection.addRange(range);
+    } else {
+      this.root.focus();
+    }
+  },
+  split: function(tagname) {
+    // Default to a new paragraph
+    if (!tagname) {
+      tagname = 'p';
+    }
+    tagname = tagname.toLowerCase();
+    // Build whatever comes after the current node, cutting the contents out
+    var afterNode = $('<' + tagname + '></' + tagname + '>');
+    var after = this.afterRange();
+    afterNode.html(after.cloneContents());
+    afterNode.append('<br />');
+    // Add the new node after the current block - and then, and this is important,
+    // SELECT the top of that block
+    var endBlock = this.endBlock();
+    endBlock.after(afterNode);
+    var startBlock = this.startBlock();
+    if (startBlock == endBlock && startBlock.text() == '') {
+      afterNode = $('<br />');
+      startBlock.append(afterNode);
+    }
+    this.select(afterNode);
+    this.range().deleteContents();
+    after.deleteContents();
+    startBlock[0].normalize();
+    endBlock[0].normalize();
+  },
+  afterRange: function() {
+    return this._data('afterRange', function() {
+      var endNode = this.endNode();
+
+      var afterRange = this.document.createRange();
+      afterRange.setStart(endNode[0], this.data['endOffset']);
+      afterRange.setEnd(endNode[0], (endNode[0].wholeText || endNode.html()).length);
+
+      return afterRange;
+    });
+  },
+  beforeRange: function() {
+    return this._data('beforeRange', function() {
+      var startNode = this.startNode();
+
+      var beforeRange = this.document.createRange();
+      beforeRange.setStart(startNode[0], 0);
+      beforeRange.setEnd(startNode[0], this.data['startOffset']);
+
+      return beforeRange;
+    });
+  },
+  endNode: function() {
+    return this._data('endNode', function() {
+      var beforeRange = this.document.createRange();
+      beforeRange.setStart(this.selection.anchorNode, this.selection.anchorOffset);
+      beforeRange.collapse(true);
+
+      var afterRange = this.document.createRange();
+      afterRange.setStart(this.selection.focusNode, this.selection.focusOffset);
+      afterRange.collapse(true);
+
+      var ltr = beforeRange.compareBoundaryPoints(beforeRange.START_TO_END, afterRange) < 0;
+
+      var endNode = $(ltr ? this.selection.focusNode : this.selection.anchorNode);
+      this.data['startNode'] = $(ltr ? this.selection.anchorNode : this.selection.focusNode);
+      this.data['startOffset'] = ltr ? this.selection.anchorOffset : this.selection.focusOffset;
+      this.data['endOffset'] = ltr ? this.selection.focusOffset : this.selection.anchorOffset;
+
+      return endNode;
+
+    });
+  },
+  endBlock: function() {
+    return this._data('endBlock', function() {
+      var endNode = this.endNode();
+      var endBlock = endNode.parents(':block:not(body, html, ' + this.rootSelector + '):first') || endNode;
+      if (endBlock.length > 0) {
+        endBlock[0].normalize();
+      }
+      return endBlock;
+    });
+  },
+  startBlock: function() {
+    return this._data('startBlock', function() {
+      var startNode = this.startNode();
+      return startNode.parents(':block:not(body, html):first') || startNode;
+    });
+  },
+  startNode: function() {
+    return this._data('startNode', function() {
+      var beforeRange = this.document.createRange();
+      beforeRange.setStart(this.selection.anchorNode, this.selection.anchorOffset);
+      beforeRange.collapse(true);
+
+      var afterRange = this.document.createRange();
+      afterRange.setStart(this.selection.focusNode, this.selection.focusOffset);
+      afterRange.collapse(true);
+
+      var ltr = beforeRange.compareBoundaryPoints(beforeRange.START_TO_END, afterRange) < 0;
+      var startNode = $(ltr ? this.selection.anchorNode : this.selection.focusNode);
+      this.data['startOffset'] = ltr ? this.selection.anchorOffset : this.selection.focusOffset;
+      this.data['endNode'] = $(ltr ? this.selection.focusNode : this.selection.anchorNode);
+      this.data['endOffset'] = ltr ? this.selection.focusOffset : this.selection.anchorOffset;
+
+      return startNode;
+    });
+  },
+  unwrap: function(tagname) {
+    var tags = this.wrappedIn(tagname);
+    if (tags) {
+
+    }
+  },
+  wrap: function(tagname) {
+    // Nice, clean-looking HTML.
+    tagname = tagname.toLowerCase();
+    var wrapper = this.document.createElement(tagname);
+    this.range().surroundContents(wrapper);
+  },
+  // Returns a boolean for whether or not the selection (or caret position)
+  // is inside of a certain tag. Useful for activating / deactivating button
+  // items as the user navigates.
+  wrappedIn: function(selector) {
+    var startNode = this.startNode();
+    if (startNode.is(selector)) {
+      return startNode;
+    } else {
+      var parents = startNode.parents(selector);
+      if (parents.length === 0) {
+        return false;
+      } else {
+        return parents;
+      }
+    }
+  },
+  _data: function(name, block) {
+    if (!this.data) {
+      this.data = {};
+    }
+    if (!this.data[name]) {
+      this.selection = this.window.getSelection ? this.window.getSelection() : this.document.selection;
+      this.data[name] = block.call(this);
+    }
+    return this.data[name];
+  }
+};