codemirror-rails 2.2.1 → 2.3

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

@@ -0,0 +1,316 @@
+CodeMirror.defineMode('tiki', function(config, parserConfig) {
+	function inBlock(style, terminator, returnTokenizer) {
+		return function(stream, state) {
+			while (!stream.eol()) {
+				if (stream.match(terminator)) {
+					state.tokenize = inText;
+					break;
+				}
+				stream.next();
+			}
+			
+			if (returnTokenizer) state.tokenize = returnTokenizer;
+			
+			return style;
+		};
+	}
+	
+	function inLine(style, terminator) {
+		return function(stream, state) {
+			while(!stream.eol()) {
+				stream.next()
+			}
+			state.tokenize = inText;
+			return style;
+		};
+	}
+	
+	function inText(stream, state) {
+		function chain(parser) {
+			state.tokenize = parser;
+			return parser(stream, state);
+		}
+		
+		var sol = stream.sol();
+		var ch = stream.next();
+		
+		//non start of line
+		switch (ch) { //switch is generally much faster than if, so it is used here
+			case "{": //plugin
+				type = stream.eat("/") ? "closeTag" : "openTag";
+				stream.eatSpace();
+				tagName = "";
+				var c;
+				while ((c = stream.eat(/[^\s\u00a0=\"\'\/?(}]/))) tagName += c;
+				state.tokenize = inPlugin;
+				return "tag";
+				break;
+			case "_": //bold
+				if (stream.eat("_")) {
+					return chain(inBlock("strong", "__", inText));
+				}
+				break;
+			case "'": //italics
+				if (stream.eat("'")) {
+					// Italic text
+					return chain(inBlock("em", "''", inText));
+				}
+				break;
+			case "(":// Wiki Link
+				if (stream.eat("(")) {
+					return chain(inBlock("variable-2", "))", inText));
+				}
+				break;
+			case "[":// Weblink
+				return chain(inBlock("variable-3", "]", inText));
+				break;
+			case "|": //table
+				if (stream.eat("|")) {
+					return chain(inBlock("comment", "||"));
+				}
+				break;
+			case "-": 
+				if (stream.eat("=")) {//titleBar
+					return chain(inBlock("header string", "=-", inText));
+				} else if (stream.eat("-")) {//deleted
+					return chain(inBlock("error tw-deleted", "--", inText));
+				}
+				break;
+			case "=": //underline
+				if (stream.match("==")) {
+					return chain(inBlock("tw-underline", "===", inText));
+				}
+				break;
+			case ":":
+				if (stream.eat(":")) {
+					return chain(inBlock("comment", "::"));
+				}
+				break;
+			case "^": //box
+				return chain(inBlock("tw-box", "^"));
+				break;
+			case "~": //np
+				if (stream.match("np~")) {
+					return chain(inBlock("meta", "~/np~"));
+				}
+				break;
+		}
+		
+		//start of line types
+		if (sol) {
+			switch (ch) {
+				case "!": //header at start of line
+					if (stream.match('!!!!!')) {
+						return chain(inLine("header string"));
+					} else if (stream.match('!!!!')) {
+						return chain(inLine("header string"));
+					} else if (stream.match('!!!')) {
+						return chain(inLine("header string"));
+					} else if (stream.match('!!')) {
+						return chain(inLine("header string"));
+					} else {
+						return chain(inLine("header string"));
+					}
+					break;
+				case "*": //unordered list line item, or <li /> at start of line
+				case "#": //ordered list line item, or <li /> at start of line
+				case "+": //ordered list line item, or <li /> at start of line
+					return chain(inLine("tw-listitem bracket"));
+					break;
+			}
+		}
+		
+		//stream.eatWhile(/[&{]/); was eating up plugins, turned off to act less like html and more like tiki
+		return null;
+	}
+	
+	var indentUnit = config.indentUnit;
+
+	// Return variables for tokenizers
+	var pluginName, type;
+	function inPlugin(stream, state) {
+		var ch = stream.next();
+		var peek = stream.peek();
+		
+		if (ch == "}") {
+			state.tokenize = inText;
+			//type = ch == ")" ? "endPlugin" : "selfclosePlugin"; inPlugin
+			return "tag";
+		} else if (ch == "(" || ch == ")") {
+			return "bracket";
+		} else if (ch == "=") {
+			type = "equals";
+			
+			if (peek == ">") {
+				ch = stream.next();
+				peek = stream.peek();
+			}
+			
+			//here we detect values directly after equal character with no quotes
+			if (!/[\'\"]/.test(peek)) {
+				state.tokenize = inAttributeNoQuote();
+			}
+			//end detect values
+			
+			return "operator";
+		} else if (/[\'\"]/.test(ch)) {
+			state.tokenize = inAttribute(ch);
+			return state.tokenize(stream, state);
+		} else {
+			stream.eatWhile(/[^\s\u00a0=\"\'\/?]/);
+			return "keyword";
+		}
+	}
+
+	function inAttribute(quote) {
+		return function(stream, state) {
+			while (!stream.eol()) {
+				if (stream.next() == quote) {
+					state.tokenize = inPlugin;
+					break;
+				}
+			}
+			return "string";
+		};
+	}
+	
+	function inAttributeNoQuote() {
+		return function(stream, state) {
+			while (!stream.eol()) {
+				var ch = stream.next();
+				var peek = stream.peek();
+				if (ch == " " || ch == "," || /[ )}]/.test(peek)) {
+					state.tokenize = inPlugin;
+					break;
+				}
+			}
+			return "string";
+		};
+	}
+
+	var curState, setStyle;
+	function pass() {
+		for (var i = arguments.length - 1; i >= 0; i--) curState.cc.push(arguments[i]);
+	}
+	
+	function cont() {
+		pass.apply(null, arguments);
+		return true;
+	}
+
+	function pushContext(pluginName, startOfLine) {
+		var noIndent = curState.context && curState.context.noIndent;
+		curState.context = {
+			prev: curState.context,
+			pluginName: pluginName,
+			indent: curState.indented,
+			startOfLine: startOfLine,
+			noIndent: noIndent
+		};
+	}
+	
+	function popContext() {
+		if (curState.context) curState.context = curState.context.prev;
+	}
+
+	function element(type) {
+		if (type == "openPlugin") {curState.pluginName = pluginName; return cont(attributes, endplugin(curState.startOfLine));}
+		else if (type == "closePlugin") {
+			var err = false;
+			if (curState.context) {
+				err = curState.context.pluginName != pluginName;
+				popContext();
+			} else {
+				err = true;
+			}
+			if (err) setStyle = "error";
+			return cont(endcloseplugin(err));
+		}
+		else if (type == "string") {
+			if (!curState.context || curState.context.name != "!cdata") pushContext("!cdata");
+			if (curState.tokenize == inText) popContext();
+			return cont();
+		}
+		else return cont();
+	}
+	
+	function endplugin(startOfLine) {
+		return function(type) {
+			if (
+			type == "selfclosePlugin" ||
+			type == "endPlugin"
+		)
+				return cont();
+			if (type == "endPlugin") {pushContext(curState.pluginName, startOfLine); return cont();}
+			return cont();
+		};
+	}
+	
+	function endcloseplugin(err) {
+		return function(type) {
+			if (err) setStyle = "error";
+			if (type == "endPlugin") return cont();
+			return pass();
+		}
+	}
+
+	function attributes(type) {
+		if (type == "keyword") {setStyle = "attribute"; return cont(attributes);}
+		if (type == "equals") return cont(attvalue, attributes);
+		return pass();
+	}
+	function attvalue(type) {
+		if (type == "keyword") {setStyle = "string"; return cont();}
+		if (type == "string") return cont(attvaluemaybe);
+			return pass();
+	}
+	function attvaluemaybe(type) {
+		if (type == "string") return cont(attvaluemaybe);
+		else return pass();
+	}
+	return {
+		startState: function() {
+			return {tokenize: inText, cc: [], indented: 0, startOfLine: true, pluginName: null, context: null};
+		},
+		token: function(stream, state) {
+			if (stream.sol()) {
+				state.startOfLine = true;
+				state.indented = stream.indentation();
+			}
+			if (stream.eatSpace()) return null;
+
+			setStyle = type = pluginName = null;
+			var style = state.tokenize(stream, state);
+				if ((style || type) && style != "comment") {
+				curState = state;
+				while (true) {
+					var comb = state.cc.pop() || element;
+					if (comb(type || style)) break;
+				}
+			}
+			state.startOfLine = false;
+			return setStyle || style;
+				},
+		indent: function(state, textAfter) {
+			var context = state.context;
+			if (context && context.noIndent) return 0;
+			if (context && /^{\//.test(textAfter))
+				context = context.prev;
+			while (context && !context.startOfLine)
+				context = context.prev;
+			if (context) return context.indent + indentUnit;
+			else return 0;
+		},
+		compareStates: function(a, b) {
+			if (a.indented != b.indented || a.pluginName != b.pluginName) return false;
+			for (var ca = a.context, cb = b.context; ; ca = ca.prev, cb = cb.prev) {
+				if (!ca || !cb) return ca == cb;
+				if (ca.pluginName != cb.pluginName) return false;
+			}
+		},
+		electricChars: "/"
+	};
+});
+
+//I figure, why not
+CodeMirror.defineMIME("text/tiki", "tiki");

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

@@ -0,0 +1,26 @@
+CodeMirror.defineMode("vbscript", function() {
+  var regexVBScriptKeyword = /^(?:Call|Case|CDate|Clear|CInt|CLng|Const|CStr|Description|Dim|Do|Each|Else|ElseIf|End|Err|Error|Exit|False|For|Function|If|LCase|Loop|LTrim|Next|Nothing|Now|Number|On|Preserve|Quit|ReDim|Resume|RTrim|Select|Set|Sub|Then|To|Trim|True|UBound|UCase|Until|VbCr|VbCrLf|VbLf|VbTab)$/im;
+
+  return {
+    token: function(stream) {
+      if (stream.eatSpace()) return null;
+      var ch = stream.next();
+      if (ch == "'") {
+      	stream.skipToEnd();
+      	return "comment";
+      }
+      if (ch == '"') {
+      	stream.skipTo('"');
+      	return "string";
+      }
+
+      if (/\w/.test(ch)) {
+        stream.eatWhile(/\w/);
+        if (regexVBScriptKeyword.test(stream.current())) return "keyword";
+      }
+      return null;
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/vbscript", "vbscript");

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

@@ -0,0 +1,194 @@
+CodeMirror.defineMode("verilog", function(config, parserConfig) {
+  var indentUnit = config.indentUnit,
+      keywords = parserConfig.keywords || {},
+      blockKeywords = parserConfig.blockKeywords || {},
+      atoms = parserConfig.atoms || {},
+      hooks = parserConfig.hooks || {},
+      multiLineStrings = parserConfig.multiLineStrings;
+  var isOperatorChar = /[&|~><!\)\(*#%@+\/=?\:;}{,\.\^\-\[\]]/;
+
+  var curPunc;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (hooks[ch]) {
+      var result = hooks[ch](stream, state);
+      if (result !== false) return result;
+    }
+    if (ch == '"') {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+      curPunc = ch;
+      return null
+    }
+    if (/[\d']/.test(ch)) {
+      stream.eatWhile(/[\w\.']/);
+      return "number";
+    }
+    if (ch == "/") {
+      if (stream.eat("*")) {
+        state.tokenize = tokenComment;
+        return tokenComment(stream, state);
+      }
+      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 || multiLineStrings))
+        state.tokenize = tokenBase;
+      return "string";
+    };
+  }
+
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = tokenBase;
+        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 == "]" || 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) - 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 == "(") pushContext(state, stream.column(), ")");
+      else if (curPunc == "}") {
+        while (ctx.type == "statement") ctx = popContext(state);
+        if (ctx.type == "}") ctx = popContext(state);
+        while (ctx.type == "statement") ctx = popContext(state);
+      }
+      else if (curPunc == ctx.type) popContext(state);
+      else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
+        pushContext(state, stream.column(), "statement");
+      state.startOfLine = false;
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
+      var firstChar = textAfter && textAfter.charAt(0), ctx = state.context, closing = firstChar == ctx.type;
+      if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : indentUnit);
+      else if (ctx.align) return ctx.column + (closing ? 0 : 1);
+      else return ctx.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: "{}"
+  };
+});
+
+(function() {
+  function words(str) {
+    var obj = {}, words = str.split(" ");
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+
+  var verilogKeywords = "always and assign automatic begin buf bufif0 bufif1 case casex casez cell cmos config " +
+    "deassign default defparam design disable edge else end endcase endconfig endfunction endgenerate endmodule " +
+    "endprimitive endspecify endtable endtask event for force forever fork function generate genvar highz0 " +
+    "highz1 if ifnone incdir include initial inout input instance integer join large liblist library localparam " +
+    "macromodule medium module nand negedge nmos nor noshowcancelled not notif0 notif1 or output parameter pmos " +
+    "posedge primitive pull0 pull1 pulldown pullup pulsestyle_onevent pulsestyle_ondetect rcmos real realtime " +
+    "reg release repeat rnmos rpmos rtran rtranif0 rtranif1 scalared showcancelled signed small specify specparam " +
+    "strong0 strong1 supply0 supply1 table task time tran tranif0 tranif1 tri tri0 tri1 triand trior trireg " +
+    "unsigned use vectored wait wand weak0 weak1 while wire wor xnor xor";
+
+  var verilogBlockKeywords = "begin bufif0 bufif1 case casex casez config else end endcase endconfig endfunction " +
+    "endgenerate endmodule endprimitive endspecify endtable endtask for forever function generate if ifnone " +
+    "macromodule module primitive repeat specify table task while";
+
+  function metaHook(stream, state) {
+    stream.eatWhile(/[\w\$_]/);
+    return "meta";
+  }
+
+  // C#-style strings where "" escapes a quote.
+  function tokenAtString(stream, state) {
+    var next;
+    while ((next = stream.next()) != null) {
+      if (next == '"' && !stream.eat('"')) {
+        state.tokenize = null;
+        break;
+      }
+    }
+    return "string";
+  }
+
+  CodeMirror.defineMIME("text/x-verilog", {
+    name: "verilog",
+    keywords: words(verilogKeywords),
+    blockKeywords: words(verilogBlockKeywords),
+    atoms: words("null"),
+    hooks: {"`": metaHook, "$": metaHook}
+  });
+}());