edge_framework 0.6.0 → 0.6.1

data/assets/js/edge/edge.prism.js

@@ -0,0 +1,692 @@
+/*
+EDGE PRISM - Syntax Highlighter
+  Supported languages: Markup, CSS, JS, Python, Ruby, PHP, Sass
+  Based on Prism JS [http://prismjs.com/] by Lea Verou [http://lea.verou.me]
+*/
+
+(function(){
+
+// Private helper vars
+var lang = /\blang(?:uage)?-(?!\*)(\w+)\b/i;
+
+var _ = self.Prism = {
+  util: {
+    type: function (o) { 
+      return Object.prototype.toString.call(o).match(/\[object (\w+)\]/)[1];
+    },
+    
+    // Deep clone a language definition (e.g. to extend it)
+    clone: function (o) {
+      var type = _.util.type(o);
+
+      switch (type) {
+        case 'Object':
+          var clone = {};
+          
+          for (var key in o) {
+            if (o.hasOwnProperty(key) ) {
+              clone[key] = _.util.clone(o[key]);
+            }
+          }
+          
+          return clone;
+          
+        case 'Array':
+          return o.slice();
+      }
+      
+      return o;
+    },
+
+    // Remove excess whitespace
+    filter: function(code, language) {
+      // escape special characters
+      code = code.replace(/</g, "&lt;").replace(/\u00a0/g, "  ");
+      // If not python, convert spaces into tabs
+      if(language !== "python") {
+        code = code.replace(/\t/g, "  ");
+      }
+
+      // remove trailing and following line break
+      var filteredText = code.replace(/^\n/, "").replace(/\n\s+$/, "");
+
+      // split the lines and count the offset
+      var lines = filteredText.split("\n");
+      var offset = lines[0].match(/^\s*/)[ 0 ].length;
+
+      // remove excess whitespace from each line
+      lines = lines.map(function(line) {
+        return line.slice(offset);
+      });
+
+      return lines.join("\n");
+    }
+  },
+  
+  languages: {
+    extend: function (id, redef) {
+      var lang = _.util.clone(_.languages[id]);
+      
+      for (var key in redef) {
+        lang[key] = redef[key];
+      }
+      
+      return lang;
+    },
+    
+    // Insert a token before another token in a language literal
+    insertBefore: function (inside, before, insert, root) {
+      root = root || _.languages;
+      var grammar = root[inside];
+      var ret = {};
+        
+      for (var token in grammar) {
+      
+        if (grammar.hasOwnProperty(token)) {
+          
+          if (token == before) {
+          
+            for (var newToken in insert) {
+            
+              if (insert.hasOwnProperty(newToken)) {
+                ret[newToken] = insert[newToken];
+              }
+            }
+          }
+          
+          ret[token] = grammar[token];
+        }
+      }
+      
+      return root[inside] = ret;
+    },
+    
+    // Traverse a language definition with Depth First Search
+    DFS: function(o, callback) {
+      for (var i in o) {
+        callback.call(o, i, o[i]);
+        
+        if (_.util.type(o) === 'Object') {
+          _.languages.DFS(o[i], callback);
+        }
+      }
+    }
+  },
+
+  highlightAll: function(async, callback) {
+    //var elements = document.querySelectorAll('code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code');
+    var elements = document.querySelectorAll("code[data-lang], [data-lang] code");
+
+    for (var i=0, element; element = elements[i++];) {
+      _.highlightElement(element, async === true, callback);
+    }
+  },
+    
+  highlightElement: function(element, async, callback) {
+    var language, grammar, parent = element;
+    
+    // Look for element that has attribute "data-lang"
+    while (parent && !parent.getAttribute("data-lang") ) {
+      parent = parent.parentNode;
+    }
+    
+    if(parent) {
+      language = parent.getAttribute("data-lang");
+      grammar = _.languages[language];
+    }
+
+    if (!grammar) {
+      return;
+    }
+
+    var code = _.util.filter(element.innerHTML, language);
+
+    if(!code) {
+      return;
+    }
+    
+    var env = {
+      element: element,
+      language: language,
+      grammar: grammar,
+      code: code
+    };
+    
+    _.hooks.run('before-highlight', env);
+    
+    if (async && self.Worker) {
+      var worker = new Worker(_.filename);  
+      
+      worker.onmessage = function(evt) {
+        env.highlightedCode = Token.stringify(JSON.parse(evt.data), language);
+
+        _.hooks.run('before-insert', env);
+
+        env.element.innerHTML = env.highlightedCode;
+        
+        callback && callback.call(env.element);
+        _.hooks.run('after-highlight', env);
+      };
+      
+      worker.postMessage(JSON.stringify({
+        language: env.language,
+        code: env.code
+      }));
+    }
+    else {
+      env.highlightedCode = _.highlight(env.code, env.grammar, env.language)
+
+      _.hooks.run('before-insert', env);
+
+      env.element.innerHTML = env.highlightedCode;
+      
+      callback && callback.call(element);
+      
+      _.hooks.run('after-highlight', env);
+    }
+  },
+  
+  highlight: function (text, grammar, language) {
+    return Token.stringify(_.tokenize(text, grammar), language);
+  },
+  
+  tokenize: function(text, grammar, language) {
+    var Token = _.Token;
+    
+    var strarr = [text];
+    
+    var rest = grammar.rest;
+    
+    if (rest) {
+      for (var token in rest) {
+        grammar[token] = rest[token];
+      }
+      
+      delete grammar.rest;
+    }
+                
+    tokenloop: for (var token in grammar) {
+      if(!grammar.hasOwnProperty(token) || !grammar[token]) {
+        continue;
+      }
+      
+      var pattern = grammar[token], 
+        inside = pattern.inside,
+        lookbehind = !!pattern.lookbehind,
+        lookbehindLength = 0;
+      
+      pattern = pattern.pattern || pattern;
+      
+      for (var i=0; i<strarr.length; i++) { // Don’t cache length as it changes during the loop
+        
+        var str = strarr[i];
+        
+        if (strarr.length > text.length) {
+          // Something went terribly wrong, ABORT, ABORT!
+          break tokenloop;
+        }
+        
+        if (str instanceof Token) {
+          continue;
+        }
+        
+        pattern.lastIndex = 0;
+        
+        var match = pattern.exec(str);
+        
+        if (match) {
+          if(lookbehind) {
+            lookbehindLength = match[1].length;
+          }
+
+          var from = match.index - 1 + lookbehindLength,
+              match = match[0].slice(lookbehindLength),
+              len = match.length,
+              to = from + len,
+            before = str.slice(0, from + 1),
+            after = str.slice(to + 1); 
+
+          var args = [i, 1];
+          
+          if (before) {
+            args.push(before);
+          }
+          
+          var wrapped = new Token(token, inside? _.tokenize(match, inside) : match);
+          
+          args.push(wrapped);
+          
+          if (after) {
+            args.push(after);
+          }
+          
+          Array.prototype.splice.apply(strarr, args);
+        }
+      }
+    }
+
+    return strarr;
+  },
+  
+  hooks: {
+    all: {},
+    
+    add: function (name, callback) {
+      var hooks = _.hooks.all;
+      
+      hooks[name] = hooks[name] || [];
+      
+      hooks[name].push(callback);
+    },
+    
+    run: function (name, env) {
+      var callbacks = _.hooks.all[name];
+      
+      if (!callbacks || !callbacks.length) {
+        return;
+      }
+      
+      for (var i=0, callback; callback = callbacks[i++];) {
+        callback(env);
+      }
+    }
+  }
+};
+
+var Token = _.Token = function(type, content) {
+  this.type = type;
+  this.content = content;
+};
+
+Token.stringify = function(o, language, parent) {
+  if (typeof o == 'string') {
+    return o;
+  }
+
+  if (Object.prototype.toString.call(o) == '[object Array]') {
+    return o.map(function(element) {
+      return Token.stringify(element, language, o);
+    }).join('');
+  }
+  
+  var env = {
+    type: o.type,
+    content: Token.stringify(o.content, language, parent),
+    tag: 'span',
+    classes: ['token', o.type],
+    attributes: {},
+    language: language,
+    parent: parent
+  };
+  
+  if (env.type == 'comment') {
+    env.attributes['spellcheck'] = 'true';
+  }
+  
+  _.hooks.run('wrap', env);
+  
+  var attributes = '';
+  
+  for (var name in env.attributes) {
+    attributes += name + '="' + (env.attributes[name] || '') + '"';
+  }
+  
+  return '<' + env.tag + ' class="' + env.classes.join(' ') + '" ' + attributes + '>' + env.content + '</' + env.tag + '>';
+  
+};
+
+if (!self.document) {
+  // In worker
+  self.addEventListener('message', function(evt) {
+    var message = JSON.parse(evt.data),
+        lang = message.language,
+        code = message.code;
+    
+    self.postMessage(JSON.stringify(_.tokenize(code, _.languages[lang])));
+    self.close();
+  }, false);
+  
+  return;
+}
+
+// Get current script and highlight
+var script = document.getElementsByTagName('script');
+
+script = script[script.length - 1];
+
+if (script) {
+  _.filename = script.src;
+  
+  if (document.addEventListener && !script.hasAttribute('data-manual')) {
+    document.addEventListener('DOMContentLoaded', _.highlightAll);
+  }
+}
+
+})();;
+Prism.languages.markup = {
+  'comment': /&lt;!--[\w\W]*?-->/g,
+  'prolog': /&lt;\?.+?\?>/,
+  'doctype': /&lt;!DOCTYPE.+?>/,
+  'cdata': /&lt;!\[CDATA\[[\w\W]*?]]>/i,
+  'tag': {
+    pattern: /&lt;\/?[\w:-]+\s*(?:\s+[\w:-]+(?:=(?:("|')(\\?[\w\W])*?\1|\w+))?\s*)*\/?>/gi,
+    inside: {
+      'tag': {
+        pattern: /^&lt;\/?[\w:-]+/i,
+        inside: {
+          'punctuation': /^&lt;\/?/,
+          'namespace': /^[\w-]+?:/
+        }
+      },
+      'attr-value': {
+        pattern: /=(?:('|")[\w\W]*?(\1)|[^\s>]+)/gi,
+        inside: {
+          'punctuation': /=|>|"/g
+        }
+      },
+      'punctuation': /\/?>/g,
+      'attr-name': {
+        pattern: /[\w:-]+/g,
+        inside: {
+          'namespace': /^[\w-]+?:/
+        }
+      }
+      
+    }
+  },
+  'entity': /&amp;#?[\da-z]{1,8};/gi
+};
+
+// Plugin to make entity title show the real entity, idea by Roman Komarov
+Prism.hooks.add('wrap', function(env) {
+
+  if (env.type === 'entity') {
+    env.attributes['title'] = env.content.replace(/&amp;/, '&');
+  }
+});;
+Prism.languages.css = {
+  'comment': /\/\*[\w\W]*?\*\//g,
+  'atrule': {
+    pattern: /@[\w-]+?.*?(;|(?=\s*{))/gi,
+    inside: {
+      'punctuation': /[;:]/g
+    }
+  },
+  'url': /url\((["']?).*?\1\)/gi,
+  'selector': /[^\{\}\s][^\{\};]*(?=\s*\{)/g,
+  'property': /(\b|\B)[\w-]+(?=\s*:)/ig,
+  'string': /("|')(\\?.)*?\1/g,
+  'important': /\B!important\b/gi,
+  'ignore': /&(lt|gt|amp);/gi,
+  'punctuation': /[\{\};:]/g
+};
+
+if (Prism.languages.markup) {
+  Prism.languages.insertBefore('markup', 'tag', {
+    'style': {
+      pattern: /(&lt;|<)style[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/style(>|&gt;)/ig,
+      inside: {
+        'tag': {
+          pattern: /(&lt;|<)style[\w\W]*?(>|&gt;)|(&lt;|<)\/style(>|&gt;)/ig,
+          inside: Prism.languages.markup.tag.inside
+        },
+        rest: Prism.languages.css
+      }
+    }
+  });
+};
+Prism.languages.clike = {
+  'comment': {
+    pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|(^|[^:])\/\/.*?(\r?\n|$))/g,
+    lookbehind: true
+  },
+  'string': /("|')(\\?.)*?\1/g,
+  'class-name': {
+    pattern: /((?:(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[a-z0-9_\.\\]+/ig,
+    lookbehind: true,
+    inside: {
+      punctuation: /(\.|\\)/
+    }
+  },
+  'keyword': /\b(if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/g,
+  'boolean': /\b(true|false)\b/g,
+  'function': {
+    pattern: /[a-z0-9_]+\(/ig,
+    inside: {
+      punctuation: /\(/
+    }
+  },
+  'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?)\b/g,
+  'operator': /[-+]{1,2}|!|&lt;=?|>=?|={1,3}|(&amp;){1,2}|\|?\||\?|\*|\/|\~|\^|\%/g,
+  'ignore': /&(lt|gt|amp);/gi,
+  'punctuation': /[{}[\];(),.:]/g
+};
+;
+Prism.languages.javascript = Prism.languages.extend('clike', {
+  'keyword': /\b(var|let|if|else|while|do|for|return|in|instanceof|function|new|with|typeof|try|throw|catch|finally|null|break|continue)\b/g,
+  'number': /\b-?(0x[\dA-Fa-f]+|\d*\.?\d+([Ee]-?\d+)?|NaN|-?Infinity)\b/g
+});
+
+Prism.languages.insertBefore('javascript', 'keyword', {
+  'regex': {
+    pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,
+    lookbehind: true
+  }
+});
+
+if (Prism.languages.markup) {
+  Prism.languages.insertBefore('markup', 'tag', {
+    'script': {
+      pattern: /(&lt;|<)script[\w\W]*?(>|&gt;)[\w\W]*?(&lt;|<)\/script(>|&gt;)/ig,
+      inside: {
+        'tag': {
+          pattern: /(&lt;|<)script[\w\W]*?(>|&gt;)|(&lt;|<)\/script(>|&gt;)/ig,
+          inside: Prism.languages.markup.tag.inside
+        },
+        rest: Prism.languages.javascript
+      }
+    }
+  });
+}
+;
+Prism.languages.scss = Prism.languages.extend('css', {
+  'comment': {
+    pattern: /(^|[^\\])(\/\*[\w\W]*?\*\/|\/\/.*?(\r?\n|$))/g,
+    lookbehind: true
+  },
+  // atrule is just the @***, not the entire rule (to highlight var & stuffs)
+  // + add ability to highlight number & unit for media queries
+  'atrule': /@[\w-]+(?=\s+(\(|\{|;))/gi,
+  // url, compassified
+  'url': /([-a-z]+-)*url(?=\()/gi,
+  // CSS selector regex is not appropriate for Sass
+  // since there can be lot more things (var, @ directive, nesting..)
+  // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+  // it can contain some caracters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+  // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+  // can "pass" as a selector- e.g: proper#{$erty})
+  // this one was ard to do, so please be careful if you edit this one :)
+  'selector': /([^@;\{\}\(\)]?([^@;\{\}\(\)]|&amp;|\#\{\$[-_\w]+\})+)(?=\s*\{(\}|\s|[^\}]+(:|\{)[^\}]+))/gm
+});
+
+Prism.languages.insertBefore('scss', 'atrule', {
+  'keyword': /@(if|else if|else|for|each|while|import|extend|debug|warn|mixin|include|function|return)|(?=@for\s+\$[-_\w]+\s)+from/i
+});
+
+Prism.languages.insertBefore('scss', 'property', {
+  // var and interpolated vars
+  'variable': /((\$[-_\w]+)|(#\{\$[-_\w]+\}))/i
+});
+
+Prism.languages.insertBefore('scss', 'ignore', {
+  'placeholder': /%[-_\w]+/i,
+  'statement': /\B!(default|optional)\b/gi,
+  'boolean': /\b(true|false)\b/g,
+  'null': /\b(null)\b/g,
+  'operator': /\s+([-+]{1,2}|={1,2}|!=|\|?\||\?|\*|\/|\%)\s+/g
+});
+;
+
+Prism.languages.python= { 
+  'comment': {
+    pattern: /(^|[^\\])#.*?(\r?\n|$)/g,
+    lookbehind: true
+  },
+  'string' : /("|')(\\?.)*?\1/g,
+  'keyword' : /\b(as|assert|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|pass|print|raise|return|try|while|with|yield)\b/g,
+  'boolean' : /\b(True|False)\b/g,
+  'number' : /\b-?(0x)?\d*\.?[\da-f]+\b/g,
+  'operator' : /[-+]{1,2}|=?&lt;|=?&gt;|!|={1,2}|(&){1,2}|(&amp;){1,2}|\|?\||\?|\*|\/|~|\^|%|\b(or|and|not)\b/g,
+  'ignore' : /&(lt|gt|amp);/gi,
+  'punctuation' : /[{}[\];(),.:]/g
+};
+/**
+ * Original by Samuel Flores
+ *
+ * Adds the following new token classes:
+ *    constant, builtin, variable, symbol, regex
+ */
+Prism.languages.ruby = Prism.languages.extend('clike', {
+  'comment': /#[^\r\n]*(\r?\n|$)/g,
+  'keyword': /\b(alias|and|BEGIN|begin|break|case|class|def|define_method|defined|do|each|else|elsif|END|end|ensure|false|for|if|in|module|new|next|nil|not|or|raise|redo|require|rescue|retry|return|self|super|then|throw|true|undef|unless|until|when|while|yield)\b/g,
+  'builtin': /\b(Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Stat|File|Fixnum|Fload|Hash|Integer|IO|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|String|Struct|TMS|Symbol|ThreadGroup|Thread|Time|TrueClass)\b/,
+  'constant': /\b[A-Z][a-zA-Z_0-9]*[?!]?\b/g
+});
+
+Prism.languages.insertBefore('ruby', 'keyword', {
+  'regex': {
+    pattern: /(^|[^/])\/(?!\/)(\[.+?]|\\.|[^/\r\n])+\/[gim]{0,3}(?=\s*($|[\r\n,.;})]))/g,
+    lookbehind: true
+  },
+  'variable': /[@$&]+\b[a-zA-Z_][a-zA-Z_0-9]*[?!]?\b/g,
+  'symbol': /:\b[a-zA-Z_][a-zA-Z_0-9]*[?!]?\b/g
+});
+;
+
+/* -------------------
+  Line Highlighter
+-------------------- */
+
+(function(){
+
+if(!window.Prism) {
+  return;
+}
+
+function $$(expr, con) {
+  return Array.prototype.slice.call((con || document).querySelectorAll(expr));
+}
+
+var CRLF = crlf = /\r?\n|\r/g;
+    
+function highlightLines(pre, lines, classes) {
+  var ranges = lines.replace(/\s+/g, '').split(','),
+      offset = +pre.getAttribute('data-line-offset') || 0;
+  
+  var lineHeight = parseFloat(getComputedStyle(pre).lineHeight);
+
+  for (var i=0, range; range = ranges[i++];) {
+    range = range.split('-');
+          
+    var start = +range[0],
+        end = +range[1] || start;
+    
+    var line = document.createElement('div');
+    
+    line.textContent = Array(end - start + 2).join(' \r\n');
+    line.className = (classes || '') + ' line-highlight';
+    line.setAttribute('data-start', start);
+    
+    if(end > start) {
+      line.setAttribute('data-end', end);
+    }
+  
+    line.style.top = (start - offset - 1) * lineHeight + 'px';
+    
+    (pre.querySelector('code') || pre).appendChild(line);
+  }
+}
+
+function applyHash() {
+  var hash = location.hash.slice(1);
+  
+  // Remove pre-existing temporary lines
+  $$('.temporary.line-highlight').forEach(function (line) {
+    line.parentNode.removeChild(line);
+  });
+  
+  var range = (hash.match(/\.([\d,-]+)$/) || [,''])[1];
+  
+  if (!range || document.getElementById(hash)) {
+    return;
+  }
+  
+  var id = hash.slice(0, hash.lastIndexOf('.')),
+      pre = document.getElementById(id);
+      
+  if (!pre) {
+    return;
+  }
+  
+  if (!pre.hasAttribute('data-line')) {
+    pre.setAttribute('data-line', '');
+  }
+
+  highlightLines(pre, range, 'temporary ');
+
+  document.querySelector('.temporary.line-highlight').scrollIntoView();
+}
+
+var fakeTimer = 0; // Hack to limit the number of times applyHash() runs
+
+Prism.hooks.add('after-highlight', function(env) {
+  var pre = env.element.parentNode;
+  var lines = pre && pre.getAttribute('data-line');
+  
+  if (!pre || !lines || !/pre/i.test(pre.nodeName)) {
+    return;
+  }
+  
+  clearTimeout(fakeTimer);
+  
+  $$('.line-highlight', pre).forEach(function (line) {
+    line.parentNode.removeChild(line);
+  });
+  
+  highlightLines(pre, lines);
+  
+  fakeTimer = setTimeout(applyHash, 1);
+});
+
+addEventListener('hashchange', applyHash);
+
+})();;
+
+/* ----------------
+  Line Numbering
+----------------- */
+
+Prism.hooks.add('after-highlight', function (env) {
+  // works only for <code> wrapped inside <pre data-line-numbers> (not inline)
+  var pre = env.element.parentNode;
+  if (!pre || !/pre/i.test(pre.nodeName) || pre.className.indexOf('line-numbers') === -1) {
+    return;
+  }
+
+  var linesNum = (1 + env.code.split('\n').length);
+  var lineNumbersWrapper;
+
+  lines = new Array(linesNum);
+  lines = lines.join('<span></span>');
+
+  lineNumbersWrapper = document.createElement('span');
+  lineNumbersWrapper.className = 'line-numbers-rows';
+  lineNumbersWrapper.innerHTML = lines;
+
+  if (pre.hasAttribute('data-start')) {
+    pre.style.counterReset = 'linenumber ' + (parseInt(pre.getAttribute('data-start'), 10) - 1);
+  }
+
+  env.element.appendChild(lineNumbersWrapper);
+
+});;

data/assets/js/edge/edge.template.js

@@ -0,0 +1,15 @@
+;(function ($, window, document, undefined) {
+	"use strict";
+
+	Edge.libs.ie8 = {
+		name     : "name",
+		version  : "1.0",
+		settings : {
+
+		},
+
+		init: function( scope, method, options ) {
+			
+		},
+	}
+}(jQuery, this, this.document) );