File modules/editor/codemirror/mode/xml/xml.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 (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 var htmlConfig = {
    15   autoSelfClosers: {'area': true, 'base': true, 'br': true, 'col': true, 'command': true,
    16                     'embed': true, 'frame': true, 'hr': true, 'img': true, 'input': true,
    17                     'keygen': true, 'link': true, 'meta': true, 'param': true, 'source': true,
    18                     'track': true, 'wbr': true, 'menuitem': true},
    19   implicitlyClosed: {'dd': true, 'li': true, 'optgroup': true, 'option': true, 'p': true,
    20                      'rp': true, 'rt': true, 'tbody': true, 'td': true, 'tfoot': true,
    21                      'th': true, 'tr': true},
    22   contextGrabbers: {
    23     'dd': {'dd': true, 'dt': true},
    24     'dt': {'dd': true, 'dt': true},
    25     'li': {'li': true},
    26     'option': {'option': true, 'optgroup': true},
    27     'optgroup': {'optgroup': true},
    28     'p': {'address': true, 'article': true, 'aside': true, 'blockquote': true, 'dir': true,
    29           'div': true, 'dl': true, 'fieldset': true, 'footer': true, 'form': true,
    30           'h1': true, 'h2': true, 'h3': true, 'h4': true, 'h5': true, 'h6': true,
    31           'header': true, 'hgroup': true, 'hr': true, 'menu': true, 'nav': true, 'ol': true,
    32           'p': true, 'pre': true, 'section': true, 'table': true, 'ul': true},
    33     'rp': {'rp': true, 'rt': true},
    34     'rt': {'rp': true, 'rt': true},
    35     'tbody': {'tbody': true, 'tfoot': true},
    36     'td': {'td': true, 'th': true},
    37     'tfoot': {'tbody': true},
    38     'th': {'td': true, 'th': true},
    39     'thead': {'tbody': true, 'tfoot': true},
    40     'tr': {'tr': true}
    41   },
    42   doNotIndent: {"pre": true},
    43   allowUnquoted: true,
    44   allowMissing: true,
    45   caseFold: true
    46 }
    47 
    48 var xmlConfig = {
    49   autoSelfClosers: {},
    50   implicitlyClosed: {},
    51   contextGrabbers: {},
    52   doNotIndent: {},
    53   allowUnquoted: false,
    54   allowMissing: false,
    55   caseFold: false
    56 }
    57 
    58 CodeMirror.defineMode("xml", function(editorConf, config_) {
    59   var indentUnit = editorConf.indentUnit
    60   var config = {}
    61   var defaults = config_.htmlMode ? htmlConfig : xmlConfig
    62   for (var prop in defaults) config[prop] = defaults[prop]
    63   for (var prop in config_) config[prop] = config_[prop]
    64 
    65   // Return variables for tokenizers
    66   var type, setStyle;
    67 
    68   function inText(stream, state) {
    69     function chain(parser) {
    70       state.tokenize = parser;
    71       return parser(stream, state);
    72     }
    73 
    74     var ch = stream.next();
    75     if (ch == "<") {
    76       if (stream.eat("!")) {
    77         if (stream.eat("[")) {
    78           if (stream.match("CDATA[")) return chain(inBlock("atom", "]]>"));
    79           else return null;
    80         } else if (stream.match("--")) {
    81           return chain(inBlock("comment", "-->"));
    82         } else if (stream.match("DOCTYPE", true, true)) {
    83           stream.eatWhile(/[\w\._\-]/);
    84           return chain(doctype(1));
    85         } else {
    86           return null;
    87         }
    88       } else if (stream.eat("?")) {
    89         stream.eatWhile(/[\w\._\-]/);
    90         state.tokenize = inBlock("meta", "?>");
    91         return "meta";
    92       } else {
    93         type = stream.eat("/") ? "closeTag" : "openTag";
    94         state.tokenize = inTag;
    95         return "tag bracket";
    96       }
    97     } else if (ch == "&") {
    98       var ok;
    99       if (stream.eat("#")) {
   100         if (stream.eat("x")) {
   101           ok = stream.eatWhile(/[a-fA-F\d]/) && stream.eat(";");
   102         } else {
   103           ok = stream.eatWhile(/[\d]/) && stream.eat(";");
   104         }
   105       } else {
   106         ok = stream.eatWhile(/[\w\.\-:]/) && stream.eat(";");
   107       }
   108       return ok ? "atom" : "error";
   109     } else {
   110       stream.eatWhile(/[^&<]/);
   111       return null;
   112     }
   113   }
   114   inText.isInText = true;
   115 
   116   function inTag(stream, state) {
   117     var ch = stream.next();
   118     if (ch == ">" || (ch == "/" && stream.eat(">"))) {
   119       state.tokenize = inText;
   120       type = ch == ">" ? "endTag" : "selfcloseTag";
   121       return "tag bracket";
   122     } else if (ch == "=") {
   123       type = "equals";
   124       return null;
   125     } else if (ch == "<") {
   126       state.tokenize = inText;
   127       state.state = baseState;
   128       state.tagName = state.tagStart = null;
   129       var next = state.tokenize(stream, state);
   130       return next ? next + " tag error" : "tag error";
   131     } else if (/[\'\"]/.test(ch)) {
   132       state.tokenize = inAttribute(ch);
   133       state.stringStartCol = stream.column();
   134       return state.tokenize(stream, state);
   135     } else {
   136       stream.match(/^[^\s\u00a0=<>\"\']*[^\s\u00a0=<>\"\'\/]/);
   137       return "word";
   138     }
   139   }
   140 
   141   function inAttribute(quote) {
   142     var closure = function(stream, state) {
   143       while (!stream.eol()) {
   144         if (stream.next() == quote) {
   145           state.tokenize = inTag;
   146           break;
   147         }
   148       }
   149       return "string";
   150     };
   151     closure.isInAttribute = true;
   152     return closure;
   153   }
   154 
   155   function inBlock(style, terminator) {
   156     return function(stream, state) {
   157       while (!stream.eol()) {
   158         if (stream.match(terminator)) {
   159           state.tokenize = inText;
   160           break;
   161         }
   162         stream.next();
   163       }
   164       return style;
   165     };
   166   }
   167   function doctype(depth) {
   168     return function(stream, state) {
   169       var ch;
   170       while ((ch = stream.next()) != null) {
   171         if (ch == "<") {
   172           state.tokenize = doctype(depth + 1);
   173           return state.tokenize(stream, state);
   174         } else if (ch == ">") {
   175           if (depth == 1) {
   176             state.tokenize = inText;
   177             break;
   178           } else {
   179             state.tokenize = doctype(depth - 1);
   180             return state.tokenize(stream, state);
   181           }
   182         }
   183       }
   184       return "meta";
   185     };
   186   }
   187 
   188   function Context(state, tagName, startOfLine) {
   189     this.prev = state.context;
   190     this.tagName = tagName;
   191     this.indent = state.indented;
   192     this.startOfLine = startOfLine;
   193     if (config.doNotIndent.hasOwnProperty(tagName) || (state.context && state.context.noIndent))
   194       this.noIndent = true;
   195   }
   196   function popContext(state) {
   197     if (state.context) state.context = state.context.prev;
   198   }
   199   function maybePopContext(state, nextTagName) {
   200     var parentTagName;
   201     while (true) {
   202       if (!state.context) {
   203         return;
   204       }
   205       parentTagName = state.context.tagName;
   206       if (!config.contextGrabbers.hasOwnProperty(parentTagName) ||
   207           !config.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {
   208         return;
   209       }
   210       popContext(state);
   211     }
   212   }
   213 
   214   function baseState(type, stream, state) {
   215     if (type == "openTag") {
   216       state.tagStart = stream.column();
   217       return tagNameState;
   218     } else if (type == "closeTag") {
   219       return closeTagNameState;
   220     } else {
   221       return baseState;
   222     }
   223   }
   224   function tagNameState(type, stream, state) {
   225     if (type == "word") {
   226       state.tagName = stream.current();
   227       setStyle = "tag";
   228       return attrState;
   229     } else {
   230       setStyle = "error";
   231       return tagNameState;
   232     }
   233   }
   234   function closeTagNameState(type, stream, state) {
   235     if (type == "word") {
   236       var tagName = stream.current();
   237       if (state.context && state.context.tagName != tagName &&
   238           config.implicitlyClosed.hasOwnProperty(state.context.tagName))
   239         popContext(state);
   240       if ((state.context && state.context.tagName == tagName) || config.matchClosing === false) {
   241         setStyle = "tag";
   242         return closeState;
   243       } else {
   244         setStyle = "tag error";
   245         return closeStateErr;
   246       }
   247     } else {
   248       setStyle = "error";
   249       return closeStateErr;
   250     }
   251   }
   252 
   253   function closeState(type, _stream, state) {
   254     if (type != "endTag") {
   255       setStyle = "error";
   256       return closeState;
   257     }
   258     popContext(state);
   259     return baseState;
   260   }
   261   function closeStateErr(type, stream, state) {
   262     setStyle = "error";
   263     return closeState(type, stream, state);
   264   }
   265 
   266   function attrState(type, _stream, state) {
   267     if (type == "word") {
   268       setStyle = "attribute";
   269       return attrEqState;
   270     } else if (type == "endTag" || type == "selfcloseTag") {
   271       var tagName = state.tagName, tagStart = state.tagStart;
   272       state.tagName = state.tagStart = null;
   273       if (type == "selfcloseTag" ||
   274           config.autoSelfClosers.hasOwnProperty(tagName)) {
   275         maybePopContext(state, tagName);
   276       } else {
   277         maybePopContext(state, tagName);
   278         state.context = new Context(state, tagName, tagStart == state.indented);
   279       }
   280       return baseState;
   281     }
   282     setStyle = "error";
   283     return attrState;
   284   }
   285   function attrEqState(type, stream, state) {
   286     if (type == "equals") return attrValueState;
   287     if (!config.allowMissing) setStyle = "error";
   288     return attrState(type, stream, state);
   289   }
   290   function attrValueState(type, stream, state) {
   291     if (type == "string") return attrContinuedState;
   292     if (type == "word" && config.allowUnquoted) {setStyle = "string"; return attrState;}
   293     setStyle = "error";
   294     return attrState(type, stream, state);
   295   }
   296   function attrContinuedState(type, stream, state) {
   297     if (type == "string") return attrContinuedState;
   298     return attrState(type, stream, state);
   299   }
   300 
   301   return {
   302     startState: function(baseIndent) {
   303       var state = {tokenize: inText,
   304                    state: baseState,
   305                    indented: baseIndent || 0,
   306                    tagName: null, tagStart: null,
   307                    context: null}
   308       if (baseIndent != null) state.baseIndent = baseIndent
   309       return state
   310     },
   311 
   312     token: function(stream, state) {
   313       if (!state.tagName && stream.sol())
   314         state.indented = stream.indentation();
   315 
   316       if (stream.eatSpace()) return null;
   317       type = null;
   318       var style = state.tokenize(stream, state);
   319       if ((style || type) && style != "comment") {
   320         setStyle = null;
   321         state.state = state.state(type || style, stream, state);
   322         if (setStyle)
   323           style = setStyle == "error" ? style + " error" : setStyle;
   324       }
   325       return style;
   326     },
   327 
   328     indent: function(state, textAfter, fullLine) {
   329       var context = state.context;
   330       // Indent multi-line strings (e.g. css).
   331       if (state.tokenize.isInAttribute) {
   332         if (state.tagStart == state.indented)
   333           return state.stringStartCol + 1;
   334         else
   335           return state.indented + indentUnit;
   336       }
   337       if (context && context.noIndent) return CodeMirror.Pass;
   338       if (state.tokenize != inTag && state.tokenize != inText)
   339         return fullLine ? fullLine.match(/^(\s*)/)[0].length : 0;
   340       // Indent the starts of attribute names.
   341       if (state.tagName) {
   342         if (config.multilineTagIndentPastTag !== false)
   343           return state.tagStart + state.tagName.length + 2;
   344         else
   345           return state.tagStart + indentUnit * (config.multilineTagIndentFactor || 1);
   346       }
   347       if (config.alignCDATA && /<!\[CDATA\[/.test(textAfter)) return 0;
   348       var tagAfter = textAfter && /^<(\/)?([\w_:\.-]*)/.exec(textAfter);
   349       if (tagAfter && tagAfter[1]) { // Closing tag spotted
   350         while (context) {
   351           if (context.tagName == tagAfter[2]) {
   352             context = context.prev;
   353             break;
   354           } else if (config.implicitlyClosed.hasOwnProperty(context.tagName)) {
   355             context = context.prev;
   356           } else {
   357             break;
   358           }
   359         }
   360       } else if (tagAfter) { // Opening tag spotted
   361         while (context) {
   362           var grabbers = config.contextGrabbers[context.tagName];
   363           if (grabbers && grabbers.hasOwnProperty(tagAfter[2]))
   364             context = context.prev;
   365           else
   366             break;
   367         }
   368       }
   369       while (context && context.prev && !context.startOfLine)
   370         context = context.prev;
   371       if (context) return context.indent + indentUnit;
   372       else return state.baseIndent || 0;
   373     },
   374 
   375     electricInput: /<\/[\s\w:]+>$/,
   376     blockCommentStart: "<!--",
   377     blockCommentEnd: "-->",
   378 
   379     configuration: config.htmlMode ? "html" : "xml",
   380     helperType: config.htmlMode ? "html" : "xml",
   381 
   382     skipAttribute: function(state) {
   383       if (state.state == attrValueState)
   384         state.state = attrState
   385     }
   386   };
   387 });
   388 
   389 CodeMirror.defineMIME("text/xml", "xml");
   390 CodeMirror.defineMIME("application/xml", "xml");
   391 if (!CodeMirror.mimeModes.hasOwnProperty("text/html"))
   392   CodeMirror.defineMIME("text/html", {name: "xml", htmlMode: true});
   393 
   394 });



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