gollum 3.1.2 → 3.1.3

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/mode/xml_highlight_rules.js

@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2010, Ajax.org B.V.
  * All rights reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *     * Redistributions of source code must retain the above copyright
@@ -14,7 +14,7 @@
  *     * Neither the name of Ajax.org B.V. nor the
  *       names of its contributors may be used to endorse or promote products
  *       derived from this software without specific prior written permission.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -32,70 +32,210 @@ define(function(require, exports, module) {
 "use strict";
 
 var oop = require("../lib/oop");
-var xmlUtil = require("./xml_util");
 var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
-var XmlHighlightRules = function() {
-
-    // regexp must not have capturing parentheses
-    // regexps are ordered -> the first match is used
+var XmlHighlightRules = function(normalize) {
     this.$rules = {
-        start : [{
-            token : "text",
-            regex : "<\\!\\[CDATA\\[",
-            next : "cdata"
-        }, {
-            token : "xml-pe",
-            regex : "<\\?.*?\\?>"
+        start : [
+            {token : "string.cdata.xml", regex : "<\\!\\[CDATA\\[", next : "cdata"},
+            {
+                token : ["punctuation.xml-decl.xml", "keyword.xml-decl.xml"],
+                regex : "(<\\?)(xml)(?=[\\s])", next : "xml_decl", caseInsensitive: true
+            },
+            {
+                token : ["punctuation.instruction.xml", "keyword.instruction.xml"],
+                regex : "(<\\?)([-_a-zA-Z0-9]+)", next : "processing_instruction",
+            },
+            {token : "comment.xml", regex : "<\\!--", next : "comment"},
+            {
+                token : ["xml-pe.doctype.xml", "xml-pe.doctype.xml"],
+                regex : "(<\\!)(DOCTYPE)(?=[\\s])", next : "doctype", caseInsensitive: true
+            },
+            {include : "tag"},
+            {token : "text.end-tag-open.xml", regex: "</"},
+            {token : "text.tag-open.xml", regex: "<"},
+            {include : "reference"},
+            {defaultToken : "text.xml"}
+        ],
+
+        xml_decl : [{
+            token : "entity.other.attribute-name.decl-attribute-name.xml",
+            regex : "(?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+"
         }, {
-            token : "comment",
-            merge : true,
-            regex : "<\\!--",
-            next : "comment"
+            token : "keyword.operator.decl-attribute-equals.xml",
+            regex : "="
         }, {
-            token : "xml-pe",
-            regex : "<\\!.*?>"
+            include: "whitespace"
         }, {
-            token : "meta.tag", // opening tag
-            regex : "<\\/?",
-            next : "tag"
+            include: "string"
         }, {
-            token : "text",
+            token : "punctuation.xml-decl.xml",
+            regex : "\\?>",
+            next : "start"
+        }],
+
+        processing_instruction : [
+            {token : "punctuation.instruction.xml", regex : "\\?>", next : "start"},
+            {defaultToken : "instruction.xml"}
+        ],
+
+        doctype : [
+            {include : "whitespace"},
+            {include : "string"},
+            {token : "xml-pe.doctype.xml", regex : ">", next : "start"},
+            {token : "xml-pe.xml", regex : "[-_a-zA-Z0-9:]+"},
+            {token : "punctuation.int-subset", regex : "\\[", push : "int_subset"}
+        ],
+
+        int_subset : [{
+            token : "text.xml",
             regex : "\\s+"
         }, {
-            token : "constant.character.entity",
+            token: "punctuation.int-subset.xml",
+            regex: "]",
+            next: "pop"
+        }, {
+            token : ["punctuation.markup-decl.xml", "keyword.markup-decl.xml"],
+            regex : "(<\\!)([-_a-zA-Z0-9]+)",
+            push : [{
+                token : "text",
+                regex : "\\s+"
+            },
+            {
+                token : "punctuation.markup-decl.xml",
+                regex : ">",
+                next : "pop"
+            },
+            {include : "string"}]
+        }],
+
+        cdata : [
+            {token : "string.cdata.xml", regex : "\\]\\]>", next : "start"},
+            {token : "text.xml", regex : "\\s+"},
+            {token : "text.xml", regex : "(?:[^\\]]|\\](?!\\]>))+"}
+        ],
+
+        comment : [
+            {token : "comment.xml", regex : "-->", next : "start"},
+            {defaultToken : "comment.xml"}
+        ],
+
+        reference : [{
+            token : "constant.language.escape.reference.xml",
             regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
+        }],
+
+        attr_reference : [{
+            token : "constant.language.escape.reference.attribute-value.xml",
+            regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
+        }],
+
+        tag : [{
+            token : ["meta.tag.punctuation.tag-open.xml", "meta.tag.punctuation.end-tag-open.xml", "meta.tag.tag-name.xml"],
+            regex : "(?:(<)|(</))((?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+)",
+            next: [
+                {include : "attributes"},
+                {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}
+            ]
+        }],
+
+        tag_whitespace : [
+            {token : "text.tag-whitespace.xml", regex : "\\s+"}
+        ],
+        // for doctype and processing instructions
+        whitespace : [
+            {token : "text.whitespace.xml", regex : "\\s+"}
+        ],
+
+        // for doctype and processing instructions
+        string: [{
+            token : "string.xml",
+            regex : "'",
+            push : [
+                {token : "string.xml", regex: "'", next: "pop"},
+                {defaultToken : "string.xml"}
+            ]
         }, {
-            token : "text",
-            regex : "[^<]+"
+            token : "string.xml",
+            regex : '"',
+            push : [
+                {token : "string.xml", regex: '"', next: "pop"},
+                {defaultToken : "string.xml"}
+            ]
         }],
-        
-        cdata : [{
-            token : "text",
-            regex : "\\]\\]>",
-            next : "start"
+
+        attributes: [{
+            token : "entity.other.attribute-name.xml",
+            regex : "(?:[-_a-zA-Z0-9]+:)?[-_a-zA-Z0-9]+"
         }, {
-            token : "text",
-            regex : "\\s+"
+            token : "keyword.operator.attribute-equals.xml",
+            regex : "="
+        }, {
+            include: "tag_whitespace"
         }, {
-            token : "text",
-            regex : "(?:[^\\]]|\\](?!\\]>))+"
+            include: "attribute_value"
         }],
 
-        comment : [{
-            token : "comment",
-            regex : ".*?-->",
-            next : "start"
+        attribute_value: [{
+            token : "string.attribute-value.xml",
+            regex : "'",
+            push : [
+                {token : "string.attribute-value.xml", regex: "'", next: "pop"},
+                {include : "attr_reference"},
+                {defaultToken : "string.attribute-value.xml"}
+            ]
         }, {
-            token : "comment",
-            merge : true,
-            regex : ".+"
+            token : "string.attribute-value.xml",
+            regex : '"',
+            push : [
+                {token : "string.attribute-value.xml", regex: '"', next: "pop"},
+                {include : "attr_reference"},
+                {defaultToken : "string.attribute-value.xml"}
+            ]
         }]
     };
-    
-    xmlUtil.tag(this.$rules, "tag", "start");
+
+    if (this.constructor === XmlHighlightRules)
+        this.normalizeRules();
 };
 
+
+(function() {
+
+    this.embedTagRules = function(HighlightRules, prefix, tag){
+        this.$rules.tag.unshift({
+            token : ["meta.tag.punctuation.tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],
+            regex : "(<)(" + tag + "(?=\\s|>|$))",
+            next: [
+                {include : "attributes"},
+                {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : prefix + "start"}
+            ]
+        });
+
+        this.$rules[tag + "-end"] = [
+            {include : "attributes"},
+            {token : "meta.tag.punctuation.tag-close.xml", regex : "/?>",  next: "start",
+                onMatch : function(value, currentState, stack) {
+                    stack.splice(0);
+                    return this.token;
+            }}
+        ]
+
+        this.embedRules(HighlightRules, prefix, [{
+            token: ["meta.tag.punctuation.end-tag-open.xml", "meta.tag." + tag + ".tag-name.xml"],
+            regex : "(</)(" + tag + "(?=\\s|>|$))",
+            next: tag + "-end"
+        }, {
+            token: "string.cdata.xml",
+            regex : "<\\!\\[CDATA\\["
+        }, {
+            token: "string.cdata.xml",
+            regex : "\\]\\]>"
+        }]);
+    };
+
+}).call(TextHighlightRules.prototype);
+
 oop.inherits(XmlHighlightRules, TextHighlightRules);
 
 exports.XmlHighlightRules = XmlHighlightRules;

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/mode/xml_test.js

@@ -51,14 +51,14 @@ module.exports = {
         assert.ok(tokenizer instanceof Tokenizer);
 
         var tokens = tokenizer.getLineTokens("<juhu>", "start").tokens;
-        assert.equal("meta.tag", tokens[0].type);
+        assert.equal("meta.tag.punctuation.tag-open.xml", tokens[0].type);
     },
 
     "test: toggle comment lines should not do anything" : function() {
-        var session = new EditSession(["  abc", "cde", "fg"]);
+        var session = new EditSession(["    abc", "  cde", "fg"]);
 
         this.mode.toggleCommentLines("start", session, 0, 1);
-        assert.equal(["  abc", "cde", "fg"].join("\n"), session.toString());
+        assert.equal(["  <!--  abc-->", "  <!--cde-->", "fg"].join("\n"), session.toString());
     },
 
     "test: next line indent should be the same as the current line indent" : function() {

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/mode/xml_worker.js

@@ -0,0 +1,92 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Distributed under the BSD license:
+ *
+ * Copyright (c) 2010, Ajax.org B.V.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of Ajax.org B.V. nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+define(function(require, exports, module) {
+"use strict";
+
+var oop = require("../lib/oop");
+var lang = require("../lib/lang");
+var Mirror = require("../worker/mirror").Mirror;
+var DOMParser = require("./xml/dom-parser").DOMParser;
+
+var Worker = exports.Worker = function(sender) {
+    Mirror.call(this, sender);
+    this.setTimeout(400);
+    this.context = null;
+};
+
+oop.inherits(Worker, Mirror);
+
+(function() {
+
+    this.setOptions = function(options) {
+        this.context = options.context;
+    };
+
+    this.onUpdate = function() {
+        var value = this.doc.getValue();
+        if (!value)
+            return;
+        var parser = new DOMParser();
+        var errors = [];
+        parser.options.errorHandler = {
+            fatalError: function(fullMsg, errorMsg, locator) {
+                errors.push({
+                    row: locator.lineNumber,
+                    column: locator.columnNumber,
+                    text: errorMsg,
+                    type: "error"
+                });
+            },
+            error: function(fullMsg, errorMsg, locator) {
+                errors.push({
+                    row: locator.lineNumber,
+                    column: locator.columnNumber,
+                    text: errorMsg,
+                    type: "error"
+                });
+            },
+            warning: function(fullMsg, errorMsg, locator) {
+                errors.push({
+                    row: locator.lineNumber,
+                    column: locator.columnNumber,
+                    text: errorMsg,
+                    type: "warning"
+                });
+            }
+        };
+        
+        parser.parseFromString(value);
+        this.sender.emit("error", errors);
+    };
+
+}).call(Worker.prototype);
+
+});

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/mode/xquery.js

@@ -33,41 +33,51 @@ define(function(require, exports, module) {
 var WorkerClient = require("../worker/worker_client").WorkerClient;
 var oop = require("../lib/oop");
 var TextMode = require("./text").Mode;
-var Tokenizer = require("../tokenizer").Tokenizer;
-var XQueryHighlightRules = require("./xquery_highlight_rules").XQueryHighlightRules;
-//var XQueryBehaviour = require("./behaviour/xquery").XQueryBehaviour;
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+var XQueryLexer = require("./xquery/xquery_lexer").XQueryLexer;
 var Range = require("../range").Range;
-var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour;
+var XQueryBehaviour = require("./behaviour/xquery").XQueryBehaviour;
 var CStyleFoldMode = require("./folding/cstyle").FoldMode;
+var Anchor = require("../anchor").Anchor;
 
-
-var Mode = function(parent) {
-    this.$tokenizer   = new Tokenizer(new XQueryHighlightRules().getRules());
-    this.$behaviour   = new CstyleBehaviour(parent);
+var Mode = function() {
+    this.$tokenizer   = new XQueryLexer();
+    this.$behaviour   = new XQueryBehaviour();
     this.foldingRules = new CStyleFoldMode();
+    this.$highlightRules = new TextHighlightRules();
 };
-
 oop.inherits(Mode, TextMode);
 
 (function() {
+    
+    this.completer = {
+        getCompletions: function(editor, session, pos, prefix, callback) {
+            if (!session.$worker)
+                return callback();
+            session.$worker.emit("complete", { data: { pos: pos, prefix: prefix } });
+            session.$worker.on("complete", function(e){
+                callback(null, e.data);
+            });
+        }
+    };
 
     this.getNextLineIndent = function(state, line, tab) {
-      var indent = this.$getIndent(line);
-      var match = line.match(/\s*(?:then|else|return|[{\(]|<\w+>)\s*$/);
-      if (match)
-        indent += tab;
+        var indent = this.$getIndent(line);
+        var match = line.match(/\s*(?:then|else|return|[{\(]|<\w+>)\s*$/);
+        if (match)
+            indent += tab;
         return indent;
     };
     
     this.checkOutdent = function(state, line, input) {
-      if (! /^\s+$/.test(line))
+        if (! /^\s+$/.test(line))
             return false;
 
-        return /^\s*[\}\)]/.test(input);
+        return (/^\s*[\}\)]/).test(input);
     };
     
     this.autoOutdent = function(state, doc, row) {
-      var line = doc.getLine(row);
+        var line = doc.getLine(row);
         var match = line.match(/^(\s*[\}\)])/);
 
         if (!match) return 0;
@@ -81,15 +91,6 @@ oop.inherits(Mode, TextMode);
         doc.replace(new Range(row, 0, row, column-1), indent);
     };
 
-    this.$getIndent = function(line) {
-        var match = line.match(/^(\s+)/);
-        if (match) {
-            return match[1];
-        }
-
-        return "";
-    };
-    
     this.toggleCommentLines = function(state, doc, startRow, endRow) {
         var i, line;
         var outdent = true;
@@ -114,83 +115,101 @@ oop.inherits(Mode, TextMode);
     };
     
     this.createWorker = function(session) {
-        this.$deltas = [];
-        var worker = new WorkerClient(["ace"], "ace/mode/xquery_worker", "XQueryWorker");
+        
+      var worker = new WorkerClient(["ace"], "ace/mode/xquery_worker", "XQueryWorker");
         var that = this;
 
-        session.getDocument().on('change', function(evt){
-          that.$deltas.push(evt.data);
-        });
-
         worker.attachToDocument(session.getDocument());
         
-        worker.on("start", function(e) {
-          //console.log("start");
-          that.$deltas = [];
-        });
-
-        worker.on("error", function(e) {
-          session.setAnnotations([e.data]);
-        });
-        
         worker.on("ok", function(e) {
-            session.clearAnnotations();
+          session.clearAnnotations();
         });
         
+        worker.on("markers", function(e) {
+          session.clearAnnotations();
+          that.addMarkers(e.data, session);
+        });
+ 
         worker.on("highlight", function(tokens) {
-          var firstRow = 0;
-          var lastRow = session.getLength() - 1;
+          that.$tokenizer.tokens = tokens.data.tokens;
+          that.$tokenizer.lines  = session.getDocument().getAllLines();
           
-          var lines = tokens.data.lines;
-          var states = tokens.data.states;
-          
-          for(var i=0; i < that.$deltas.length; i++)
-          {
-            var delta = that.$deltas[i];
-         
-            if (delta.action === "insertLines")
-            {
-              var newLineCount = delta.lines.length;
-              for (var i = 0; i < newLineCount; i++) {
-                lines.splice(delta.range.start.row + i, 0, undefined);
-                states.splice(delta.range.start.row + i, 0, undefined);
-              }
-            }
-            else if (delta.action === "insertText")
-            {
-              if (session.getDocument().isNewLine(delta.text))
-              {
-                lines.splice(delta.range.end.row, 0, undefined);
-                states.splice(delta.range.end.row, 0, undefined);
-              } else {
-                lines[delta.range.start.row] = undefined;
-                states[delta.range.start.row] = undefined;
-              } 
-            } else if (delta.action === "removeLines") {
-              var oldLineCount = delta.lines.length;
-              lines.splice(delta.range.start.row, oldLineCount);
-              states.splice(delta.range.start.row, oldLineCount);
-            } else if (delta.action === "removeText") {
-              if (session.getDocument().isNewLine(delta.text))
-              {
-                lines[delta.range.start.row] = undefined;
-                lines.splice(delta.range.end.row, 1);
-                states[delta.range.start.row] = undefined;
-                states.splice(delta.range.end.row, 1);
-              } else {
-                lines[delta.range.start.row] = undefined;
-                states[delta.range.start.row] = undefined;
-              }
-            }           
+          var rows = Object.keys(that.$tokenizer.tokens);
+          for(var i=0; i < rows.length; i++) {
+            var row = parseInt(rows[i]);
+            delete session.bgTokenizer.lines[row];
+            delete session.bgTokenizer.states[row];
+            session.bgTokenizer.fireUpdateEvent(row, row);
           }
-          session.bgTokenizer.lines = lines;
-          session.bgTokenizer.states = states;
-          session.bgTokenizer.fireUpdateEvent(firstRow, lastRow);
         });
         
         return worker;
     };
-    
+
+    this.removeMarkers = function(session) {
+        var markers = session.getMarkers(false);
+        for (var id in markers) {
+            // All language analysis' markers are prefixed with language_highlight
+            if (markers[id].clazz.indexOf('language_highlight_') === 0) {
+                session.removeMarker(id);
+            }
+        }
+        for (var i = 0; i < session.markerAnchors.length; i++) {
+            session.markerAnchors[i].detach();
+        }
+        session.markerAnchors = [];
+    };
+
+    this.addMarkers = function(annos, mySession) {
+        var _self = this;
+        
+        if (!mySession.markerAnchors) mySession.markerAnchors = [];
+        this.removeMarkers(mySession);
+        mySession.languageAnnos = [];
+        annos.forEach(function(anno) {
+            // Certain annotations can temporarily be disabled
+            //if (_self.disabledMarkerTypes[anno.type])
+            //    return;
+            // Multi-line markers are not supported, and typically are a result from a bad error recover, ignore
+            //if(anno.pos.el && anno.pos.sl !== anno.pos.el)
+            //    return;
+            // Using anchors here, to automaticaly move markers as text around the marker is updated
+            var anchor = new Anchor(mySession.getDocument(), anno.pos.sl, anno.pos.sc || 0);
+            mySession.markerAnchors.push(anchor);
+            var markerId;
+            var colDiff = anno.pos.ec - anno.pos.sc;
+            var rowDiff = anno.pos.el - anno.pos.sl;
+            var gutterAnno = {
+                guttertext: anno.message,
+                type: anno.level || "warning",
+                text: anno.message
+                // row will be filled in updateFloat()
+            };
+
+            function updateFloat(single) {
+                if (markerId)
+                    mySession.removeMarker(markerId);
+                gutterAnno.row = anchor.row;
+                if (anno.pos.sc !== undefined && anno.pos.ec !== undefined) {
+                    var range = new Range(anno.pos.sl, anno.pos.sc, anno.pos.el, anno.pos.ec);
+                    //var range = Range.fromPoints(anchor.getPosition(), {
+                    //    row: anchor.row + rowDiff,
+                    //    column: anchor.column + colDiff
+                    //});
+                    markerId = mySession.addMarker(range, "language_highlight_" + (anno.type ? anno.type : "default"));
+                }
+                if (single) mySession.setAnnotations(mySession.languageAnnos);
+            }
+            updateFloat();
+            anchor.on("change", function() {
+                updateFloat(true);
+            });
+            if (anno.message) mySession.languageAnnos.push(gutterAnno);
+        });
+        mySession.setAnnotations(mySession.languageAnnos);
+    };    
+        
+    this.$id = "ace/mode/xquery";
 }).call(Mode.prototype);
 
 exports.Mode = Mode;