[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/LICENSE
   3  
   4  (function(mod) {
   5    if (typeof exports == "object" && typeof module == "object") // CommonJS
   6      mod(require("../../lib/codemirror"));
   7    else if (typeof define == "function" && define.amd) // AMD
   8      define(["../../lib/codemirror"], mod);
   9    else // Plain browser env
  10      mod(CodeMirror);
  11  })(function(CodeMirror) {
  12    "use strict";
  13  
  14    CodeMirror.defineMode("crystal", function(config) {
  15      function wordRegExp(words, end) {
  16        return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b"));
  17      }
  18  
  19      function chain(tokenize, stream, state) {
  20        state.tokenize.push(tokenize);
  21        return tokenize(stream, state);
  22      }
  23  
  24      var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/;
  25      var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/;
  26      var indexingOperators = /^(?:\[\][?=]?)/;
  27      var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/;
  28      var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
  29      var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
  30      var keywords = wordRegExp([
  31        "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do",
  32        "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if",
  33        "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof",
  34        "private", "protected", "rescue", "return", "require", "select", "sizeof", "struct",
  35        "super", "then", "type", "typeof", "uninitialized", "union", "unless", "until", "when", "while", "with",
  36        "yield", "__DIR__", "__END_LINE__", "__FILE__", "__LINE__"
  37      ]);
  38      var atomWords = wordRegExp(["true", "false", "nil", "self"]);
  39      var indentKeywordsArray = [
  40        "def", "fun", "macro",
  41        "class", "module", "struct", "lib", "enum", "union",
  42        "do", "for"
  43      ];
  44      var indentKeywords = wordRegExp(indentKeywordsArray);
  45      var indentExpressionKeywordsArray = ["if", "unless", "case", "while", "until", "begin", "then"];
  46      var indentExpressionKeywords = wordRegExp(indentExpressionKeywordsArray);
  47      var dedentKeywordsArray = ["end", "else", "elsif", "rescue", "ensure"];
  48      var dedentKeywords = wordRegExp(dedentKeywordsArray);
  49      var dedentPunctualsArray = ["\\)", "\\}", "\\]"];
  50      var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$");
  51      var nextTokenizer = {
  52        "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef,
  53        "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType,
  54        "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType
  55      };
  56      var matching = {"[": "]", "{": "}", "(": ")", "<": ">"};
  57  
  58      function tokenBase(stream, state) {
  59        if (stream.eatSpace()) {
  60          return null;
  61        }
  62  
  63        // Macros
  64        if (state.lastToken != "\\" && stream.match("{%", false)) {
  65          return chain(tokenMacro("%", "%"), stream, state);
  66        }
  67  
  68        if (state.lastToken != "\\" && stream.match("{{", false)) {
  69          return chain(tokenMacro("{", "}"), stream, state);
  70        }
  71  
  72        // Comments
  73        if (stream.peek() == "#") {
  74          stream.skipToEnd();
  75          return "comment";
  76        }
  77  
  78        // Variables and keywords
  79        var matched;
  80        if (stream.match(idents)) {
  81          stream.eat(/[?!]/);
  82  
  83          matched = stream.current();
  84          if (stream.eat(":")) {
  85            return "atom";
  86          } else if (state.lastToken == ".") {
  87            return "property";
  88          } else if (keywords.test(matched)) {
  89            if (indentKeywords.test(matched)) {
  90              if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0) && !(matched == "def" && state.lastToken == "abstract")) {
  91                state.blocks.push(matched);
  92                state.currentIndent += 1;
  93              }
  94            } else if ((state.lastStyle == "operator" || !state.lastStyle) && indentExpressionKeywords.test(matched)) {
  95              state.blocks.push(matched);
  96              state.currentIndent += 1;
  97            } else if (matched == "end") {
  98              state.blocks.pop();
  99              state.currentIndent -= 1;
 100            }
 101  
 102            if (nextTokenizer.hasOwnProperty(matched)) {
 103              state.tokenize.push(nextTokenizer[matched]);
 104            }
 105  
 106            return "keyword";
 107          } else if (atomWords.test(matched)) {
 108            return "atom";
 109          }
 110  
 111          return "variable";
 112        }
 113  
 114        // Class variables and instance variables
 115        // or attributes
 116        if (stream.eat("@")) {
 117          if (stream.peek() == "[") {
 118            return chain(tokenNest("[", "]", "meta"), stream, state);
 119          }
 120  
 121          stream.eat("@");
 122          stream.match(idents) || stream.match(types);
 123          return "variable-2";
 124        }
 125  
 126        // Constants and types
 127        if (stream.match(types)) {
 128          return "tag";
 129        }
 130  
 131        // Symbols or ':' operator
 132        if (stream.eat(":")) {
 133          if (stream.eat("\"")) {
 134            return chain(tokenQuote("\"", "atom", false), stream, state);
 135          } else if (stream.match(idents) || stream.match(types) ||
 136                     stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) {
 137            return "atom";
 138          }
 139          stream.eat(":");
 140          return "operator";
 141        }
 142  
 143        // Strings
 144        if (stream.eat("\"")) {
 145          return chain(tokenQuote("\"", "string", true), stream, state);
 146        }
 147  
 148        // Strings or regexps or macro variables or '%' operator
 149        if (stream.peek() == "%") {
 150          var style = "string";
 151          var embed = true;
 152          var delim;
 153  
 154          if (stream.match("%r")) {
 155            // Regexps
 156            style = "string-2";
 157            delim = stream.next();
 158          } else if (stream.match("%w")) {
 159            embed = false;
 160            delim = stream.next();
 161          } else if (stream.match("%q")) {
 162            embed = false;
 163            delim = stream.next();
 164          } else {
 165            if(delim = stream.match(/^%([^\w\s=])/)) {
 166              delim = delim[1];
 167            } else if (stream.match(/^%[a-zA-Z_\u009F-\uFFFF][\w\u009F-\uFFFF]*/)) {
 168              // Macro variables
 169              return "meta";
 170            } else if (stream.eat('%')) {
 171              // '%' operator
 172              return "operator";
 173            }
 174          }
 175  
 176          if (matching.hasOwnProperty(delim)) {
 177            delim = matching[delim];
 178          }
 179          return chain(tokenQuote(delim, style, embed), stream, state);
 180        }
 181  
 182        // Here Docs
 183        if (matched = stream.match(/^<<-('?)([A-Z]\w*)\1/)) {
 184          return chain(tokenHereDoc(matched[2], !matched[1]), stream, state)
 185        }
 186  
 187        // Characters
 188        if (stream.eat("'")) {
 189          stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/);
 190          stream.eat("'");
 191          return "atom";
 192        }
 193  
 194        // Numbers
 195        if (stream.eat("0")) {
 196          if (stream.eat("x")) {
 197            stream.match(/^[0-9a-fA-F_]+/);
 198          } else if (stream.eat("o")) {
 199            stream.match(/^[0-7_]+/);
 200          } else if (stream.eat("b")) {
 201            stream.match(/^[01_]+/);
 202          }
 203          return "number";
 204        }
 205  
 206        if (stream.eat(/^\d/)) {
 207          stream.match(/^[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?/);
 208          return "number";
 209        }
 210  
 211        // Operators
 212        if (stream.match(operators)) {
 213          stream.eat("="); // Operators can follow assign symbol.
 214          return "operator";
 215        }
 216  
 217        if (stream.match(conditionalOperators) || stream.match(anotherOperators)) {
 218          return "operator";
 219        }
 220  
 221        // Parens and braces
 222        if (matched = stream.match(/[({[]/, false)) {
 223          matched = matched[0];
 224          return chain(tokenNest(matched, matching[matched], null), stream, state);
 225        }
 226  
 227        // Escapes
 228        if (stream.eat("\\")) {
 229          stream.next();
 230          return "meta";
 231        }
 232  
 233        stream.next();
 234        return null;
 235      }
 236  
 237      function tokenNest(begin, end, style, started) {
 238        return function (stream, state) {
 239          if (!started && stream.match(begin)) {
 240            state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true);
 241            state.currentIndent += 1;
 242            return style;
 243          }
 244  
 245          var nextStyle = tokenBase(stream, state);
 246          if (stream.current() === end) {
 247            state.tokenize.pop();
 248            state.currentIndent -= 1;
 249            nextStyle = style;
 250          }
 251  
 252          return nextStyle;
 253        };
 254      }
 255  
 256      function tokenMacro(begin, end, started) {
 257        return function (stream, state) {
 258          if (!started && stream.match("{" + begin)) {
 259            state.currentIndent += 1;
 260            state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true);
 261            return "meta";
 262          }
 263  
 264          if (stream.match(end + "}")) {
 265            state.currentIndent -= 1;
 266            state.tokenize.pop();
 267            return "meta";
 268          }
 269  
 270          return tokenBase(stream, state);
 271        };
 272      }
 273  
 274      function tokenMacroDef(stream, state) {
 275        if (stream.eatSpace()) {
 276          return null;
 277        }
 278  
 279        var matched;
 280        if (matched = stream.match(idents)) {
 281          if (matched == "def") {
 282            return "keyword";
 283          }
 284          stream.eat(/[?!]/);
 285        }
 286  
 287        state.tokenize.pop();
 288        return "def";
 289      }
 290  
 291      function tokenFollowIdent(stream, state) {
 292        if (stream.eatSpace()) {
 293          return null;
 294        }
 295  
 296        if (stream.match(idents)) {
 297          stream.eat(/[!?]/);
 298        } else {
 299          stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators);
 300        }
 301        state.tokenize.pop();
 302        return "def";
 303      }
 304  
 305      function tokenFollowType(stream, state) {
 306        if (stream.eatSpace()) {
 307          return null;
 308        }
 309  
 310        stream.match(types);
 311        state.tokenize.pop();
 312        return "def";
 313      }
 314  
 315      function tokenQuote(end, style, embed) {
 316        return function (stream, state) {
 317          var escaped = false;
 318  
 319          while (stream.peek()) {
 320            if (!escaped) {
 321              if (stream.match("{%", false)) {
 322                state.tokenize.push(tokenMacro("%", "%"));
 323                return style;
 324              }
 325  
 326              if (stream.match("{{", false)) {
 327                state.tokenize.push(tokenMacro("{", "}"));
 328                return style;
 329              }
 330  
 331              if (embed && stream.match("#{", false)) {
 332                state.tokenize.push(tokenNest("#{", "}", "meta"));
 333                return style;
 334              }
 335  
 336              var ch = stream.next();
 337  
 338              if (ch == end) {
 339                state.tokenize.pop();
 340                return style;
 341              }
 342  
 343              escaped = embed && ch == "\\";
 344            } else {
 345              stream.next();
 346              escaped = false;
 347            }
 348          }
 349  
 350          return style;
 351        };
 352      }
 353  
 354      function tokenHereDoc(phrase, embed) {
 355        return function (stream, state) {
 356          if (stream.sol()) {
 357            stream.eatSpace()
 358            if (stream.match(phrase)) {
 359              state.tokenize.pop();
 360              return "string";
 361            }
 362          }
 363  
 364          var escaped = false;
 365          while (stream.peek()) {
 366            if (!escaped) {
 367              if (stream.match("{%", false)) {
 368                state.tokenize.push(tokenMacro("%", "%"));
 369                return "string";
 370              }
 371  
 372              if (stream.match("{{", false)) {
 373                state.tokenize.push(tokenMacro("{", "}"));
 374                return "string";
 375              }
 376  
 377              if (embed && stream.match("#{", false)) {
 378                state.tokenize.push(tokenNest("#{", "}", "meta"));
 379                return "string";
 380              }
 381  
 382              escaped = embed && stream.next() == "\\";
 383            } else {
 384              stream.next();
 385              escaped = false;
 386            }
 387          }
 388  
 389          return "string";
 390        }
 391      }
 392  
 393      return {
 394        startState: function () {
 395          return {
 396            tokenize: [tokenBase],
 397            currentIndent: 0,
 398            lastToken: null,
 399            lastStyle: null,
 400            blocks: []
 401          };
 402        },
 403  
 404        token: function (stream, state) {
 405          var style = state.tokenize[state.tokenize.length - 1](stream, state);
 406          var token = stream.current();
 407  
 408          if (style && style != "comment") {
 409            state.lastToken = token;
 410            state.lastStyle = style;
 411          }
 412  
 413          return style;
 414        },
 415  
 416        indent: function (state, textAfter) {
 417          textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, "");
 418  
 419          if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) {
 420            return config.indentUnit * (state.currentIndent - 1);
 421          }
 422  
 423          return config.indentUnit * state.currentIndent;
 424        },
 425  
 426        fold: "indent",
 427        electricInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true),
 428        lineComment: '#'
 429      };
 430    });
 431  
 432    CodeMirror.defineMIME("text/x-crystal", "crystal");
 433  });