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.


      // CodeMirror, copyright (c) by Marijn Haverbeke and others
      // Distributed under an MIT license: http://codemirror.net/LICENSE
      
      /**
       * Link to the project's GitHub page:
       * https://github.com/pickhardt/coffeescript-codemirror-mode
       */
      (function(mod) {
        if (typeof exports == "object" && typeof module == "object") // CommonJS
         mod(require("../../lib/codemirror"));
       else if (typeof define == "function" && define.amd) // AMD
         define(["../../lib/codemirror"], mod);
       else // Plain browser env
         mod(CodeMirror);
     })(function(CodeMirror) {
     "use strict";
     
     CodeMirror.defineMode("coffeescript", function(conf, parserConf) {
       var ERRORCLASS = "error";
     
       function wordRegexp(words) {
         return new RegExp("^((" + words.join(")|(") + "))\\b");
       }
     
       var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/;
       var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/;
       var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;
       var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;
     
       var wordOperators = wordRegexp(["and", "or", "not",
                                       "is", "isnt", "in",
                                       "instanceof", "typeof"]);
       var indentKeywords = ["for", "while", "loop", "if", "unless", "else",
                             "switch", "try", "catch", "finally", "class"];
       var commonKeywords = ["break", "by", "continue", "debugger", "delete",
                             "do", "in", "of", "new", "return", "then",
                             "this", "@", "throw", "when", "until", "extends"];
     
       var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
     
       indentKeywords = wordRegexp(indentKeywords);
     
     
       var stringPrefixes = /^('{3}|\"{3}|['\"])/;
       var regexPrefixes = /^(\/{3}|\/)/;
       var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"];
       var constants = wordRegexp(commonConstants);
     
       // Tokenizers
       function tokenBase(stream, state) {
         // Handle scope changes
         if (stream.sol()) {
           if (state.scope.align === null) state.scope.align = false;
           var scopeOffset = state.scope.offset;
           if (stream.eatSpace()) {
             var lineOffset = stream.indentation();
             if (lineOffset > scopeOffset && state.scope.type == "coffee") {
               return "indent";
             } else if (lineOffset < scopeOffset) {
               return "dedent";
             }
             return null;
           } else {
             if (scopeOffset > 0) {
               dedent(stream, state);
             }
           }
         }
         if (stream.eatSpace()) {
           return null;
         }
     
         var ch = stream.peek();
     
         // Handle docco title comment (single line)
         if (stream.match("####")) {
           stream.skipToEnd();
           return "comment";
         }
     
         // Handle multi line comments
         if (stream.match("###")) {
           state.tokenize = longComment;
           return state.tokenize(stream, state);
         }
     
         // Single line comment
         if (ch === "#") {
           stream.skipToEnd();
           return "comment";
         }
     
         // Handle number literals
         if (stream.match(/^-?[0-9\.]/, false)) {
           var floatLiteral = false;
           // Floats
           if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
             floatLiteral = true;
           }
          if (stream.match(/^-?\d+\.\d*/)) {
            floatLiteral = true;
          }
          if (stream.match(/^-?\.\d+/)) {
            floatLiteral = true;
          }
    
          if (floatLiteral) {
            // prevent from getting extra . on 1..
            if (stream.peek() == "."){
              stream.backUp(1);
            }
            return "number";
          }
          // Integers
          var intLiteral = false;
          // Hex
          if (stream.match(/^-?0x[0-9a-f]+/i)) {
            intLiteral = true;
          }
          // Decimal
          if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
            intLiteral = true;
          }
          // Zero by itself with no other piece of number.
          if (stream.match(/^-?0(?![\dx])/i)) {
            intLiteral = true;
          }
          if (intLiteral) {
            return "number";
          }
        }
    
        // Handle strings
        if (stream.match(stringPrefixes)) {
          state.tokenize = tokenFactory(stream.current(), false, "string");
          return state.tokenize(stream, state);
        }
        // Handle regex literals
        if (stream.match(regexPrefixes)) {
          if (stream.current() != "/" || stream.match(/^.*\//, false)) { // prevent highlight of division
            state.tokenize = tokenFactory(stream.current(), true, "string-2");
            return state.tokenize(stream, state);
          } else {
            stream.backUp(1);
          }
        }
    
    
    
        // Handle operators and delimiters
        if (stream.match(operators) || stream.match(wordOperators)) {
          return "operator";
        }
        if (stream.match(delimiters)) {
          return "punctuation";
        }
    
        if (stream.match(constants)) {
          return "atom";
        }
    
        if (stream.match(atProp) || state.prop && stream.match(identifiers)) {
          return "property";
        }
    
        if (stream.match(keywords)) {
          return "keyword";
        }
    
        if (stream.match(identifiers)) {
          return "variable";
        }
    
        // Handle non-detected items
        stream.next();
        return ERRORCLASS;
      }
    
      function tokenFactory(delimiter, singleline, outclass) {
        return function(stream, state) {
          while (!stream.eol()) {
            stream.eatWhile(/[^'"\/\\]/);
            if (stream.eat("\\")) {
              stream.next();
              if (singleline && stream.eol()) {
                return outclass;
              }
            } else if (stream.match(delimiter)) {
              state.tokenize = tokenBase;
              return outclass;
            } else {
              stream.eat(/['"\/]/);
            }
          }
          if (singleline) {
            if (parserConf.singleLineStringErrors) {
              outclass = ERRORCLASS;
            } else {
              state.tokenize = tokenBase;
            }
          }
          return outclass;
        };
      }
    
      function longComment(stream, state) {
        while (!stream.eol()) {
          stream.eatWhile(/[^#]/);
          if (stream.match("###")) {
            state.tokenize = tokenBase;
            break;
          }
          stream.eatWhile("#");
        }
        return "comment";
      }
    
      function indent(stream, state, type) {
        type = type || "coffee";
        var offset = 0, align = false, alignOffset = null;
        for (var scope = state.scope; scope; scope = scope.prev) {
          if (scope.type === "coffee" || scope.type == "}") {
            offset = scope.offset + conf.indentUnit;
            break;
          }
        }
        if (type !== "coffee") {
          align = null;
          alignOffset = stream.column() + stream.current().length;
        } else if (state.scope.align) {
          state.scope.align = false;
        }
        state.scope = {
          offset: offset,
          type: type,
          prev: state.scope,
          align: align,
          alignOffset: alignOffset
        };
      }
    
      function dedent(stream, state) {
        if (!state.scope.prev) return;
        if (state.scope.type === "coffee") {
          var _indent = stream.indentation();
          var matched = false;
          for (var scope = state.scope; scope; scope = scope.prev) {
            if (_indent === scope.offset) {
              matched = true;
              break;
            }
          }
          if (!matched) {
            return true;
          }
          while (state.scope.prev && state.scope.offset !== _indent) {
            state.scope = state.scope.prev;
          }
          return false;
        } else {
          state.scope = state.scope.prev;
          return false;
        }
      }
    
      function tokenLexer(stream, state) {
        var style = state.tokenize(stream, state);
        var current = stream.current();
    
        // Handle scope changes.
        if (current === "return") {
          state.dedent = true;
        }
        if (((current === "->" || current === "=>") && stream.eol())
            || style === "indent") {
          indent(stream, state);
        }
        var delimiter_index = "[({".indexOf(current);
        if (delimiter_index !== -1) {
          indent(stream, state, "])}".slice(delimiter_index, delimiter_index+1));
        }
        if (indentKeywords.exec(current)){
          indent(stream, state);
        }
        if (current == "then"){
          dedent(stream, state);
        }
    
    
        if (style === "dedent") {
          if (dedent(stream, state)) {
            return ERRORCLASS;
          }
        }
        delimiter_index = "])}".indexOf(current);
        if (delimiter_index !== -1) {
          while (state.scope.type == "coffee" && state.scope.prev)
            state.scope = state.scope.prev;
          if (state.scope.type == current)
            state.scope = state.scope.prev;
        }
        if (state.dedent && stream.eol()) {
          if (state.scope.type == "coffee" && state.scope.prev)
            state.scope = state.scope.prev;
          state.dedent = false;
        }
    
        return style;
      }
    
      var external = {
        startState: function(basecolumn) {
          return {
            tokenize: tokenBase,
            scope: {offset:basecolumn || 0, type:"coffee", prev: null, align: false},
            prop: false,
            dedent: 0
          };
        },
    
        token: function(stream, state) {
          var fillAlign = state.scope.align === null && state.scope;
          if (fillAlign && stream.sol()) fillAlign.align = false;
    
          var style = tokenLexer(stream, state);
          if (style && style != "comment") {
            if (fillAlign) fillAlign.align = true;
            state.prop = style == "punctuation" && stream.current() == "."
          }
    
          return style;
        },
    
        indent: function(state, text) {
          if (state.tokenize != tokenBase) return 0;
          var scope = state.scope;
          var closer = text && "])}".indexOf(text.charAt(0)) > -1;
          if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev;
          var closes = closer && scope.type === text.charAt(0);
          if (scope.align)
            return scope.alignOffset - (closes ? 1 : 0);
          else
            return (closes ? scope.prev : scope).offset;
        },
    
        lineComment: "#",
        fold: "indent"
      };
      return external;
    });
    
    // IANA registered media type
    // https://www.iana.org/assignments/media-types/
    CodeMirror.defineMIME("application/vnd.coffeescript", "coffeescript");
    
    CodeMirror.defineMIME("text/x-coffeescript", "coffeescript");
    CodeMirror.defineMIME("text/coffeescript", "coffeescript");
    
    });


Download modules/editor/codemirror/mode/coffeescript/coffeescript.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.