/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to js/ace/mode-lua.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-31 06:15:46 UTC
  • mfrom: (90.1.20 lenasys2)
  • Revision ID: gustav.hartvigsson@gmail.com-20130531061546-vj8z28sq375kvghq
Merged Jonsson:s changes:
Fixed the layout on cms index so the arrows and dots marks expanded objects.
Fixed so the course content is sorted by course occasion and not by name

Show diffs side-by-side

added added

removed removed

Lines of Context:
js/ace/mode-lua.js
 
1
/* ***** BEGIN LICENSE BLOCK *****
 
2
 * Distributed under the BSD license:
 
3
 *
 
4
 * Copyright (c) 2010, Ajax.org B.V.
 
5
 * All rights reserved.
 
6
 * 
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are met:
 
9
 *     * Redistributions of source code must retain the above copyright
 
10
 *       notice, this list of conditions and the following disclaimer.
 
11
 *     * Redistributions in binary form must reproduce the above copyright
 
12
 *       notice, this list of conditions and the following disclaimer in the
 
13
 *       documentation and/or other materials provided with the distribution.
 
14
 *     * Neither the name of Ajax.org B.V. nor the
 
15
 *       names of its contributors may be used to endorse or promote products
 
16
 *       derived from this software without specific prior written permission.
 
17
 * 
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
21
 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
 
22
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 
25
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 *
 
29
 * ***** END LICENSE BLOCK ***** */
 
30
 
 
31
define('ace/mode/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/lua_highlight_rules', 'ace/mode/folding/lua', 'ace/range'], function(require, exports, module) {
 
32
 
 
33
 
 
34
var oop = require("../lib/oop");
 
35
var TextMode = require("./text").Mode;
 
36
var Tokenizer = require("../tokenizer").Tokenizer;
 
37
var LuaHighlightRules = require("./lua_highlight_rules").LuaHighlightRules;
 
38
var LuaFoldMode = require("./folding/lua").FoldMode;
 
39
var Range = require("../range").Range;
 
40
 
 
41
var Mode = function() {
 
42
    this.$tokenizer = new Tokenizer(new LuaHighlightRules().getRules());
 
43
    this.foldingRules = new LuaFoldMode();
 
44
};
 
45
oop.inherits(Mode, TextMode);
 
46
 
 
47
(function() {
 
48
   
 
49
    this.lineCommentStart = "--";
 
50
    this.blockComment = {start: "--[", end: "]--"};
 
51
    
 
52
    var indentKeywords = {
 
53
        "function": 1,
 
54
        "then": 1,
 
55
        "do": 1,
 
56
        "else": 1,
 
57
        "elseif": 1,
 
58
        "repeat": 1,
 
59
        "end": -1,
 
60
        "until": -1
 
61
    };
 
62
    var outdentKeywords = [
 
63
        "else",
 
64
        "elseif",
 
65
        "end",
 
66
        "until"
 
67
    ];
 
68
 
 
69
    function getNetIndentLevel(tokens) {
 
70
        var level = 0;
 
71
        for (var i = 0; i < tokens.length; i++) {
 
72
            var token = tokens[i];
 
73
            if (token.type == "keyword") {
 
74
                if (token.value in indentKeywords) {
 
75
                    level += indentKeywords[token.value];
 
76
                }
 
77
            } else if (token.type == "paren.lparen") {
 
78
                level ++;
 
79
            } else if (token.type == "paren.rparen") {
 
80
                level --;
 
81
            }
 
82
        }
 
83
        if (level < 0) {
 
84
            return -1;
 
85
        } else if (level > 0) {
 
86
            return 1;
 
87
        } else {
 
88
            return 0;
 
89
        }
 
90
    }
 
91
 
 
92
    this.getNextLineIndent = function(state, line, tab) {
 
93
        var indent = this.$getIndent(line);
 
94
        var level = 0;
 
95
 
 
96
        var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
 
97
        var tokens = tokenizedLine.tokens;
 
98
 
 
99
        if (state == "start") {
 
100
            level = getNetIndentLevel(tokens);
 
101
        }
 
102
        if (level > 0) {
 
103
            return indent + tab;
 
104
        } else if (level < 0 && indent.substr(indent.length - tab.length) == tab) {
 
105
            if (!this.checkOutdent(state, line, "\n")) {
 
106
                return indent.substr(0, indent.length - tab.length);
 
107
            }
 
108
        }
 
109
        return indent;
 
110
    };
 
111
 
 
112
    this.checkOutdent = function(state, line, input) {
 
113
        if (input != "\n" && input != "\r" && input != "\r\n")
 
114
            return false;
 
115
 
 
116
        if (line.match(/^\s*[\)\}\]]$/))
 
117
            return true;
 
118
 
 
119
        var tokens = this.$tokenizer.getLineTokens(line.trim(), state).tokens;
 
120
 
 
121
        if (!tokens || !tokens.length)
 
122
            return false;
 
123
 
 
124
        return (tokens[0].type == "keyword" && outdentKeywords.indexOf(tokens[0].value) != -1);
 
125
    };
 
