codemirror-rails 3.19 → 3.20

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

@@ -0,0 +1,262 @@
+CodeMirror.defineMode("julia", function(_conf, parserConf) {
+  var ERRORCLASS = 'error';
+
+  function wordRegexp(words) {
+    return new RegExp("^((" + words.join(")|(") + "))\\b");
+  }
+
+  var operators = parserConf.operators || /^(?:\.?[|&^\\%*+\-<>!=\/]=?|\?|~|:|\$|<:|\.[<>]|<<=?|>>>?=?|\.[<>=]=|->?|\/\/|\bin\b|\.{3})/;
+  var delimiters = parserConf.delimiters || /^[;,()[\]{}]/;
+  var identifiers = parserConf.identifiers|| /^[_A-Za-z][_A-Za-z0-9]*!*/;
+  var blockOpeners = ["begin", "function", "type", "immutable", "let", "macro", "for", "while", "quote", "if", "else", "elseif", "try", "finally", "catch"];
+  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', '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 stringPrefixes = new RegExp("^[br]?('|\")")
+  var stringPrefixes = /^[br]?('|"{3}|")/;
+  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 indentInfo = null;
+
+  function in_array(state) {
+    var ch = cur_scope(state);
+    if(ch=="[" || ch=="{") {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+
+  function cur_scope(state) {
+    if(state.scopes.length==0) {
+      return null;
+    }
+    return state.scopes[state.scopes.length - 1];
+  }
+
+  // tokenizers
+  function tokenBase(stream, state) {
+    // Handle scope changes
+    var leaving_expr = state.leaving_expr;
+    state.leaving_expr = false;
+    if(leaving_expr) {
+      if(stream.match(/^'+/)) {
+        return 'operator';
+      }
+      if(stream.match("...")) {
+        return 'operator';
+      }
+    }
+
+    if (stream.eatSpace()) {
+      return null;
+    }
+
+    var ch = stream.peek();
+    // Handle Comments
+    if (ch === '#') {
+        stream.skipToEnd();
+        return 'comment';
+    }
+    if(ch==='[') {
+      state.scopes.push("[");
+    }
+
+    if(ch==='{') {
+      state.scopes.push("{");
+    }
+
+    var scope=cur_scope(state);
+
+    if(scope==='[' && ch===']') {
+      state.scopes.pop();
+      state.leaving_expr=true;
+    }
+
+    if(scope==='{' && ch==='}') {
+      state.scopes.pop();
+      state.leaving_expr=true;
+    }
+
+    var match;
+    if(match=stream.match(openers, false)) {
+      state.scopes.push(match);
+    }
+
+    if(!in_array(state) && stream.match(closers, false)) {
+      state.scopes.pop();
+    }
+
+    if(in_array(state)) {
+      if(stream.match("end")) {
+        return 'number';
+      }
+
+    }
+    if(stream.match("=>")) {
+      return 'operator';
+    }
+    // Handle Number Literals
+    if (stream.match(/^[0-9\.]/, false)) {
+      var imMatcher = RegExp(/^im\b/);
+      var floatLiteral = false;
+      // Floats
+      if (stream.match(/^\d*\.\d+([ef][\+\-]?\d+)?/i)) { floatLiteral = true; }
+      if (stream.match(/^\d+\.\d*/)) { floatLiteral = true; }
+      if (stream.match(/^\.\d+/)) { floatLiteral = true; }
+      if (floatLiteral) {
+          // Float literals may be "imaginary"
+          stream.match(imMatcher);
+          return 'number';
+      }
+      // Integers
+      var intLiteral = false;
+      // Hex
+      if (stream.match(/^0x[0-9a-f]+/i)) { intLiteral = true; }
+      // Binary
+      if (stream.match(/^0b[01]+/i)) { intLiteral = true; }
+      // Octal
+      if (stream.match(/^0o[0-7]+/i)) { intLiteral = true; }
+      // Decimal
+      if (stream.match(/^[1-9]\d*(e[\+\-]?\d+)?/)) {
+          // Decimal literals may be "imaginary"
+          stream.eat(/J/i);
+          // TODO - Can you have imaginary longs?
+          intLiteral = true;
+      }
+      // Zero by itself with no other piece of number.
+      if (stream.match(/^0(?![\dx])/i)) { intLiteral = true; }
+      if (intLiteral) {
+          // Integer literals may be "long"
+          stream.match(imMatcher);
+          return 'number';
+      }
+    }
+
+    // Handle Strings
+    if (stream.match(stringPrefixes)) {
+      state.tokenize = tokenStringFactory(stream.current());
+      return state.tokenize(stream, state);
+    }
+
+    // Handle operators and Delimiters
+    if (stream.match(operators)) {
+      return 'operator';
+    }
+
+    if (stream.match(delimiters)) {
+      return null;
+    }
+
+    if (stream.match(keywords)) {
+      return 'keyword';
+    }
+
+    if (stream.match(builtins)) {
+      return 'builtin';
+    }
+
+    if (stream.match(macro)) {
+      return 'meta';
+    }
+
+    if (stream.match(identifiers)) {
+      state.leaving_expr=true;
+      return 'variable';
+    }
+    // Handle non-detected items
+    stream.next();
+    return ERRORCLASS;
+  }
+
+  function tokenStringFactory(delimiter) {
+    while ('rub'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
+      delimiter = delimiter.substr(1);
+    }
+    var singleline = delimiter.length == 1;
+    var OUTCLASS = 'string';
+
+    function tokenString(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) {
+            return ERRORCLASS;
+        } else {
+            state.tokenize = tokenBase;
+        }
+      }
+      return OUTCLASS;
+    }
+    tokenString.isString = true;
+    return tokenString;
+  }
+
+  function tokenLexer(stream, state) {
+    indentInfo = null;
+    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
+      };
+    },
+
+    token: function(stream, state) {
+      var style = tokenLexer(stream, state);
+      state.lastStyle = style;
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      var delta = 0;
+      if(textAfter=="end" || textAfter=="]" || textAfter=="}" || textAfter=="else" || textAfter=="elseif" || textAfter=="catch" || textAfter=="finally") {
+        delta = -1;
+      }
+      return (state.scopes.length + delta) * 2;
+    },
+
+    lineComment: "#",
+    fold: "indent",
+    electricChars: "edlsifyh]}"
+  };
+  return external;
+});
+
+
+CodeMirror.defineMIME("text/x-julia", "julia");

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

