codemirror-rails 5.10 → 5.11

data/vendor/assets/javascripts/codemirror/modes/javascript.js

@@ -13,6 +13,11 @@
 })(function(CodeMirror) {
 "use strict";
 
+function expressionAllowed(stream, state, backUp) {
+  return /^(?:operator|sof|keyword c|case|new|[\[{}\(,;:]|=>)$/.test(state.lastType) ||
+    (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - (backUp || 0))))
+}
+
 CodeMirror.defineMode("javascript", function(config, parserConfig) {
   var indentUnit = config.indentUnit;
   var statementIndent = parserConfig.statementIndent;
@@ -126,8 +131,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
       } else if (stream.eat("/")) {
         stream.skipToEnd();
         return ret("comment", "comment");
-      } else if (/^(?:operator|sof|keyword c|case|new|[\[{}\(,;:])$/.test(state.lastType) ||
-                 (state.lastType == "quasi" && /\{\s*$/.test(stream.string.slice(0, stream.pos - 1)))) {
+      } else if (expressionAllowed(stream, state, 1)) {
         readRegexp(stream);
         stream.match(/^\b(([gimyu])(?![gimyu]*\2))+\b/);
         return ret("regexp", "string-2");
@@ -533,6 +537,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
     }
     if (type == "variable") cx.marked = "property";
     if (type == "spread") return cont(pattern);
+    if (type == "}") return pass();
     return cont(expect(":"), pattern, maybeAssign);
   }
   function maybeAssign(_type, value) {
@@ -655,7 +660,7 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
         lexical: new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false),
         localVars: parserConfig.localVars,
         context: parserConfig.localVars && {vars: parserConfig.localVars},
-        indented: 0
+        indented: basecolumn || 0
       };
       if (parserConfig.globalVars && typeof parserConfig.globalVars == "object")
         state.globalVars = parserConfig.globalVars;
@@ -711,7 +716,13 @@ CodeMirror.defineMode("javascript", function(config, parserConfig) {
 
     helperType: jsonMode ? "json" : "javascript",
     jsonldMode: jsonldMode,
-    jsonMode: jsonMode
+    jsonMode: jsonMode,
+
+    expressionAllowed: expressionAllowed,
+    skipExpression: function(state) {
+      var top = state.cc[state.cc.length - 1]
+      if (top == expression || top == expressionNoComma) state.cc.pop()
+    }
   };
 });
 

data/vendor/assets/javascripts/codemirror/modes/jsx.js

@@ -0,0 +1,147 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../xml/xml"), require("../javascript/javascript"))
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../xml/xml", "../javascript/javascript"], mod)
+  else // Plain browser env
+    mod(CodeMirror)
+})(function(CodeMirror) {
+  "use strict"
+
+  // Depth means the amount of open braces in JS context, in XML
+  // context 0 means not in tag, 1 means in tag, and 2 means in tag
+  // and js block comment.
+  function Context(state, mode, depth, prev) {
+    this.state = state; this.mode = mode; this.depth = depth; this.prev = prev
+  }
+
+  function copyContext(context) {
+    return new Context(CodeMirror.copyState(context.mode, context.state),
+                       context.mode,
+                       context.depth,
+                       context.prev && copyContext(context.prev))
+  }
+
+  CodeMirror.defineMode("jsx", function(config) {
+    var xmlMode = CodeMirror.getMode(config, {name: "xml", allowMissing: true, multilineTagIndentPastTag: false})
+    var jsMode = CodeMirror.getMode(config, "javascript")
+
+    function flatXMLIndent(state) {
+      var tagName = state.tagName
+      state.tagName = null
+      var result = xmlMode.indent(state, "")
+      state.tagName = tagName
+      return result
+    }
+
+    function token(stream, state) {
+      if (state.context.mode == xmlMode)
+        return xmlToken(stream, state, state.context)
+      else
+        return jsToken(stream, state, state.context)
+    }
+
+    function xmlToken(stream, state, cx) {
+      if (cx.depth == 2) { // Inside a JS /* */ comment
+        if (stream.match(/^.*?\*\//)) cx.depth = 1
+        else stream.skipToEnd()
+        return "comment"
+      }
+
+      if (stream.peek() == "{") {
+        xmlMode.skipAttribute(cx.state)
+
+        var indent = flatXMLIndent(cx.state), xmlContext = cx.state.context
+        // If JS starts on same line as tag
+        if (xmlContext && stream.match(/^[^>]*>\s*$/, false)) {
+          while (xmlContext.prev && !xmlContext.startOfLine)
+            xmlContext = xmlContext.prev
+          // If tag starts the line, use XML indentation level
+          if (xmlContext.startOfLine) indent -= config.indentUnit
+          // Else use JS indentation level
+          else if (cx.prev.state.lexical) indent = cx.prev.state.lexical.indented
+        // Else if inside of tag
+        } else if (cx.depth == 1) {
+          indent += config.indentUnit
+        }
+
+        state.context = new Context(CodeMirror.startState(jsMode, indent),
+                                    jsMode, 0, state.context)
+        return null
+      }
+
+      if (cx.depth == 1) { // Inside of tag
+        if (stream.peek() == "<") { // Tag inside of tag
+          xmlMode.skipAttribute(cx.state)
+          state.context = new Context(CodeMirror.startState(xmlMode, flatXMLIndent(cx.state)),
+                                      xmlMode, 0, state.context)
+          return null
+        } else if (stream.match("//")) {
+          stream.skipToEnd()
+          return "comment"
+        } else if (stream.match("/*")) {
+          cx.depth = 2
+          return token(stream, state)
+        }
+      }
+
+      var style = xmlMode.token(stream, cx.state), cur = stream.current(), stop
+      if (/\btag\b/.test(style)) {
+        if (/>$/.test(cur)) {
+          if (cx.state.context) cx.depth = 0
+          else state.context = state.context.prev
+        } else if (/^</.test(cur)) {
+          cx.depth = 1
+        }
+      } else if (!style && (stop = cur.indexOf("{")) > -1) {
+        stream.backUp(cur.length - stop)
+      }
+      return style
+    }
+
+    function jsToken(stream, state, cx) {
+      if (stream.peek() == "<" && jsMode.expressionAllowed(stream, cx.state)) {
+        jsMode.skipExpression(cx.state)
+        state.context = new Context(CodeMirror.startState(xmlMode, jsMode.indent(cx.state, "")),
+                                    xmlMode, 0, state.context)
+        return null
+      }
+
+      var style = jsMode.token(stream, cx.state)
+      if (!style && cx.depth != null) {
+        var cur = stream.current()
+        if (cur == "{") {
+          cx.depth++
+        } else if (cur == "}") {
+          if (--cx.depth == 0) state.context = state.context.prev
+        }
+      }
+      return style
+    }
+
+    return {
+      startState: function() {
+        return {context: new Context(CodeMirror.startState(jsMode), jsMode)}
+      },
+
+      copyState: function(state) {
+        return {context: copyContext(state.context)}
+      },
+
+      token: token,
+
+      indent: function(state, textAfter, fullLine) {
+        return state.context.mode.indent(state.context.state, textAfter, fullLine)
+      },
+
+      innerMode: function(state) {
+        return state.context
+      }
+    }
+  }, "xml", "javascript")
+
+  CodeMirror.defineMIME("text/jsx", "jsx")
+})

data/vendor/assets/javascripts/codemirror/modes/julia.js

@@ -18,35 +18,34 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
     return new RegExp("^((" + words.join(")|(") + "))\\b");
   }
 
-  var operators = parserConf.operators || /^\.?[|&^\\%*+\-<>!=\/]=?|\?|~|:|\$|\.[<>]|<<=?|>>>?=?|\.[<>=]=|->?|\/\/|\bin\b/;
+  var operators = parserConf.operators || /^\.?[|&^\\%*+\-<>!=\/]=?|\?|~|:|\$|\.[<>]|<<=?|>>>?=?|\.[<>=]=|->?|\/\/|\bin\b(?!\()|[\u2208\u2209](?!\()/;
   var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
-  var identifiers = parserConf.identifiers|| /^[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*!*/;
+  var identifiers = parserConf.identifiers || /^[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*!*/;
   var blockOpeners = ["begin", "function", "type", "immutable", "let", "macro", "for", "while", "quote", "if", "else", "elseif", "try", "finally", "catch", "do"];
   var blockClosers = ["end", "else", "elseif", "catch", "finally"];
-  var keywordList = ['if', 'else', 'elseif', 'while', 'for', 'begin', 'let', 'end', 'do', 'try', 'catch', 'finally', 'return', 'break', 'continue', 'global', 'local', 'const', 'export', 'import', 'importall', 'using', 'function', 'macro', 'module', 'baremodule', 'type', 'immutable', 'quote', 'typealias', 'abstract', 'bitstype', 'ccall'];
-  var builtinList = ['true', 'false', 'enumerate', 'open', 'close', 'nothing', 'NaN', 'Inf', 'print', 'println', 'Int', 'Int8', 'Uint8', 'Int16', 'Uint16', 'Int32', 'Uint32', 'Int64', 'Uint64', 'Int128', 'Uint128', 'Bool', 'Char', 'Float16', 'Float32', 'Float64', 'Array', 'Vector', 'Matrix', 'String', 'UTF8String', 'ASCIIString', 'error', 'warn', 'info', '@printf'];
+  var keywordList = ['if', 'else', 'elseif', 'while', 'for', 'begin', 'let', 'end', 'do', 'try', 'catch', 'finally', 'return', 'break', 'continue', 'global', 'local', 'const', 'export', 'import', 'importall', 'using', 'function', 'macro', 'module', 'baremodule', 'type', 'immutable', 'quote', 'typealias', 'abstract', 'bitstype'];
+  var builtinList = ['true', 'false', 'nothing', 'NaN', 'Inf'];
 
   //var stringPrefixes = new RegExp("^[br]?('|\")")
-  var stringPrefixes = /^(`|'|"{3}|([br]?"))/;
+  var stringPrefixes = /^(`|'|"{3}|([brv]?"))/;
   var keywords = wordRegexp(keywordList);
   var builtins = wordRegexp(builtinList);
   var openers = wordRegexp(blockOpeners);
   var closers = wordRegexp(blockClosers);
   var macro = /^@[_A-Za-z][_A-Za-z0-9]*/;
-  var symbol = /^:[_A-Za-z][_A-Za-z0-9]*/;
+  var symbol = /^:[_A-Za-z\u00A1-\uFFFF][_A-Za-z0-9\u00A1-\uFFFF]*!*/;
+  var typeAnnotation = /^::[^.,;"{()=$\s]+({[^}]*}+)*/;
 
-  function in_array(state) {
-    var ch = cur_scope(state);
-    if(ch=="[" || ch=="{") {
+  function inArray(state) {
+    var ch = currentScope(state);
+    if (ch == '[') {
       return true;
     }
-    else {
-      return false;
-    }
+    return false;
   }
 
-  function cur_scope(state) {
-    if(state.scopes.length==0) {
+  function currentScope(state) {
+    if (state.scopes.length == 0) {
       return null;
     }
     return state.scopes[state.scopes.length - 1];
@@ -54,20 +53,34 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
 
   // tokenizers
   function tokenBase(stream, state) {
+    //Handle multiline comments
+    if (stream.match(/^#=\s*/)) {
+      state.scopes.push('#=');
+    }
+    if (currentScope(state) == '#=' && stream.match(/^=#/)) {
+      state.scopes.pop();
+      return 'comment';
+    }
+    if (state.scopes.indexOf('#=') >= 0) {
+      if (!stream.match(/.*?(?=(#=|=#))/)) {
+        stream.skipToEnd();
+      }
+      return 'comment';
+    }
+
     // Handle scope changes
-    var leaving_expr = state.leaving_expr;
-    if(stream.sol()) {
-      leaving_expr = false;
+    var leavingExpr = state.leavingExpr;
+    if (stream.sol()) {
+      leavingExpr = false;
     }
-    state.leaving_expr = false;
-    if(leaving_expr) {
-      if(stream.match(/^'+/)) {
+    state.leavingExpr = false;
+    if (leavingExpr) {
+      if (stream.match(/^'+/)) {
         return 'operator';
       }
-
     }
 
-    if(stream.match(/^\.{2,3}/)) {
+    if (stream.match(/^\.{2,3}/)) {
       return 'operator';
     }
 
@@ -76,56 +89,51 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
     }
 
     var ch = stream.peek();
-    // Handle Comments
+
+    // Handle single line comments
     if (ch === '#') {
-        stream.skipToEnd();
-        return 'comment';
-    }
-    if(ch==='[') {
-      state.scopes.push("[");
+      stream.skipToEnd();
+      return 'comment';
     }
 
-    if(ch==='{') {
-      state.scopes.push("{");
+    if (ch === '[') {
+      state.scopes.push('[');
     }
 
-    var scope=cur_scope(state);
+    var scope = currentScope(state);
 
-    if(scope==='[' && ch===']') {
+    if (scope == '[' && ch === ']') {
       state.scopes.pop();
-      state.leaving_expr=true;
+      state.leavingExpr = true;
     }
 
-    if(scope==='{' && ch==='}') {
+    if (scope == '(' && ch === ')') {
       state.scopes.pop();
-      state.leaving_expr=true;
-    }
-
-    if(ch===')') {
-      state.leaving_expr = true;
+      state.leavingExpr = true;
     }
 
     var match;
-    if(!in_array(state) && (match=stream.match(openers, false))) {
+    if (!inArray(state) && (match=stream.match(openers, false))) {
       state.scopes.push(match);
     }
 
-    if(!in_array(state) && stream.match(closers, false)) {
+    if (!inArray(state) && stream.match(closers, false)) {
       state.scopes.pop();
     }
 
-    if(in_array(state)) {
-      if(stream.match(/^end/)) {
+    if (inArray(state)) {
+      if (state.lastToken == 'end' && stream.match(/^:/)) {
+        return 'operator';
+      }
+      if (stream.match(/^end/)) {
         return 'number';
       }
-
     }
 
-    if(stream.match(/^=>/)) {
+    if (stream.match(/^=>/)) {
       return 'operator';
     }
 
-
     // Handle Number Literals
     if (stream.match(/^[0-9\.]/, false)) {
       var imMatcher = RegExp(/^im\b/);
@@ -134,10 +142,11 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
       if (stream.match(/^\d*\.(?!\.)\d+([ef][\+\-]?\d+)?/i)) { floatLiteral = true; }
       if (stream.match(/^\d+\.(?!\.)\d*/)) { floatLiteral = true; }
       if (stream.match(/^\.\d+/)) { floatLiteral = true; }
+      if (stream.match(/^0x\.[0-9a-f]+p[\+\-]?\d+/i)) { floatLiteral = true; }
       if (floatLiteral) {
           // Float literals may be "imaginary"
           stream.match(imMatcher);
-          state.leaving_expr = true;
+          state.leavingExpr = true;
           return 'number';
       }
       // Integers
@@ -157,18 +166,27 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
       if (intLiteral) {
           // Integer literals may be "long"
           stream.match(imMatcher);
-          state.leaving_expr = true;
+          state.leavingExpr = true;
           return 'number';
       }
     }
 
-    if(stream.match(/^(::)|(<:)/)) {
+    if (stream.match(/^<:/)) {
       return 'operator';
     }
 
+    if (stream.match(typeAnnotation)) {
+      return 'builtin';
+    }
+
     // Handle symbols
-    if(!leaving_expr && stream.match(symbol)) {
-      return 'string';
+    if (!leavingExpr && stream.match(symbol) || stream.match(/:\./)) {
+      return 'builtin';
+    }
+
+    // Handle parametric types
+    if (stream.match(/^{[^}]*}(?=\()/)) {
+      return 'builtin';
     }
 
     // Handle operators and Delimiters
@@ -176,7 +194,6 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
       return 'operator';
     }
 
-
     // Handle Strings
     if (stream.match(stringPrefixes)) {
       state.tokenize = tokenStringFactory(stream.current());
@@ -187,7 +204,6 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
       return 'meta';
     }
 
-
     if (stream.match(delimiters)) {
       return null;
     }
@@ -200,21 +216,74 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
       return 'builtin';
     }
 
+    var isDefinition = state.isDefinition ||
+                       state.lastToken == 'function' ||
+                       state.lastToken == 'macro' ||
+                       state.lastToken == 'type' ||
+                       state.lastToken == 'immutable';
 
     if (stream.match(identifiers)) {
-      state.leaving_expr=true;
+      if (isDefinition) {
+        if (stream.peek() === '.') {
+          state.isDefinition = true;
+          return 'variable';
+        }
+        state.isDefinition = false;
+        return 'def';
+      }
+      if (stream.match(/^({[^}]*})*\(/, false)) {
+        return callOrDef(stream, state);
+      }
+      state.leavingExpr = true;
       return 'variable';
     }
+
     // Handle non-detected items
     stream.next();
     return ERRORCLASS;
   }
 
+  function callOrDef(stream, state) {
+    var match = stream.match(/^(\(\s*)/);
+    if (match) {
+      if (state.firstParenPos < 0)
+        state.firstParenPos = state.scopes.length;
+      state.scopes.push('(');
+      state.charsAdvanced += match[1].length;
+    }
+    if (currentScope(state) == '(' && stream.match(/^\)/)) {
+      state.scopes.pop();
+      state.charsAdvanced += 1;
+      if (state.scopes.length <= state.firstParenPos) {
+        var isDefinition = stream.match(/^\s*?=(?!=)/, false);
+        stream.backUp(state.charsAdvanced);
+        state.firstParenPos = -1;
+        state.charsAdvanced = 0;
+        if (isDefinition)
+          return 'def';
+        return 'builtin';
+      }
+    }
+    // Unfortunately javascript does not support multiline strings, so we have
+    // to undo anything done upto here if a function call or definition splits
+    // over two or more lines.
+    if (stream.match(/^$/g, false)) {
+      stream.backUp(state.charsAdvanced);
+      while (state.scopes.length > state.firstParenPos + 1)
+        state.scopes.pop();
+      state.firstParenPos = -1;
+      state.charsAdvanced = 0;
+      return 'builtin';
+    }
+    state.charsAdvanced += stream.match(/^([^()]*)/)[1].length;
+    return callOrDef(stream, state);
+  }
+
   function tokenStringFactory(delimiter) {
-    while ('rub'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
+    while ('bruv'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
       delimiter = delimiter.substr(1);
     }
-    var singleline = delimiter.length == 1;
+    var singleline = delimiter == "'";
     var OUTCLASS = 'string';
 
     function tokenString(stream, state) {
@@ -245,42 +314,38 @@ CodeMirror.defineMode("julia", function(_conf, parserConf) {
     return tokenString;
   }
 
-  function tokenLexer(stream, state) {
-    var style = state.tokenize(stream, state);
-    var current = stream.current();
-
-    // Handle '.' connected identifiers
-    if (current === '.') {
-      style = stream.match(identifiers, false) ? null : ERRORCLASS;
-      if (style === null && state.lastStyle === 'meta') {
-          // Apply 'meta' style to '.' connected identifiers when
-          // appropriate.
-        style = 'meta';
-      }
-      return style;
-    }
-
-    return style;
-  }
-
   var external = {
     startState: function() {
       return {
         tokenize: tokenBase,
         scopes: [],
-        leaving_expr: false
+        lastToken: null,
+        leavingExpr: false,
+        isDefinition: false,
+        charsAdvanced: 0,
+        firstParenPos: -1
       };
     },
 
     token: function(stream, state) {
-      var style = tokenLexer(stream, state);
-      state.lastStyle = style;
+      var style = state.tokenize(stream, state);
+      var current = stream.current();
+
+      if (current && style) {
+        state.lastToken = current;
+      }
+
+      // Handle '.' connected identifiers
+      if (current === '.') {
+        style = stream.match(identifiers, false) || stream.match(macro, false) ||
+                stream.match(/\(/, false) ? 'operator' : ERRORCLASS;
+      }
       return style;
     },
 
     indent: function(state, textAfter) {
       var delta = 0;
-      if(textAfter=="end" || textAfter=="]" || textAfter=="}" || textAfter=="else" || textAfter=="elseif" || textAfter=="catch" || textAfter=="finally") {
+      if (textAfter == "end" || textAfter == "]" || textAfter == "}" || textAfter == "else" || textAfter == "elseif" || textAfter == "catch" || textAfter == "finally") {
         delta = -1;
       }
       return (state.scopes.length + delta) * _conf.indentUnit;