codemirror-rails 0.2.3 → 0.3.0

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

@@ -0,0 +1,172 @@
+/**********************************************************
+* This script provides syntax highlighting support for 
+* the Ntriples format.
+* Ntriples format specification: 
+*     http://www.w3.org/TR/rdf-testcases/#ntriples
+***********************************************************/
+
+/* 
+    The following expression defines the defined ASF grammar transitions.
+
+    pre_subject ->
+        {
+        ( writing_subject_uri | writing_bnode_uri )
+            -> pre_predicate 
+                -> writing_predicate_uri 
+                    -> pre_object 
+                        -> writing_object_uri | writing_object_bnode | 
+                          ( 
+                            writing_object_literal 
+                                -> writing_literal_lang | writing_literal_type
+                          )
+                            -> post_object
+                                -> BEGIN
+         } otherwise {
+             -> ERROR
+         }
+*/
+CodeMirror.defineMode("ntriples", function() {  
+
+  Location = {
+    PRE_SUBJECT         : 0,
+    WRITING_SUB_URI     : 1,
+    WRITING_BNODE_URI   : 2,
+    PRE_PRED            : 3,
+    WRITING_PRED_URI    : 4,
+    PRE_OBJ             : 5,
+    WRITING_OBJ_URI     : 6,
+    WRITING_OBJ_BNODE   : 7,
+    WRITING_OBJ_LITERAL : 8,
+    WRITING_LIT_LANG    : 9,
+    WRITING_LIT_TYPE    : 10,
+    POST_OBJ            : 11,
+    ERROR               : 12
+  };
+  function transitState(currState, c) {
+    var currLocation = currState.location;
+    var ret;
+    
+    // Opening.
+    if     (currLocation == Location.PRE_SUBJECT && c == '<') ret = Location.WRITING_SUB_URI;
+    else if(currLocation == Location.PRE_SUBJECT && c == '_') ret = Location.WRITING_BNODE_URI;
+    else if(currLocation == Location.PRE_PRED    && c == '<') ret = Location.WRITING_PRED_URI;
+    else if(currLocation == Location.PRE_OBJ     && c == '<') ret = Location.WRITING_OBJ_URI;
+    else if(currLocation == Location.PRE_OBJ     && c == '_') ret = Location.WRITING_OBJ_BNODE;
+    else if(currLocation == Location.PRE_OBJ     && c == '"') ret = Location.WRITING_OBJ_LITERAL;
+    
+    // Closing.
+    else if(currLocation == Location.WRITING_SUB_URI     && c == '>') ret = Location.PRE_PRED;
+    else if(currLocation == Location.WRITING_BNODE_URI   && c == ' ') ret = Location.PRE_PRED;
+    else if(currLocation == Location.WRITING_PRED_URI    && c == '>') ret = Location.PRE_OBJ;
+    else if(currLocation == Location.WRITING_OBJ_URI     && c == '>') ret = Location.POST_OBJ;
+    else if(currLocation == Location.WRITING_OBJ_BNODE   && c == ' ') ret = Location.POST_OBJ;
+    else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '"') ret = Location.POST_OBJ;
+    else if(currLocation == Location.WRITING_LIT_LANG && c == ' ') ret = Location.POST_OBJ;
+    else if(currLocation == Location.WRITING_LIT_TYPE && c == '>') ret = Location.POST_OBJ;
+    
+    // Closing typed and language literal.
+    else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '@') ret = Location.WRITING_LIT_LANG;
+    else if(currLocation == Location.WRITING_OBJ_LITERAL && c == '^') ret = Location.WRITING_LIT_TYPE;
+
+    // Spaces.
+    else if( c == ' ' &&                             
+             (
+               currLocation == Location.PRE_SUBJECT || 
+               currLocation == Location.PRE_PRED    || 
+               currLocation == Location.PRE_OBJ     || 
+               currLocation == Location.POST_OBJ
+             )
+           ) ret = currLocation;
+    
+    // Reset.
+    else if(currLocation == Location.POST_OBJ && c == '.') ret = Location.PRE_SUBJECT;    
+    
+    // Error
+    else ret = Location.ERROR;
+    
+    currState.location=ret;
+  }
+
+  untilSpace  = function(c) { return c != ' '; };
+  untilEndURI = function(c) { return c != '>'; };
+  return {
+    startState: function() {
+       return { 
+           location : Location.PRE_SUBJECT,
+           uris     : [],
+           anchors  : [],
+           bnodes   : [],
+           langs    : [],
+           types    : []
+       };
+    },
+    token: function(stream, state) {
+      var ch = stream.next();
+      if(ch == '<') {
+         transitState(state, ch);
+         var parsedURI = '';
+         stream.eatWhile( function(c) { if( c != '#' && c != '>' ) { parsedURI += c; return true; } return false;} );
+         state.uris.push(parsedURI);
+         if( stream.match('#', false) ) return 'variable';
+         stream.next();
+         transitState(state, '>');
+         return 'variable';
+      }
+      if(ch == '#') {
+        var parsedAnchor = '';
+        stream.eatWhile(function(c) { if(c != '>' && c != ' ') { parsedAnchor+= c; return true; } return false});
+        state.anchors.push(parsedAnchor);
+        return 'variable-2';
+      }
+      if(ch == '>') {
+          transitState(state, '>');
+          return 'variable';
+      }
+      if(ch == '_') {
+          transitState(state, ch);
+          var parsedBNode = '';
+          stream.eatWhile(function(c) { if( c != ' ' ) { parsedBNode += c; return true; } return false;});
+          state.bnodes.push(parsedBNode);
+          stream.next();
+          transitState(state, ' ');
+          return 'builtin';
+      }
+      if(ch == '"') {
+          transitState(state, ch);
+          stream.eatWhile( function(c) { return c != '"'; } );
+          stream.next();
+          if( stream.peek() != '@' && stream.peek() != '^' ) {
+              transitState(state, '"');
+          }
+          return 'string';
+      }
+      if( ch == '@' ) {
+          transitState(state, '@');
+          var parsedLang = '';
+          stream.eatWhile(function(c) { if( c != ' ' ) { parsedLang += c; return true; } return false;});
+          state.langs.push(parsedLang);
+          stream.next();
+          transitState(state, ' ');
+          return 'string-2';
+      }
+      if( ch == '^' ) {
+          stream.next();
+          transitState(state, '^');
+          var parsedType = '';
+          stream.eatWhile(function(c) { if( c != '>' ) { parsedType += c; return true; } return false;} );
+          state.types.push(parsedType);
+          stream.next();
+          transitState(state, '>');
+          return 'variable';
+      }
+      if( ch == ' ' ) {
+          transitState(state, ch);
+      }
+      if( ch == '.' ) {
+          transitState(state, ch);
+      }
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/n-triples", "ntriples");

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

@@ -0,0 +1,138 @@
+CodeMirror.defineMode("pascal", function(config) {
+  function words(str) {
+    var obj = {}, words = str.split(" ");
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+  var keywords = words("and array begin case const div do downto else end file for forward integer " +
+                       "boolean char function goto if in label mod nil not of or packed procedure " +
+                       "program record repeat set string then to type until var while with");
+  var blockKeywords = words("case do else for if switch while struct then of");
+  var atoms = {"null": true};
+
+  var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+  var curPunc;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == "#" && state.startOfLine) {
+      stream.skipToEnd();
+      return "meta";
+    }
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (ch == "(" && stream.eat("*")) {
+      state.tokenize = tokenComment;
+      return tokenComment(stream, state);
+    }
+    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+      curPunc = ch;
+      return null
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (ch == "/") {
+      if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var cur = stream.current();
+    if (keywords.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "keyword";
+    }
+    if (atoms.propertyIsEnumerable(cur)) return "atom";
+    return "word";
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {end = true; break;}
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !escaped) state.tokenize = null;
+      return "string";
+    };
+  }
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == ")" && maybeEnd) {
+        state.tokenize = null;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return "comment";
+  }
+
+  function Context(indented, column, type, align, prev) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.align = align;
+    this.prev = prev;
+  }
+  function pushContext(state, col, type) {
+    return state.context = new Context(state.indented, col, type, null, state.context);
+  }
+  function popContext(state) {
+    var t = state.context.type;
+    if (t == ")" || t == "]" )
+      state.indented = state.context.indented;
+    return state.context = state.context.prev;
+  }
+
+  // Interface
+
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: null,
+        context: new Context((basecolumn || 0) - config.indentUnit, 0, "top", false),
+        indented: 0,
+        startOfLine: true
+      };
+    },
+
+    token: function(stream, state) {
+      var ctx = state.context;
+      if (stream.sol()) {
+        if (ctx.align == null) ctx.align = false;
+        state.indented = stream.indentation();
+        state.startOfLine = true;
+      }
+      if (stream.eatSpace()) return null;
+      curPunc = null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment" || style == "meta") return style;
+      if (ctx.align == null) ctx.align = true;
+
+      if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
+      else if (curPunc == "[") pushContext(state, stream.column(), "]");
+      else if (curPunc == "(") pushContext(state, stream.column(), ")");
+      else if (curPunc == ctx.type) popContext(state);
+      else if ( ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
+        pushContext(state, stream.column(), "statement");
+      state.startOfLine = false;
+      return style;
+    },
+
+    electricChars: "{}"
+  };
+});
+
+CodeMirror.defineMIME("text/x-pascal", "pascal");

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

