RubyGems - erp_app - Versions diffs - 3.0.0 → 3.0.1 - Mend

erp_app 3.0.0 → 3.0.1

Files changed (909) hide show

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/regex/js-regex.html ADDED Viewed

@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>CodeMirror Regex Highlighting</title>
+<script type="text/javascript" src="../../js/codemirror.js"></script>
+<script type="text/javascript">
+window.onload = function () {
+  createEditor('js-regexp', 'uniform');
+  createEditor('js-regexp-type', 'type');
+  createEditor('js-regexp-none', false);
+  function createEditor (id, type) {
+      var jseditor = CodeMirror.fromTextArea(id, {
+        noScriptCaching: true,
+        // continuousScanning: true,  // Normally Debugging only, but useful with regex
+        parserConfig: {
+            // flags: 'x',
+            //literal: true,
+            flavor: 'ecma-262-ed3',
+            regex_mode_modifier: true,
+            regex_max_levels:2,
+            regex_max_alternating:2,
+            regex_inner_group_mode: type
+        },
+        parserfile: ["tokenizejavascript.js", "parsejavascript.js", "../contrib/regex/js/parseregex.js","../contrib/regex/js/parsejavascript_and_regex.js"],
+        stylesheet: ["css/js-regexcolors.css", "../../css/jscolors.css"],
+        path: '../../js/',
+        height: 'dynamic',
+        minHeight: 20,
+        // Demonstrates Unicode tooltip features
+        activeTokens : (function () {
+            var charLimit = 500;
+            var lastEquivalent, rangeBegan, lastRangeHyphen;
+            function _buildTitle (beginChar, endChar) {
+                var beginCode = beginChar.charCodeAt(0), endCode = endChar.charCodeAt(0);
+                var title = '';
+                if (endCode - beginCode <= charLimit) {
+                    for (var i = beginCode; i <= endCode; i++) {
+                        title += String.fromCharCode(i);
+                    }
+                }
+                return title;
+            }
+            return function (spanNode, token, editor) {
+                var content = token.content;
+                if (lastEquivalent && token.style === 'regex-class-range-hyphen') {
+                    rangeBegan = true;
+                    lastRangeHyphen = spanNode;
+                }
+                else if (rangeBegan) {
+                    var beginChar = lastEquivalent;
+                    var endChar = (token.equivalent || content);
+                    lastRangeHyphen.title = _buildTitle(beginChar, endChar);
+                    rangeBegan = false;
+                    lastEquivalent = null;
+                }
+                else if (content === ']') {
+                    rangeBegan = false;
+                }
+                else {
+                    rangeBegan = false;
+                    // Fix: 'regex-unicode-class-inside' not supported and should not be since it wouldn't make sense as a starting range?
+                    lastEquivalent = token.equivalent || content;
+                }
+                if (token.display) {
+                    spanNode.title = token.display;
+                }
+                else if (token.equivalent) {
+                    if (token.unicode) {
+                        var range = /(.)-(.)/g;
+                        spanNode.title = token.equivalent.replace(range,
+                            function (n0, n1, n2) {
+                                return _buildTitle(n1, n2);
+                            }
+                        );
+                    }
+                    else {
+                        spanNode.title = token.equivalent;
+                    }
+                }
+            };
+        }())
+      });
+  }
+};
+</script>
+</head>
+<body>
+<div>
+    <h1>CodeMirror JavaScript-Integrated Regex Code Editor Demonstration</h1>
+        <p>This demonstrates a parser in the regex folder which wraps the regular CodeMirror JavaScript editor and adds syntax coloring to
+        regular expression literals in JavaScript.</p>
+        <textarea id="js-regexp" cols="60" rows="1">
+var aVar = "aString" + 42 + aFunction(anArg, true);
+var myRgx = /test(group1|group2|(?:group3))and(group4)and(gr(ou)p5)/gi;
+</textarea>
+        <p>While the above styles by depth or sequence no matter the grouping type, this parser also allows styling distinctly by grouping type (capturing, named, non-capturing), while also still allowing alternating of colors within a type.</p>
+        <textarea id="js-regexp-type" cols="60" rows="1">
+var aVar = "aString" + 42 + aFunction(anArg, true);
+var myRgx = /test(group1|group2|(?:group3))and(group4)and(gr(ou)p5)/gi;
+</textarea>
+        <p>One may also simply turn off the styling of content inside groups, allowing only individual tokens to be styled per the stylesheet (though the parentheses tokens themselves can still indicate depth or sequence):</p>
+        <textarea id="js-regexp-none" cols="60" rows="1">
+var aVar = "aString" + 42 + aFunction(anArg, true);
+var myRgx = /test(group1|group2|(?:group3))and(group4)and(gr(ou)p5)/gi;
+</textarea>
+</div>
+</body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/scheme/LICENSE ADDED Viewed

