File modules/editor/codemirror/mode/livescript/livescript.js

Last commit: Sun Dec 17 01:14:09 2017 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.


     1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
     2 // Distributed under an MIT license: http://codemirror.net/LICENSE
     3 
     4 /**
     5  * Link to the project's GitHub page:
     6  * https://github.com/duralog/CodeMirror
     7  */
     8 
     9 (function(mod) {
    10   if (typeof exports == "object" && typeof module == "object") // CommonJS
    11     mod(require("../../lib/codemirror"));
    12   else if (typeof define == "function" && define.amd) // AMD
    13     define(["../../lib/codemirror"], mod);
    14   else // Plain browser env
    15     mod(CodeMirror);
    16 })(function(CodeMirror) {
    17   "use strict";
    18 
    19   CodeMirror.defineMode('livescript', function(){
    20     var tokenBase = function(stream, state) {
    21       var next_rule = state.next || "start";
    22       if (next_rule) {
    23         state.next = state.next;
    24         var nr = Rules[next_rule];
    25         if (nr.splice) {
    26           for (var i$ = 0; i$ < nr.length; ++i$) {
    27             var r = nr[i$];
    28             if (r.regex && stream.match(r.regex)) {
    29               state.next = r.next || state.next;
    30               return r.token;
    31             }
    32           }
    33           stream.next();
    34           return 'error';
    35         }
    36         if (stream.match(r = Rules[next_rule])) {
    37           if (r.regex && stream.match(r.regex)) {
    38             state.next = r.next;
    39             return r.token;
    40           } else {
    41             stream.next();
    42             return 'error';
    43           }
    44         }
    45       }
    46       stream.next();
    47       return 'error';
    48     };
    49     var external = {
    50       startState: function(){
    51         return {
    52           next: 'start',
    53           lastToken: {style: null, indent: 0, content: ""}
    54         };
    55       },
    56       token: function(stream, state){
    57         while (stream.pos == stream.start)
    58           var style = tokenBase(stream, state);
    59         state.lastToken = {
    60           style: style,
    61           indent: stream.indentation(),
    62           content: stream.current()
    63         };
    64         return style.replace(/\./g, ' ');
    65       },
    66       indent: function(state){
    67         var indentation = state.lastToken.indent;
    68         if (state.lastToken.content.match(indenter)) {
    69           indentation += 2;
    70         }
    71         return indentation;
    72       }
    73     };
    74     return external;
    75   });
    76 
    77   var identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
    78   var indenter = RegExp('(?:[({[=:]|[-~]>|\\b(?:e(?:lse|xport)|d(?:o|efault)|t(?:ry|hen)|finally|import(?:\\s*all)?|const|var|let|new|catch(?:\\s*' + identifier + ')?))\\s*$');
    79   var keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
    80   var stringfill = {
    81     token: 'string',
    82     regex: '.+'
    83   };
    84   var Rules = {
    85     start: [
    86       {
    87         token: 'comment.doc',
    88         regex: '/\\*',
    89         next: 'comment'
    90       }, {
    91         token: 'comment',
    92         regex: '#.*'
    93       }, {
    94         token: 'keyword',
    95         regex: '(?:t(?:h(?:is|row|en)|ry|ypeof!?)|c(?:on(?:tinue|st)|a(?:se|tch)|lass)|i(?:n(?:stanceof)?|mp(?:ort(?:\\s+all)?|lements)|[fs])|d(?:e(?:fault|lete|bugger)|o)|f(?:or(?:\\s+own)?|inally|unction)|s(?:uper|witch)|e(?:lse|x(?:tends|port)|val)|a(?:nd|rguments)|n(?:ew|ot)|un(?:less|til)|w(?:hile|ith)|o[fr]|return|break|let|var|loop)' + keywordend
    96       }, {
    97         token: 'constant.language',
    98         regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
    99       }, {
   100         token: 'invalid.illegal',
   101         regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
   102       }, {
   103         token: 'language.support.class',
   104         regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
   105       }, {
   106         token: 'language.support.function',
   107         regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
   108       }, {
   109         token: 'variable.language',
   110         regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
   111       }, {
   112         token: 'identifier',
   113         regex: identifier + '\\s*:(?![:=])'
   114       }, {
   115         token: 'variable',
   116         regex: identifier
   117       }, {
   118         token: 'keyword.operator',
   119         regex: '(?:\\.{3}|\\s+\\?)'
   120       }, {
   121         token: 'keyword.variable',
   122         regex: '(?:@+|::|\\.\\.)',
   123         next: 'key'
   124       }, {
   125         token: 'keyword.operator',
   126         regex: '\\.\\s*',
   127         next: 'key'
   128       }, {
   129         token: 'string',
   130         regex: '\\\\\\S[^\\s,;)}\\]]*'
   131       }, {
   132         token: 'string.doc',
   133         regex: '\'\'\'',
   134         next: 'qdoc'
   135       }, {
   136         token: 'string.doc',
   137         regex: '"""',
   138         next: 'qqdoc'
   139       }, {
   140         token: 'string',
   141         regex: '\'',
   142         next: 'qstring'
   143       }, {
   144         token: 'string',
   145         regex: '"',
   146         next: 'qqstring'
   147       }, {
   148         token: 'string',
   149         regex: '`',
   150         next: 'js'
   151       }, {
   152         token: 'string',
   153         regex: '<\\[',
   154         next: 'words'
   155       }, {
   156         token: 'string.regex',
   157         regex: '//',
   158         next: 'heregex'
   159       }, {
   160         token: 'string.regex',
   161         regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
   162         next: 'key'
   163       }, {
   164         token: 'constant.numeric',
   165         regex: '(?:0x[\\da-fA-F][\\da-fA-F_]*|(?:[2-9]|[12]\\d|3[0-6])r[\\da-zA-Z][\\da-zA-Z_]*|(?:\\d[\\d_]*(?:\\.\\d[\\d_]*)?|\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[\\w$]*)'
   166       }, {
   167         token: 'lparen',
   168         regex: '[({[]'
   169       }, {
   170         token: 'rparen',
   171         regex: '[)}\\]]',
   172         next: 'key'
   173       }, {
   174         token: 'keyword.operator',
   175         regex: '\\S+'
   176       }, {
   177         token: 'text',
   178         regex: '\\s+'
   179       }
   180     ],
   181     heregex: [
   182       {
   183         token: 'string.regex',
   184         regex: '.*?//[gimy$?]{0,4}',
   185         next: 'start'
   186       }, {
   187         token: 'string.regex',
   188         regex: '\\s*#{'
   189       }, {
   190         token: 'comment.regex',
   191         regex: '\\s+(?:#.*)?'
   192       }, {
   193         token: 'string.regex',
   194         regex: '\\S+'
   195       }
   196     ],
   197     key: [
   198       {
   199         token: 'keyword.operator',
   200         regex: '[.?@!]+'
   201       }, {
   202         token: 'identifier',
   203         regex: identifier,
   204         next: 'start'
   205       }, {
   206         token: 'text',
   207         regex: '',
   208         next: 'start'
   209       }
   210     ],
   211     comment: [
   212       {
   213         token: 'comment.doc',
   214         regex: '.*?\\*/',
   215         next: 'start'
   216       }, {
   217         token: 'comment.doc',
   218         regex: '.+'
   219       }
   220     ],
   221     qdoc: [
   222       {
   223         token: 'string',
   224         regex: ".*?'''",
   225         next: 'key'
   226       }, stringfill
   227     ],
   228     qqdoc: [
   229       {
   230         token: 'string',
   231         regex: '.*?"""',
   232         next: 'key'
   233       }, stringfill
   234     ],
   235     qstring: [
   236       {
   237         token: 'string',
   238         regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
   239         next: 'key'
   240       }, stringfill
   241     ],
   242     qqstring: [
   243       {
   244         token: 'string',
   245         regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
   246         next: 'key'
   247       }, stringfill
   248     ],
   249     js: [
   250       {
   251         token: 'string',
   252         regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
   253         next: 'key'
   254       }, stringfill
   255     ],
   256     words: [
   257       {
   258         token: 'string',
   259         regex: '.*?\\]>',
   260         next: 'key'
   261       }, stringfill
   262     ]
   263   };
   264   for (var idx in Rules) {
   265     var r = Rules[idx];
   266     if (r.splice) {
   267       for (var i = 0, len = r.length; i < len; ++i) {
   268         var rr = r[i];
   269         if (typeof rr.regex === 'string') {
   270           Rules[idx][i].regex = new RegExp('^' + rr.regex);
   271         }
   272       }
   273     } else if (typeof rr.regex === 'string') {
   274       Rules[idx].regex = new RegExp('^' + r.regex);
   275     }
   276   }
   277 
   278   CodeMirror.defineMIME('text/x-livescript', 'livescript');
   279 
   280 });



Download modules/editor/codemirror/mode/livescript/livescript.js


History
Sun, 17 Dec 2017 01:14:09 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.