~ubuntu-branches/ubuntu/trusty/0ad/trusty-backports

« back to all changes in this revision

Viewing changes to source/tools/jsdebugger/js/lib/ace/mode-asciidoc.js

  • Committer: Package Import Robot
  • Author(s): Vincent Cheng
  • Date: 2014-02-18 23:21:11 UTC
  • mfrom: (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20140218232111-9x3ag0s782wd9w62
* Repack tarball to remove minified javascript files without source in
  source/tools/jsdebugger/. (Closes: #735349)
  - debian/control: Hardcode versions of 0ad-data{,-common} to depend on to
    workaround the fact that 0.0.15+dfsg is strictly greater than 0.0.15.
* Update debian/copyright to include text of IBM Common Public License.
* Update email address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/asciidoc', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/asciidoc_highlight_rules', 'ace/mode/folding/asciidoc'], 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 AsciidocHighlightRules = require("./asciidoc_highlight_rules").AsciidocHighlightRules;
38
 
var AsciidocFoldMode = require("./folding/asciidoc").FoldMode;
39
 
 
40
 
var Mode = function() {
41
 
    var highlighter = new AsciidocHighlightRules();
42
 
    
43
 
    this.$tokenizer = new Tokenizer(highlighter.getRules());
44
 
    this.foldingRules = new AsciidocFoldMode();    
45
 
};
46
 
oop.inherits(Mode, TextMode);
47
 
 
48
 
(function() {
49
 
    this.getNextLineIndent = function(state, line, tab) {
50
 
        if (state == "listblock") {
51
 
            var match = /^((?:.+)?)([-+*][ ]+)/.exec(line);
52
 
            if (match) {
53
 
                return new Array(match[1].length + 1).join(" ") + match[2];
54
 
            } else {
55
 
                return "";
56
 
            }
57
 
        } else {
58
 
            return this.$getIndent(line);
59
 
        }
60
 
    };
61
 
}).call(Mode.prototype);
62
 
 
63
 
exports.Mode = Mode;
64
 
});
65
 
 
66
 
