liquid_cms 0.2.0.2 → 0.2.0.3

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/mirrorframe.js

@@ -36,7 +36,7 @@ MirrorFrame.prototype = {
 
     var first = true;
     do {
-      var cursor = this.mirror.getSearchCursor(text, first, true);
+      var cursor = this.mirror.getSearchCursor(text, first);
       first = false;
       while (cursor.findNext()) {
         cursor.select();

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/parsecss.js

@@ -112,16 +112,18 @@ var CSSParser = Editor.Parser = (function() {
   function parseCSS(source, basecolumn) {
     basecolumn = basecolumn || 0;
     var tokens = tokenizeCSS(source);
-    var inBraces = false, inRule = false;
+    var inBraces = false, inRule = false, inDecl = false;;
 
     var iter = {
       next: function() {
         var token = tokens.next(), style = token.style, content = token.content;
 
-        if (style == "css-identifier" && inRule)
-          token.style = "css-value";
         if (style == "css-hash")
-          token.style =  inRule ? "css-colorcode" : "css-identifier";
+          style = token.style =  inRule ? "css-colorcode" : "css-identifier";
+        if (style == "css-identifier") {
+          if (inRule) token.style = "css-value";
+          else if (!inBraces && !inDecl) token.style = "css-selector";
+        }
 
         if (content == "\n")
           token.indentation = indentCSS(inBraces, inRule, basecolumn);
@@ -129,11 +131,13 @@ var CSSParser = Editor.Parser = (function() {
         if (content == "{")
           inBraces = true;
         else if (content == "}")
-          inBraces = inRule = false;
-        else if (inBraces && content == ";")
-          inRule = false;
+          inBraces = inRule = inDecl = false;
+        else if (content == ";")
+          inRule = inDecl = false;
         else if (inBraces && style != "css-comment" && style != "whitespace")
           inRule = true;
+        else if (!inBraces && style == "css-at" && content != "@media")
+          inDecl = true;
 
         return token;
       },

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/parsejavascript.js

@@ -60,7 +60,7 @@ var JSParser = Editor.Parser = (function() {
     // semicolon. Actions at the end of the stack go first. It is
     // initialized with an infinitely looping action that consumes
     // whole statements.
-    var cc = [statements];
+    var cc = [json ? expressions : statements];
     // Context contains information about the current local scope, the
     // variables defined in that, and the scopes above it.
     var context = null;
@@ -206,6 +206,8 @@ var JSParser = Editor.Parser = (function() {
     }
     // Pop off the current lexical context.
     function poplex(){
+      if (lexical.type == ")")
+        indented = lexical.indented;
       lexical = lexical.prev;
     }
     poplex.lex = true;
@@ -218,6 +220,7 @@ var JSParser = Editor.Parser = (function() {
     function expect(wanted){
       return function expecting(type){
         if (type == wanted) cont();
+        else if (wanted == ";") pass();
         else cont(arguments.callee);
       };
     }
@@ -226,14 +229,17 @@ var JSParser = Editor.Parser = (function() {
     function statements(type){
       return pass(statement, statements);
     }
+    function expressions(type){
+      return pass(expression, expressions);
+    }
     // Dispatches various types of statements based on the type of the
     // current token.
     function statement(type){
       if (type == "var") cont(pushlex("vardef"), vardef1, expect(";"), poplex);
       else if (type == "keyword a") cont(pushlex("form"), expression, statement, poplex);
       else if (type == "keyword b") cont(pushlex("form"), statement, poplex);
-      else if (type == "{" && json) cont(pushlex("}"), commasep(objprop, "}"), poplex);
       else if (type == "{") cont(pushlex("}"), block, poplex);
+      else if (type == ";") cont();
       else if (type == "function") cont(functiondef);
       else if (type == "for") cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"), poplex, statement, poplex);
       else if (type == "variable") cont(pushlex("stat"), maybelabel);
@@ -252,13 +258,16 @@ var JSParser = Editor.Parser = (function() {
       else if (type == "operator") cont(expression);
       else if (type == "[") cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
       else if (type == "{") cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
+      else cont();
     }
     // Called for places where operators, function calls, or
     // subscripts are valid. Will skip on to the next action if none
     // is found.
-    function maybeoperator(type){
-      if (type == "operator") cont(expression);
-      else if (type == "(") cont(pushlex(")"), expression, commasep(expression, ")"), poplex, maybeoperator);
+    function maybeoperator(type, value){
+      if (type == "operator" && /\+\+|--/.test(value)) cont(maybeoperator);
+      else if (type == "operator") cont(expression);
+      else if (type == ";") pass();
+      else if (type == "(") cont(pushlex(")"), commasep(expression, ")"), poplex, maybeoperator);
       else if (type == ".") cont(property, maybeoperator);
       else if (type == "[") cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
     }

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/parsesparql.js

@@ -6,7 +6,7 @@ var SparqlParser = Editor.Parser = (function() {
                         "isblank", "isliteral", "union", "a"]);
   var keywords = wordRegexp(["base", "prefix", "select", "distinct", "reduced", "construct", "describe",
                              "ask", "from", "named", "where", "order", "limit", "offset", "filter", "optional",
-                             "graph", "by", "asc", "desc", ]);
+                             "graph", "by", "asc", "desc"]);
   var operatorChars = /[*+\-<>=&|]/;
 
   var tokenizeSparql = (function() {

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/select.js

@@ -29,11 +29,10 @@ var select = {};
 
   var fourSpaces = "\u00a0\u00a0\u00a0\u00a0";
 
-  select.scrollToNode = function(element) {
-    if (!element) return;
-    var doc = element.ownerDocument, body = doc.body,
-        win = (doc.defaultView || doc.parentWindow),
-        html = doc.documentElement,
+  select.scrollToNode = function(node, cursor) {
+    if (!node) return;
+    var element = node, body = document.body,
+        html = document.documentElement,
         atEnd = !element.nextSibling || !element.nextSibling.nextSibling
                 || !element.nextSibling.nextSibling.nextSibling;
     // In Opera (and recent Webkit versions), BR elements *always*
@@ -48,7 +47,14 @@ var select = {};
     // offset, just scroll to the end.
     if (compensateHack == 0) atEnd = false;
 
-    var y = compensateHack * (element ? element.offsetHeight : 0), x = 0, pos = element;
+    // WebKit has a bad habit of (sometimes) happily returning bogus
+    // offsets when the document has just been changed. This seems to
+    // always be 5/5, so we don't use those.
+    if (webkit && element && element.offsetTop == 5 && element.offsetLeft == 5)
+      return;
+
+    var y = compensateHack * (element ? element.offsetHeight : 0), x = 0,
+        width = (node ? node.offsetWidth : 0), pos = element;
     while (pos && pos.offsetParent) {
       y += pos.offsetTop;
       // Don't count X offset for <br> nodes
@@ -59,21 +65,29 @@ var select = {};
 
     var scroll_x = body.scrollLeft || html.scrollLeft || 0,
         scroll_y = body.scrollTop || html.scrollTop || 0,
-        screen_x = x - scroll_x, screen_y = y - scroll_y, scroll = false;
+        scroll = false, screen_width = window.innerWidth || html.clientWidth || 0;
 
-    if (screen_x < 0 || screen_x > (win.innerWidth || html.clientWidth || 0)) {
-      scroll_x = x;
-      scroll = true;
+    if (cursor || width < screen_width) {
+      if (cursor) {
+        var off = select.offsetInNode(node), size = nodeText(node).length;
+        if (size) x += width * (off / size);
+      }
+      var screen_x = x - scroll_x;
+      if (screen_x < 0 || screen_x > screen_width) {
+        scroll_x = x;
+        scroll = true;
+      }
     }
-    if (screen_y < 0 || atEnd || screen_y > (win.innerHeight || html.clientHeight || 0) - 50) {
+    var screen_y = y - scroll_y;
+    if (screen_y < 0 || atEnd || screen_y > (window.innerHeight || html.clientHeight || 0) - 50) {
       scroll_y = atEnd ? 1e6 : y;
       scroll = true;
     }
-    if (scroll) win.scrollTo(scroll_x, scroll_y);
+    if (scroll) window.scrollTo(scroll_x, scroll_y);
   };
 
   select.scrollToCursor = function(container) {
-    select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild);
+    select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild, true);
   };
 
   // Used to prevent restoring a selection when we do not need to.
@@ -130,8 +144,8 @@ var select = {};
   // Most functions are defined in two ways, one for the IE selection
   // model, one for the W3C one.
   if (select.ie_selection) {
-    function selectionNode(win, start) {
-      var range = win.document.selection.createRange();
+    function selectionNode(start) {
+      var range = document.selection.createRange();
       range.collapse(start);
 
       function nodeAfter(node) {
@@ -149,7 +163,7 @@ var select = {};
       }
 
       var containing = range.parentElement();
-      if (!isAncestor(win.document.body, containing)) return null;
+      if (!isAncestor(document.body, containing)) return null;
       if (!containing.firstChild) return nodeAtStartOf(containing);
 
       var working = range.duplicate();
@@ -176,25 +190,24 @@ var select = {};
       return nodeAfter(containing);
     }
 
-    select.markSelection = function(win) {
+    select.markSelection = function() {
       currentSelection = null;
-      var sel = win.document.selection;
+      var sel = document.selection;
       if (!sel) return;
-      var start = selectionNode(win, true),
-          end = selectionNode(win, false);
+      var start = selectionNode(true),
+          end = selectionNode(false);
       if (!start || !end) return;
-      currentSelection = {start: start, end: end, window: win, changed: false};
+      currentSelection = {start: start, end: end, changed: false};
     };
 
     select.selectMarked = function() {
       if (!currentSelection || !currentSelection.changed) return;
-      var win = currentSelection.window, doc = win.document;
 
       function makeRange(point) {
-        var range = doc.body.createTextRange(),
+        var range = document.body.createTextRange(),
             node = point.node;
         if (!node) {
-          range.moveToElementText(currentSelection.window.document.body);
+          range.moveToElementText(document.body);
           range.collapse(false);
         }
         else if (node.nodeType == 3) {
@@ -218,11 +231,20 @@ var select = {};
       start.select();
     };
 
+    select.offsetInNode = function(node) {
+      var sel = document.selection;
+      if (!sel) return 0;
+      var range = sel.createRange(), range2 = range.duplicate();
+      try {range2.moveToElementText(node);} catch(e){return 0;}
+      range.setEndPoint("StartToStart", range2);
+      return range.text.length;
+    };
+
     // Get the top-level node that one end of the cursor is inside or
     // after. Note that this returns false for 'no cursor', and null
     // for 'start of document'.
     select.selectionTopNode = function(container, start) {
-      var selection = container.ownerDocument.selection;
+      var selection = document.selection;
       if (!selection) return false;
 
       var range = selection.createRange(), range2 = range.duplicate();
@@ -272,6 +294,13 @@ var select = {};
         else
           end = middle - 1;
       }
+      
+      if (start == 0) {
+        var test1 = selection.createRange(), test2 = test1.duplicate();
+        test2.moveToElementText(container);
+        if (test1.compareEndPoints("StartToStart", test2) == 0)
+          return null;
+      }
       return container.childNodes[start] || null;
     };
 
@@ -279,19 +308,19 @@ var select = {};
     // manually moving the cursor instead of restoring it to its old
     // position.
     select.focusAfterNode = function(node, container) {
-      var range = container.ownerDocument.body.createTextRange();
+      var range = document.body.createTextRange();
       range.moveToElementText(node || container);
       range.collapse(!node);
       range.select();
     };
 
-    select.somethingSelected = function(win) {
-      var sel = win.document.selection;
+    select.somethingSelected = function() {
+      var sel = document.selection;
       return sel && (sel.createRange().text != "");
     };
 
-    function insertAtCursor(window, html) {
-      var selection = window.document.selection;
+    function insertAtCursor(html) {
+      var selection = document.selection;
       if (selection) {
         var range = selection.createRange();
         range.pasteHTML(html);
@@ -302,19 +331,19 @@ var select = {};
 
     // Used to normalize the effect of the enter key, since browsers
     // do widely different things when pressing enter in designMode.
-    select.insertNewlineAtCursor = function(window) {
-      insertAtCursor(window, "<br>");
+    select.insertNewlineAtCursor = function() {
+      insertAtCursor("<br>");
     };
 
-    select.insertTabAtCursor = function(window) {
-      insertAtCursor(window, fourSpaces);
+    select.insertTabAtCursor = function() {
+      insertAtCursor(fourSpaces);
     };
 
     // Get the BR node at the start of the line on which the cursor
     // currently is, and the offset into the line. Returns null as
     // node if cursor is on first line.
     select.cursorPos = function(container, start) {
-      var selection = container.ownerDocument.selection;
+      var selection = document.selection;
       if (!selection) return null;
 
       var topNode = select.selectionTopNode(container, start);
@@ -340,7 +369,7 @@ var select = {};
 
     select.setCursorPos = function(container, from, to) {
       function rangeAt(pos) {
-        var range = container.ownerDocument.body.createTextRange();
+        var range = document.body.createTextRange();
         if (!pos.node) {
           range.moveToElementText(container);
           range.collapse(true);
@@ -373,42 +402,38 @@ var select = {};
   }
   // W3C model
   else {
+    // Find the node right at the cursor, not one of its
+    // ancestors with a suitable offset. This goes down the DOM tree
+    // until a 'leaf' is reached (or is it *up* the DOM tree?).
+    function innerNode(node, offset) {
+      while (node.nodeType != 3 && !isBR(node)) {
+        var newNode = node.childNodes[offset] || node.nextSibling;
+        offset = 0;
+        while (!newNode && node.parentNode) {
+          node = node.parentNode;
+          newNode = node.nextSibling;
+        }
+        node = newNode;
+        if (!newNode) break;
+      }
+      return {node: node, offset: offset};
+    }
+
     // Store start and end nodes, and offsets within these, and refer
     // back to the selection object from those nodes, so that this
     // object can be updated when the nodes are replaced before the
     // selection is restored.
-    select.markSelection = function (win) {
-      var selection = win.getSelection();
+    select.markSelection = function () {
+      var selection = window.getSelection();
       if (!selection || selection.rangeCount == 0)
         return (currentSelection = null);
       var range = selection.getRangeAt(0);
 
       currentSelection = {
-        start: {node: range.startContainer, offset: range.startOffset},
-        end: {node: range.endContainer, offset: range.endOffset},
-        window: win,
+        start: innerNode(range.startContainer, range.startOffset),
+        end: innerNode(range.endContainer, range.endOffset),
         changed: false
       };
-
-      // We want the nodes right at the cursor, not one of their
-      // ancestors with a suitable offset. This goes down the DOM tree
-      // until a 'leaf' is reached (or is it *up* the DOM tree?).
-      function normalize(point){
-        while (point.node.nodeType != 3 && !isBR(point.node)) {
-          var newNode = point.node.childNodes[point.offset] || point.node.nextSibling;
-          point.offset = 0;
-          while (!newNode && point.node.parentNode) {
-            point.node = point.node.parentNode;
-            newNode = point.node.nextSibling;
-          }
-          point.node = newNode;
-          if (!newNode)
-            break;
-        }
-      }
-
-      normalize(currentSelection.start);
-      normalize(currentSelection.end);
     };
 
     select.selectMarked = function () {
@@ -419,10 +444,15 @@ var select = {};
       // this occurs is when a selection is deleted or overwitten. we
       // check for that here.
       function focusIssue() {
-        return cs.start.node == cs.end.node && cs.start.offset == 0 && cs.end.offset == 0;
+        if (cs.start.node == cs.end.node && cs.start.offset == cs.end.offset) {
+          var selection = window.getSelection();
+          if (!selection || selection.rangeCount == 0) return true;
+          var range = selection.getRangeAt(0), point = innerNode(range.startContainer, range.startOffset);
+          return cs.start.node != point.node || cs.start.offset != point.offset;
+        }
       }
       if (!cs || !(cs.changed || (webkit && focusIssue()))) return;
-      var win = cs.window, range = win.document.createRange();
+      var range = document.createRange();
 
       function setPoint(point, which) {
         if (point.node) {
@@ -434,22 +464,23 @@ var select = {};
             range["set" + which](point.node, point.offset);
         }
         else {
-          range.setStartAfter(win.document.body.lastChild || win.document.body);
+          range.setStartAfter(document.body.lastChild || document.body);
         }
       }
 
       setPoint(cs.end, "End");
       setPoint(cs.start, "Start");
-      selectRange(range, win);
+      selectRange(range);
     };
 
     // Helper for selecting a range object.
-    function selectRange(range, window) {
+    function selectRange(range) {
       var selection = window.getSelection();
+      if (!selection) return;
       selection.removeAllRanges();
       selection.addRange(range);
     }
-    function selectionRange(window) {
+    function selectionRange() {
       var selection = window.getSelection();
       if (!selection || selection.rangeCount == 0)
         return false;
@@ -460,7 +491,7 @@ var select = {};
     // Finding the top-level node at the cursor in the W3C is, as you
     // can see, quite an involved process.
     select.selectionTopNode = function(container, start) {
-      var range = selectionRange(container.ownerDocument.defaultView);
+      var range = selectionRange();
       if (!range) return false;
 
       var node = start ? range.startContainer : range.endContainer;
@@ -505,8 +536,7 @@ var select = {};
     };
 
     select.focusAfterNode = function(node, container) {
-      var win = container.ownerDocument.defaultView,
-          range = win.document.createRange();
+      var range = document.createRange();
       range.setStartBefore(container.firstChild || container);
       // In Opera, setting the end of a range at the end of a line
       // (before a BR) will cause the cursor to appear on the next
@@ -519,37 +549,59 @@ var select = {};
       else
         range.setEndBefore(container.firstChild || container);
       range.collapse(false);
-      selectRange(range, win);
+      selectRange(range);
     };
 
-    select.somethingSelected = function(win) {
-      var range = selectionRange(win);
+    select.somethingSelected = function() {
+      var range = selectionRange();
       return range && !range.collapsed;
     };
 
-    function insertNodeAtCursor(window, node) {
-      var range = selectionRange(window);
+    select.offsetInNode = function(node) {
+      var range = selectionRange();
+      if (!range) return 0;
+      range = range.cloneRange();
+      range.setStartBefore(node);
+      return range.toString().length;
+    };
+
+    function insertNodeAtCursor(node) {
+      var range = selectionRange();
       if (!range) return;
 
       range.deleteContents();
       range.insertNode(node);
-      webkitLastLineHack(window.document.body);
-      range = window.document.createRange();
+      webkitLastLineHack(document.body);
+
+      // work around weirdness where Opera will magically insert a new
+      // BR node when a BR node inside a span is moved around. makes
+      // sure the BR ends up outside of spans.
+      if (window.opera && isBR(node) && isSpan(node.parentNode)) {
+        var next = node.nextSibling, p = node.parentNode, outer = p.parentNode;
+        outer.insertBefore(node, p.nextSibling);
+        var textAfter = "";
+        for (; next && next.nodeType == 3; next = next.nextSibling) {
+          textAfter += next.nodeValue;
+          removeElement(next);
+        }
+        outer.insertBefore(makePartSpan(textAfter, document), node.nextSibling);
+      }
+      range = document.createRange();
       range.selectNode(node);
       range.collapse(false);
-      selectRange(range, window);
+      selectRange(range);
     }
 
-    select.insertNewlineAtCursor = function(window) {
-      insertNodeAtCursor(window, window.document.createElement("BR"));
+    select.insertNewlineAtCursor = function() {
+      insertNodeAtCursor(document.createElement("BR"));
     };
 
-    select.insertTabAtCursor = function(window) {
-      insertNodeAtCursor(window, window.document.createTextNode(fourSpaces));
+    select.insertTabAtCursor = function() {
+      insertNodeAtCursor(document.createTextNode(fourSpaces));
     };
 
     select.cursorPos = function(container, start) {
-      var range = selectionRange(window);
+      var range = selectionRange();
       if (!range) return;
 
       var topNode = select.selectionTopNode(container, start);
@@ -562,12 +614,13 @@ var select = {};
         range.setStartAfter(topNode);
       else
         range.setStartBefore(container);
-      return {node: topNode, offset: range.toString().length};
+
+      var text = range.toString();
+      return {node: topNode, offset: text.length};
     };
 
     select.setCursorPos = function(container, from, to) {
-      var win = container.ownerDocument.defaultView,
-          range = win.document.createRange();
+      var range = document.createRange();
 
       function setPoint(node, offset, side) {
         if (offset == 0 && node && !node.nextSibling) {
@@ -613,7 +666,7 @@ var select = {};
 
       to = to || from;
       if (setPoint(to.node, to.offset, "End") && setPoint(from.node, from.offset, "Start"))
-        selectRange(range, win);
+        selectRange(range);
     };
   }
 })();

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/stringstream.js

@@ -39,11 +39,13 @@ var stringStream = function(source){
   }
 
   return {
+    // peek: -> character
     // Return the next character in the stream.
     peek: function() {
       if (!ensureChars()) return null;
       return current.charAt(pos);
     },
+    // next: -> character
     // Get the next character, throw StopIteration if at end, check
     // for unused content.
     next: function() {
@@ -55,6 +57,7 @@ var stringStream = function(source){
       }
       return current.charAt(pos++);
     },
+    // get(): -> string
     // Return the characters iterated over since the last call to
     // .get().
     get: function() {
@@ -108,6 +111,8 @@ var stringStream = function(source){
     },
 
     // Utils built on top of the above
+    // more: -> boolean
+    // Produce true if the stream isn't empty.
     more: function() {
       return this.peek() !== null;
     },

data/{generators → lib/generators}/liquid_cms/templates/public/cms/codemirror/js/tokenizejavascript.js

@@ -65,7 +65,7 @@ var tokenizeJavaScript = (function() {
     };
   }
 
-  // The token reader, inteded to be used by the tokenizer from
+  // The token reader, intended to be used by the tokenizer from
   // tokenize.js (through jsTokenState). Advances the source stream
   // over a token, and returns an object containing the type and style
   // of that token.