/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 codeigniter/js/ace/mode-r.js

  • Committer: galaxyAbstractor
  • Date: 2013-04-10 15:49:32 UTC
  • mto: (19.1.5 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410154932-4vizlzk0ar5gykvi
* Added an simple admin panel to the codeviewer-cmssy stuff
* Redesigned a bit like the mockups - still stuff to come
* Implemented the codeviewer + admin panel again using the Framework CodeIgniter instead 

Show diffs side-by-side

added added

removed removed

Lines of Context:
codeigniter/js/ace/mode-r.js
 
1
/*
 
2
 * r.js
 
3
 *
 
4
 * Copyright (C) 2009-11 by RStudio, Inc.
 
5
 *
 
6
 * The Initial Developer of the Original Code is
 
7
 * Ajax.org B.V.
 
8
 * Portions created by the Initial Developer are Copyright (C) 2010
 
9
 * the Initial Developer. All Rights Reserved.
 
10
 *
 
11
 * This program is licensed to you under the terms of version 3 of the
 
12
 * GNU Affero General Public License. This program is distributed WITHOUT
 
13
 * ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
 
14
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
 
15
 * AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.
 
16
 *
 
17
 */
 
18
define('ace/mode/r', ['require', 'exports', 'module' , 'ace/range', 'ace/lib/oop', 'ace/mode/text', 'ace/tokenizer', 'ace/mode/text_highlight_rules', 'ace/mode/r_highlight_rules', 'ace/mode/matching_brace_outdent', 'ace/unicode'], function(require, exports, module) {
 
19
   
 
20
 
 
21
   var Range = require("../range").Range;
 
22
   var oop = require("../lib/oop");
 
23
   var TextMode = require("./text").Mode;
 
24
   var Tokenizer = require("../tokenizer").Tokenizer;
 
25
   var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
26
   var RHighlightRules = require("./r_highlight_rules").RHighlightRules;
 
27
   var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
 
28
   var unicode = require("../unicode");
 
29
 
 
30
   var Mode = function()
 
31
   {
 
32
      this.$tokenizer = new Tokenizer(new RHighlightRules().getRules());
 
33
      this.$outdent = new MatchingBraceOutdent();
 
34
   };
 
35
   oop.inherits(Mode, TextMode);
 
36
 
 
37
   (function()
 
38
   {
 
39
      this.tokenRe = new RegExp("^["
 
40
          + unicode.packages.L
 
41
          + unicode.packages.Mn + unicode.packages.Mc
 
42
          + unicode.packages.Nd
 
43
          + unicode.packages.Pc + "._]+", "g"
 
44
      );
 
45
 
 
46
      this.nonTokenRe = new RegExp("^(?:[^"
 
47
          + unicode.packages.L
 
48
          + unicode.packages.Mn + unicode.packages.Mc
 
49
          + unicode.packages.Nd
 
50
          + unicode.packages.Pc + "._]|\s])+", "g"
 
51
      );
 
52
 
 
53
      this.$complements = {
 
54
               "(": ")",
 
55
               "[": "]",
 
56
               '"': '"',
 
57
               "'": "'",
 
58
               "{": "}"
 
59
            };
 
60
      this.$reOpen = /^[(["'{]$/;
 
61
      this.$reClose = /^[)\]"'}]$/;
 
62
 
 
63
      this.getNextLineIndent = function(state, line, tab, tabSize, row)
 
64
      {
 
65
         return this.codeModel.getNextLineIndent(row, line, state, tab, tabSize);
 
66
      };
 
67
 
 
68
      this.allowAutoInsert = this.smartAllowAutoInsert;
 
69
 
 
70
      this.checkOutdent = function(state, line, input) {
 
71
         if (! /^\s+$/.test(line))
 
72
            return false;
 
73
 
 
74
         return /^\s*[\{\}\)]/.test(input);
 
75
      };
 
76
 
 
77
      this.getIndentForOpenBrace = function(openBracePos)
 
78
      {
 
79
         return this.codeModel.getIndentForOpenBrace(openBracePos);
 
80
      };
 
81
 
 
82
      this.autoOutdent = function(state, doc, row) {
 
83
         if (row == 0)
 
84
            return 0;
 
85
 
 
86
         var line = doc.getLine(row);
 
87
 
 
88
         var match = line.match(/^(\s*[\}\)])/);
 
89
         if (match)
 
90
         {
 
91
            var column = match[1].length;
 
92
            var openBracePos = doc.findMatchingBracket({row: row, column: column});
 
93
 
 
94
            if (!openBracePos || openBracePos.row == row) return 0;
 
95
 
 
96
            var indent = this.codeModel.getIndentForOpenBrace(openBracePos);
 
97
            doc.replace(new Range(row, 0, row, column-1), indent);
 
98
         }
 
99
 
 
100
         match = line.match(/^(\s*\{)/);
 
101
         if (match)
 
102
         {
 
103
            var column = match[1].length;
 
104
            var indent = this.codeModel.getBraceIndent(row-1);
 
105
            doc.replace(new Range(row, 0, row, column-1), indent);
 
106
         }
 
107
      };
 
108
 
 
109
      this.$getIndent = function(line) {
 
110
         var match = line.match(/^(\s+)/);
 
111
         if (match) {
 
112
            return match[1];
 
113
         }
 
114
 
 
115
         return "";
 
116
      };
 
117
 
 
118
      this.transformAction = function(state, action, editor, session, text) {
 
119
         if (action === 'insertion' && text === "\n") {
 
120
            var pos = editor.getSelectionRange().start;
 
121
            var match = /^((\s*#+')\s*)/.exec(session.doc.getLine(pos.row));
 
122
            if (match && editor.getSelectionRange().start.column >= match[2].length) {
 
123
               return {text: "\n" + match[1]};
 
124
            }
 
125
         }
 
126
         return false;
 
127
      };
 
128
   }).call(Mode.prototype);
 
129
   exports.Mode = Mode;
 
130
});
 
131
define('ace/mode/r_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules', 'ace/mode/tex_highlight_rules'], function(require, exports, module) {
 
132
 
 
133
   var oop = require("../lib/oop");
 
134
   var lang = require("../lib/lang");
 
135
   var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
136
   var TexHighlightRules = require("./tex_highlight_rules").TexHighlightRules;
 
137
 
 
138
   var RHighlightRules = function()
 
139
   {
 
140
 
 
141
      var keywords = lang.arrayToMap(
 
142
            ("function|if|in|break|next|repeat|else|for|return|switch|while|try|tryCatch|stop|warning|require|library|attach|detach|source|setMethod|setGeneric|setGroupGeneric|setClass")
 
143
                  .split("|")
 
144
            );
 
145
 
 
146
      var buildinConstants = lang.arrayToMap(
 
147
            ("NULL|NA|TRUE|FALSE|T|F|Inf|NaN|NA_integer_|NA_real_|NA_character_|" +
 
148
             "NA_complex_").split("|")
 
149
            );
 
150
 
 
151
      this.$rules = {
 
152
         "start" : [
 
153
            {
 
154
               token : "comment.sectionhead",
 
155
               regex : "#+(?!').*(?:----|====|####)\\s*$"
 
156
            },
 
157
            {
 
158
               token : "comment",
 
159
               regex : "#+'",
 
160
               next : "rd-start"
 
161
            },
 
162
            {
 
163
               token : "comment",
 
164
               regex : "#.*$"
 
165
            },
 
166
            {
 
167
               token : "string", // multi line string start
 
168
               regex : '["]',
 
169
               next : "qqstring"
 
170
            },
 
171
            {
 
172
               token : "string", // multi line string start
 
173
               regex : "[']",
 
174
               next : "qstring"
 
175
            },
 
176
            {
 
177
               token : "constant.numeric", // hex
 
178
               regex : "0[xX][0-9a-fA-F]+[Li]?\\b"
 
179
            },
 
180
            {
 
181
               token : "constant.numeric", // explicit integer
 
182
               regex : "\\d+L\\b"
 
183
            },
 
184
            {
 
185
               token : "constant.numeric", // number
 
186
               regex : "\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d*)?i?\\b"
 
187
            },
 
188
            {
 
189
               token : "constant.numeric", // number with leading decimal
 
190
               regex : "\\.\\d+(?:[eE][+\\-]?\\d*)?i?\\b"
 
191
            },
 
192
            {
 
193
               token : "constant.language.boolean",
 
194
               regex : "(?:TRUE|FALSE|T|F)\\b"
 
195
            },
 
196
            {
 
197
               token : "identifier",
 
198
               regex : "`.*?`"
 
199
            },
 
200
            {
 
201
               onMatch : function(value) {
 
202
                  if (keywords[value])
 
203
                     return "keyword";
 
204
                  else if (buildinConstants[value])
 
205
                     return "constant.language";
 
206
                  else if (value == '...' || value.match(/^\.\.\d+$/))
 
207
                     return "variable.language";
 
208
                  else
 
209
                     return "identifier";
 
210
               },
 
211
               regex : "[a-zA-Z.][a-zA-Z0-9._]*\\b"
 
212
            },
 
213
            {
 
214
               token : "keyword.operator",
 
215
               regex : "%%|>=|<=|==|!=|\\->|<\\-|\\|\\||&&|=|\\+|\\-|\\*|/|\\^|>|<|!|&|\\||~|\\$|:"
 
216
            },
 
217
            {
 
218
               token : "keyword.operator", // infix operators
 
219
               regex : "%.*?%"
 
220
            },
 
221
            {
 
222
               token : "paren.keyword.operator",
 
223
               regex : "[[({]"
 
224
            },
 
225
            {
 
226
               token : "paren.keyword.operator",
 
227
               regex : "[\\])}]"
 
228
            },
 
229
            {
 
230
               token : "text",
 
231
               regex : "\\s+"
 
232
            }
 
233
         ],
 
234
         "qqstring" : [
 
235
            {
 
236
               token : "string",
 
237
               regex : '(?:(?:\\\\.)|(?:[^"\\\\]))*?"',
 
238
               next : "start"
 
239
            },
 
240
            {
 
241
               token : "string",
 
242
               regex : '.+'
 
243
            }
 
244
         ],
 
245
         "qstring" : [
 
246
            {
 
247
               token : "string",
 
248
               regex : "(?:(?:\\\\.)|(?:[^'\\\\]))*?'",
 
249
               next : "start"
 
250
            },
 
251
            {
 
252
               token : "string",
 
253
               regex : '.+'
 
254
            }
 
255
         ]
 
256
      };
 
257
 
 
258
      var rdRules = new TexHighlightRules("comment").getRules();
 
259
      for (var i = 0; i < rdRules["start"].length; i++) {
 
260
         rdRules["start"][i].token += ".virtual-comment";
 
261
      }
 
262
 
 
263
      this.addRules(rdRules, "rd-");
 
264
      this.$rules["rd-start"].unshift({
 
265
          token: "text",
 
266
          regex: "^",
 
267
          next: "start"
 
268
      });
 
269
      this.$rules["rd-start"].unshift({
 
270
         token : "keyword",
 
271
         regex : "@(?!@)[^ ]*"
 
272
      });
 
273
      this.$rules["rd-start"].unshift({
 
274
         token : "comment",
 
275
         regex : "@@"
 
276
      });
 
277
      this.$rules["rd-start"].push({
 
278
         token : "comment",
 
279
         regex : "[^%\\\\[({\\])}]+"
 
280
      });
 
281
   };
 
282
 
 
283
   oop.inherits(RHighlightRules, TextHighlightRules);
 
284
 
 
285
   exports.RHighlightRules = RHighlightRules;
 
286
});
 
287
define('ace/mode/tex_highlight_rules', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/lang', 'ace/mode/text_highlight_rules'], function(require, exports, module) {
 
288
 
 
289
 
 
290
var oop = require("../lib/oop");
 
291
var lang = require("../lib/lang");
 
292
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
 
293
 
 
294
var TexHighlightRules = function(textClass) {
 
295
 
 
296
    if (!textClass)
 
297
        textClass = "text";
 
298
 
 
299
    this.$rules = {
 
300
        "start" : [
 
301
                {
 
302
                    token : "comment",
 
303
                    regex : "%.*$"
 
304
                }, {
 
305
                    token : textClass, // non-command
 
306
                    regex : "\\\\[$&%#\\{\\}]"
 
307
                }, {
 
308
                    token : "keyword", // command
 
309
                    regex : "\\\\(?:documentclass|usepackage|newcounter|setcounter|addtocounter|value|arabic|stepcounter|newenvironment|renewenvironment|ref|vref|eqref|pageref|label|cite[a-zA-Z]*|tag|begin|end|bibitem)\\b",
 
310
               next : "nospell"
 
311
                }, {
 
312
                    token : "keyword", // command
 
313
                    regex : "\\\\(?:[a-zA-z0-9]+|[^a-zA-z0-9])"
 
314
                }, {
 
315
               token : "paren.keyword.operator",
 
316
                    regex : "[[({]"
 
317
                }, {
 
318
               token : "paren.keyword.operator",
 
319
                    regex : "[\\])}]"
 
320
                }, {
 
321
                    token : textClass,
 
322
                    regex : "\\s+"
 
323
                }
 
324
        ],
 
325
        "nospell" : [
 
326
           {
 
327
               token : "comment",
 
328
               regex : "%.*$",
 
329
               next : "start"
 
330
           }, {
 
331
               token : "nospell." + textClass, // non-command
 
332
               regex : "\\\\[$&%#\\{\\}]"
 
333
           }, {
 
334
               token : "keyword", // command
 
335
               regex : "\\\\(?:documentclass|usepackage|newcounter|setcounter|addtocounter|value|arabic|stepcounter|newenvironment|renewenvironment|ref|vref|eqref|pageref|label|cite[a-zA-Z]*|tag|begin|end|bibitem)\\b"
 
336
           }, {
 
337
               token : "keyword", // command
 
338
               regex : "\\\\(?:[a-zA-z0-9]+|[^a-zA-z0-9])",
 
339
               next : "start"
 
340
           }, {
 
341
               token : "paren.keyword.operator",
 
342
               regex : "[[({]"
 
343
           }, {
 
344
               token : "paren.keyword.operator",
 
345
               regex : "[\\])]"
 
346
           }, {
 
347
               token : "paren.keyword.operator",
 
348
               regex : "}",
 
349
               next : "start"
 
350
           }, {
 
351
               token : "nospell." + textClass,
 
352
               regex : "\\s+"
 
353
           }, {
 
354
               token : "nospell." + textClass,
 
355
               regex : "\\w+"
 
356
           }
 
357
        ]
 
358
    };
 
359
};
 
360
 
 
361
oop.inherits(TexHighlightRules, TextHighlightRules);
 
362
 
 
363
exports.TexHighlightRules = TexHighlightRules;
 
364
});
 
365
 
 
366
define('ace/mode/matching_brace_outdent', ['require', 'exports', 'module' , 'ace/range'], function(require, exports, module) {
 
367
 
 
368
 
 
369
var Range = require("../range").Range;
 
370
 
 
371
var MatchingBraceOutdent = function() {};
 
372
 
 
373
(function() {
 
374
 
 
375
    this.checkOutdent = function(line, input) {
 
376
        if (! /^\s+$/.test(line))
 
377
            return false;
 
378
 
 
379
        return /^\s*\}/.test(input);
 
380
    };
 
381
 
 
382
    this.autoOutdent = function(doc, row) {
 
383
        var line = doc.getLine(row);
 
384
        var match = line.match(/^(\s*\})/);
 
385
 
 
386
        if (!match) return 0;
 
387
 
 
388
        var column = match[1].length;
 
389
        var openBracePos = doc.findMatchingBracket({row: row, column: column});
 
390
 
 
391
        if (!openBracePos || openBracePos.row == row) return 0;
 
392
 
 
393
        var indent = this.$getIndent(doc.getLine(openBracePos.row));
 
394
        doc.replace(new Range(row, 0, row, column-1), indent);
 
395
    };
 
396
 
 
397
    this.$getIndent = function(line) {
 
398
        return line.match(/^\s*/)[0];
 
399
    };
 
400
 
 
401
}).call(MatchingBraceOutdent.prototype);
 
402
 
 
403
exports.MatchingBraceOutdent = MatchingBraceOutdent;
 
404
});