codemirror-rails 3.16 → 3.17

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

@@ -259,7 +259,7 @@ CodeMirror.defineMode('coffeescript', function(conf) {
         if (current === '.') {
             style = state.tokenize(stream, state);
             current = stream.current();
-            if (style === 'variable') {
+            if (/^\.[\w$]+$/.test(current)) {
                 return 'variable';
             } else {
                 return ERRORCLASS;

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

@@ -1,10 +1,8 @@
-CodeMirror.defineMode("css", function(config) {
-  return CodeMirror.getMode(config, "text/css");
-});
-
-CodeMirror.defineMode("css-base", function(config, parserConfig) {
+CodeMirror.defineMode("css", function(config, parserConfig) {
   "use strict";
 
+  if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css");
+
   var indentUnit = config.indentUnit,
       hooks = parserConfig.hooks || {},
       atMediaTypes = parserConfig.atMediaTypes || {},
@@ -39,7 +37,7 @@ CodeMirror.defineMode("css-base", function(config, parserConfig) {
       stream.match(/^\s*\w*/);
       return ret("keyword", "important");
     }
-    else if (/\d/.test(ch)) {
+    else if (/\d/.test(ch) || ch == "." && stream.eat(/\d/)) {
       stream.eatWhile(/[\w.%]/);
       return ret("number", "unit");
     }
@@ -277,16 +275,14 @@ CodeMirror.defineMode("css-base", function(config, parserConfig) {
           state.stack[state.stack.length-1] = "@mediaType";
           state.stack.push("@mediaType(");
         }
+        else state.stack.push("(");
       }
       else if (type == ")") {
-        if (context == "propertyValue" && state.stack[state.stack.length-2] == "@mediaType(") {
+        if (context == "propertyValue") {
           // In @mediaType( without closing ; after propertyValue
           state.stack.pop();
-          state.stack.pop();
-        }
-        else if (context == "@mediaType(") {
-          state.stack.pop();
         }
+        state.stack.pop();
       }
       else if (type == ":" && state.lastToken == "property") state.stack.push("propertyValue");
       else if (context == "propertyValue" && type == ";") state.stack.pop();
@@ -582,7 +578,7 @@ CodeMirror.defineMode("css-base", function(config, parserConfig) {
         return false;
       }
     },
-    name: "css-base"
+    name: "css"
   });
 
   CodeMirror.defineMIME("text/x-scss", {
@@ -593,6 +589,12 @@ CodeMirror.defineMode("css-base", function(config, parserConfig) {
     valueKeywords: valueKeywords,
     allowNested: true,
     hooks: {
+      ":": function(stream) {
+        if (stream.match(/\s*{/)) {
+          return [null, "{"];
+        }
+        return false;
+      },
       "$": function(stream) {
         stream.match(/^[\w-]+/);
         if (stream.peek() == ":") {
@@ -620,6 +622,6 @@ CodeMirror.defineMode("css-base", function(config, parserConfig) {
         }
       }
     },
-    name: "css-base"
+    name: "css"
   });
 })();

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

@@ -0,0 +1,127 @@
+/*
+  DTD mode
+  Ported to CodeMirror by Peter Kroon <plakroon@gmail.com>
+  Report bugs/issues here: https://github.com/marijnh/CodeMirror/issues
+  GitHub: @peterkroon
+*/
+
+CodeMirror.defineMode("dtd", function(config) {
+  var indentUnit = config.indentUnit, type;
+  function ret(style, tp) {type = tp; return style;}
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+
+    if (ch == "<" && stream.eat("!") ) {
+      if (stream.eatWhile(/[\-]/)) {
+        state.tokenize = tokenSGMLComment;
+        return tokenSGMLComment(stream, state);
+      } else if (stream.eatWhile(/[\w]/)) return ret("keyword", "doindent");
+    } else if (ch == "<" && stream.eat("?")) { //xml declaration
+      state.tokenize = inBlock("meta", "?>");
+      return ret("meta", ch);
+    } else if (ch == "#" && stream.eatWhile(/[\w]/)) return ret("atom", "tag");
+    else if (ch == "|") return ret("keyword", "seperator");
+    else if (ch.match(/[\(\)\[\]\-\.,\+\?>]/)) return ret(null, ch);//if(ch === ">") return ret(null, "endtag"); else
+    else if (ch.match(/[\[\]]/)) return ret("rule", ch);
+    else if (ch == "\"" || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    } else if (stream.eatWhile(/[a-zA-Z\?\+\d]/)) {
+      var sc = stream.current();
+      if( sc.substr(sc.length-1,sc.length).match(/\?|\+/) !== null )stream.backUp(1);
+      return ret("tag", "tag");
+    } else if (ch == "%" || ch == "*" ) return ret("number", "number");
+    else {
+      stream.eatWhile(/[\w\\\-_%.{,]/);
+      return ret(null, null);
+    }
+  }
+
+  function tokenSGMLComment(stream, state) {
+    var dashes = 0, ch;
+    while ((ch = stream.next()) != null) {
+      if (dashes >= 2 && ch == ">") {
+        state.tokenize = tokenBase;
+        break;
+      }
+      dashes = (ch == "-") ? dashes + 1 : 0;
+    }
+    return ret("comment", "comment");
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, ch;
+      while ((ch = stream.next()) != null) {
+        if (ch == quote && !escaped) {
+          state.tokenize = tokenBase;
+          break;
+        }
+        escaped = !escaped && ch == "\\";
+      }
+      return ret("string", "tag");
+    };
+  }
+
+  function inBlock(style, terminator) {
+    return function(stream, state) {
+      while (!stream.eol()) {
+        if (stream.match(terminator)) {
+          state.tokenize = tokenBase;
+          break;
+        }
+        stream.next();
+      }
+      return style;
+    };
+  }
+
+  return {
+    startState: function(base) {
+      return {tokenize: tokenBase,
+              baseIndent: base || 0,
+              stack: []};
+    },
+
+    token: function(stream, state) {
+      if (stream.eatSpace()) return null;
+      var style = state.tokenize(stream, state);
+
+      var context = state.stack[state.stack.length-1];
+      if (stream.current() == "[" || type === "doindent" || type == "[") state.stack.push("rule");
+      else if (type === "endtag") state.stack[state.stack.length-1] = "endtag";
+      else if (stream.current() == "]" || type == "]" || (type == ">" && context == "rule")) state.stack.pop();
+      else if (type == "[") state.stack.push("[");
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      var n = state.stack.length;
+
+      if( textAfter.match(/\]\s+|\]/) )n=n-1;
+      else if(textAfter.substr(textAfter.length-1, textAfter.length) === ">"){
+        if(textAfter.substr(0,1) === "<")n;
+        else if( type == "doindent" && textAfter.length > 1 )n;
+        else if( type == "doindent")n--;
+        else if( type == ">" && textAfter.length > 1)n;
+        else if( type == "tag" && textAfter !== ">")n;
+        else if( type == "tag" && state.stack[state.stack.length-1] == "rule")n--;
+        else if( type == "tag")n++;
+        else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule" && type === ">")n--;
+        else if( textAfter === ">" && state.stack[state.stack.length-1] == "rule")n;
+        else if( textAfter.substr(0,1) !== "<" && textAfter.substr(0,1) === ">" )n=n-1;
+        else if( textAfter === ">")n;
+        else n=n-1;
+        //over rule them all
+        if(type == null || type == "]")n--;
+      }
+
+      return state.baseIndent + n * indentUnit;
+    },
+
+    electricChars: "]>"
+  };
+});
+
+CodeMirror.defineMIME("application/xml-dtd", "dtd");

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

@@ -0,0 +1,173 @@
+CodeMirror.defineMode("fortran", function() {
+  function words(array) {
+    var keys = {};
+    for (var i = 0; i < array.length; ++i) {
+      keys[array[i]] = true;
+    }
+    return keys;
+  }
+
+  var keywords = words([
+                  "abstract", "accept", "allocatable", "allocate",
+                  "array", "assign", "asynchronous", "backspace",
+                  "bind", "block", "byte", "call", "case",
+                  "class", "close", "common", "contains",
+                  "continue", "cycle", "data", "deallocate",
+                  "decode", "deferred", "dimension", "do",
+                  "elemental", "else", "encode", "end",
+                  "endif", "entry", "enumerator", "equivalence",
+                  "exit", "external", "extrinsic", "final",
+                  "forall", "format", "function", "generic",
+                  "go", "goto", "if", "implicit", "import", "include",
+                  "inquire", "intent", "interface", "intrinsic",
+                  "module", "namelist", "non_intrinsic",
+                  "non_overridable", "none", "nopass",
+                  "nullify", "open", "optional", "options",
+                  "parameter", "pass", "pause", "pointer",
+                  "print", "private", "program", "protected",
+                  "public", "pure", "read", "recursive", "result",
+                  "return", "rewind", "save", "select", "sequence",
+                  "stop", "subroutine", "target", "then", "to", "type",
+                  "use", "value", "volatile", "where", "while",
+                  "write"]);
+  var builtins = words(["abort", "abs", "access", "achar", "acos",
+                          "adjustl", "adjustr", "aimag", "aint", "alarm",
+                          "all", "allocated", "alog", "amax", "amin",
+                          "amod", "and", "anint", "any", "asin",
+                          "associated", "atan", "besj", "besjn", "besy",
+                          "besyn", "bit_size", "btest", "cabs", "ccos",
+                          "ceiling", "cexp", "char", "chdir", "chmod",
+                          "clog", "cmplx", "command_argument_count",
+                          "complex", "conjg", "cos", "cosh", "count",
+                          "cpu_time", "cshift", "csin", "csqrt", "ctime",
+                          "c_funloc", "c_loc", "c_associated", "c_null_ptr",
+                          "c_null_funptr", "c_f_pointer", "c_null_char",
+                          "c_alert", "c_backspace", "c_form_feed",
+                          "c_new_line", "c_carriage_return",
+                          "c_horizontal_tab", "c_vertical_tab", "dabs",
+                          "dacos", "dasin", "datan", "date_and_time",
+                          "dbesj", "dbesj", "dbesjn", "dbesy", "dbesy",
+                          "dbesyn", "dble", "dcos", "dcosh", "ddim", "derf",
+                          "derfc", "dexp", "digits", "dim", "dint", "dlog",
+                          "dlog", "dmax", "dmin", "dmod", "dnint",
+                          "dot_product", "dprod", "dsign", "dsinh",
+                          "dsin", "dsqrt", "dtanh", "dtan", "dtime",
+                          "eoshift", "epsilon", "erf", "erfc", "etime",
+                          "exit", "exp", "exponent", "extends_type_of",
+                          "fdate", "fget", "fgetc", "float", "floor",
+                          "flush", "fnum", "fputc", "fput", "fraction",
+                          "fseek", "fstat", "ftell", "gerror", "getarg",
+                          "get_command", "get_command_argument",
+                          "get_environment_variable", "getcwd",
+                          "getenv", "getgid", "getlog", "getpid",
+                          "getuid", "gmtime", "hostnm", "huge", "iabs",
+                          "iachar", "iand", "iargc", "ibclr", "ibits",
+                          "ibset", "ichar", "idate", "idim", "idint",
+                          "idnint", "ieor", "ierrno", "ifix", "imag",
+                          "imagpart", "index", "int", "ior", "irand",
+                          "isatty", "ishft", "ishftc", "isign",
+                          "iso_c_binding", "is_iostat_end", "is_iostat_eor",
+                          "itime", "kill", "kind", "lbound", "len", "len_trim",
+                          "lge", "lgt", "link", "lle", "llt", "lnblnk", "loc",
+                          "log", "logical", "long", "lshift", "lstat", "ltime",
+                          "matmul", "max", "maxexponent", "maxloc", "maxval",
+                          "mclock", "merge", "move_alloc", "min", "minexponent",
+                          "minloc", "minval", "mod", "modulo", "mvbits",
+                          "nearest", "new_line", "nint", "not", "or", "pack",
+                          "perror", "precision", "present", "product", "radix",
+                          "rand", "random_number", "random_seed", "range",
+                          "real", "realpart", "rename", "repeat", "reshape",
+                          "rrspacing", "rshift", "same_type_as", "scale",
+                          "scan", "second", "selected_int_kind",
+                          "selected_real_kind", "set_exponent", "shape",
+                          "short", "sign", "signal", "sinh", "sin", "sleep",
+                          "sngl", "spacing", "spread", "sqrt", "srand", "stat",
+                          "sum", "symlnk", "system", "system_clock", "tan",
+                          "tanh", "time", "tiny", "transfer", "transpose",
+                          "trim", "ttynam", "ubound", "umask", "unlink",
+                          "unpack", "verify", "xor", "zabs", "zcos", "zexp",
+                          "zlog", "zsin", "zsqrt"]);
+
+    var dataTypes =  words(["c_bool", "c_char", "c_double", "c_double_complex",
+                     "c_float", "c_float_complex", "c_funptr", "c_int",
+                     "c_int16_t", "c_int32_t", "c_int64_t", "c_int8_t",
+                     "c_int_fast16_t", "c_int_fast32_t", "c_int_fast64_t",
+                     "c_int_fast8_t", "c_int_least16_t", "c_int_least32_t",
+                     "c_int_least64_t", "c_int_least8_t", "c_intmax_t",
+                     "c_intptr_t", "c_long", "c_long_double",
+                     "c_long_double_complex", "c_long_long", "c_ptr",
+                     "c_short", "c_signed_char", "c_size_t", "character",
+                     "complex", "double", "integer", "logical", "real"]);
+  var isOperatorChar = /[+\-*&=<>\/\:]/;
+  var litOperator = new RegExp("(\.and\.|\.or\.|\.eq\.|\.lt\.|\.le\.|\.gt\.|\.ge\.|\.ne\.|\.not\.|\.eqv\.|\.neqv\.)", "i");
+
+  function tokenBase(stream, state) {
+
+    if (stream.match(litOperator)){
+        return 'operator';
+    }
+
+    var ch = stream.next();
+    if (ch == "!") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\[\]\(\),]/.test(ch)) {
+      return null;
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var word = stream.current().toLowerCase();
+
+    if (keywords.hasOwnProperty(word)){
+            return 'keyword';
+    }
+    if (builtins.hasOwnProperty(word) || dataTypes.hasOwnProperty(word)) {
+            return 'builtin';
+    }
+    return "variable";
+  }
+
+  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";
+    };
+  }
+
+  // Interface
+
+  return {
+    startState: function() {
+      return {tokenize: null};
+    },
+
+    token: function(stream, state) {
+      if (stream.eatSpace()) return null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment" || style == "meta") return style;
+      return style;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-fortran", "fortran");

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

@@ -1,4 +1,4 @@
-CodeMirror.defineMode("haskell", function() {
+CodeMirror.defineMode("haskell", function(_config, modeConfig) {
 
   function switchState(source, setState, f) {
     setState(f);
@@ -221,6 +221,10 @@ CodeMirror.defineMode("haskell", function() {
       "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
       "zip3", "zipWith", "zipWith3");
 
+    var override = modeConfig.overrideKeywords;
+    if (override) for (var word in override) if (override.hasOwnProperty(word))
+      wkw[word] = override[word];
+
     return wkw;
   })();
 

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

@@ -1,7 +1,8 @@
 /*
   LESS mode - http://www.lesscss.org/
   Ported to CodeMirror by Peter Kroon <plakroon@gmail.com>
-  Report bugs/issues here: https://github.com/marijnh/CodeMirror/issues  GitHub: @peterkroon
+  Report bugs/issues here: https://github.com/marijnh/CodeMirror/issues
+  GitHub: @peterkroon
 */
 
 CodeMirror.defineMode("less", function(config) {
@@ -17,68 +18,60 @@ CodeMirror.defineMode("less", function(config) {
     else if (ch == "/" && stream.eat("*")) {
       state.tokenize = tokenCComment;
       return tokenCComment(stream, state);
-    }
-    else if (ch == "<" && stream.eat("!")) {
+    } else if (ch == "<" && stream.eat("!")) {
       state.tokenize = tokenSGMLComment;
       return tokenSGMLComment(stream, state);
-    }
-    else if (ch == "=") ret(null, "compare");
+    } else if (ch == "=") ret(null, "compare");
     else if (ch == "|" && stream.eat("=")) return ret(null, "compare");
     else if (ch == "\"" || ch == "'") {
       state.tokenize = tokenString(ch);
       return state.tokenize(stream, state);
-    }
-    else if (ch == "/") { // e.g.: .png will not be parsed as a class
+    } else if (ch == "/") { // e.g.: .png will not be parsed as a class
       if(stream.eat("/")){
         state.tokenize = tokenSComment;
         return tokenSComment(stream, state);
-      }else{
-        if(type == "string" || type == "(")return ret("string", "string");
-        if(state.stack[state.stack.length-1] != undefined)return ret(null, ch);
+      } else {
+        if(type == "string" || type == "(") return ret("string", "string");
+        if(state.stack[state.stack.length-1] != undefined) return ret(null, ch);
         stream.eatWhile(/[\a-zA-Z0-9\-_.\s]/);
         if( /\/|\)|#/.test(stream.peek() || (stream.eatSpace() && stream.peek() == ")"))  || stream.eol() )return ret("string", "string"); // let url(/images/logo.png) without quotes return as string
       }
-    }
-    else if (ch == "!") {
+    } else if (ch == "!") {
       stream.match(/^\s*\w*/);
       return ret("keyword", "important");
-    }
-    else if (/\d/.test(ch)) {
+    } else if (/\d/.test(ch)) {
       stream.eatWhile(/[\w.%]/);
       return ret("number", "unit");
-    }
-    else if (/[,+<>*\/]/.test(ch)) {
+    } else if (/[,+<>*\/]/.test(ch)) {
       if(stream.peek() == "=" || type == "a")return ret("string", "string");
+      if(ch === ",")return ret(null, ch);
       return ret(null, "select-op");
-    }
-    else if (/[;{}:\[\]()~\|]/.test(ch)) {
+    } else if (/[;{}:\[\]()~\|]/.test(ch)) {
       if(ch == ":"){
         stream.eatWhile(/[a-z\\\-]/);
         if( selectors.test(stream.current()) ){
           return ret("tag", "tag");
-        }else if(stream.peek() == ":"){//::-webkit-search-decoration
+        } else if(stream.peek() == ":"){//::-webkit-search-decoration
           stream.next();
           stream.eatWhile(/[a-z\\\-]/);
           if(stream.current().match(/\:\:\-(o|ms|moz|webkit)\-/))return ret("string", "string");
           if( selectors.test(stream.current().substring(1)) )return ret("tag", "tag");
           return ret(null, ch);
-        }else{
+        } else {
           return ret(null, ch);
         }
-      }else if(ch == "~"){
+      } else if(ch == "~"){
         if(type == "r")return ret("string", "string");
-      }else{
+      } else {
         return ret(null, ch);
       }
-    }
-    else if (ch == ".") {
+    } else if (ch == ".") {
       if(type == "(" || type == "string")return ret("string", "string"); // allow url(../image.png)
       stream.eatWhile(/[\a-zA-Z0-9\-_]/);
       if(stream.peek() == " ")stream.eatSpace();
       if(stream.peek() == ")")return ret("number", "unit");//rgba(0,0,0,.25);
       return ret("tag", "tag");
-    }
-    else if (ch == "#") {
+    } else if (ch == "#") {
       //we don't eat white-space, we want the hex color and or id only
       stream.eatWhile(/[A-Za-z0-9]/);
       //check if there is a proper hex color length e.g. #eee || #eeeEEE
@@ -93,43 +86,41 @@ CodeMirror.defineMode("less", function(config) {
           //#time { color: #aaa }
           else if(stream.peek() == "}" )return ret("number", "unit");
           //we have a valid hex color value, parse as id whenever an element/class is defined after the hex(id) value e.g. #eee aaa || #eee .aaa
-          else if( /[a-zA-Z\\]/.test(stream.peek()) )return ret("atom", "tag");
+            else if( /[a-zA-Z\\]/.test(stream.peek()) )return ret("atom", "tag");
           //when a hex value is on the end of a line, parse as id
-          else if(stream.eol())return ret("atom", "tag");
+              else if(stream.eol())return ret("atom", "tag");
           //default
-          else return ret("number", "unit");
-        }else{//when not a valid hexvalue in the current stream e.g. #footer
+                else return ret("number", "unit");
+        } else {//when not a valid hexvalue in the current stream e.g. #footer
           stream.eatWhile(/[\w\\\-]/);
           return ret("atom", "tag");
         }
-      }else{//when not a valid hexvalue length
+      } else {//when not a valid hexvalue length
         stream.eatWhile(/[\w\\\-]/);
         return ret("atom", "tag");
       }
-    }
-    else if (ch == "&") {
+    } else if (ch == "&") {
       stream.eatWhile(/[\w\-]/);
       return ret(null, ch);
-    }
-    else {
+    } else {
       stream.eatWhile(/[\w\\\-_%.{]/);
       if(type == "string"){
         return ret("string", "string");
-      }else if(stream.current().match(/(^http$|^https$)/) != null){
+      } else if(stream.current().match(/(^http$|^https$)/) != null){
         stream.eatWhile(/[\w\\\-_%.{:\/]/);
         return ret("string", "string");
-      }else if(stream.peek() == "<" || stream.peek() == ">"){
+      } else if(stream.peek() == "<" || stream.peek() == ">" || stream.peek() == "+"){
         return ret("tag", "tag");
-      }else if( /\(/.test(stream.peek()) ){
+      } else if( /\(/.test(stream.peek()) ){
         return ret(null, ch);
-      }else if (stream.peek() == "/" && state.stack[state.stack.length-1] != undefined){ // url(dir/center/image.png)
+      } else if (stream.peek() == "/" && state.stack[state.stack.length-1] != undefined){ // url(dir/center/image.png)
         return ret("string", "string");
-      }else if( stream.current().match(/\-\d|\-.\d/) ){ // match e.g.: -5px -0.4 etc... only colorize the minus sign
+      } else if( stream.current().match(/\-\d|\-.\d/) ){ // match e.g.: -5px -0.4 etc... only colorize the minus sign
         //commment out these 2 comment if you want the minus sign to be parsed as null -500px
         //stream.backUp(stream.current().length-1);
-        //return ret(null, ch); //console.log( stream.current() );
+        //return ret(null, ch);
         return ret("number", "unit");
-      }else if( /\/|[\s\)]/.test(stream.peek() || stream.eol() || (stream.eatSpace() && stream.peek() == "/")) && stream.current().indexOf(".") !== -1){
+      } else if( /\/|[\s\)]/.test(stream.peek() || stream.eol() || (stream.eatSpace() && stream.peek() == "/")) && stream.current().indexOf(".") !== -1){
         if(stream.current().substring(stream.current().length-1,stream.current().length) == "{"){
           stream.backUp(1);
           return ret("tag", "tag");
@@ -137,14 +128,15 @@ CodeMirror.defineMode("less", function(config) {
         stream.eatSpace();
         if( /[{<>.a-zA-Z\/]/.test(stream.peek())  || stream.eol() )return ret("tag", "tag"); // e.g. button.icon-plus
         return ret("string", "string"); // let url(/images/logo.png) without quotes return as string
-      }else if( stream.eol() || stream.peek() == "[" || stream.peek() == "#" || type == "tag" ){
+      } else if( stream.eol() || stream.peek() == "[" || stream.peek() == "#" || type == "tag" ){
         if(stream.current().substring(stream.current().length-1,stream.current().length) == "{")stream.backUp(1);
         return ret("tag", "tag");
-      }else if(type == "compare" || type == "a" || type == "("){
+      } else if(type == "compare" || type == "a" || type == "("){
         return ret("string", "string");
-      }else if(type == "|" || stream.current() == "-" || type == "["){
+      } else if(type == "|" || stream.current() == "-" || type == "["){
+        if(type == "|" )return ret("tag", "tag");
         return ret(null, ch);
-      }else if(stream.peek() == ":") {
+      } else if(stream.peek() == ":") {
         stream.next();
         var t_v = stream.peek() == ":" ? true : false;
         if(!t_v){
@@ -156,11 +148,14 @@ CodeMirror.defineMode("less", function(config) {
             stream.backUp(new_pos-(old_pos-1));
             return ret("tag", "tag");
           } else stream.backUp(new_pos-(old_pos-1));
-        }else{
+        } else {
           stream.backUp(1);
         }
         if(t_v)return ret("tag", "tag"); else return ret("variable", "variable");
-      }else{
+      } else if(state.stack[state.stack.length-1]  === "font-family"){
+        return ret(null, null);
+      } else {
+        if(state.stack[state.stack.length-1] === "{" || type === "select-op"  || (state.stack[state.stack.length-1] === "rule" && type === ",") )return ret("tag", "tag");
         return ret("variable", "variable");
       }
     }
@@ -238,12 +233,15 @@ CodeMirror.defineMode("less", function(config) {
       }
       else if (type == "}") state.stack.pop();
       else if (type == "@media") state.stack.push("@media");
-      else if (context == "{" && type != "comment") state.stack.push("rule");
+      else if (stream.current() === "font-family") state.stack[state.stack.length-1] = "font-family";
+      else if (context == "{" && type != "comment" && type !== "tag") state.stack.push("rule");
+      else if (stream.peek() === ":" && stream.current().match(/@|#/) === null) style = type;
       return style;
     },
 
     indent: function(state, textAfter) {
       var n = state.stack.length;
+
       if (/^\}/.test(textAfter))
         n -= state.stack[state.stack.length-1] == "rule" ? 2 : 1;
       return state.baseIndent + n * indentUnit;