[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"), require("../javascript/javascript"), require("../css/css"), require("../htmlmixed/htmlmixed"));
   7    else if (typeof define == "function" && define.amd) // AMD
   8      define(["../../lib/codemirror", "../javascript/javascript", "../css/css", "../htmlmixed/htmlmixed"], mod);
   9    else // Plain browser env
  10      mod(CodeMirror);
  11  })(function(CodeMirror) {
  12  "use strict";
  13  
  14  CodeMirror.defineMode("pug", function (config) {
  15    // token types
  16    var KEYWORD = 'keyword';
  17    var DOCTYPE = 'meta';
  18    var ID = 'builtin';
  19    var CLASS = 'qualifier';
  20  
  21    var ATTRS_NEST = {
  22      '{': '}',
  23      '(': ')',
  24      '[': ']'
  25    };
  26  
  27    var jsMode = CodeMirror.getMode(config, 'javascript');
  28  
  29    function State() {
  30      this.javaScriptLine = false;
  31      this.javaScriptLineExcludesColon = false;
  32  
  33      this.javaScriptArguments = false;
  34      this.javaScriptArgumentsDepth = 0;
  35  
  36      this.isInterpolating = false;
  37      this.interpolationNesting = 0;
  38  
  39      this.jsState = CodeMirror.startState(jsMode);
  40  
  41      this.restOfLine = '';
  42  
  43      this.isIncludeFiltered = false;
  44      this.isEach = false;
  45  
  46      this.lastTag = '';
  47      this.scriptType = '';
  48  
  49      // Attributes Mode
  50      this.isAttrs = false;
  51      this.attrsNest = [];
  52      this.inAttributeName = true;
  53      this.attributeIsType = false;
  54      this.attrValue = '';
  55  
  56      // Indented Mode
  57      this.indentOf = Infinity;
  58      this.indentToken = '';
  59  
  60      this.innerMode = null;
  61      this.innerState = null;
  62  
  63      this.innerModeForLine = false;
  64    }
  65    /**
  66     * Safely copy a state
  67     *
  68     * @return {State}
  69     */
  70    State.prototype.copy = function () {
  71      var res = new State();
  72      res.javaScriptLine = this.javaScriptLine;
  73      res.javaScriptLineExcludesColon = this.javaScriptLineExcludesColon;
  74      res.javaScriptArguments = this.javaScriptArguments;
  75      res.javaScriptArgumentsDepth = this.javaScriptArgumentsDepth;
  76      res.isInterpolating = this.isInterpolating;
  77      res.interpolationNesting = this.interpolationNesting;
  78  
  79      res.jsState = CodeMirror.copyState(jsMode, this.jsState);
  80  
  81      res.innerMode = this.innerMode;
  82      if (this.innerMode && this.innerState) {
  83        res.innerState = CodeMirror.copyState(this.innerMode, this.innerState);
  84      }
  85  
  86      res.restOfLine = this.restOfLine;
  87  
  88      res.isIncludeFiltered = this.isIncludeFiltered;
  89      res.isEach = this.isEach;
  90      res.lastTag = this.lastTag;
  91      res.scriptType = this.scriptType;
  92      res.isAttrs = this.isAttrs;
  93      res.attrsNest = this.attrsNest.slice();
  94      res.inAttributeName = this.inAttributeName;
  95      res.attributeIsType = this.attributeIsType;
  96      res.attrValue = this.attrValue;
  97      res.indentOf = this.indentOf;
  98      res.indentToken = this.indentToken;
  99  
 100      res.innerModeForLine = this.innerModeForLine;
 101  
 102      return res;
 103    };
 104  
 105    function javaScript(stream, state) {
 106      if (stream.sol()) {
 107        // if javaScriptLine was set at end of line, ignore it
 108        state.javaScriptLine = false;
 109        state.javaScriptLineExcludesColon = false;
 110      }
 111      if (state.javaScriptLine) {
 112        if (state.javaScriptLineExcludesColon && stream.peek() === ':') {
 113          state.javaScriptLine = false;
 114          state.javaScriptLineExcludesColon = false;
 115          return;
 116        }
 117        var tok = jsMode.token(stream, state.jsState);
 118        if (stream.eol()) state.javaScriptLine = false;
 119        return tok || true;
 120      }
 121    }
 122    function javaScriptArguments(stream, state) {
 123      if (state.javaScriptArguments) {
 124        if (state.javaScriptArgumentsDepth === 0 && stream.peek() !== '(') {
 125          state.javaScriptArguments = false;
 126          return;
 127        }
 128        if (stream.peek() === '(') {
 129          state.javaScriptArgumentsDepth++;
 130        } else if (stream.peek() === ')') {
 131          state.javaScriptArgumentsDepth--;
 132        }
 133        if (state.javaScriptArgumentsDepth === 0) {
 134          state.javaScriptArguments = false;
 135          return;
 136        }
 137  
 138        var tok = jsMode.token(stream, state.jsState);
 139        return tok || true;
 140      }
 141    }
 142  
 143    function yieldStatement(stream) {
 144      if (stream.match(/^yield\b/)) {
 145          return 'keyword';
 146      }
 147    }
 148  
 149    function doctype(stream) {
 150      if (stream.match(/^(?:doctype) *([^\n]+)?/)) {
 151          return DOCTYPE;
 152      }
 153    }
 154  
 155    function interpolation(stream, state) {
 156      if (stream.match('#{')) {
 157        state.isInterpolating = true;
 158        state.interpolationNesting = 0;
 159        return 'punctuation';
 160      }
 161    }
 162  
 163    function interpolationContinued(stream, state) {
 164      if (state.isInterpolating) {
 165        if (stream.peek() === '}') {
 166          state.interpolationNesting--;
 167          if (state.interpolationNesting < 0) {
 168            stream.next();
 169            state.isInterpolating = false;
 170            return 'punctuation';
 171          }
 172        } else if (stream.peek() === '{') {
 173          state.interpolationNesting++;
 174        }
 175        return jsMode.token(stream, state.jsState) || true;
 176      }
 177    }
 178  
 179    function caseStatement(stream, state) {
 180      if (stream.match(/^case\b/)) {
 181        state.javaScriptLine = true;
 182        return KEYWORD;
 183      }
 184    }
 185  
 186    function when(stream, state) {
 187      if (stream.match(/^when\b/)) {
 188        state.javaScriptLine = true;
 189        state.javaScriptLineExcludesColon = true;
 190        return KEYWORD;
 191      }
 192    }
 193  
 194    function defaultStatement(stream) {
 195      if (stream.match(/^default\b/)) {
 196        return KEYWORD;
 197      }
 198    }
 199  
 200    function extendsStatement(stream, state) {
 201      if (stream.match(/^extends?\b/)) {
 202        state.restOfLine = 'string';
 203        return KEYWORD;
 204      }
 205    }
 206  
 207    function append(stream, state) {
 208      if (stream.match(/^append\b/)) {
 209        state.restOfLine = 'variable';
 210        return KEYWORD;
 211      }
 212    }
 213    function prepend(stream, state) {
 214      if (stream.match(/^prepend\b/)) {
 215        state.restOfLine = 'variable';
 216        return KEYWORD;
 217      }
 218    }
 219    function block(stream, state) {
 220      if (stream.match(/^block\b *(?:(prepend|append)\b)?/)) {
 221        state.restOfLine = 'variable';
 222        return KEYWORD;
 223      }
 224    }
 225  
 226    function include(stream, state) {
 227      if (stream.match(/^include\b/)) {
 228        state.restOfLine = 'string';
 229        return KEYWORD;
 230      }
 231    }
 232  
 233    function includeFiltered(stream, state) {
 234      if (stream.match(/^include:([a-zA-Z0-9\-]+)/, false) && stream.match('include')) {
 235        state.isIncludeFiltered = true;
 236        return KEYWORD;
 237      }
 238    }
 239  
 240    function includeFilteredContinued(stream, state) {
 241      if (state.isIncludeFiltered) {
 242        var tok = filter(stream, state);
 243        state.isIncludeFiltered = false;
 244        state.restOfLine = 'string';
 245        return tok;
 246      }
 247    }
 248  
 249    function mixin(stream, state) {
 250      if (stream.match(/^mixin\b/)) {
 251        state.javaScriptLine = true;
 252        return KEYWORD;
 253      }
 254    }
 255  
 256    function call(stream, state) {
 257      if (stream.match(/^\+([-\w]+)/)) {
 258        if (!stream.match(/^\( *[-\w]+ *=/, false)) {
 259          state.javaScriptArguments = true;
 260          state.javaScriptArgumentsDepth = 0;
 261        }
 262        return 'variable';
 263      }
 264      if (stream.match('+#{', false)) {
 265        stream.next();
 266        state.mixinCallAfter = true;
 267        return interpolation(stream, state);
 268      }
 269    }
 270    function callArguments(stream, state) {
 271      if (state.mixinCallAfter) {
 272        state.mixinCallAfter = false;
 273        if (!stream.match(/^\( *[-\w]+ *=/, false)) {
 274          state.javaScriptArguments = true;
 275          state.javaScriptArgumentsDepth = 0;
 276        }
 277        return true;
 278      }
 279    }
 280  
 281    function conditional(stream, state) {
 282      if (stream.match(/^(if|unless|else if|else)\b/)) {
 283        state.javaScriptLine = true;
 284        return KEYWORD;
 285      }
 286    }
 287  
 288    function each(stream, state) {
 289      if (stream.match(/^(- *)?(each|for)\b/)) {
 290        state.isEach = true;
 291        return KEYWORD;
 292      }
 293    }
 294    function eachContinued(stream, state) {
 295      if (state.isEach) {
 296        if (stream.match(/^ in\b/)) {
 297          state.javaScriptLine = true;
 298          state.isEach = false;
 299          return KEYWORD;
 300        } else if (stream.sol() || stream.eol()) {
 301          state.isEach = false;
 302        } else if (stream.next()) {
 303          while (!stream.match(/^ in\b/, false) && stream.next());
 304          return 'variable';
 305        }
 306      }
 307    }
 308  
 309    function whileStatement(stream, state) {
 310      if (stream.match(/^while\b/)) {
 311        state.javaScriptLine = true;
 312        return KEYWORD;
 313      }
 314    }
 315  
 316    function tag(stream, state) {
 317      var captures;
 318      if (captures = stream.match(/^(\w(?:[-:\w]*\w)?)\/?/)) {
 319        state.lastTag = captures[1].toLowerCase();
 320        if (state.lastTag === 'script') {
 321          state.scriptType = 'application/javascript';
 322        }
 323        return 'tag';
 324      }
 325    }
 326  
 327    function filter(stream, state) {
 328      if (stream.match(/^:([\w\-]+)/)) {
 329        var innerMode;
 330        if (config && config.innerModes) {
 331          innerMode = config.innerModes(stream.current().substring(1));
 332        }
 333        if (!innerMode) {
 334          innerMode = stream.current().substring(1);
 335        }
 336        if (typeof innerMode === 'string') {
 337          innerMode = CodeMirror.getMode(config, innerMode);
 338        }
 339        setInnerMode(stream, state, innerMode);
 340        return 'atom';
 341      }
 342    }
 343  
 344    function code(stream, state) {
 345      if (stream.match(/^(!?=|-)/)) {
 346        state.javaScriptLine = true;
 347        return 'punctuation';
 348      }
 349    }
 350  
 351    function id(stream) {
 352      if (stream.match(/^#([\w-]+)/)) {
 353        return ID;
 354      }
 355    }
 356  
 357    function className(stream) {
 358      if (stream.match(/^\.([\w-]+)/)) {
 359        return CLASS;
 360      }
 361    }
 362  
 363    function attrs(stream, state) {
 364      if (stream.peek() == '(') {
 365        stream.next();
 366        state.isAttrs = true;
 367        state.attrsNest = [];
 368        state.inAttributeName = true;
 369        state.attrValue = '';
 370        state.attributeIsType = false;
 371        return 'punctuation';
 372      }
 373    }
 374  
 375    function attrsContinued(stream, state) {
 376      if (state.isAttrs) {
 377        if (ATTRS_NEST[stream.peek()]) {
 378          state.attrsNest.push(ATTRS_NEST[stream.peek()]);
 379        }
 380        if (state.attrsNest[state.attrsNest.length - 1] === stream.peek()) {
 381          state.attrsNest.pop();
 382        } else  if (stream.eat(')')) {
 383          state.isAttrs = false;
 384          return 'punctuation';
 385        }
 386        if (state.inAttributeName && stream.match(/^[^=,\)!]+/)) {
 387          if (stream.peek() === '=' || stream.peek() === '!') {
 388            state.inAttributeName = false;
 389            state.jsState = CodeMirror.startState(jsMode);
 390            if (state.lastTag === 'script' && stream.current().trim().toLowerCase() === 'type') {
 391              state.attributeIsType = true;
 392            } else {
 393              state.attributeIsType = false;
 394            }
 395          }
 396          return 'attribute';
 397        }
 398  
 399        var tok = jsMode.token(stream, state.jsState);
 400        if (state.attributeIsType && tok === 'string') {
 401          state.scriptType = stream.current().toString();
 402        }
 403        if (state.attrsNest.length === 0 && (tok === 'string' || tok === 'variable' || tok === 'keyword')) {
 404          try {
 405            Function('', 'var x ' + state.attrValue.replace(/,\s*$/, '').replace(/^!/, ''));
 406            state.inAttributeName = true;
 407            state.attrValue = '';
 408            stream.backUp(stream.current().length);
 409            return attrsContinued(stream, state);
 410          } catch (ex) {
 411            //not the end of an attribute
 412          }
 413        }
 414        state.attrValue += stream.current();
 415        return tok || true;
 416      }
 417    }
 418  
 419    function attributesBlock(stream, state) {
 420      if (stream.match(/^&attributes\b/)) {
 421        state.javaScriptArguments = true;
 422        state.javaScriptArgumentsDepth = 0;
 423        return 'keyword';
 424      }
 425    }
 426  
 427    function indent(stream) {
 428      if (stream.sol() && stream.eatSpace()) {
 429        return 'indent';
 430      }
 431    }
 432  
 433    function comment(stream, state) {
 434      if (stream.match(/^ *\/\/(-)?([^\n]*)/)) {
 435        state.indentOf = stream.indentation();
 436        state.indentToken = 'comment';
 437        return 'comment';
 438      }
 439    }
 440  
 441    function colon(stream) {
 442      if (stream.match(/^: */)) {
 443        return 'colon';
 444      }
 445    }
 446  
 447    function text(stream, state) {
 448      if (stream.match(/^(?:\| ?| )([^\n]+)/)) {
 449        return 'string';
 450      }
 451      if (stream.match(/^(<[^\n]*)/, false)) {
 452        // html string
 453        setInnerMode(stream, state, 'htmlmixed');
 454        state.innerModeForLine = true;
 455        return innerMode(stream, state, true);
 456      }
 457    }
 458  
 459    function dot(stream, state) {
 460      if (stream.eat('.')) {
 461        var innerMode = null;
 462        if (state.lastTag === 'script' && state.scriptType.toLowerCase().indexOf('javascript') != -1) {
 463          innerMode = state.scriptType.toLowerCase().replace(/"|'/g, '');
 464        } else if (state.lastTag === 'style') {
 465          innerMode = 'css';
 466        }
 467        setInnerMode(stream, state, innerMode);
 468        return 'dot';
 469      }
 470    }
 471  
 472    function fail(stream) {
 473      stream.next();
 474      return null;
 475    }
 476  
 477  
 478    function setInnerMode(stream, state, mode) {
 479      mode = CodeMirror.mimeModes[mode] || mode;
 480      mode = config.innerModes ? config.innerModes(mode) || mode : mode;
 481      mode = CodeMirror.mimeModes[mode] || mode;
 482      mode = CodeMirror.getMode(config, mode);
 483      state.indentOf = stream.indentation();
 484  
 485      if (mode && mode.name !== 'null') {
 486        state.innerMode = mode;
 487      } else {
 488        state.indentToken = 'string';
 489      }
 490    }
 491    function innerMode(stream, state, force) {
 492      if (stream.indentation() > state.indentOf || (state.innerModeForLine && !stream.sol()) || force) {
 493        if (state.innerMode) {
 494          if (!state.innerState) {
 495            state.innerState = state.innerMode.startState ? CodeMirror.startState(state.innerMode, stream.indentation()) : {};
 496          }
 497          return stream.hideFirstChars(state.indentOf + 2, function () {
 498            return state.innerMode.token(stream, state.innerState) || true;
 499          });
 500        } else {
 501          stream.skipToEnd();
 502          return state.indentToken;
 503        }
 504      } else if (stream.sol()) {
 505        state.indentOf = Infinity;
 506        state.indentToken = null;
 507        state.innerMode = null;
 508        state.innerState = null;
 509      }
 510    }
 511    function restOfLine(stream, state) {
 512      if (stream.sol()) {
 513        // if restOfLine was set at end of line, ignore it
 514        state.restOfLine = '';
 515      }
 516      if (state.restOfLine) {
 517        stream.skipToEnd();
 518        var tok = state.restOfLine;
 519        state.restOfLine = '';
 520        return tok;
 521      }
 522    }
 523  
 524  
 525    function startState() {
 526      return new State();
 527    }
 528    function copyState(state) {
 529      return state.copy();
 530    }
 531    /**
 532     * Get the next token in the stream
 533     *
 534     * @param {Stream} stream
 535     * @param {State} state
 536     */
 537    function nextToken(stream, state) {
 538      var tok = innerMode(stream, state)
 539        || restOfLine(stream, state)
 540        || interpolationContinued(stream, state)
 541        || includeFilteredContinued(stream, state)
 542        || eachContinued(stream, state)
 543        || attrsContinued(stream, state)
 544        || javaScript(stream, state)
 545        || javaScriptArguments(stream, state)
 546        || callArguments(stream, state)
 547  
 548        || yieldStatement(stream)
 549        || doctype(stream)
 550        || interpolation(stream, state)
 551        || caseStatement(stream, state)
 552        || when(stream, state)
 553        || defaultStatement(stream)
 554        || extendsStatement(stream, state)
 555        || append(stream, state)
 556        || prepend(stream, state)
 557        || block(stream, state)
 558        || include(stream, state)
 559        || includeFiltered(stream, state)
 560        || mixin(stream, state)
 561        || call(stream, state)
 562        || conditional(stream, state)
 563        || each(stream, state)
 564        || whileStatement(stream, state)
 565        || tag(stream, state)
 566        || filter(stream, state)
 567        || code(stream, state)
 568        || id(stream)
 569        || className(stream)
 570        || attrs(stream, state)
 571        || attributesBlock(stream, state)
 572        || indent(stream)
 573        || text(stream, state)
 574        || comment(stream, state)
 575        || colon(stream)
 576        || dot(stream, state)
 577        || fail(stream);
 578  
 579      return tok === true ? null : tok;
 580    }
 581    return {
 582      startState: startState,
 583      copyState: copyState,
 584      token: nextToken
 585    };
 586  }, 'javascript', 'css', 'htmlmixed');
 587  
 588  CodeMirror.defineMIME('text/x-pug', 'pug');
 589  CodeMirror.defineMIME('text/x-jade', 'pug');
 590  
 591  });