gollum 2.4.4 → 2.4.5

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/mode/_test/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "ace-mode-creator",
+    "version": "0.1.0",
+    "dependencies": {
+        "connect": "",
+        "socket.io": ""
+    }
+}

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/mode/_test/test_highlight_rules.js

@@ -0,0 +1,144 @@
+var fs = require("fs");
+if (!fs.existsSync)
+    fs.existsSync = require("path").existsSync;
+
+require("amd-loader");
+
+var cwd = __dirname + "/";
+
+function generateTestData() {
+    var root = Array(5).join("../") + "/demo/kitchen-sink/docs";
+    var docs = fs.readdirSync(cwd + root);
+    var specialDocs = fs.readdirSync(cwd);
+    var modes = fs.readdirSync(cwd + "../").filter(function(x){
+        return /^\w+_highlight_rules.js$/.test(x);
+    }).map(function(x) {
+        return x.replace(/_highlight_rules.js$/, "");
+    });
+
+    console.log("Docs:", docs);
+    console.log("Modes:", modes);
+
+    docs.forEach(function(docName) {
+        var p = docName.toLowerCase().split(".");
+        if (!p[1])
+            return;
+        var modeName;
+        if (modes.indexOf(p[0]) != -1)
+            modeName = p[0];
+        else if (modes.indexOf(p[1]) != -1)
+            modeName = p[1];
+        else
+            modeName = {"txt": "text", cpp: "c_cpp"}[p[1]];
+
+        var filePath = "text_" + modeName + ".txt";
+        if (specialDocs.indexOf(filePath) == -1) {
+            filePath = root + "/" + docName;
+        }
+
+        var text = fs.readFileSync(cwd + filePath, "utf8");
+        try {
+            var Mode = require("../" + modeName).Mode;
+        } catch(e) {
+            console.warn("Can't load mode :" + modeName, e);
+            return;
+        }
+        var tokenizer = new Mode().getTokenizer();
+
+        var state = "start";
+        var data = text.split(/\n|\r|\r\n/).map(function(line) {
+            var tokens = tokenizer.getLineTokens(line, state);
+            state = tokens.state;
+            tokens = tokens.tokens;
+            return {
+                state: state,
+                data: tokens.map(function(x) {return [x.type, x.value]})
+            };
+        });
+        var jsonStr = JSON.stringify(data, null, 1);
+        jsonStr = jsonStr.replace(/\n {4}/g, " ").replace(/\n {3}]/g, " ]");
+        fs.writeFileSync(cwd + "tokens_" + modeName + ".json", jsonStr, "utf8");
+    });
+}
+
+function test(startAt) {
+    var docs = fs.readdirSync(cwd).filter(function(x) {
+        return /^tokens_\w+.json$/.test(x);
+    });
+    if (startAt && startAt > 1)
+        docs = docs.slice(startAt - 1);
+    docs.forEach(function(x, i) {
+        var modeName = x.match(/tokens_(.*).json/)[1];
+
+        console.log(padNumber(i+1, 3) + ") testing: \u001b[33m" + modeName + "\u001b[0m");
+
+        var text = fs.readFileSync(cwd + x, "utf8");
+        var data = JSON.parse(text);
+        var Mode = require("../" + modeName).Mode;
+        var tokenizer = new Mode().getTokenizer();
+
+        var state = "start";
+        data.forEach(function(lineData) {
+            lineData.values = [];
+            lineData.types = [];
+            lineData.data.forEach(function(x) {
+                lineData.types.push(x[0]);
+                lineData.values.push(x[1]);
+            });
+
+            var line = lineData.values.join("");
+
+            var tokens = tokenizer.getLineTokens(line, state);
+            var values = tokens.tokens.map(function(x) {return x.value;});
+            var types = tokens.tokens.map(function(x) {return x.type;});
+
+            var success = true;
+            testEqual([
+                lineData.state, tokens.state,
+                lineData.types, types,
+                lineData.values, values]);
+
+            state = lineData.state;
+        });
+    });
+
+    console.log("\u001b[32m" + "all ok" + "\u001b[0m");
+
+    function testEqual(a) {
+        var err;
+        if (a[0] !== a[1]) {
+            console.log(a[0],a[1]);
+            err = 1;
+        }
+
+        if ( a[2] + "" !== a[3] + "" || a[4] + "" !== a[5] + "") {
+            arrayDiff(a[2],a[3]);
+            arrayDiff(a[4],a[5]);
+            err = 1;
+        }
+        if (err) {
+            throw "error";
+        }
+    }
+
+    function arrayDiff(a1, a2) {
+        var l = Math.max(a1.length, a2.length);
+        var out = [];
+        for (var i = 0; i < l; i++) {
+            out.push("\n", padNumber(i+1, 3), ") ");
+            if (a1[i] !== a2[i])
+                out.push("\u001b[31m", a1[i], " != ", a2[i], "\u001b[0m");
+            else
+                out.push(a1[i]);
+        }
+        console.log(out.join(""));
+    }
+    function padNumber(num, digits) {
+        return ("      " + num).slice(-digits);
+    }
+}
+
+if (process.argv[2] == "gen")
+    generateTestData(process.argv.splice(3));
+else
+    test(parseInt(process.argv[2],10) || 0);

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/mode/_test/text_javascript.txt

