maglev-webtools 0.2.1 → 1.0

data/public/CodeMirror/js/ruby.js

@@ -0,0 +1,195 @@
+CodeMirror.defineMode("ruby", function(config, parserConfig) {
+  function wordObj(words) {
+    var o = {};
+    for (var i = 0, e = words.length; i < e; ++i) o[words[i]] = true;
+    return o;
+  }
+  var keywords = wordObj([
+    "alias", "and", "BEGIN", "begin", "break", "case", "class", "def", "defined?", "do", "else",
+    "elsif", "END", "end", "ensure", "false", "for", "if", "in", "module", "next", "not", "or",
+    "redo", "rescue", "retry", "return", "self", "super", "then", "true", "undef", "unless",
+    "until", "when", "while", "yield", "nil", "raise", "throw", "catch", "fail", "loop", "callcc",
+    "caller", "lambda", "proc", "public", "protected", "private", "require", "load",
+    "require_relative", "extend", "autoload"
+  ]);
+  var indentWords = wordObj(["def", "class", "case", "for", "while", "do", "module", "then",
+                             "unless", "catch", "loop", "proc"]);
+  var dedentWords = wordObj(["end", "until"]);
+  var matching = {"[": "]", "{": "}", "(": ")"};
+  var curPunc;
+
+  function chain(newtok, stream, state) {
+    state.tokenize.push(newtok);
+    return newtok(stream, state);
+  }
+
+  function tokenBase(stream, state) {
+    curPunc = null;
+    if (stream.sol() && stream.match("=begin") && stream.eol()) {
+      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", ch == '"'), stream, state);
+    } else if (ch == "%") {
+      var style, embed = false;
+      if (stream.eat("s")) style = "atom";
+      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(readQuoted(delim, style, embed, true), stream, state);
+    } else if (ch == "#") {
+      stream.skipToEnd();
+      return "comment";
+    } else if (ch == "<" && stream.eat("<")) {
+      stream.eat("-");
+      stream.eat(/[\'\"\`]/);
+      var match = stream.match(/^\w+/);
+      stream.eat(/[\'\"\`]/);
+      if (match) return chain(readHereDoc(match[0]), stream, state);
+      return null;
+    } else if (ch == "0") {
+      if (stream.eat("x")) stream.eatWhile(/[\da-fA-F]/);
+      else if (stream.eat("b")) stream.eatWhile(/[01]/);
+      else stream.eatWhile(/[0-7]/);
+      return "number";
+    } else if (/\d/.test(ch)) {
+      stream.match(/^[\d_]*(?:\.[\d_]+)?(?:[eE][+\-]?[\d_]+)?/);
+      return "number";
+    } else if (ch == "?") {
+      while (stream.match(/^\\[CM]-/)) {}
+      if (stream.eat("\\")) stream.eatWhile(/\w/);
+      else stream.next();
+      return "string";
+    } else if (ch == ":") {
+      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 == "@") {
+      stream.eat("@");
+      stream.eatWhile(/[\w\?]/);
+      return "variable-2";
+    } else if (ch == "$") {
+      stream.next();
+      stream.eatWhile(/[\w\?]/);
+      return "variable-3";
+    } else if (/\w/.test(ch)) {
+      stream.eatWhile(/[\w\?]/);
+      if (stream.eat(":")) return "atom";
+      return "ident";
+    } else if (ch == "|" && (state.varList || state.lastTok == "{" || state.lastTok == "do")) {
+      curPunc = "|";
+      return null;
+    } else if (/[\(\)\[\]{}\\;]/.test(ch)) {
+      curPunc = ch;
+      return null;
+    } else if (ch == "-" && stream.eat(">")) {
+      return "arrow";
+    } else if (/[=+\-\/*:\.^%<>~|]/.test(ch)) {
+      stream.eatWhile(/[=+\-\/*:\.^%<>~|]/);
+      return "operator";
+    } else {
+      return null;
+    }
+  }
+
+  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 && (unescaped || !escaped)) {
+          state.tokenize.pop();
+          break;
+        }
+        if (embed && ch == "#" && !escaped && stream.eat("{")) {
+          state.tokenize.push(tokenBaseUntilBrace(arguments.callee));
+          break;
+        }
+        escaped = !escaped && ch == "\\";
+      }
+      return style;
+    };
+  }
+  function readHereDoc(phrase) {
+    return function(stream, state) {
+      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.pop();
+    stream.skipToEnd();
+    return "comment";
+  }
+
+  return {
+    startState: function() {
+      return {tokenize: [tokenBase],
+              indented: 0,
+              context: {type: "top", indented: -config.indentUnit},
+              continuedLine: false,
+              lastTok: null,
+              varList: false};
+    },
+
+    token: function(stream, state) {
+      if (stream.sol()) state.indented = stream.indentation();
+      var style = state.tokenize[state.tokenize.length-1](stream, state), kwtype;
+      if (style == "ident") {
+        var word = stream.current();
+        style = keywords.propertyIsEnumerable(stream.current()) ? "keyword"
+          : /^[A-Z]/.test(word) ? "tag"
+          : (state.lastTok == "def" || state.lastTok == "class" || state.varList) ? "def"
+          : "variable";
+        if (indentWords.propertyIsEnumerable(word)) kwtype = "indent";
+        else if (dedentWords.propertyIsEnumerable(word)) kwtype = "dedent";
+        else if (word == "if" && stream.column() == stream.indentation()) kwtype = "indent";
+      }
+      if (curPunc || (style && style != "comment")) state.lastTok = word || curPunc || style;
+      if (curPunc == "|") state.varList = !state.varList;
+
+      if (kwtype == "indent" || /[\(\[\{]/.test(curPunc))
+        state.context = {prev: state.context, type: curPunc || style, indented: state.indented};
+      else if ((kwtype == "dedent" || /[\)\]\}]/.test(curPunc)) && state.context.prev)
+        state.context = state.context.prev;
+
+      if (stream.eol())
+        state.continuedLine = (curPunc == "\\" || style == "operator");
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      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] ||
+        ct.type == "keyword" && /^(?:end|until|else|elsif|when)\b/.test(textAfter);
+      return ct.indented + (closing ? 0 : config.indentUnit) +
+        (state.continuedLine ? config.indentUnit : 0);
+    }
+  };
+});
+
+CodeMirror.defineMIME("text/x-ruby", "ruby");

data/public/CodeMirror/js/smalltalk.js

@@ -0,0 +1,139 @@
+CodeMirror.defineMode("smalltalk", function(config, parserConfig) {
+  var indentUnit = config.indentUnit;
+
+  function chain(stream, state, f) {
+    state.tokenize = f;
+    return f(stream, state);
+  }
+
+  var type;
+  function ret(tp, style) {
+    type = tp;
+    return style;
+  }
+
+  function tokenBase(stream, state) {
+	var identifierTest = /[A-Za-z0-9_]/;
+    var ch = stream.next();
+	if (/[A-Za-z]/.test(ch) || (ch === '_' && identifierTest.test(stream.peek()))) {
+		stream.eatWhile(identifierTest);
+		if (!stream.eol() && stream.match(':')) {
+			if (!state.context.keywordSelector) {
+				state.context.keywordSelector = stream.current();
+			} else {
+				state.context.keywordSelector += stream.current();
+			}
+			return ret('word', 'st-keyword');
+		}
+	    var current = stream.current();
+	    if (current === 'nil') { return ret('word', 'st-nil'); };
+	    if (current === 'self') { return ret('word', 'st-self'); };
+	    if (current === 'super') { return ret('word', 'st-super'); };
+	    if (current === 'thisContext') { return ret('word', 'st-thisContext'); };
+	    if (current === 'true' || current === 'false') { return ret('word', 'st-boolean'); };
+		if (/^[A-Z]/.test(current)) { return ret('word', 'st-global'); };
+		return ret('word', 'st-identifier'); } 
+	else if (ch === '.') { 
+		state.context.keywordSelector = null;
+		return ret('other', 'st-period'); }
+	else if (ch === '$') {
+		if (stream.eol()) return ret('error', 'error');
+		stream.next();
+		return ret('character', 'st-character'); }
+	else if (ch === '^') return ret('character', 'st-return');
+	else if (ch === '"')
+      return chain(stream, state, tokenString(ch, 'comment', 'st-comment'));
+	else if (ch === "'")
+      return chain(stream, state, tokenString(ch, 'string', 'st-string'));
+    else if (ch == "#") {
+	  if (stream.eat("'")) {
+	    return chain(stream, state, tokenString( "'", 'string', 'st-symbol'));
+	  }
+      stream.eatWhile(/[A-Za-z0-9_:]/);
+      return ret("string", "st-symbol"); }
+    else if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/)
+      return ret("number", "st-number"); }
+    else if (/[\[\](){}]/.test(ch)) {
+      return ret(ch, null); }
+	else if (stream.eatWhile('[\/\[\+\-\\\*\~\<\>\=\|\/\&\@\%\,\?\!]')) { 
+		return ret('selector', 'st-binary'); }
+    else {
+      stream.eatWhile(/[\w\$_]/);
+      return ret("other", "st-other");
+    }
+  }
+
+  function tokenString(endChar, tp, style) {
+    return function(stream, state) {
+      while (true) {
+	    if (stream.eol()) return ret(tp, style);
+		if (stream.next() === endChar && !stream.eat(endChar)) {
+			state.tokenize = tokenBase;
+			return ret(tp, style);
+		}
+      }
+    };
+  }
+
+  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) {
+    return state.context = state.context.prev;
+  }
+
+  // Interface
+
+  return {
+	compareStates: function(x, y) { return false; },	// force full parse to get keyword selectors that span multiple lines
+
+    startState: function(basecolumn) {
+      return {
+        tokenize: tokenBase,
+        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;
+      var style = state.tokenize(stream, state);
+      if (type == "comment") return style;
+      if (ctx.align == null) ctx.align = true;
+
+      if (type == "[") pushContext(state, stream.column(), "]");
+      else if (type == "(") pushContext(state, stream.column(), ")");
+      else if (type == "{") pushContext(state, stream.column(), "}");
+      else if (type == ctx.type) popContext(state);
+      state.startOfLine = false;
+      return style;
+    },
+
+    indent: function(state, textAfter) {
+      if (state.tokenize != tokenBase) return 0;
+      var firstChar = textAfter && textAfter.charAt(0), ctx = state.context, closing = firstChar == ctx.type;
+      if (ctx.align) return ctx.column + (closing ? 0 : 1);
+      else return ctx.indented + (closing ? 0 : indentUnit);
+    },
+
+    electricChars: "]"
+  };
+});
+
+CodeMirror.defineMIME("text/x-stsrc", {name: "smalltalk"});

data/public/Debugger.html

@@ -0,0 +1,28 @@
+<script type="text/javascript" language="javascript">
+	GemStone.runJs('scripts/Debugger.js', OOP);
+</script> 
+
+<div id='newTab' class='debuggerPanel hidden'>
+	<div class='toolbar'>
+		<button class='restart'>Restart</button>
+		<button class='into'>Into</button>
+		<button class='over'>Over</button>
+		<button class='out'>Out</button>
+		<button class='go'>Go</button>
+		<span class='label'></span>
+	</div>
+	<div class='navigation'>
+		<div class='stack divList'></div>
+		<table class='variables'>
+			<thead><tr>
+				<th>Variable</th>
+				<th>value</th>
+				<th>OOP</th>
+			</tr></thead>
+			<tbody />
+		</table>
+		<textarea class='variableValue'></textarea>
+	</div>
+	<div class='editArea newEditor' tabindex=0>
+	</div>
+</div>

data/public/MethodList.html

@@ -0,0 +1,20 @@
+<script type="text/javascript" language="javascript">
+	GemStone.runJs('scripts/MethodList.js', SEARCH_OBJECT);
+</script> 
+
+<div id='newTab' class='methodListPanel hidden'>
+	<div class='methodList'>
+		<table>
+			<thead><tr>
+				<th>Dictionary</th>
+				<th>Class Category</th>
+				<th>Class</th>
+				<th>Category</th>
+				<th>Method</th>
+			</tr></thead>
+			<tbody />
+		</table>
+	</div>
+	<div class='editArea newEditor' tabindex=0>
+	</div>
+</div>

data/public/ObjectLog.html

@@ -0,0 +1,20 @@
+<script type="text/javascript" language="javascript">
+	GemStone.runJs('scripts/ObjectLog.js');
+</script> 
+
+<div id='newTab' class='objectLogPanel hidden'>
+	<div class='objectLog'>
+		<table>
+			<thead><tr>
+				<th>Timestamp</th>
+				<th>PID</th>
+				<th>Label</th>
+				<th>Type</th>
+				<th>Tag</th>
+				<th>Object</th>
+				<th>Stack</th>
+			</tr></thead>
+			<tbody />
+		</table>
+	</div>
+</div>

data/public/SessionList.html

@@ -0,0 +1,31 @@
+<script type="text/javascript" language="javascript"> 
+	GemStone.runJs('scripts/SessionList.js');
+</script> 
+
+<div id='newTab' class='gemListPanel hidden'>
+	<div id='gemListPanelOnce' class='once'>
+		<div class='statsTemplate hidden'>
+			<div class='stats'>
+				<table>
+					<caption>Cache Statistics</caption>
+						<thead><tr>
+							<th>Name</th><th>Type</th><th>Level</th>
+							<th>Units</th><th>From OS</th><th>Value</th>
+						</tr></thead>
+					<tbody />
+				</table>
+			</div>
+		</div>
+	</div>
+	<div class='gemList'>
+		<table>
+			<caption>Current Sessions</caption>
+			<thead><tr /></thead>
+			<tbody />
+		</table>
+	</div>
+	<div class='gemListFooter maximize'>
+		<label>Stone processes:&nbsp;</label>
+		<ul class='stoneProcesses' />
+	</div>
+</div>

data/public/SharedPageCache.html

@@ -0,0 +1,78 @@
+<script type="text/javascript" language="javascript"> 
+//<![CDATA[ 
+(function() {
+	var	$tabPanel
+	;
+	GemStone.addTab({
+		id:		'newTab'
+	,	label:	'SPC'
+	,	title:	'Shared Page Cache'
+	,	onAdd:	onAdd
+	});
+	return;
+
+	function onAdd(tabPanel) {
+		$tabPanel = tabPanel;
+		GemStone.ajax('GET', 'SharedPageCache', null, gotData);
+	}
+	
+	function gotData(data) {
+		var min = 1;
+		$('.pageTypes .objectTable', 	$tabPanel).css('width', Math.max(data.objectTable, min) + '%');
+		$('.pageTypes .objectTable', 	$tabPanel).text(data.objectTable);
+		$('.pageTypes .bitmap', 		$tabPanel).css('width', Math.max(data.bitmap, min) + '%');
+		$('.pageTypes .bitmap', 		$tabPanel).text(data.bitmap);
+		$('.pageTypes .commitRecord', 	$tabPanel).css('width', Math.max(data.commitRecord, min) + '%');
+		$('.pageTypes .commitRecord', 	$tabPanel).text(data.commitRecord);
+		$('.pageTypes .other', 			$tabPanel).css('width', Math.max(data.other, min) + '%');
+		$('.pageTypes .other', 			$tabPanel).text(data.other);
+		$('.pageTypes .data', 			$tabPanel).css('width', Math.max(data.data, min) + '%');
+		$('.pageTypes .data', 			$tabPanel).text(data.data);
+		$('.frameState .globalDirty', 	$tabPanel).css('width', Math.max(data.globalDirty, min) + '%');
+		$('.frameState .globalDirty', 	$tabPanel).text(data.globalDirty);
+		$('.frameState .localDirty', 	$tabPanel).css('width', Math.max(data.localDirty, min) + '%');
+		$('.frameState .localDirty', 	$tabPanel).text(data.localDirty);
+		$('.frameState .clean', 		$tabPanel).css('width', Math.max(data.clean, min) + '%');
+		$('.frameState .clean', 		$tabPanel).text(data.clean);
+		$('.frameState .free', 			$tabPanel).css('width', Math.max(data.free - 5, min) + '%');
+		$('.frameState .free', 			$tabPanel).text(data.free);
+	}
+}())
+//]]> 
+</script> 
+
+<div id='newTab' class='spcPanel hidden'>
+	<div id='spcPanelOnce' class='once'>
+		<style type="text/css">
+.spcPanel .pageTypes { height: 2em; width: 100%; }
+.spcPanel .pageTypes div { display: inline-block; }
+.spcPanel .pageTypes .objectTable { background: Wheat; height: 100%; width: 15%; }
+.spcPanel .pageTypes .bitmap { background: Blue; height: 100%; width: 15%; }
+.spcPanel .pageTypes .commitRecord { background: Red; height: 100%; width: 15%; }
+.spcPanel .pageTypes .other { background: CadetBlue; height: 100%; width: 15%; }
+.spcPanel .pageTypes .data { background: Green; height: 100%; width: 15%; }
+.spcPanel .frameState { height: 2em; width: 100%; }
+.spcPanel .frameState div { display: inline-block; }
+.spcPanel .frameState .globalDirty { background: Orange; height: 100%; width: 25%; }
+.spcPanel .frameState .localDirty { background: Salmon; height: 100%; width: 25%; }
+.spcPanel .frameState .clean { background: GreenYellow; height: 100%; width: 25%; }
+.spcPanel .frameState .free { background: Beige; height: 100%; width: 25%; }
+		</style>
+	</div>
+	<div>Types of pages in Shared Page Cache</div>
+	<div class='pageTypes'>
+		<div class='objectTable' title='% frames with Object Table Pages'>&nbsp</div>
+		<div class='bitmap' title='% frames with Bitmap Pages'>&nbsp</div>
+		<div class='commitRecord' title='% frames with Commit Records Pages'>&nbsp</div>
+		<div class='other' title='% frames with Other Pages'>&nbsp</div>
+		<div class='data' title='% frames with Data Pages'>&nbsp</div>
+	</div>
+	<br />
+	<div>State of pages in Shared Page Cache</div>
+	<div class='frameState'>
+		<div class='globalDirty' title='% frames with dirty but not committed pages'>&nbsp</div>
+		<div class='localDirty' title='% frames with dirty committed pages'>&nbsp</div>
+		<div class='clean' title='% frames with clean pages'>&nbsp</div>
+		<div class='free' title='% free frames'>&nbsp</div>
+	</div>
+</div>