@@ -70,7 +70,9 @@ CodeMirror.defineMode("less", function(config) {
       stream.eatWhile(/[\a-zA-Z0-9\-_]/);
       if(stream.peek() === " ")stream.eatSpace();
       if(stream.peek() === ")" || type === ":")return ret("number", "unit");//rgba(0,0,0,.25);
-      else if(state.stack[state.stack.length-1] === "rule" && stream.peek().match(/{|,|\+|\(/) === null)return ret("number", "unit");
+      else if(stream.current().length >1){
+        if(state.stack[state.stack.length-1] === "rule" && stream.peek().match(/{|,|\+|\(/) === null)return ret("number", "unit");
+      }
       return ret("tag", "tag");
     } else if (ch == "#") {
       //we don't eat white-space, we want the hex color and or id only
@@ -204,7 +206,7 @@ CodeMirror.defineMode("less", function(config) {
         else if(type === "unit" && state.stack[state.stack.length-1] === "rule")return ret(null, "unit");
         else if(type === "unit" && state.stack[state.stack.length-1] === ";")return ret(null, "unit");
         else if(type === ")" && state.stack[state.stack.length-1] === "rule")return ret(null, "unit");
-        else if(type.match("@") !== null  && state.stack[state.stack.length-1] === "rule")return ret(null, "unit");
+        else if(type && type.match("@") !== null  && state.stack[state.stack.length-1] === "rule")return ret(null, "unit");
         //else if(type === "unit" && state.stack[state.stack.length-1] === "rule")return ret(null, stream.current());
 
         else if((type === ";" || type === "}" || type === ",") && state.stack[state.stack.length-1] === ";")return ret("tag", stream.current());

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

@@ -74,7 +74,8 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
   ,   ulRE = /^[*\-+]\s+/
   ,   olRE = /^[0-9]+\.\s+/
   ,   taskListRE = /^\[(x| )\](?=\s)/ // Must follow ulRE or olRE
-  ,   headerRE = /^(?:\={1,}|-{1,})$/
+  ,   atxHeaderRE = /^#+/
+  ,   setextHeaderRE = /^(?:\={1,}|-{1,})$/
   ,   textRE = /^[^!\[\]*_\\<>` "'(]+/;
 
   function switchInline(stream, state, f) {
@@ -127,14 +128,17 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
       state.listDepth = 0;
     }
 
+    var match = null;
     if (state.indentationDiff >= 4) {
       state.indentation -= 4;
       stream.skipToEnd();
       return code;
     } else if (stream.eatSpace()) {
       return null;
-    } else if (stream.peek() === '#' || (state.prevLineHasContent && stream.match(headerRE)) ) {
-      state.header = true;
+    } else if (match = stream.match(atxHeaderRE)) {
+      state.header = match[0].length <= 6 ? match[0].length : 6;
+    } else if (state.prevLineHasContent && (match = stream.match(setextHeaderRE))) {
+      state.header = match[0].charAt(0) == '=' ? 1 : 2;
     } else if (stream.eat('>')) {
       state.indentation++;
       state.quote = 1;
@@ -207,7 +211,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
 
     if (state.code) { styles.push(code); }
 
-    if (state.header) { styles.push(header); }
+    if (state.header) { styles.push(header); styles.push(header + state.header); }
     if (state.quote) { styles.push(state.quote % 2 ? quote1 : quote2); }
     if (state.list !== false) {
       var listMod = (state.listDepth - 1) % 3;
@@ -257,6 +261,9 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
     state.taskOpen = false;
     state.taskClosed = false;
 
+    // Get sol() value now, before character is consumed
+    var sol = stream.sol();
+
     var ch = stream.next();
 
     if (ch === '\\') {
@@ -355,7 +362,9 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
     }
     var t = getType(state);
     if (ch === '*' || (ch === '_' && !ignoreUnderscore)) {
-      if (state.strong === ch && stream.eat(ch)) { // Remove STRONG
+      if (sol && stream.peek() === ' ') {
+        // Do nothing, surrounded by newline and space
+      } else if (state.strong === ch && stream.eat(ch)) { // Remove STRONG
         state.strong = false;
         return t;
       } else if (!state.strong && stream.eat(ch)) { // Add STRONG
@@ -466,7 +475,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
         linkTitle: false,
         em: false,
         strong: false,
-        header: false,
+        header: 0,
         taskList: false,
         list: false,
         listDepth: 0,
@@ -517,7 +526,7 @@ CodeMirror.defineMode("markdown", function(cmCfg, modeCfg) {
         }
 
         // Reset state.header
-        state.header = false;
+        state.header = 0;
 
         // Reset state.taskList
         state.taskList = false;

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

@@ -0,0 +1,103 @@
+CodeMirror.defineMode("pegjs", function (config) {
+  var jsMode = CodeMirror.getMode(config, "javascript");
+
+  function identifier(stream) {
+    return stream.match(/^[a-zA-Z_][a-zA-Z0-9_]*/);
+  }
+
+  return {
+    startState: function () {
+      return {
+        inString: false,
+        stringType: null,
+        inComment: false,
+        inChracterClass: false,
+        braced: 0,
+        lhs: true,
+        localState: null
+      };
+    },
+    token: function (stream, state) {
+      if (stream)
+
+      //check for state changes
+      if (!state.inString && !state.inComment && ((stream.peek() == '"') || (stream.peek() == "'"))) {
+        state.stringType = stream.peek();
+        stream.next(); // Skip quote
+        state.inString = true; // Update state
+      }
+      if (!state.inString && !state.inComment && stream.match(/^\/\*/)) {
+        state.inComment = true;
+      }
+
+      //return state
+      if (state.inString) {
+        while (state.inString && !stream.eol()) {
+          if (stream.peek() === state.stringType) {
+            stream.next(); // Skip quote
+            state.inString = false; // Clear flag
+          } else if (stream.peek() === '\\') {
+            stream.next();
+            stream.next();
+          } else {
+            stream.match(/^.[^\\\"\']*/);
+          }
+        }
+        return state.lhs ? "property string" : "string"; // Token style
+      } else if (state.inComment) {
+        while (state.inComment && !stream.eol()) {
+          if (stream.match(/\*\//)) {
+            state.inComment = false; // Clear flag
+          } else {
+            stream.match(/^.[^\*]*/);
+          }
+        }
+        return "comment";
+      } else if (state.inChracterClass) {
+        if (stream.match(/^[^\]\\]+/)) {
+          return;
+        } else if (stream.match(/^\\./)) {
+          return;
+        } else {
+          stream.next();
+          state.inChracterClass = false;
+          return 'bracket';
+        }
+      } else if (stream.peek() === '[') {
+        stream.next();
+        state.inChracterClass = true;
+        return 'bracket';
+      } else if (stream.match(/^\/\//)) {
+        stream.skipToEnd();
+        return "comment";
+      } else if (state.braced || stream.peek() === '{') {
+        if (state.localState === null) {
+          state.localState = jsMode.startState();
+        }
+        var token = jsMode.token(stream, state.localState);
+        var text = stream.current();
+        if (!token) {
+          for (var i = 0; i < text.length; i++) {
+            if (text[i] === '{') {
+              state.braced++;
+            } else if (text[i] === '}') {
+              state.braced--;
+            }
+          };
+        }
+        return token;
+      } else if (identifier(stream)) {
+        if (stream.peek() === ':') {
+          return 'variable';
+        }
+        return 'variable-2';
+      } else if (['[', ']', '(', ')'].indexOf(stream.peek()) != -1) {
+        stream.next();
+        return 'bracket';
+      } else if (!stream.eatSpace()) {
+        stream.next();
+      }
+      return null;
+    }
+  };
+}, "javascript");