gollum 3.1.2 → 3.1.3

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/tokenizer_dev.js

@@ -29,59 +29,32 @@
  * ***** END LICENSE BLOCK ***** */
 
 define(function(require, exports, module) {
+var BaseTokenizer = require("./tokenizer").Tokenizer;
 
+// tokenizing lines longer than this makes editor very slow
+var MAX_TOKEN_COUNT = 100000;
 /*
  * version of Tokenizer with additional logging
  * and infinite loop checks
  * can be used for developing/testing new modes
  **/
-var Tokenizer = function(rules, flag) {
-    flag = flag ? "g" + flag : "g";
-    this.rules = rules;
-
-    this.regExps = {};
-    this.matchMappings = {};
-    for ( var key in this.rules) {
-        var rule = this.rules[key];
-        var state = rule;
-        var ruleRegExps = [];
-        var matchTotal = 0;
-        var mapping = this.matchMappings[key] = {};
-
-        for ( var i = 0; i < state.length; i++) {
-
-            if (state[i].regex instanceof RegExp)
-                state[i].regex = state[i].regex.toString().slice(1, -1);
-
-            // Count number of matching groups. 2 extra groups from the full match
-            // And the catch-all on the end (used to force a match);
-            var matchcount = new RegExp("(?:(" + state[i].regex + ")|(.))").exec("a").length - 2;
-
-            // Replace any backreferences and offset appropriately.
-            var adjustedregex = state[i].regex.replace(/\\([0-9]+)/g, function (match, digit) {
-                return "\\" + (parseInt(digit, 10) + matchTotal + 1);
-            });
-
-            if (matchcount > 1 && state[i].token.length !== matchcount-1)
-                throw new Error("For " + state[i].regex + " the matching groups and length of the token array don't match (rule #" + i + " of state " + key + ")");
-
-            mapping[matchTotal] = {
-                rule: i,
-                len: matchcount
-            };
-            matchTotal += matchcount;
-
-            ruleRegExps.push(adjustedregex);
-        }
 
-        this.regExps[key] = new RegExp("(?:(" + ruleRegExps.join(")|(") + ")|(.))", flag);
-    }
-};
+var Tokenizer = function(rules) {
+    BaseTokenizer.call(this, rules);
 
-(function() {
+    /**
+    * Returns an object containing two properties: `tokens`, which contains all the tokens; and `state`, the current state.
+    * @returns {Object}
+    **/
     this.getLineTokens = function(line, startState) {
+        if (startState && typeof startState != "string") {
+            var stack = startState.slice(0);
+            startState = stack[0];
+        } else
+            var stack = [];
+
         var currentState = startState || "start";
-        var state = this.rules[currentState];
+        var state = this.states[currentState];
         var mapping = this.matchMappings[currentState];
         var re = this.regExps[currentState];
         re.lastIndex = 0;
@@ -107,99 +80,104 @@ var Tokenizer = function(rules, flag) {
         };
         initState();
         
-        var maxRecur = 10000;
+        var maxRecur = 100000;
         
         while (match = re.exec(line)) {
-            var type = "default.text";
+            var type = mapping.defaultToken;
             var rule = null;
-            var value = [match[0]];
+            var value = match[0];
+            var index = re.lastIndex;
+
+            if (index - value.length > lastIndex) {
+                var skipped = line.substring(lastIndex, index - value.length);
+                if (token.type == type) {
+                    token.value += skipped;
+                } else {
+                    if (token.type)
+                        tokens.push(token);
+                    token = {type: type, value: skipped};
+                }
+            }
 
             for (var i = 0; i < match.length-2; i++) {
                 if (match[i + 1] === undefined)
                     continue;
                 
                 if (!maxRecur--) {
-                    throw "infinite" + mapping[i].rule + currentState
+                    throw "infinite" + state[mapping[i]] + currentState
                 }
 
-                rule = state[mapping[i].rule];
+                rule = state[mapping[i]];
 
-                if (mapping[i].len > 1)
-                    value = match.slice(i+2, i+1+mapping[i].len);
-
-                // compute token type
-                if (typeof rule.token == "function")
-                    type = rule.token.apply(this, value);
+                if (rule.onMatch)
+                    type = rule.onMatch(value, currentState, stack);
                 else
                     type = rule.token;
 
                 if (rule.next) {
-                    currentState = rule.next;
-                    state = this.rules[currentState];
+                    if (typeof rule.next == "string")
+                        currentState = rule.next;
+                    else
+                        currentState = rule.next(currentState, stack);
+
+                    state = this.states[currentState];
+                    if (!state) {
+                        window.console && console.error && console.error(currentState, "doesn't exist");
+                        currentState = "start";
+                        state = this.states[currentState];
+                    }
                     mapping = this.matchMappings[currentState];
-                    lastIndex = re.lastIndex;
-
+                    lastIndex = index;
                     re = this.regExps[currentState];
-
-                    if (re === undefined) {
-                         throw new Error("You indicated a state of " + rule.next + " to go to, but it doesn't exist!");
-                    }
-
-                    re.lastIndex = lastIndex;
+                    re.lastIndex = index;
 
                     onStateChange();
                 }
                 break;
             }
 
-            if (value[0]) {
+            if (value) {
                 if (typeof type == "string") {
-                    value = [value.join("")];
-                    type = [type];
-                }
-                for (var i = 0; i < value.length; i++) {
-                    if (!value[i])
-                        continue;
-
-                    var mergeable = (!rule || rule.merge || type[i] === "text") && token.type === type[i];
-                    
-                    if (false && mergeable) {
-                        token.value += value[i];
+                    if ((!rule || rule.merge !== false) && token.type === type) {
+                        token.value += value;
                     } else {
-                        if (token.type) {
-                            token.stateTransitions = stateTransitions;
+                        if (token.type)
                             tokens.push(token);
-                            initState()
-                        }
-                        
-                        token = {
-                            type: type[i],
-                            value: value[i],
-                            state: currentState,
-                            mergeable: mergeable
-                        };
+                        token = {type: type, value: value};
                     }
+                } else {
+                    if (token.type)
+                        tokens.push(token);
+                    token = {type: null, value: ""};
+                    for (var i = 0; i < type.length; i++)
+                        tokens.push(type[i]);
                 }
             }
 
             if (lastIndex == line.length)
                 break;
 
-            lastIndex = re.lastIndex;
+            lastIndex = index;
+
+            if (tokens.length > MAX_TOKEN_COUNT) {
+                token.value += line.substr(lastIndex);
+                currentState = "start"
+                break;
+            }
         }
 
-        if (token.type) {
-            token.stateTransitions = stateTransitions;
+        if (token.type)
             tokens.push(token);
-        }
 
         return {
             tokens : tokens,
-            state : currentState
+            state : stack.length ? stack : currentState
         };
     };
 
-}).call(Tokenizer.prototype);
+};
+
+Tokenizer.prototype = BaseTokenizer.prototype;
 
 exports.Tokenizer = Tokenizer;
 });

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/tokenizer_test.js

@@ -0,0 +1,97 @@
+/* ***** 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 ***** */
+
+ if (typeof process !== "undefined") {
+    require("amd-loader");
+ }
+
+define(function(require, exports, module) {
+"use strict";
+
+var Tokenizer = require("./tokenizer").Tokenizer;
+var assert = require("./test/assertions");
+
+module.exports = {
+    "test: createSplitterRegexp" : function() {
+        var t = new Tokenizer({});
+        var re = t.createSplitterRegexp("(a)(b)(?=[x)(])");
+        assert.equal(re.source, "(a)(b)");
+        var re = t.createSplitterRegexp("xc(?=([x)(]))");
+        assert.equal(re.source, "xc");
+        var re = t.createSplitterRegexp("(xc(?=([x)(])))");
+        assert.equal(re.source, "(xc)");
+        var re = t.createSplitterRegexp("(?=r)[(?=)](?=([x)(]))");
+        assert.equal(re.source, "(?=r)[(?=)]");
+        var re = t.createSplitterRegexp("(?=r)[(?=)](\\?=t)");
+        assert.equal(re.source, "(?=r)[(?=)](\\?=t)");
+        var re = t.createSplitterRegexp("[(?=)](\\?=t)");
+        assert.equal(re.source, "[(?=)](\\?=t)");
+    },
+
+    "test: removeCapturingGroups" : function() {
+        var t = new Tokenizer({});
+        var re = t.removeCapturingGroups("(ax(by))[()]");
+        assert.equal(re, "(?:ax(?:by))[()]");
+    },
+    
+    "test: broken highlight rules": function() {
+        var t = new Tokenizer({
+            start: [{ 
+                token: 's',
+                regex: '&&&|^^^' 
+            }, {
+                defaultToken: "def"
+            }],
+            state1: [{ 
+                token: 'x',
+                regex: /\b([\w]*)(\s*)((?::)?)/
+            }]
+        });
+        var errorReports = 0;
+        t.reportError = function() { errorReports++; };
+        var tokens = t.getLineTokens("x|", "start");
+        assert.deepEqual(tokens, {
+            tokens: [{value: 'x|', type: 'overflow'}],
+            state: 'start'
+        });
+        var tokens = t.getLineTokens("x|", "state1");
+        assert.deepEqual(tokens, {
+            tokens: [{value: 'x', type: 'x'}, {value: '|', type: 'overflow'}],
+            state: 'start'
+        });
+        assert.equal(errorReports, 2);
+    }, 
+};
+
+});
+
+if (typeof module !== "undefined" && module === require.main) {
+    require("asyncjs").test.testcase(module.exports).exec()
+}

data/lib/gollum/public/gollum/livepreview/js/ace/lib/ace/tooltip.js

@@ -0,0 +1,138 @@
+/* ***** 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 dom = require("./lib/dom");
+
+/**
+ * @class Tooltip
+ **/
+
+/**
+ * @param {Element} parentNode
+ *
+ * @constructor
+ **/
+function Tooltip (parentNode) {
+    this.isOpen = false;
+    this.$element = null;
+    this.$parentNode = parentNode;
+}
+
+(function() {
+    this.$init = function() {
+        this.$element = dom.createElement("div");
+        this.$element.className = "ace_tooltip";
+        this.$element.style.display = "none";
+        this.$parentNode.appendChild(this.$element);
+        return this.$element;
+    };
+
+    /**
+     * @returns {Element}
+     **/
+    this.getElement = function() {
+        return this.$element || this.$init();
+    };
+
+    /**
+     * @param {String} text
+     **/
+    this.setText = function(text) {
+        dom.setInnerText(this.getElement(), text);
+    };
+
+    /**
+     * @param {String} html
+     **/
+    this.setHtml = function(html) {
+        this.getElement().innerHTML = html;
+    };
+
+    /**
+     * @param {Number} x
+     * @param {Number} y
+     **/
+    this.setPosition = function(x, y) {
+        this.getElement().style.left = x + "px";
+        this.getElement().style.top = y + "px";
+    };
+
+    /**
+     * @param {String} className
+     **/
+    this.setClassName = function(className) {
+        dom.addCssClass(this.getElement(), className);
+    };
+
+    /**
+     * @param {String} text
+     * @param {Number} x
+     * @param {Number} y
+     **/
+    this.show = function(text, x, y) {
+        if (text != null)
+            this.setText(text);
+        if (x != null && y != null)
+            this.setPosition(x, y);
+        if (!this.isOpen) {
+            this.getElement().style.display = "block";
+            this.isOpen = true;
+        }
+    };
+
+    this.hide = function() {
+        if (this.isOpen) {
+            this.getElement().style.display = "none";
+            this.isOpen = false;
+        }
+    };
+
+    /**
+     * @returns {Number}
+     **/
+    this.getHeight = function() {
+        return this.getElement().offsetHeight;
+    };
+
+    /**
+     * @returns {Number}
+     **/
+    this.getWidth = function() {
+        return this.getElement().offsetWidth;
+    };
+
+}).call(Tooltip.prototype);
+
+exports.Tooltip = Tooltip;
+});