[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  // Slim Highlighting for CodeMirror copyright (c) HicknHack Software Gmbh
   5  
   6  (function(mod) {
   7    if (typeof exports == "object" && typeof module == "object") // CommonJS
   8      mod(require("../../lib/codemirror"), require("../htmlmixed/htmlmixed"), require("../ruby/ruby"));
   9    else if (typeof define == "function" && define.amd) // AMD
  10      define(["../../lib/codemirror", "../htmlmixed/htmlmixed", "../ruby/ruby"], mod);
  11    else // Plain browser env
  12      mod(CodeMirror);
  13  })(function(CodeMirror) {
  14  "use strict";
  15  
  16    CodeMirror.defineMode("slim", function(config) {
  17      var htmlMode = CodeMirror.getMode(config, {name: "htmlmixed"});
  18      var rubyMode = CodeMirror.getMode(config, "ruby");
  19      var modes = { html: htmlMode, ruby: rubyMode };
  20      var embedded = {
  21        ruby: "ruby",
  22        javascript: "javascript",
  23        css: "text/css",
  24        sass: "text/x-sass",
  25        scss: "text/x-scss",
  26        less: "text/x-less",
  27        styl: "text/x-styl", // no highlighting so far
  28        coffee: "coffeescript",
  29        asciidoc: "text/x-asciidoc",
  30        markdown: "text/x-markdown",
  31        textile: "text/x-textile", // no highlighting so far
  32        creole: "text/x-creole", // no highlighting so far
  33        wiki: "text/x-wiki", // no highlighting so far
  34        mediawiki: "text/x-mediawiki", // no highlighting so far
  35        rdoc: "text/x-rdoc", // no highlighting so far
  36        builder: "text/x-builder", // no highlighting so far
  37        nokogiri: "text/x-nokogiri", // no highlighting so far
  38        erb: "application/x-erb"
  39      };
  40      var embeddedRegexp = function(map){
  41        var arr = [];
  42        for(var key in map) arr.push(key);
  43        return new RegExp("^("+arr.join('|')+"):");
  44      }(embedded);
  45  
  46      var styleMap = {
  47        "commentLine": "comment",
  48        "slimSwitch": "operator special",
  49        "slimTag": "tag",
  50        "slimId": "attribute def",
  51        "slimClass": "attribute qualifier",
  52        "slimAttribute": "attribute",
  53        "slimSubmode": "keyword special",
  54        "closeAttributeTag": null,
  55        "slimDoctype": null,
  56        "lineContinuation": null
  57      };
  58      var closing = {
  59        "{": "}",
  60        "[": "]",
  61        "(": ")"
  62      };
  63  
  64      var nameStartChar = "_a-zA-Z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
  65      var nameChar = nameStartChar + "\\-0-9\xB7\u0300-\u036F\u203F-\u2040";
  66      var nameRegexp = new RegExp("^[:"+nameStartChar+"](?::["+nameChar+"]|["+nameChar+"]*)");
  67      var attributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*(?=\\s*=)");
  68      var wrappedAttributeNameRegexp = new RegExp("^[:"+nameStartChar+"][:\\."+nameChar+"]*");
  69      var classNameRegexp = /^\.-?[_a-zA-Z]+[\w\-]*/;
  70      var classIdRegexp = /^#[_a-zA-Z]+[\w\-]*/;
  71  
  72      function backup(pos, tokenize, style) {
  73        var restore = function(stream, state) {
  74          state.tokenize = tokenize;
  75          if (stream.pos < pos) {
  76            stream.pos = pos;
  77            return style;
  78          }
  79          return state.tokenize(stream, state);
  80        };
  81        return function(stream, state) {
  82          state.tokenize = restore;
  83          return tokenize(stream, state);
  84        };
  85      }
  86  
  87      function maybeBackup(stream, state, pat, offset, style) {
  88        var cur = stream.current();
  89        var idx = cur.search(pat);
  90        if (idx > -1) {
  91          state.tokenize = backup(stream.pos, state.tokenize, style);
  92          stream.backUp(cur.length - idx - offset);
  93        }
  94        return style;
  95      }
  96  
  97      function continueLine(state, column) {
  98        state.stack = {
  99          parent: state.stack,
 100          style: "continuation",
 101          indented: column,
 102          tokenize: state.line
 103        };
 104        state.line = state.tokenize;
 105      }
 106      function finishContinue(state) {
 107        if (state.line == state.tokenize) {
 108          state.line = state.stack.tokenize;
 109          state.stack = state.stack.parent;
 110        }
 111      }
 112  
 113      function lineContinuable(column, tokenize) {
 114        return function(stream, state) {
 115          finishContinue(state);
 116          if (stream.match(/^\\$/)) {
 117            continueLine(state, column);
 118            return "lineContinuation";
 119          }
 120          var style = tokenize(stream, state);
 121          if (stream.eol() && stream.current().match(/(?:^|[^\\])(?:\\\\)*\\$/)) {
 122            stream.backUp(1);
 123          }
 124          return style;
 125        };
 126      }
 127      function commaContinuable(column, tokenize) {
 128        return function(stream, state) {
 129          finishContinue(state);
 130          var style = tokenize(stream, state);
 131          if (stream.eol() && stream.current().match(/,$/)) {
 132            continueLine(state, column);
 133          }
 134          return style;
 135        };
 136      }
 137  
 138      function rubyInQuote(endQuote, tokenize) {
 139        // TODO: add multi line support
 140        return function(stream, state) {
 141          var ch = stream.peek();
 142          if (ch == endQuote && state.rubyState.tokenize.length == 1) {
 143            // step out of ruby context as it seems to complete processing all the braces
 144            stream.next();
 145            state.tokenize = tokenize;
 146            return "closeAttributeTag";
 147          } else {
 148            return ruby(stream, state);
 149          }
 150        };
 151      }
 152      function startRubySplat(tokenize) {
 153        var rubyState;
 154        var runSplat = function(stream, state) {
 155          if (state.rubyState.tokenize.length == 1 && !state.rubyState.context.prev) {
 156            stream.backUp(1);
 157            if (stream.eatSpace()) {
 158              state.rubyState = rubyState;
 159              state.tokenize = tokenize;
 160              return tokenize(stream, state);
 161            }
 162            stream.next();
 163          }
 164          return ruby(stream, state);
 165        };
 166        return function(stream, state) {
 167          rubyState = state.rubyState;
 168          state.rubyState = CodeMirror.startState(rubyMode);
 169          state.tokenize = runSplat;
 170          return ruby(stream, state);
 171        };
 172      }
 173  
 174      function ruby(stream, state) {
 175        return rubyMode.token(stream, state.rubyState);
 176      }
 177  
 178      function htmlLine(stream, state) {
 179        if (stream.match(/^\\$/)) {
 180          return "lineContinuation";
 181        }
 182        return html(stream, state);
 183      }
 184      function html(stream, state) {
 185        if (stream.match(/^#\{/)) {
 186          state.tokenize = rubyInQuote("}", state.tokenize);
 187          return null;
 188        }
 189        return maybeBackup(stream, state, /[^\\]#\{/, 1, htmlMode.token(stream, state.htmlState));
 190      }
 191  
 192      function startHtmlLine(lastTokenize) {
 193        return function(stream, state) {
 194          var style = htmlLine(stream, state);
 195          if (stream.eol()) state.tokenize = lastTokenize;
 196          return style;
 197        };
 198      }
 199  
 200      function startHtmlMode(stream, state, offset) {
 201        state.stack = {
 202          parent: state.stack,
 203          style: "html",
 204          indented: stream.column() + offset, // pipe + space
 205          tokenize: state.line
 206        };
 207        state.line = state.tokenize = html;
 208        return null;
 209      }
 210  
 211      function comment(stream, state) {
 212        stream.skipToEnd();
 213        return state.stack.style;
 214      }
 215  
 216      function commentMode(stream, state) {
 217        state.stack = {
 218          parent: state.stack,
 219          style: "comment",
 220          indented: state.indented + 1,
 221          tokenize: state.line
 222        };
 223        state.line = comment;
 224        return comment(stream, state);
 225      }
 226  
 227      function attributeWrapper(stream, state) {
 228        if (stream.eat(state.stack.endQuote)) {
 229          state.line = state.stack.line;
 230          state.tokenize = state.stack.tokenize;
 231          state.stack = state.stack.parent;
 232          return null;
 233        }
 234        if (stream.match(wrappedAttributeNameRegexp)) {
 235          state.tokenize = attributeWrapperAssign;
 236          return "slimAttribute";
 237        }
 238        stream.next();
 239        return null;
 240      }
 241      function attributeWrapperAssign(stream, state) {
 242        if (stream.match(/^==?/)) {
 243          state.tokenize = attributeWrapperValue;
 244          return null;
 245        }
 246        return attributeWrapper(stream, state);
 247      }
 248      function attributeWrapperValue(stream, state) {
 249        var ch = stream.peek();
 250        if (ch == '"' || ch == "\'") {
 251          state.tokenize = readQuoted(ch, "string", true, false, attributeWrapper);
 252          stream.next();
 253          return state.tokenize(stream, state);
 254        }
 255        if (ch == '[') {
 256          return startRubySplat(attributeWrapper)(stream, state);
 257        }
 258        if (stream.match(/^(true|false|nil)\b/)) {
 259          state.tokenize = attributeWrapper;
 260          return "keyword";
 261        }
 262        return startRubySplat(attributeWrapper)(stream, state);
 263      }
 264  
 265      function startAttributeWrapperMode(state, endQuote, tokenize) {
 266        state.stack = {
 267          parent: state.stack,
 268          style: "wrapper",
 269          indented: state.indented + 1,
 270          tokenize: tokenize,
 271          line: state.line,
 272          endQuote: endQuote
 273        };
 274        state.line = state.tokenize = attributeWrapper;
 275        return null;
 276      }
 277  
 278      function sub(stream, state) {
 279        if (stream.match(/^#\{/)) {
 280          state.tokenize = rubyInQuote("}", state.tokenize);
 281          return null;
 282        }
 283        var subStream = new CodeMirror.StringStream(stream.string.slice(state.stack.indented), stream.tabSize);
 284        subStream.pos = stream.pos - state.stack.indented;
 285        subStream.start = stream.start - state.stack.indented;
 286        subStream.lastColumnPos = stream.lastColumnPos - state.stack.indented;
 287        subStream.lastColumnValue = stream.lastColumnValue - state.stack.indented;
 288        var style = state.subMode.token(subStream, state.subState);
 289        stream.pos = subStream.pos + state.stack.indented;
 290        return style;
 291      }
 292      function firstSub(stream, state) {
 293        state.stack.indented = stream.column();
 294        state.line = state.tokenize = sub;
 295        return state.tokenize(stream, state);
 296      }
 297  
 298      function createMode(mode) {
 299        var query = embedded[mode];
 300        var spec = CodeMirror.mimeModes[query];
 301        if (spec) {
 302          return CodeMirror.getMode(config, spec);
 303        }
 304        var factory = CodeMirror.modes[query];
 305        if (factory) {
 306          return factory(config, {name: query});
 307        }
 308        return CodeMirror.getMode(config, "null");
 309      }
 310  
 311      function getMode(mode) {
 312        if (!modes.hasOwnProperty(mode)) {
 313          return modes[mode] = createMode(mode);
 314        }
 315        return modes[mode];
 316      }
 317  
 318      function startSubMode(mode, state) {
 319        var subMode = getMode(mode);
 320        var subState = CodeMirror.startState(subMode);
 321  
 322        state.subMode = subMode;
 323        state.subState = subState;
 324  
 325        state.stack = {
 326          parent: state.stack,
 327          style: "sub",
 328          indented: state.indented + 1,
 329          tokenize: state.line
 330        };
 331        state.line = state.tokenize = firstSub;
 332        return "slimSubmode";
 333      }
 334  
 335      function doctypeLine(stream, _state) {
 336        stream.skipToEnd();
 337        return "slimDoctype";
 338      }
 339  
 340      function startLine(stream, state) {
 341        var ch = stream.peek();
 342        if (ch == '<') {
 343          return (state.tokenize = startHtmlLine(state.tokenize))(stream, state);
 344        }
 345        if (stream.match(/^[|']/)) {
 346          return startHtmlMode(stream, state, 1);
 347        }
 348        if (stream.match(/^\/(!|\[\w+])?/)) {
 349          return commentMode(stream, state);
 350        }
 351        if (stream.match(/^(-|==?[<>]?)/)) {
 352          state.tokenize = lineContinuable(stream.column(), commaContinuable(stream.column(), ruby));
 353          return "slimSwitch";
 354        }
 355        if (stream.match(/^doctype\b/)) {
 356          state.tokenize = doctypeLine;
 357          return "keyword";
 358        }
 359  
 360        var m = stream.match(embeddedRegexp);
 361        if (m) {
 362          return startSubMode(m[1], state);
 363        }
 364  
 365        return slimTag(stream, state);
 366      }
 367  
 368      function slim(stream, state) {
 369        if (state.startOfLine) {
 370          return startLine(stream, state);
 371        }
 372        return slimTag(stream, state);
 373      }
 374  
 375      function slimTag(stream, state) {
 376        if (stream.eat('*')) {
 377          state.tokenize = startRubySplat(slimTagExtras);
 378          return null;
 379        }
 380        if (stream.match(nameRegexp)) {
 381          state.tokenize = slimTagExtras;
 382          return "slimTag";
 383        }
 384        return slimClass(stream, state);
 385      }
 386      function slimTagExtras(stream, state) {
 387        if (stream.match(/^(<>?|><?)/)) {
 388          state.tokenize = slimClass;
 389          return null;
 390        }
 391        return slimClass(stream, state);
 392      }
 393      function slimClass(stream, state) {
 394        if (stream.match(classIdRegexp)) {
 395          state.tokenize = slimClass;
 396          return "slimId";
 397        }
 398        if (stream.match(classNameRegexp)) {
 399          state.tokenize = slimClass;
 400          return "slimClass";
 401        }
 402        return slimAttribute(stream, state);
 403      }
 404      function slimAttribute(stream, state) {
 405        if (stream.match(/^([\[\{\(])/)) {
 406          return startAttributeWrapperMode(state, closing[RegExp.$1], slimAttribute);
 407        }
 408        if (stream.match(attributeNameRegexp)) {
 409          state.tokenize = slimAttributeAssign;
 410          return "slimAttribute";
 411        }
 412        if (stream.peek() == '*') {
 413          stream.next();
 414          state.tokenize = startRubySplat(slimContent);
 415          return null;
 416        }
 417        return slimContent(stream, state);
 418      }
 419      function slimAttributeAssign(stream, state) {
 420        if (stream.match(/^==?/)) {
 421          state.tokenize = slimAttributeValue;
 422          return null;
 423        }
 424        // should never happen, because of forward lookup
 425        return slimAttribute(stream, state);
 426      }
 427  
 428      function slimAttributeValue(stream, state) {
 429        var ch = stream.peek();
 430        if (ch == '"' || ch == "\'") {
 431          state.tokenize = readQuoted(ch, "string", true, false, slimAttribute);
 432          stream.next();
 433          return state.tokenize(stream, state);
 434        }
 435        if (ch == '[') {
 436          return startRubySplat(slimAttribute)(stream, state);
 437        }
 438        if (ch == ':') {
 439          return startRubySplat(slimAttributeSymbols)(stream, state);
 440        }
 441        if (stream.match(/^(true|false|nil)\b/)) {
 442          state.tokenize = slimAttribute;
 443          return "keyword";
 444        }
 445        return startRubySplat(slimAttribute)(stream, state);
 446      }
 447      function slimAttributeSymbols(stream, state) {
 448        stream.backUp(1);
 449        if (stream.match(/^[^\s],(?=:)/)) {
 450          state.tokenize = startRubySplat(slimAttributeSymbols);
 451          return null;
 452        }
 453        stream.next();
 454        return slimAttribute(stream, state);
 455      }
 456      function readQuoted(quote, style, embed, unescaped, nextTokenize) {
 457        return function(stream, state) {
 458          finishContinue(state);
 459          var fresh = stream.current().length == 0;
 460          if (stream.match(/^\\$/, fresh)) {
 461            if (!fresh) return style;
 462            continueLine(state, state.indented);
 463            return "lineContinuation";
 464          }
 465          if (stream.match(/^#\{/, fresh)) {
 466            if (!fresh) return style;
 467            state.tokenize = rubyInQuote("}", state.tokenize);
 468            return null;
 469          }
 470          var escaped = false, ch;
 471          while ((ch = stream.next()) != null) {
 472            if (ch == quote && (unescaped || !escaped)) {
 473              state.tokenize = nextTokenize;
 474              break;
 475            }
 476            if (embed && ch == "#" && !escaped) {
 477              if (stream.eat("{")) {
 478                stream.backUp(2);
 479                break;
 480              }
 481            }
 482            escaped = !escaped && ch == "\\";
 483          }
 484          if (stream.eol() && escaped) {
 485            stream.backUp(1);
 486          }
 487          return style;
 488        };
 489      }
 490      function slimContent(stream, state) {
 491        if (stream.match(/^==?/)) {
 492          state.tokenize = ruby;
 493          return "slimSwitch";
 494        }
 495        if (stream.match(/^\/$/)) { // tag close hint
 496          state.tokenize = slim;
 497          return null;
 498        }
 499        if (stream.match(/^:/)) { // inline tag
 500          state.tokenize = slimTag;
 501          return "slimSwitch";
 502        }
 503        startHtmlMode(stream, state, 0);
 504        return state.tokenize(stream, state);
 505      }
 506  
 507      var mode = {
 508        // default to html mode
 509        startState: function() {
 510          var htmlState = CodeMirror.startState(htmlMode);
 511          var rubyState = CodeMirror.startState(rubyMode);
 512          return {
 513            htmlState: htmlState,
 514            rubyState: rubyState,
 515            stack: null,
 516            last: null,
 517            tokenize: slim,
 518            line: slim,
 519            indented: 0
 520          };
 521        },
 522  
 523        copyState: function(state) {
 524          return {
 525            htmlState : CodeMirror.copyState(htmlMode, state.htmlState),
 526            rubyState: CodeMirror.copyState(rubyMode, state.rubyState),
 527            subMode: state.subMode,
 528            subState: state.subMode && CodeMirror.copyState(state.subMode, state.subState),
 529            stack: state.stack,
 530            last: state.last,
 531            tokenize: state.tokenize,
 532            line: state.line
 533          };
 534        },
 535  
 536        token: function(stream, state) {
 537          if (stream.sol()) {
 538            state.indented = stream.indentation();
 539            state.startOfLine = true;
 540            state.tokenize = state.line;
 541            while (state.stack && state.stack.indented > state.indented && state.last != "slimSubmode") {
 542              state.line = state.tokenize = state.stack.tokenize;
 543              state.stack = state.stack.parent;
 544              state.subMode = null;
 545              state.subState = null;
 546            }
 547          }
 548          if (stream.eatSpace()) return null;
 549          var style = state.tokenize(stream, state);
 550          state.startOfLine = false;
 551          if (style) state.last = style;
 552          return styleMap.hasOwnProperty(style) ? styleMap[style] : style;
 553        },
 554  
 555        blankLine: function(state) {
 556          if (state.subMode && state.subMode.blankLine) {
 557            return state.subMode.blankLine(state.subState);
 558          }
 559        },
 560  
 561        innerMode: function(state) {
 562          if (state.subMode) return {state: state.subState, mode: state.subMode};
 563          return {state: state, mode: mode};
 564        }
 565  
 566        //indent: function(state) {
 567        //  return state.indented;
 568        //}
 569      };
 570      return mode;
 571    }, "htmlmixed", "ruby");
 572  
 573    CodeMirror.defineMIME("text/x-slim", "slim");
 574    CodeMirror.defineMIME("application/x-slim", "slim");
 575  });