@@ -0,0 +1,23 @@
+ Copyright (c) 2010 Danny Yoo
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any
+ damages arising from the use of this software.
+ Permission is granted to anyone to use this software for any
+ purpose, including commercial applications, and to alter it and
+ redistribute it freely, subject to the following restrictions:
+ 1. The origin of this software must not be misrepresented; you must
+    not claim that you wrote the original software. If you use this
+    software in a product, an acknowledgment in the product
+    documentation would be appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must
+    not be misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source
+    distribution.
+ Danny Yoo
+ dyoo@cs.wpi.edu

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/scheme/css/schemecolors.css ADDED Viewed

@@ -0,0 +1,45 @@
+html {
+  cursor: text;
+  width: 100%;
+  height: 100%;
+  background-color: white;
+}
+.editbox {
+  width: 100%;
+  height: 100%;
+  margin: 0pt;
+  padding: 0;
+  font-family: monospace;
+  font-size: 10pt;
+  color: black;
+}
+pre.code, .editbox {
+  color: #666666;
+}
+.editbox p {
+  margin: 0;
+}
+span.scheme-string	{color: green;}
+span.scheme-number	{color: blue;}
+span.scheme-boolean     {color: darkred;}
+span.scheme-character	{color: orange;}
+span.scheme-symbol	{color: steelblue;}
+span.scheme-punctuation {color: black;}
+span.scheme-lparen      {color: black;}
+span.scheme-rparen      {color: black;}
+span.scheme-comment     { color: orange; }
+span.good-matching-paren {
+    font-weight: bold;
+    color: #3399FF;
+}
+span.bad-matching-paren {
+    font-weight: bold;
+    color: red;
+}

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/scheme/index.html ADDED Viewed

@@ -0,0 +1,82 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <script src="../../js/codemirror.js" type="text/javascript"></script>
+    <script src="../../js/mirrorframe.js" type="text/javascript"></script>
+    <title>CodeMirror: Scheme demonstration</title>
+    <link rel="stylesheet" type="text/css" href="../../css/docs.css"/>
+    <style type="text/css">
+      .CodeMirror-line-numbers {
+        width: 2.2em;
+        color: #aaa;
+        background-color: #eee;
+        text-align: right;
+        padding-right: .3em;
+        font-size: 10pt;
+        font-family: monospace;
+        padding-top: .4em;
+        line-height: normal;
+      }
+    </style>
+  </head>
+  <body style="padding: 20px;">
+<p>This page demonstrates <a href="index.html">CodeMirror</a>'s
+Scheme parser. (<a href="LICENSE">license</a>)</p>
+<div style="border-top: 1px solid black; border-bottom: 1px solid black;">
+<textarea id="code" cols="120" rows="30">
+(define (factorial x)
+  (cond
+    [(= x 0)
+     1]
+    [else
+     (* x (factorial (sub1 x)))]))
+(list "This is a string"
+      'boolean
+      true
+      3.14)
+(local [(define x 42)]
+  (printf "ok~n"))
+</textarea>
+</div>
+<script type="text/javascript">
+  function addClass(element, className) {
+    if (!editor.win.hasClass(element, className)) {
+      element.className = ((element.className.split(" ")).concat([className])).join(" ");
+    }
+  }
+  function removeClass(element, className) {
+    if (editor.win.hasClass(element, className)) {
+      var classes = element.className.split(" ");
+      for (var i = classes.length - 1 ; i >= 0; i--) {
+        if (classes[i] === className) {
+            classes.splice(i, 1);
+        }
+      }
+      element.className = classes.join(" ");
+    }
+  }
+  var textarea = document.getElementById('code');
+  var editor = new CodeMirror(CodeMirror.replace(textarea), {
+    height: "350px",
+    content: textarea.value,
+    path: "../../js/",
+    parserfile: ["../contrib/scheme/js/tokenizescheme.js",
+                 "../contrib/scheme/js/parsescheme.js"],
+    stylesheet:  "css/schemecolors.css",
+    autoMatchParens: true,
+    disableSpellcheck: true,
+    lineNumbers: true,
+    markParen: function(span, good) {addClass(span, good ? "good-matching-paren" : "bad-matching-paren");},
+    unmarkParen: function(span) {removeClass(span, "good-matching-paren"); removeClass(span, "bad-matching-paren");}
+  });
+</script>
+  </body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/scheme/js/parsescheme.js ADDED Viewed