126
 
 
127
    this.autoOutdent = function(state, session, row) {
 
128
        var prevLine = session.getLine(row - 1);
 
129
        var prevIndent = this.$getIndent(prevLine).length;
 
130
        var prevTokens = this.$tokenizer.getLineTokens(prevLine, "start").tokens;
 
131
        var tabLength = session.getTabString().length;
 
132
        var expectedIndent = prevIndent + tabLength * getNetIndentLevel(prevTokens);
 
133
        var curIndent = this.$getIndent(session.getLine(row)).length;
 
134
        if (curIndent < expectedIndent) {
 
135
            return;
 
136
        }
 
137
        session.outdentRows(new Range(row, 0, row + 2, 0));
 
138
    };
 
139
 
 
140
}).call(Mode.prototype);
 
141
 
 
142
exports.Mode = Mode;
 
143
});
 
144
 
 
145
define('ace/mode/lua_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
 
146
 
 
147
 
 
148
var oop = require("../lib/oop");
 
149
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
150
 
 
151
var LuaHighlightRules = function() {
 
152
 
 
153
    var keywords = (
 
154
        "break|do|else|elseif|end|for|function|if|in|local|repeat|"+
 
155
         "return|then|until|while|or|and|not"
 
156
    );
 
157
 
 
158
    var builtinConstants = ("true|false|nil|_G|_VERSION");
 
159
 
 
160
    var functions = (
 
161
        "string|xpcall|package|tostring|print|os|unpack|require|"+
 
162
        "getfenv|setmetatable|next|assert|tonumber|io|rawequal|"+
 
163
        "collectgarbage|getmetatable|module|rawset|math|debug|"+
 
164
        "pcall|table|newproxy|type|coroutine|_G|select|gcinfo|"+
 
165
        "pairs|rawget|loadstring|ipairs|_VERSION|dofile|setfenv|"+
 
166
        "load|error|loadfile|"+
 
167
 
 
168
        "sub|upper|len|gfind|rep|find|match|char|dump|gmatch|"+
 
169
        "reverse|byte|format|gsub|lower|preload|loadlib|loaded|"+
 
170
        "loaders|cpath|config|path|seeall|exit|setlocale|date|"+
 
171
        "getenv|difftime|remove|time|clock|tmpname|rename|execute|"+
 
172
        "lines|write|close|flush|open|output|type|read|stderr|"+
 
173
        "stdin|input|stdout|popen|tmpfile|log|max|acos|huge|"+
 
174
        "ldexp|pi|cos|tanh|pow|deg|tan|cosh|sinh|random|randomseed|"+
 
175
        "frexp|ceil|floor|rad|abs|sqrt|modf|asin|min|mod|fmod|log10|"+
 
176
        "atan2|exp|sin|atan|getupvalue|debug|sethook|getmetatable|"+
 
177
        "gethook|setmetatable|setlocal|traceback|setfenv|getinfo|"+
 
178
        "setupvalue|getlocal|getregistry|getfenv|setn|insert|getn|"+
 
179
        "foreachi|maxn|foreach|concat|sort|remove|resume|yield|"+
 
180
        "status|wrap|create|running|"+
 
181
        "__add|__sub|__mod|__unm|__concat|__lt|__index|__call|__gc|__metatable|"+
 
182
         "__mul|__div|__pow|__len|__eq|__le|__newindex|__tostring|__mode|__tonumber"
 
183
    );
 
184
 
 
185
    var stdLibaries = ("string|package|os|io|math|debug|table|coroutine");
 
186
 
 
187
    var futureReserved = "";
 
188
 
 
189
    var deprecatedIn5152 = ("setn|foreach|foreachi|gcinfo|log10|maxn");
 
190
 
 
191
    var keywordMapper = this.createKeywordMapper({
 
192
        "keyword": keywords,
 
193
        "support.function": functions,
 
194
        "invalid.deprecated": deprecatedIn5152,
 
195
        "constant.library": stdLibaries,
 
196
        "constant.language": builtinConstants,
 
197
        "invalid.illegal": futureReserved,
 
198
        "variable.language": "this"
 
199
    }, "identifier");
 
200
 
 
201
    var decimalInteger = "(?:(?:[1-9]\\d*)|(?:0))";
 
202
    var hexInteger = "(?:0[xX][\\dA-Fa-f]+)";
 
203
    var integer = "(?:" + decimalInteger + "|" + hexInteger + ")";
 
204
 
 
205
    var fraction = "(?:\\.\\d+)";
 
206
    var intPart = "(?:\\d+)";
 
207
    var pointFloat = "(?:(?:" + intPart + "?" + fraction + ")|(?:" + intPart + "\\.))";
 
208
    var floatNumber = "(?:" + pointFloat + ")";
 
209
 
 
210
    this.$rules = {
 
211
        "start" : [{
 
212
            stateName: "bracketedComment",
 
213
            onMatch : function(value, currentState, stack){
 
214
                stack.unshift(this.next, value.length, currentState);
 
215
                return "comment";
 
216
            },
 
217
            regex : /\-\-\[=*\[/,
 
218
            next  : [
 
219
                {
 
220
                    onMatch : function(value, currentState, stack) {
 
221
                        if (value.length == stack[1]) {
 
222
                            stack.shift();
 
223
                            stack.shift();
 
224
                            this.next = stack.shift();
 
225
                        } else {
 
226
                            this.next = "";
 
227
                        }
 
228
                        return "comment";
 
229
                    },
 
230
                    regex : /(?:[^\\]|\\.)*?\]=*\]/,
 
231
                    next  : "start"
 
232
                }, {
 
233
                    defaultToken : "comment"
 
234
                }
 
235
            ]
 
236
        },
 
237
 
 
238
        {
 
239
            token : "comment",
 
240
            regex : "\\-\\-.*$"
 
241
        },
 
242
        {
 
243
            stateName: "bracketedString",
 
244
            onMatch : function(value, currentState, stack){
 
245
                stack.unshift(this.next, value.length, currentState);
 
246
                return "comment";
 
247
            },
 
248
            regex : /\[=*\[/,
 
249
            next  : [
 
250
                {
 
251
                    onMatch : function(value, currentState, stack) {
 
252
                        if (value.length == stack[1]) {
 
253
                            stack.shift();
 
254
                            stack.shift();
 
255
                            this.next = stack.shift();
 
256
                        } else {
 
257
                            this.next = "";
 
258
                        }
 
259
                        return "comment";
 
260
                    },
 
261
                    
 
262
                    regex : /(?:[^\\]|\\.)*?\]=*\]/,
 
263
                    next  : "start"
 
264
                }, {
 
265
                    defaultToken : "comment"
 
266
                }
 
267
            ]
 
268
        },
 
269
        {
 
270
            token : "string",           // " string
 
271
            regex : '"(?:[^\\\\]|\\\\.)*?"'
 
272
        }, {
 
273
            token : "string",           // ' string
 
274
            regex : "'(?:[^\\\\]|\\\\.)*?'"
 
275
        }, {
 
276
            token : "constant.numeric", // float
 
277
            regex : floatNumber
 
278
        }, {
 
279
            token : "constant.numeric", // integer
 
280
            regex : integer + "\\b"
 
281
        }, {
 
282
            token : keywordMapper,
 
283
            regex : "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
 
284
        }, {
 
285
            token : "keyword.operator",
 
286
            regex : "\\+|\\-|\\*|\\/|%|\\#|\\^|~|<|>|<=|=>|==|~=|=|\\:|\\.\\.\\.|\\.\\."
 
287
        }, {
 
288
            token : "paren.lparen",
 
289
            regex : "[\\[\\(\\{]"
 
290
        }, {
 
291
            token : "paren.rparen",
 
292
            regex : "[\\]\\)\\}]"
 
293
        }, {
 
294
            token : "text",
 
295
            regex : "\\s+|\\w+"
 
296
        } ]
 
297
    };
 
298
    
 
299
    this.normalizeRules();
 
300
}
 
301
 
 
302
oop.inherits(LuaHighlightRules, TextHighlightRules);
 
303
 
 
304
exports.LuaHighlightRules = LuaHighlightRules;
 
305
});
 