@@ -0,0 +1,52 @@
+function foo(items, nada) {
+    for (var i=0; i<items.length; i++) {
+        alert(items[i] + "juhu\n");
+    }	// Real Tab.
+}
+
+regexp = /p|p/ // ends here
+
+r = /d{1,2}?f{e}++r*?\d+?[]r[^r-o\f\f[\f]?r{7}+r\{7}+rr--rr$^(?:d|s)(?=a|)(?!y)[]|$?|^*/ o
+a=/a/ jk = / / / / /
+ /************************************/
+/** total mess, tricky to highlight**/
+
+function () {
+	/**
+	 * docComment
+	 **/
+	r = /u\t*/
+	g = 1.00E^1, y = 1.2 + .2 + 052 + 0x25
+	t = ['d', '']
+}
+function () {
+	/* eee */
+}
+
+"s\
+s\u7824sss\u1"
+
+'\
+string'
+
+'
+string'
+
+"trailing space\   
+"         "    /not a regexp/g
+
+/**
+ *doc
+ */
+
+a = {
+	'a': b,
+	'g': function(t)
+	gta:function(a,b)
+}
+
+
+foo.protoype.d = function(a, b,
+                          c, d)
+foo.d =function(a,     b)
+foo.d =function(a,  /*****/ d"string"   

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/mode/_test/tokens_c9search.json

@@ -0,0 +1,175 @@
+[
+ {
+  "state": "start",
+  "data": [
+   [ "text", "Searching for 'var' in /workspace/configs" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "string", "configs/default.js" ],
+   [ "text", ":" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "    1" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var fs = require(\"fs\");" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t2" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var argv = require('optimist').argv;" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t3" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var path = require(\"path\");" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t5" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var clientExtensions = {};" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t6" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var clientDirs = fs.readdirSync(__dirname + \"/../plugins-client\");" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t7" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "for (var i = 0; i < clientDirs.length; i++) {" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t8" ],
+   [ "c9searchresults.text", ":     " ],
+   [ "c9searchresults.text", "var dir = clientDirs[i];" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t12" ],
+   [ "c9searchresults.text", ":     " ],
+   [ "c9searchresults.text", "var name = dir.split(\".\")[1];" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t16" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var projectDir = (argv.w && path.resolve(process.cwd(), argv.w)) || process.cwd();" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t17" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var fsUrl = \"/workspace\";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t19" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var port = argv.p || process.env.PORT || 3131;" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t20" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var host = argv.l || \"localhost\";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t22" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var config = {" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "string", "configs/local.js" ],
+   [ "text", ":" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t2" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var config = require(\"./default\");" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "string", "configs/packed.js" ],
+   [ "text", ":" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "c9searchresults.constant.numeric", "\t1" ],
+   [ "c9searchresults.text", ": " ],
+   [ "c9searchresults.text", "var config = require(\"./default\");" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "Found 15 matches in 3 files" ]
+  ]
+ }
+]

data/lib/gollum/frontend/public/gollum/livepreview/js/ace/lib/ace/mode/_test/tokens_c_cpp.json

@@ -0,0 +1,124 @@
+[
+ {
+  "state": "start",
+  "data": [
+   [ "comment", "// compound assignment operators" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "keyword", "#include" ],
+   [ "text", " " ],
+   [ "constant", "<iostream>" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "keyword.control", "using" ],
+   [ "text", " " ],
+   [ "keyword.operator", "namespace" ],
+   [ "text", " " ],
+   [ "identifier", "std" ],
+   [ "punctuation.operator", ";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": []
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "storage.type", "int" ],
+   [ "text", " " ],
+   [ "entity.name.function", "main" ],
+   [ "text", " " ],
+   [ "paren.lparen", "(" ],
+   [ "paren.rparen", ")" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "paren.lparen", "{" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "    " ],
+   [ "storage.type", "int" ],
+   [ "text", " " ],
+   [ "identifier", "a" ],
+   [ "punctuation.operator", "," ],
+   [ "text", " " ],
+   [ "identifier", "b" ],
+   [ "keyword.operator", "=" ],
+   [ "constant.numeric", "3" ],
+   [ "punctuation.operator", ";" ],
+   [ "text", " " ],
+   [ "comment", "/*" ],
+   [ "comment", " foobar */" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "    " ],
+   [ "identifier", "a" ],
+   [ "text", " " ],
+   [ "keyword.operator", "=" ],
+   [ "text", " " ],
+   [ "identifier", "b" ],
+   [ "punctuation.operator", ";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "    " ],
+   [ "identifier", "a" ],
+   [ "keyword.operator", "+" ],
+   [ "keyword.operator", "=" ],
+   [ "constant.numeric", "2" ],
+   [ "punctuation.operator", ";" ],
+   [ "text", " " ],
+   [ "comment", "// equivalent to a=a+2" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "    " ],
+   [ "identifier", "cout" ],
+   [ "text", " " ],
+   [ "keyword.operator", "<" ],
+   [ "keyword.operator", "<" ],
+   [ "text", " " ],
+   [ "identifier", "a" ],
+   [ "punctuation.operator", ";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "text", "    " ],
+   [ "keyword.control", "return" ],
+   [ "text", " " ],
+   [ "constant.numeric", "0" ],
+   [ "punctuation.operator", ";" ]
+  ]
+ },
+ {
+  "state": "start",
+  "data": [
+   [ "paren.rparen", "}" ]
+  ]
+ }
+]