maglev-webtools 0.2.1

data/public/javascript/CodeMirror/js/highlight.js

@@ -0,0 +1,68 @@
+// Minimal framing needed to use CodeMirror-style parsers to highlight
+// code. Load this along with tokenize.js, stringstream.js, and your
+// parser. Then call highlightText, passing a string as the first
+// argument, and as the second argument either a callback function
+// that will be called with an array of SPAN nodes for every line in
+// the code, or a DOM node to which to append these spans, and
+// optionally (not needed if you only loaded one parser) a parser
+// object.
+
+// Stuff from util.js that the parsers are using.
+var StopIteration = {toString: function() {return "StopIteration"}};
+
+var Editor = {};
+var indentUnit = 2;
+
+(function(){
+  function normaliseString(string) {
+    var tab = "";
+    for (var i = 0; i < indentUnit; i++) tab += " ";
+
+    string = string.replace(/\t/g, tab).replace(/\u00a0/g, " ").replace(/\r\n?/g, "\n");
+    var pos = 0, parts = [], lines = string.split("\n");
+    for (var line = 0; line < lines.length; line++) {
+      if (line != 0) parts.push("\n");
+      parts.push(lines[line]);
+    }
+
+    return {
+      next: function() {
+        if (pos < parts.length) return parts[pos++];
+        else throw StopIteration;
+      }
+    };
+  }
+
+  window.highlightText = function(string, callback, parser) {
+    parser = (parser || Editor.Parser).make(stringStream(normaliseString(string)));
+    var line = [];
+    if (callback.nodeType == 1) {
+      var node = callback;
+      callback = function(line) {
+        for (var i = 0; i < line.length; i++)
+          node.appendChild(line[i]);
+        node.appendChild(document.createElement("br"));
+      };
+    }
+
+    try {
+      while (true) {
+        var token = parser.next();
+        if (token.value == "\n") {
+          callback(line);
+          line = [];
+        }
+        else {
+          var span = document.createElement("span");
+          span.className = token.style;
+          span.appendChild(document.createTextNode(token.value));
+          line.push(span);
+        }
+      }
+    }
+    catch (e) {
+      if (e != StopIteration) throw e;
+    }
+    if (line.length) callback(line);
+  }
+})();

data/public/javascript/CodeMirror/js/parseSmalltalk.js

@@ -0,0 +1,126 @@
+/* Simple parser for Smalltalk */
+
+var SmalltalkParser = (function() {
+	var tokenizeSmalltalk = (function() {
+		var identifierTest = /[A-Za-z0-9_]/;
+		function normal(source, setState) {
+			var char = source.next();
+			if (char == ' ' || char == '\t') {
+				return 'whitespace';
+			}
+			if (char == '\n') {
+				return 'newline';
+			}
+			if (/[A-Za-z]/.test(char) || (char == '_' && identifierTest.test(source.peek()))) {
+				source.nextWhileMatches(identifierTest);
+				if (!source.endOfLine() && source.peek() == ':') {
+					source.next();
+					return 'st-keyword';
+				}
+				return 'st-identifier';
+			}
+			if (char == '$') {
+				if (source.endOfLine()) return 'st-error';
+				source.next();	
+				return 'st-character';
+			}
+			if (char == '^') {
+				return 'st-return';
+			}
+			else if (char == "'") {
+				setState(inString("'", 'st-string'));
+				return null;
+			}
+			else if (char == '"') {
+				setState(inString('"', 'st-comment'));
+				return null;
+			}
+			else if (char == '#') {
+				if (source.endOfLine()) return 'st-error';
+				char = source.next();
+				if (char == "'") {
+					setState(inString("'", 'st-symbol'));
+					return null;
+				} else {
+					if (/[A-Za-z]/.test(char) || (char == '_' && identifierTest.test(source.peek()))) {
+						source.nextWhileMatches(/[A-Za-z0-9_:]/);
+						return 'st-symbol';
+					}
+				}
+				return 'st-error';
+			}
+			return 'st-other';
+		}
+
+		function inString(endChar, styleClass) {
+			return function(source, setState) {
+				while (true) {
+					if (source.endOfLine())
+						return styleClass;
+					if (source.next() == endChar) {
+						if (!source.endOfLine() && source.peek() == endChar)
+							source.next();
+						else
+							break;
+					}
+				}
+				setState(normal);
+				return styleClass;
+			}
+		}	
+		return function(source, startState) {
+		  return tokenizer(source, startState || normal);
+		};
+	})();
+	function parseSmalltalk(source, basecolumn) {
+		var tokens = tokenizeSmalltalk(source);	
+		var iter = {
+			next: function() {
+				var token = tokens.next()
+				,	style = token.style
+				,	content = token.content
+				;
+				if (style == 'newline') {
+					token['indentation'] = function(text, current, direction) {  };
+					return token;
+				}
+				if (style == 'st-identifier') {
+					if (content == 'true' || content == 'false') {
+						token.style = 'st-boolean';
+						return token;
+					}
+					if (content == 'self') {
+						token.style = 'st-self';
+						return token;
+					}
+					if (content == 'super') {
+						token.style = 'st-super';
+						return token;
+					}
+					if (content == 'nil') {
+						token.style = 'st-nil';
+						return token;
+					}
+					if (content.substring(0,1) == content.substring(0,1).toUpperCase()) {
+						token.style = 'st-global';
+						return token;
+					}
+				}
+				return token;
+			},
+			copy: function() {
+				var _tokenState = tokens.state;
+				return function(source) {
+					tokens = tokenizeSmalltalk(source, _tokenState);
+					return iter;
+				};
+			}
+		};
+		return iter;
+	}
+	return { make: parseSmalltalk };
+})();
+
+if (Editor) {
+	Editor.Parser = SmalltalkParser;
+}

data/public/javascript/CodeMirror/js/parsedummy.js

@@ -0,0 +1,32 @@
+var DummyParser = Editor.Parser = (function() {
+  function tokenizeDummy(source) {
+    while (!source.endOfLine()) source.next();
+    return "text";
+  }
+  function parseDummy(source) {
+    function indentTo(n) {return function() {return n;}}
+    source = tokenizer(source, tokenizeDummy);
+    var space = 0;
+
+    var iter = {
+      next: function() {
+        var tok = source.next();
+        if (tok.type == "whitespace") {
+          if (tok.value == "\n") tok.indentation = indentTo(space);
+          else space = tok.value.length;
+        }
+        return tok;
+      },
+      copy: function() {
+        var _space = space;
+        return function(_source) {
+          space = _space;
+          source = tokenizer(_source, tokenizeDummy);
+          return iter;
+        };
+      }
+    };
+    return iter;
+  }
+  return {make: parseDummy};
+})();