@@ -0,0 +1,428 @@
+var SchemeParser = Editor.Parser = (function() {
+    // isLparen: char -> boolean
+    var isLparen = function(ch) {
+	return ch === '(' || ch === '[' || ch === '{';
+    };
+    // isRparen: char -> boolean
+    var isRparen = function(ch) {
+	return ch === ')' || ch === ']' || ch === '}';
+    };
+    // isMatchingParens: char char -> boolean
+    var isMatchingParens = function(lparen, rparen) {
+	return ((lparen === '(' && rparen === ')') ||
+		(lparen === '[' && rparen === ']') ||
+		(lparen === '{' && rparen === '}'));
+    };
+    // Compute the indentation context enclosing the end of the token
+    // sequence tokens.
+    // The context is the token sequence of the enclosing s-expression,
+    // augmented with column information.
+    var getIndentationContext = function(tokenStack) {
+	var EMPTY_CONTEXT = [];
+	var pendingParens = [], i = 0, j, line, column, context;
+	var tokens = [];
+	// Scan for the start of the indentation context, accumulating tokens.
+	while (! isEmptyPair(tokenStack)) {
+	    i++;
+	    tokens.push(pairFirst(tokenStack));
+	    if (isLparen(pairFirst(tokenStack).type)) {
+		if (pendingParens.length === 0) {
+		    break;
+		} else {
+		    if (isMatchingParens(pairFirst(tokenStack).value,
+					 pendingParens[pendingParens.length - 1])) {
+			pendingParens.pop();
+		    } else {
+			// Error condition: we see mismatching parens,
+			// so we exit with no known indentation context.
+			return EMPTY_CONTEXT;
+		    }
+		}
+	    } else if (isRparen(pairFirst(tokenStack).type))  {
+		pendingParens.push(pairFirst(tokenStack).type);
+	    }
+	    tokenStack = pairRest(tokenStack);
+	}
+	// If we scanned backward too far, we couldn't find a context.  Just
+	// return the empty context.
+	if (isEmptyPair(tokenStack)) {
+	    return EMPTY_CONTEXT;
+	}
+	// Position tokenStack to the next token beyond.
+	tokenStack = pairRest(tokenStack);
+	// We now scan backwards to closest newline to figure out the column
+	// number:
+	while (! isEmptyPair(tokenStack)) {
+	    if(pairFirst(tokenStack).type === 'whitespace' &&
+	       pairFirst(tokenStack).value === '\n') {
+		break;
+	    }
+	    tokens.push(pairFirst(tokenStack));
+	    tokenStack = pairRest(tokenStack);
+	}
+	line = 0;
+	column = 0;
+	context = [];
+	// Start generating the context, walking forward.
+	for (j = tokens.length-1; j >= 0; j--) {
+	    if (j < i) {
+		context.push({ type: tokens[j].type,
+			       value: tokens[j].value,
+			       line: line,
+			       column: column });
+	    }
+	    if (tokens[j].type === 'whitespace' &&
+		tokens[j].value === '\n') {
+		column = 0;
+		line++;
+	    } else {
+		column += tokens[j].value.length;
+	    }
+	}
+	return context;
+    };
+    // calculateIndentationFromContext: indentation-context number -> number
+    var calculateIndentationFromContext = function(context, currentIndentation) {
+	if (context.length === 0) {
+	    return 0;
+	}
+ 	if (isBeginLikeContext(context)) {
+	    return beginLikeIndentation(context);
+ 	}
+	if (isDefineLikeContext(context)) {
+	    return defineLikeIndentation(context);
+	}
+  	if (isLambdaLikeContext(context)) {
+	    return lambdaLikeIndentation(context);
+  	}
+	return beginLikeIndentation(context, 0);
+    };
+    // findContextElement: indentation-context number -> index or -1
+    var findContextElement = function(context, index) {
+	var depth = 0;
+	for(var i = 0; i < context.length; i++) {
+	    if (context[i].type !== 'whitespace' && depth === 1) {
+		if (index === 0)
+		    return i;
+		else
+		    index--;
+	    }
+	    if (isLparen(context[i].type)) {
+		depth++;
+	    }
+	    if (isRparen(context[i].type)) {
+		depth = Math.max(depth - 1, 0);
+	    }
+	}
+	return -1;
+    };
+    // contextElement: context -> (arrayof index)
+    var contextElements = function(context) {
+	var i = 0, index, results = [];
+	while ((index = findContextElement(context, i++)) != -1) {
+	    results.push(index);
+	}
+	return results;
+    };
+    //////////////////////////////////////////////////////////////////////
+    var BEGIN_LIKE_KEYWORDS = ["case-lambda",
+			       "compound-unit",
+			       "compound-unit/sig",
+			       "cond",
+			       "delay",
+			       "inherit",
+			       "match-lambda",
+			       "match-lambda*",
+			       "override",
+			       "private",
+			       "public",
+			       "sequence",
+			       "unit"];
+    var isBeginLikeContext = function(context) {
+	var j = findContextElement(context, 0);
+	if (j === -1) { return false; }
+	return (/^begin/.test(context[j].value) ||
+		isMember(context[j].value, BEGIN_LIKE_KEYWORDS));
+    };
+    // Begin: if there's no elements within the begin context,
+    // the indentation is that of the begin keyword's column + offset.
+    // Otherwise, find the leading element on the last line.
+    // Also used for default indentation.
+    var beginLikeIndentation = function(context, offset) {
+	if (typeof(offset) === 'undefined') { offset = 1; }
+	var indices = contextElements(context), j;
+	if (indices.length === 0) {
+	    return context[0].column + 1;
+	} else if (indices.length === 1) {
+	    // if we only see the begin keyword, indentation is based
+	    // off the keyword.
+	    return context[indices[0]].column + offset;
+	} else {
+	    // Otherwise, we scan for the contextElement of the last line
+	    for (j = indices.length -1; j > 1; j--) {
+		if (context[indices[j]].line !==
+		    context[indices[j-1]].line) {
+		    return context[indices[j]].column;
+		}
+	    }
+	    return context[indices[j]].column;
+	}
+    };
+    //////////////////////////////////////////////////////////////////////
+    var DEFINE_LIKE_KEYWORDS = ["local"];
+    var isDefineLikeContext = function(context) {
+	var j = findContextElement(context, 0);
+	if (j === -1) { return false; }
+	return (/^def/.test(context[j].value) ||
+		isMember(context[j].value, DEFINE_LIKE_KEYWORDS));
+    };
+    var defineLikeIndentation = function(context) {
+	var i = findContextElement(context, 0);
+	if (i === -1) { return 0; }
+	return context[i].column +1;
+    };
+    //////////////////////////////////////////////////////////////////////
+    var LAMBDA_LIKE_KEYWORDS = ["cases",
+				"instantiate",
+				"super-instantiate",
+				"syntax/loc",
+				"quasisyntax/loc",
+				"lambda",
+				"let",
+				"let*",
+				"letrec",
+				"recur",
+				"lambda/kw",
+				"letrec-values",
+				"with-syntax",
+				"with-continuation-mark",
+				"module",
+				"match",
+				"match-let",
+				"match-let*",
+				"match-letrec",
+				"let/cc",
+				"let/ec",
+				"letcc",
+				"catch",
+				"let-syntax",
+				"letrec-syntax",
+				"fluid-let-syntax",
+				"letrec-syntaxes+values",
+				"for",
+				"for/list",
+				"for/hash",
+				"for/hasheq",
+				"for/and",
+				"for/or",
+				"for/lists",
+				"for/first",
+				"for/last",
+				"for/fold",
+				"for*",
+				"for*/list",
+				"for*/hash",
+				"for*/hasheq",
+				"for*/and",
+				"for*/or",
+				"for*/lists",
+				"for*/first",
+				"for*/last",
+				"for*/fold",
+				"kernel-syntax-case",
+				"syntax-case",
+				"syntax-case*",
+				"syntax-rules",
+				"syntax-id-rules",
+				"let-signature",
+				"fluid-let",
+				"let-struct",
+				"let-macro",
+				"let-values",
+				"let*-values",
+				"case",
+				"when",
+				"unless",
+				"let-enumerate",
+				"class",
+				"class*",
+				"class-asi",
+				"class-asi*",
+				"class*/names",
+				"class100",
+				"class100*",
+				"class100-asi",
+				"class100-asi*",
+				"class100*/names",
+				"rec",
+				"make-object",
+				"mixin",
+				"define-some",
+				"do",
+				"opt-lambda",
+				"send*",
+				"with-method",
+				"define-record",
+				"catch",
+				"shared",
+				"unit/sig",
+				"unit/lang",
+				"with-handlers",
+				"interface",
+				"parameterize",
+				"call-with-input-file",
+				"call-with-input-file*",
+				"with-input-from-file",
+				"with-input-from-port",
+				"call-with-output-file",
+				"with-output-to-file",
+				"with-output-to-port",
+				"for-all"];
+    var isLambdaLikeContext = function(context) {
+	var j = findContextElement(context, 0);
+	if (j === -1) { return false; }
+	return (isMember(context[j].value, LAMBDA_LIKE_KEYWORDS));
+    };
+    var lambdaLikeIndentation = function(context) {
+	var i = findContextElement(context, 0);
+	if (i === -1) { return 0; }
+	var j = findContextElement(context, 1);
+	if (j === -1) {
+	    return context[i].column + 4;
+	} else {
+	    return context[i].column + 1;
+	}
+    };
+    //////////////////////////////////////////////////////////////////////
+    // Helpers
+    var isMember = function(x, l) {
+	for (var i = 0; i < l.length; i++) {
+	    if (x === l[i]) { return true; }
+	}
+	return false;
+    };
+    //////////////////////////////////////////////////////////////////////
+    var pair = function(x, y) {
+	return [x,y];
+    };
+    var EMPTY_PAIR = [];
+    var pairFirst = function(p) { return p[0]; }
+    var pairRest = function(p) { return p[1]; }
+    var isEmptyPair = function(p) { return p === EMPTY_PAIR; }
+    var pairLength = function(p) {
+	var l = 0;
+	while (! isEmptyPair(p)) {
+	    p = pairRest(p);
+	}
+	return l;
+    };
+    //////////////////////////////////////////////////////////////////////
+    var indentTo = function(tokenStack) {
+	return function(tokenText, currentIndentation, direction) {
+	    // If we're in the middle of an unclosed token,
+	    // do not change indentation.
+	    if ((! isEmptyPair(tokenStack)) &&
+		(! isEmptyPair(pairRest(tokenStack))) &&
+		(pairFirst(pairRest(tokenStack)).isUnclosed)) {
+		return currentIndentation;
+	    }
+	    var indentationContext =
+		getIndentationContext(tokenStack);
+	    return calculateIndentationFromContext(indentationContext,
+						   currentIndentation);
+	};
+    };
+    var startParse = function(source) {
+	source = tokenizeScheme(source);
+	var tokenStack = EMPTY_PAIR;
+	var iter = {
+	    next: function() {
+		var tok = source.next();
+		tokenStack = pair(tok, tokenStack);
+		if (tok.type === "whitespace") {
+		    if (tok.value === "\n") {
+			tok.indentation = indentTo(tokenStack);
+		    }
+		}
+		return tok;
+	    },
+	    copy: function() {
+		var _tokenStack = tokenStack;
+		var _tokenState = source.state;
+		return function(_source) {
+		    tokenStack = _tokenStack;
+		    source = tokenizeScheme(_source, _tokenState);
+		    return iter;
+		};
+	    }
+	};
+	return iter;
+    };
+    return { make: startParse };
+})();