define('ace/mode/asciidoc_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
67
 
 
68
 
 
69
 
var oop = require("../lib/oop");
70
 
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
71
 
 
72
 
var AsciidocHighlightRules = function() {
73
 
    var identifierRe = "[a-zA-Z\u00a1-\uffff]+\\b";
74
 
 
75
 
    this.$rules = {
76
 
        "start": [
77
 
            {token: "empty",   regex: /$/},
78
 
            {token: "literal", regex: /^\.{4,}\s*$/,  next: "listingBlock"},
79
 
            {token: "literal", regex: /^-{4,}\s*$/,   next: "literalBlock"},
80
 
            {token: "string",  regex: /^\+{4,}\s*$/,  next: "passthroughBlock"},
81
 
            {token: "keyword", regex: /^={4,}\s*$/},
82
 
            {token: "text",    regex: /^\s*$/},
83
 
            {token: "empty", regex: "", next: "dissallowDelimitedBlock"}
84
 
        ],
85
 
 
86
 
        "dissallowDelimitedBlock": [
87
 
            {include: "paragraphEnd"},
88
 
            {token: "comment", regex: '^//.+$'},
89
 
            {token: "keyword", regex: "^(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION):"},
90
 
 
91
 
            {include: "listStart"},
92
 
            {token: "literal", regex: /^\s+.+$/, next: "indentedBlock"},
93
 
            {token: "empty",   regex: "", next: "text"}
94
 
        ],
95
 
 
96
 
        "paragraphEnd": [
97
 
            {token: "doc.comment", regex: /^\/{4,}\s*$/,    next: "commentBlock"},
98
 
            {token: "tableBlock",  regex: /^\s*[|!]=+\s*$/, next: "tableBlock"},
99
 
            {token: "keyword",     regex: /^(?:--|''')\s*$/, next: "start"},
100
 
            {token: "option",      regex: /^\[.*\]\s*$/,     next: "start"},
101
 
            {token: "pageBreak",   regex: /^>{3,}$/,         next: "start"},
102
 
            {token: "literal",     regex: /^\.{4,}\s*$/,     next: "listingBlock"},
103
 
            {token: "titleUnderline",    regex: /^(?:={2,}|-{2,}|~{2,}|\^{2,}|\+{2,})\s*$/, next: "start"},
104
 
            {token: "singleLineTitle",   regex: /^={1,5}\s+\S.*$/, next: "start"},
105
 
 
106
 
            {token: "otherBlock",    regex: /^(?:\*{2,}|_{2,})\s*$/, next: "start"},
107
 
            {token: "optionalTitle", regex: /^\.[^.\s].+$/,  next: "start"}
108
 
        ],
109
 
 
110
 
        "listStart": [
111
 
            {token: "keyword",  regex: /^\s*(?:\d+\.|[a-zA-Z]\.|[ixvmIXVM]+\)|\*{1,5}|-|\.{1,5})\s/, next: "listText"},
112
 
            {token: "meta.tag", regex: /^.+(?::{2,4}|;;)(?: |$)/, next: "listText"},
113
 
            {token: "support.function.list.callout", regex: /^(?:<\d+>|\d+>|>) /, next: "text"},
114
 
            {token: "keyword",  regex: /^\+\s*$/, next: "start"}
115
 
        ],
116
 
 
117
 
        "text": [
118
 
            {token: ["link", "variable.language"], regex: /((?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+)(\[.*?\])/},
119
 
            {token: "link", regex: /(?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+/},
120
 
            {token: "link", regex: /\b[\w\.\/\-]+@[\w\.\/\-]+\b/},
121
 
            {include: "macros"},
122
 
            {include: "paragraphEnd"},
123
 
            {token: "literal", regex:/\+{3,}/, next:"smallPassthrough"},
124
 
            {token: "escape", regex: /\((?:C|TM|R)\)|\.{3}|->|<-|=>|<=|&#(?:\d+|x[a-fA-F\d]+);|(?: |^)--(?=\s+\S)/},
125
 
            {token: "escape", regex: /\\[_*'`+#]|\\{2}[_*'`+#]{2}/},
126
 
            {token: "keyword", regex: /\s\+$/},
127
 
            {token: "text", regex: identifierRe},
128
 
            {token: ["keyword", "string", "keyword"],
129
 
                regex: /(<<[\w\d\-$]+,)(.*?)(>>|$)/, merge: true},
130
 
            {token: "keyword", regex: /<<[\w\d\-$]+,?|>>/, merge: true},
131
 
            {token: "constant.character", regex: /\({2,3}.*?\){2,3}/, merge: true},
132
 
            {token: "keyword", regex: /\[\[.+?\]\]/},
133
 
            {token: "support", regex: /^\[{3}[\w\d =\-]+\]{3}/},
134
 
 
135
 
            {include: "quotes"},
136
 
            {token: "empty", regex: /^\s*$/, next: "start"}
137
 
        ],
138
 
 
139
 
        "listText": [
140
 
            {include: "listStart"},
141
 
            {include: "text"}
142
 
        ],
143
 
 
144
 
        "indentedBlock": [
145
 
            {token: "literal", regex: /^[\s\w].+$/, next: "indentedBlock"},
146
 
            {token: "literal", regex: "", next: "start"}
147
 
        ],
148
 
 
149
 
        "listingBlock": [
150
 
            {token: "literal", regex: /^\.{4,}\s*$/, next: "dissallowDelimitedBlock"},
151
 
            {token: "constant.numeric", regex: '<\\d+>'},
152
 
            {token: "literal", regex: '[^<]+', merge: true},
153
 
            {token: "literal", regex: '<', merge: true}
154
 
        ],
155
 
        "literalBlock": [
156
 
            {token: "literal", regex: /^-{4,}\s*$/, next: "dissallowDelimitedBlock"},
157
 
            {token: "constant.numeric", regex: '<\\d+>'},
158
 
            {token: "literal", regex: '[^<]+', merge: true},
159
 
            {token: "literal", regex: '<', merge: true}
160
 
        ],
161
 
        "passthroughBlock": [
162
 
            {token: "literal", regex: /^\+{4,}\s*$/, next: "dissallowDelimitedBlock"},
163
 
            {token: "literal", regex: identifierRe + "|\\d+", merge: true},
164
 
            {include: "macros"},
165
 
            {token: "literal", regex: ".", merge: true}
166
 
        ],
167
 
 
168
 
        "smallPassthrough": [
169
 
            {token: "literal", regex: /[+]{3,}/, next: "dissallowDelimitedBlock"},
170
 
            {token: "literal", regex: /^\s*$/, next: "dissallowDelimitedBlock", merge: true},
171
 
            {token: "literal", regex: identifierRe + "|\\d+", merge: true},
172
 
            {include: "macros"}
173
 
        ],
174
 
 
175
 
        "commentBlock": [
176
 
            {token: "doc.comment", regex: /^\/{4,}\s*$/, next: "dissallowDelimitedBlock"},
177
 
            {token: "doc.comment", regex: '^.*$'}
178
 
        ],
179
 
        "tableBlock": [
180
 
            {token: "tableBlock", regex: /^\s*\|={3,}\s*$/, next: "dissallowDelimitedBlock"},
181
 
            {token: "tableBlock", regex: /^\s*!={3,}\s*$/, next: "innerTableBlock"},
182
 
            {token: "tableBlock", regex: /\|/},
183
 
            {include: "text", noEscape: true}
184
 
        ],
185
 
        "innerTableBlock": [
186
 
            {token: "tableBlock", regex: /^\s*!={3,}\s*$/, next: "tableBlock"},
187
 
            {token: "tableBlock", regex: /^\s*|={3,}\s*$/, next: "dissallowDelimitedBlock"},
188
 
            {token: "tableBlock", regex: /\!/}
189
 
        ],
190
 
        "macros": [
191
 
            {token: "macro", regex: /{[\w\-$]+}/},
192
 
            {token: ["text", "string", "text", "constant.character", "text"], regex: /({)([\w\-$]+)(:)?(.+)?(})/},
193
 
            {token: ["text", "markup.list.macro", "keyword", "string"], regex: /(\w+)(footnote(?:ref)?::?)([^\s\[]+)?(\[.*?\])?/},
194
 
            {token: ["markup.list.macro", "keyword", "string"], regex: /([a-zA-Z\-][\w\.\/\-]*::?)([^\s\[]+)(\[.*?\])?/},
195
 
            {token: ["markup.list.macro", "keyword"], regex: /([a-zA-Z\-][\w\.\/\-]+::?)(\[.*?\])/},
196
 
            {token: "keyword",     regex: /^:.+?:(?= |$)/}
197
 
        ],
198
 
 
199
 
        "quotes": [
200
 
            {token: "string.italic", regex: /__[^_\s].*?__/},
201
 
            {token: "string.italic", regex: quoteRule("_")},
202
 
            
203
 
            {token: "keyword.bold", regex: /\*\*[^*\s].*?\*\*/},
204
 
            {token: "keyword.bold", regex: quoteRule("\\*")},
205
 
            
206
 
            {token: "literal", regex: quoteRule("\\+")},
207
 
            {token: "literal", regex: /\+\+[^+\s].*?\+\+/},
208
 
            {token: "literal", regex: /\$\$.+?\$\$/},
209
 
            {token: "literal", regex: quoteRule("`")},
210
 
 
211
 
            {token: "keyword", regex: quoteRule("^")},
212
 
            {token: "keyword", regex: quoteRule("~")},
213
 
            {token: "keyword", regex: /##?/},
214
 
            {token: "keyword", regex: /(?:\B|^)``|\b''/}
215
 
        ]
216
 
 
217
 
    };
218
 
 
219
 
    function quoteRule(ch) {
220
 
        var prefix = /\w/.test(ch) ? "\\b" : "(?:\\B|^)";
221
 
        return prefix + ch + "[^" + ch + "].*?" + ch + "(?![\\w*])";
222
 
    }
223
 
 
224
 
    var tokenMap = {
225
 
        macro: "constant.character",
226
 
        tableBlock: "doc.comment",
227
 
        titleUnderline: "markup.heading",
228
 
        singleLineTitle: "markup.heading",
229
 
        pageBreak: "string",
230
 
        option: "string.regexp",
231
 
        otherBlock: "markup.list",
232
 
        literal: "support.function",
233
 
        optionalTitle: "constant.numeric",
234
 
        escape: "constant.language.escape",
235
 
        link: "markup.underline.list"
236
 
    };
237
 
 
238
 
    for (var state in this.$rules) {
239
 
        var stateRules = this.$rules[state];
240
 
        for (var i = stateRules.length; i--; ) {
241
 
            var rule = stateRules[i];
242
 
            if (rule.include || typeof rule == "string") {
243
 
                var args = [i, 1].concat(this.$rules[rule.include || rule]);
244
 
                if (rule.noEscape) {
245
 
                    args = args.filter(function(x) {
246
 
                        return !x.next;
247
 
                    });
248
 
                }
249
 
                stateRules.splice.apply(stateRules, args);
250
 
            } else if (rule.token in tokenMap) {
251
 
                rule.token = tokenMap[rule.token];
252
 
            }
253
 
        }
254
 
    }
255
 
};
256
 
oop.inherits(AsciidocHighlightRules, TextHighlightRules);
257
 
 
258
 
exports.AsciidocHighlightRules = AsciidocHighlightRules;
259
 
});
260
 
 
261
 
define('ace/mode/folding/asciidoc', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/mode/folding/fold_mode', 'ace/range'], function(require, exports, module) {
262
 
 
263
 
 
264
 
var oop = require("../../lib/oop");
265
 
var BaseFoldMode = require("./fold_mode").FoldMode;
266
 
var Range = require("../../range").Range;
267
 
 
268
 
var FoldMode = exports.FoldMode = function() {};
269
 
oop.inherits(FoldMode, BaseFoldMode);
270
 
 
271
 
(function() {
272
 
    this.foldingStartMarker = /^(?:\|={10,}|[\.\/=\-~^+]{4,}\s*$|={1,5} )/;
273
 
    this.singleLineHeadingRe = /^={1,5}(?=\s+\S)/;
274
 
 
275
 
    this.getFoldWidget = function(session, foldStyle, row) {
276
 
        var line = session.getLine(row);
277
 
        if (!this.foldingStartMarker.test(line))
278
 
            return ""
279
 
 
280
 
        if (line[0] == "=") {
281
 
            if (this.singleLineHeadingRe.test(line))
282
 
                return "start";
283
 
            if (session.getLine(row - 1).length != session.getLine(row).length)
284
 
                return "";
285
 
            return "start";
286
 
        }
287
 
        if (session.bgTokenizer.getState(row) == "dissallowDelimitedBlock")
288
 
            return "end";
289
 
        return "start";
290
 
    };
291
 
 
292
 
    this.getFoldWidgetRange = function(session, foldStyle, row) {
293
 
        var line = session.getLine(row);
294
 
        var startColumn = line.length;
295
 
        var maxRow = session.getLength();
296
 
        var startRow = row;
297
 
        var endRow = row;
298
 
        if (!line.match(this.foldingStartMarker))
299
 
            return;
300
 
 
301
 
        var token;
302
 
        function getTokenType(row) {
303
 
            token = session.getTokens(row)[0];
304
 
            return token && token.type;
305
 
        }
306
 
 
307
 
        var levels = ["=","-","~","^","+"];
308
 
        var heading = "markup.heading";
309
 
        var singleLineHeadingRe = this.singleLineHeadingRe;
310
 
        function getLevel() {
311
 
            var match = token.value.match(singleLineHeadingRe);
312
 
            if (match)
313
 
                return match[0].length;
314
 
            var level = levels.indexOf(token.value[0]) + 1;
315
 
            if (level == 1) {
316
 
                if (session.getLine(row - 1).length != session.getLine(row).length)
317
 
                    return Infinity;
318
 
            }
319
 
            return level;
320
 
        }
321
 
 
322
 
        if (getTokenType(row) == heading) {
323
 
            var startHeadingLevel = getLevel();
324
 
            while (++row < maxRow) {
325
 
                if (getTokenType(row) != heading)
326
 
                    continue;
327
 
                var level = getLevel();
328
 
                if (level <= startHeadingLevel)
329
 
                    break;
330
 
            }
331
 
 
332
 
            var isSingleLineHeading = token && token.value.match(this.singleLineHeadingRe);
333
 
            endRow = isSingleLineHeading ? row - 1 : row - 2;
334
 
 
335
 
            if (endRow > startRow) {
336
 
                while (endRow > startRow && (!getTokenType(endRow) || token.value[0] == "["))
337
 
                    endRow--;
338
 
            }
339
 
 
340
 
            if (endRow > startRow) {
341
 
                var endColumn = session.getLine(endRow).length;
342
 
                return new Range(startRow, startColumn, endRow, endColumn);
343
 
            }
344
 
        } else {
345
 
            var state = session.bgTokenizer.getState(row);
346
 
            if (state == "dissallowDelimitedBlock") {
347
 
                while (row -- > 0) {
348
 
                    if (session.bgTokenizer.getState(row).lastIndexOf("Block") == -1)
349
 
                        break;
350
 
                }
351
 
                endRow = row + 1;
352
 
                if (endRow < startRow) {
353
 
                    var endColumn = session.getLine(row).length;
354
 
                    return new Range(endRow, 5, startRow, startColumn - 5);
355
 
                }
356
 
            } else {
357
 
                while (++row < maxRow) {
358
 
                    if (session.bgTokenizer.getState(row) == "dissallowDelimitedBlock")
359
 
                        break;
360
 
                }
361
 
                endRow = row;
362
 
                if (endRow > startRow) {
363
 
                    var endColumn = session.getLine(row).length;
364
 
                    return new Range(startRow, 5, endRow, endColumn - 5);
365
 
                }
366
 
            }
367
 
        }
368
 
    };
369
 
 
370
 
}).call(FoldMode.prototype);
371
 
 
372
 
});