@@ -16,9 +16,10 @@
     keywords: keywords("abstract and array as break case catch cfunction class clone const continue declare " +
                        "default do else elseif enddeclare endfor endforeach endif endswitch endwhile extends " +
                        "final for foreach function global goto if implements interface instanceof namespace " +
-                       "new or private protected public static switch throw try use var while xor return"),
+                       "new or private protected public static switch throw try use var while xor return" +
+                       "die echo empty exit eval include include_once isset list require require_once print unset"),
     blockKeywords: keywords("catch do else elseif for foreach if switch try while"),
-    atoms: keywords("true false null"),
+    atoms: keywords("true false null TRUE FALSE NULL"),
     multiLineStrings: true,
     hooks: {
       "$": function(stream, state) {

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

@@ -1,4 +1,4 @@
-CodeMirror.defineMode("python", function(conf) {
+CodeMirror.defineMode("python", function(conf, parserConf) {
     var ERRORCLASS = 'error';
     
     function wordRegexp(words) {
@@ -29,7 +29,7 @@ CodeMirror.defineMode("python", function(conf) {
                          'open', 'range', 'zip'],
                'keywords': ['nonlocal']};
 
-    if (!!conf.mode.version && parseInt(conf.mode.version, 10) === 3) {
+    if (!!parserConf.version && parseInt(parserConf.version, 10) === 3) {
         commonkeywords = commonkeywords.concat(py3.keywords);
         commontypes = commontypes.concat(py3.types);
         var stringPrefixes = new RegExp("^(([rb]|(br))?('{3}|\"{3}|['\"]))", "i");
@@ -147,10 +147,9 @@ CodeMirror.defineMode("python", function(conf) {
     }
     
     function tokenStringFactory(delimiter) {
-        while ('rub'.indexOf(delimiter[0].toLowerCase()) >= 0) {
+        while ('rub'.indexOf(delimiter.charAt(0).toLowerCase()) >= 0) {
             delimiter = delimiter.substr(1);
         }
-        var delim_re = new RegExp(delimiter);
         var singleline = delimiter.length == 1;
         var OUTCLASS = 'string';
         
@@ -162,7 +161,7 @@ CodeMirror.defineMode("python", function(conf) {
                     if (singleline && stream.eol()) {
                         return OUTCLASS;
                     }
-                } else if (stream.match(delim_re)) {
+                } else if (stream.match(delimiter)) {
                     state.tokenize = tokenBase;
                     return OUTCLASS;
                 } else {
@@ -170,7 +169,7 @@ CodeMirror.defineMode("python", function(conf) {
                 }
             }
             if (singleline) {
-                if (conf.mode.singleLineStringErrors) {
+                if (parserConf.singleLineStringErrors) {
                     return ERRORCLASS;
                 } else {
                     state.tokenize = tokenBase;

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

@@ -46,6 +46,8 @@ CodeMirror.defineMode("r", function(config) {
       return "variable-2";
     } else if (ch == "<" && stream.eat("-")) {
       return "arrow";
+    } else if (ch == "=" && state.ctx.argList) {
+      return "arg-is";
     } else if (opChars.test(ch)) {
       if (ch == "$") return "dollar";
       stream.eatWhile(opChars);
@@ -98,7 +100,8 @@ CodeMirror.defineMode("r", function(config) {
               ctx: {type: "top",
                     indent: -config.indentUnit,
                     align: false},
-              indent: 0};
+              indent: 0,
+              afterIdent: false};
     },
 
     token: function(stream, state) {
@@ -113,10 +116,14 @@ CodeMirror.defineMode("r", function(config) {
       var ctype = state.ctx.type;
       if ((curPunc == ";" || curPunc == "{" || curPunc == "}") && ctype == "block") pop(state);
       if (curPunc == "{") push(state, "}", stream);
-      else if (curPunc == "(") push(state, ")", stream);
+      else if (curPunc == "(") {
+        push(state, ")", stream);
+        if (state.afterIdent) state.ctx.argList = true;
+      }
       else if (curPunc == "[") push(state, "]", stream);
       else if (curPunc == "block") push(state, "block", stream);
       else if (curPunc == ctype) pop(state);
+      state.afterIdent = style == "variable" || style == "keyword";
       return style;
     },
 

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

@@ -19,28 +19,29 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
   var curPunc;
 
   function chain(newtok, stream, state) {
-    state.tokenize = newtok;
+    state.tokenize.push(newtok);
     return newtok(stream, state);
   }
 
   function tokenBase(stream, state) {
     curPunc = null;
     if (stream.sol() && stream.match("=begin") && stream.eol()) {
-      state.tokenize = readBlockComment;
+      state.tokenize.push(readBlockComment);
       return "comment";
     }
     if (stream.eatSpace()) return null;
     var ch = stream.next();
     if (ch == "`" || ch == "'" || ch == '"' || ch == "/") {
-      return chain(readQuoted(ch, "string"), stream, state);
+      return chain(readQuoted(ch, "string", ch == '"'), stream, state);
     } else if (ch == "%") {
-      var style;
+      var style, embed = false;
       if (stream.eat("s")) style = "atom";
-      else if (stream.eat(/[wWxqQr]/)) style = "string";
+      else if (stream.eat(/[WQ]/)) { style = "string"; embed = true; }
+      else if (stream.eat(/[wxqr]/)) style = "string";
       var delim = stream.eat(/[^\w\s]/);
       if (!delim) return "operator";
       if (matching.propertyIsEnumerable(delim)) delim = matching[delim];
-      return chain(readPercentQuoted(delim, style), stream, state);
+      return chain(readQuoted(delim, style, embed, true), stream, state);
     } else if (ch == "#") {
       stream.skipToEnd();
       return "comment";
@@ -65,8 +66,8 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
       else stream.next();
       return "string";
     } else if (ch == ":") {
-      if (stream.eat("'")) return chain(readQuoted("'", "atom"), stream, state);
-      if (stream.eat('"')) return chain(readQuoted('"', "atom"), stream, state);
+      if (stream.eat("'")) return chain(readQuoted("'", "atom", false), stream, state);
+      if (stream.eat('"')) return chain(readQuoted('"', "atom", true), stream, state);
       stream.eatWhile(/[\w\?]/);
       return "atom";
     } else if (ch == "@") {
@@ -97,12 +98,31 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
     }
   }
 
-  function readQuoted(quote, style) {
+  function tokenBaseUntilBrace() {
+    var depth = 1;
+    return function(stream, state) {
+      if (stream.peek() == "}") {
+        depth--;
+        if (depth == 0) {
+          state.tokenize.pop();
+          return state.tokenize[state.tokenize.length-1](stream, state);
+        }
+      } else if (stream.peek() == "{") {
+        depth++;
+      }
+      return tokenBase(stream, state);
+    };
+  }
+  function readQuoted(quote, style, embed, unescaped) {
     return function(stream, state) {
       var escaped = false, ch;
       while ((ch = stream.next()) != null) {
-        if (ch == quote && !escaped) {
-          state.tokenize = tokenBase;
+        if (ch == quote && (unescaped || !escaped)) {
+          state.tokenize.pop();
+          break;
+        }
+        if (embed && ch == "#" && !escaped && stream.eat("{")) {
+          state.tokenize.push(tokenBaseUntilBrace(arguments.callee));
           break;
         }
         escaped = !escaped && ch == "\\";
@@ -110,30 +130,23 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
       return style;
     };
   }
-  function readPercentQuoted(quote, style) {
-    return function(stream, state) {
-      if (stream.skipTo(quote)) {stream.next(); state.tokenize = tokenBase;}
-      else stream.skipToEnd();
-      return style;
-    };
-  }
   function readHereDoc(phrase) {
     return function(stream, state) {
-      if (stream.match(phrase)) state.tokenize = tokenBase;
+      if (stream.match(phrase)) state.tokenize.pop();
       else stream.skipToEnd();
       return "string";
     };
   }
   function readBlockComment(stream, state) {
     if (stream.sol() && stream.match("=end") && stream.eol())
-      state.tokenize = tokenBase;
+      state.tokenize.pop();
     stream.skipToEnd();
     return "comment";
   }
 
   return {
     startState: function() {
-      return {tokenize: tokenBase,
+      return {tokenize: [tokenBase],
               indented: 0,
               context: {type: "top", indented: -config.indentUnit},
               continuedLine: false,
@@ -143,7 +156,7 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
 
     token: function(stream, state) {
       if (stream.sol()) state.indented = stream.indentation();
-      var style = state.tokenize(stream, state), kwtype;
+      var style = state.tokenize[state.tokenize.length-1](stream, state), kwtype;
       if (style == "ident") {
         var word = stream.current();
         style = keywords.propertyIsEnumerable(stream.current()) ? "keyword"
@@ -168,7 +181,7 @@ CodeMirror.defineMode("ruby", function(config, parserConfig) {
     },
 
     indent: function(state, textAfter) {
-      if (state.tokenize != tokenBase) return 0;
+      if (state.tokenize[state.tokenize.length-1] != tokenBase) return 0;
       var firstChar = textAfter && textAfter.charAt(0);
       var ct = state.context;
       var closing = ct.type == matching[firstChar] ||