306
 
 
307
define('ace/mode/folding/lua', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/folding/fold_mode', 'ace/range', 'ace/token_iterator'], function(require, exports, module) {
 
308
 
 
309
 
 
310
var oop = require("../../lib/oop");
 
311
var BaseFoldMode = require("./fold_mode").FoldMode;
 
312
var Range = require("../../range").Range;
 
313
var TokenIterator = require("../../token_iterator").TokenIterator;
 
314
 
 
315
 
 
316
var FoldMode = exports.FoldMode = function() {};
 
317
 
 
318
oop.inherits(FoldMode, BaseFoldMode);
 
319
 
 
320
(function() {
 
321
 
 
322
    this.foldingStartMarker = /\b(function|then|do|repeat)\b|{\s*$|(\[=*\[)/;
 
323
    this.foldingStopMarker = /\bend\b|^\s*}|\]=*\]/;
 
324
 
 
325
    this.getFoldWidget = function(session, foldStyle, row) {
 
326
        var line = session.getLine(row);
 
327
        var isStart = this.foldingStartMarker.test(line);
 
328
        var isEnd = this.foldingStopMarker.test(line);
 
329
 
 
330
        if (isStart && !isEnd) {
 
331
            var match = line.match(this.foldingStartMarker);
 
332
            if (match[1] == "then" && /\belseif\b/.test(line))
 
333
                return;
 
334
            if (match[1]) {
 
335
                if (session.getTokenAt(row, match.index + 1).type === "keyword")
 
336
                    return "start";
 
337
            } else if (match[2]) {
 
338
                var type = session.bgTokenizer.getState(row) || "";
 
339
                if (type[0] == "bracketedComment" || type[0] == "bracketedString")
 
340
                    return "start";
 
341
            } else {
 
342
                return "start";
 
343
            }
 
344
        }
 
345
        if (foldStyle != "markbeginend" || !isEnd || isStart && isEnd)
 
346
            return "";
 
347
 
 
348
        var match = line.match(this.foldingStopMarker);
 
349
        if (match[0] === "end") {
 
350
            if (session.getTokenAt(row, match.index + 1).type === "keyword")
 
351
                return "end";
 
352
        } else if (match[0][0] === "]") {
 
353
            var type = session.bgTokenizer.getState(row - 1) || "";
 
354
            if (type[0] == "bracketedComment" || type[0] == "bracketedString")
 
355
                return "end";
 
356
        } else
 
357
            return "end";
 
358
    };
 
359
 
 
360
    this.getFoldWidgetRange = function(session, foldStyle, row) {
 
361
        var line = session.doc.getLine(row);
 
362
        var match = this.foldingStartMarker.exec(line);
 
363
        if (match) {
 
364
            if (match[1])
 
365
                return this.luaBlock(session, row, match.index + 1);
 
366
 
 
367
            if (match[2])
 
368
                return session.getCommentFoldRange(row, match.index + 1);
 
369
 
 
370
            return this.openingBracketBlock(session, "{", row, match.index);
 
371
        }
 
372
 
 
373
        var match = this.foldingStopMarker.exec(line);
 
374
        if (match) {
 
375
            if (match[0] === "end") {
 
376
                if (session.getTokenAt(row, match.index + 1).type === "keyword")
 
377
                    return this.luaBlock(session, row, match.index + 1);
 
378
            }
 
379
 
 
380
            if (match[0][0] === "]")
 
381
                return session.getCommentFoldRange(row, match.index + 1);
 
382
 
 
383
            return this.closingBracketBlock(session, "}", row, match.index + match[0].length);
 
384
        }
 
385
    };
 
386
 
 
387
    this.luaBlock = function(session, row, column) {
 
388
        var stream = new TokenIterator(session, row, column);
 
389
        var indentKeywords = {
 
390
            "function": 1,
 
391
            "do": 1,
 
392
            "then": 1,
 
393
            "elseif": -1,
 
394
            "end": -1,
 
395
            "repeat": 1,
 
396
            "until": -1,
 
397
        };
 
398
 
 
399
        var token = stream.getCurrentToken();
 
400
        if (!token || token.type != "keyword")
 
401
            return;
 
402
 
 
403
        var val = token.value;
 
404
        var stack = [val];
 
405
        var dir = indentKeywords[val];
 
406
 
 
407
        if (!dir)
 
408
            return;
 
409
 
 
410
        var startColumn = dir === -1 ? stream.getCurrentTokenColumn() : session.getLine(row).length;
 
411
        var startRow = row;
 
412
 
 
413
        stream.step = dir === -1 ? stream.stepBackward : stream.stepForward;
 
414
        while(token = stream.step()) {
 
415
            if (token.type !== "keyword")
 
416
                continue;
 
417
            var level = dir * indentKeywords[token.value];
 
418
 
 
419
            if (level > 0) {
 
420
                stack.unshift(token.value);
 
421
            } else if (level <= 0) {
 
422
                stack.shift();
 
423
                if (!stack.length && token.value != "elseif")
 
424
                    break;
 
425
                if (level === 0)
 
426
                    stack.unshift(token.value);
 
427
            }
 
428
        }
 
429
 
 
430
        var row = stream.getCurrentTokenRow();
 
431
        if (dir === -1)
 
432
            return new Range(row, session.getLine(row).length, startRow, startColumn);
 
433
        else
 
434
            return new Range(startRow, startColumn, row, stream.getCurrentTokenColumn());
 
435
    };
 
436
 
 
437
}).call(FoldMode.prototype);
 
438
 
 
439
});