erp_app 3.0.0 → 3.0.1

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/scheme/js/tokenizescheme.js

@@ -0,0 +1,241 @@
+/* Tokenizer for Scheme code */
+
+
+
+
+/**
+  TODO: follow the definitions in:
+
+      http://docs.racket-lang.org/reference/reader.html
+
+  to the letter; at the moment, we've just done something quick-and-dirty.
+
+*/
+
+
+var tokenizeScheme = (function() {
+    var isWhiteSpace = function(ch) {
+	// The messy regexp is because IE's regexp matcher is of the
+	// opinion that non-breaking spaces are no whitespace.
+	return ch != "\n" && /^[\s\u00a0]*$/.test(ch);
+    };
+
+
+    // scanUntilUnescaped: string-stream char -> boolean
+    // Advances the stream until the given character (not preceded by a
+    // backslash) is encountered.
+    // Returns true if we hit end of line without closing.
+    // Returns false otherwise.
+    var scanUntilUnescaped = function(source, end) {
+	var escaped = false;
+	while (true) {
+	    if (source.endOfLine()) {
+		return true;
+	    }
+	    var next = source.next();
+	    if (next == end && !escaped)
+		return false;
+	    escaped = !escaped && next == "\\";
+	}
+	return false;
+    }
+    
+
+    // Advance the stream until endline.
+    var scanUntilEndline = function(source, end) {
+	while (!source.endOfLine()) {
+	    source.next();
+	}
+    }
+
+    
+    // Some helper regexps
+    var isHexDigit = /[0-9A-Fa-f]/;
+    
+
+    var whitespaceChar = new RegExp("[\\s\\u00a0]");
+    
+    var isDelimiterChar = 
+	new RegExp("[\\s\\\(\\\)\\\[\\\]\\\{\\\}\\\"\\\,\\\'\\\`\\\;]");
+
+    var isNotDelimiterChar = 
+	new RegExp("[^\\s\\\(\\\)\\\[\\\]\\\{\\\}\\\"\\\,\\\'\\\`\\\;]");
+
+
+    var numberHeader = ("(?:(?:\\d+\\/\\d+)|"+
+			(  "(?:(?:\\d+\\.\\d+|\\d+\\.|\\.\\d+)(?:[eE][+\\-]?\\d+)?)|")+
+			(  "(?:\\d+(?:[eE][+\\-]?\\d+)?))"));
+    var numberPatterns = [
+	// complex numbers
+	new RegExp("^((?:(?:\\#[ei])?[+\\-]?" + numberHeader +")?"
+		   + "(?:[+\\-]" + numberHeader + ")i$)"),
+	    /^((?:\#[ei])?[+-]inf.0)$/,
+	    /^((?:\#[ei])?[+-]nan.0)$/,
+	new RegExp("^((?:\\#[ei])?[+\\-]?" + numberHeader + "$)"),
+	new RegExp("^0[xX][0-9A-Fa-f]+$")];
+   
+
+    // looksLikeNumber: string -> boolean
+    // Returns true if string s looks like a number.
+    var looksLikeNumber = function(s) {
+	for (var i = 0; i < numberPatterns.length; i++) {
+	    if (numberPatterns[i].test(s)) {
+		return true;
+	    }
+	}
+	return false;
+    };
+
+
+
+    var UNCLOSED_STRING = function(source, setState) {
+	var readNewline = function() {
+	    var content = source.get();
+	    return { type:'whitespace', style:'whitespace', content: content };
+	};
+
+	var ch = source.peek();
+	if (ch === '\n') {
+	    source.next();
+	    return readNewline();
+	} else {
+	    var isUnclosedString = scanUntilUnescaped(source, '"');
+	    if (isUnclosedString) {
+		setState(UNCLOSED_STRING);
+	    } else {
+		setState(START);
+	    }
+	    var content = source.get();
+	    return {type: "string", style: "scheme-string", content: content,
+		    isUnclosed: isUnclosedString};
+	}
+    };
+
+
+
+    var START = function(source, setState) {
+	// Read a word, look it up in keywords. If not found, it is a
+	// variable, otherwise it is a keyword of the type found.
+	var readWordOrNumber = function() {
+	    source.nextWhileMatches(isNotDelimiterChar);
+	    var word = source.get();
+	    if (looksLikeNumber(word)) {
+		return {type: "number", style: "scheme-number", content: word};
+	    } else {
+		return {type: "variable", style: "scheme-symbol", content: word};
+	    }
+	};
+
+
+	var readString = function(quote) {
+	    var isUnclosedString = scanUntilUnescaped(source, quote);
+	    if (isUnclosedString) {
+		setState(UNCLOSED_STRING);
+	    }
+	    var word = source.get();
+	    return {type: "string", style: "scheme-string", content: word,
+		    isUnclosed: isUnclosedString};
+	};
+
+
+	var readPound = function() {
+	    var text;
+	    // FIXME: handle special things here
+	    if (source.equals(";")) {
+		source.next();
+		text = source.get();
+		return {type: text, 
+			style:"scheme-symbol",
+			content: text};
+	    } else {
+		text = source.get();
+
+		return {type : "symbol",
+			style: "scheme-symbol",
+			content: text};
+	    }
+
+	};
+	
+	var readLineComment = function() {
+	    scanUntilEndline(source);
+	    var text = source.get();
+	    return { type: "comment", style: "scheme-comment", content: text};	
+	};
+
+
+	var readWhitespace = function() {
+	    source.nextWhile(isWhiteSpace);
+	    var content = source.get();
+	    return { type: 'whitespace', style:'whitespace', content: content };
+	};
+
+	var readNewline = function() {
+	    var content = source.get();
+	    return { type:'whitespace', style:'whitespace', content: content };
+	};
+
+
+	// Fetch the next token. Dispatches on first character in the
+	// stream, or first two characters when the first is a slash.
+	var ch = source.next();
+	if (ch === '\n') {
+	    return readNewline();
+	} else if (whitespaceChar.test(ch)) {
+	    return readWhitespace();
+	} else if (ch === "#") {
+	    return readPound();
+	} else if (ch ===';') {
+	    return readLineComment();
+	} else if (ch === "\"") {
+	    return readString(ch);
+	} else if (isDelimiterChar.test(ch)) {
+	    return {type: ch, style: "scheme-punctuation"};
+	} else {
+	    return readWordOrNumber();
+	}
+    }
+
+
+
+
+
+
+
+    var makeTokenizer = function(source, state) {
+	// Newlines are always a separate token.
+
+	var tokenizer = {
+	    state: state,
+
+	    take: function(type) {
+ 		if (typeof(type) == "string")
+ 		    type = {style: type, type: type};
+
+ 		type.content = (type.content || "") + source.get();
+		type.value = type.content;
+		return type;
+	    },
+
+	    next: function () {
+		if (!source.more()) throw StopIteration;
+
+		var type;
+		while (!type) {
+		    type = tokenizer.state(source, function(s) {
+			tokenizer.state = s;
+		    });
+		}
+		var result = this.take(type);
+		return result;		    
+	    }
+	};
+	return tokenizer;
+    };
+
+
+    // The external interface to the tokenizer.
+    return function(source, startState) {
+	return makeTokenizer(source, startState || START);
+    };
+})();

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/sql/LICENSE

@@ -0,0 +1,22 @@
+ Copyright (c) 2009 John Benediktsson
+
+ 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.
+
+ John Benediktsson

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/sql/css/sqlcolors.css

@@ -0,0 +1,59 @@
+html {
+  cursor: text;
+}
+
+.editbox {
+  margin: .4em;
+  padding: 0;
+  font-family: monospace;
+  font-size: 10pt;
+  color: black;
+}
+
+.editbox p {
+  margin: 0;
+}
+
+span.sql-keyword {
+  color: blue;
+}
+
+span.sql-var {
+  color: red;
+}
+
+span.sql-comment {
+  color: #AA7700;
+}
+
+span.sql-literal {
+  color: green;
+}
+
+span.sql-operator {
+  color: blue;
+}
+
+span.sql-word {
+  color: black;
+}
+
+span.sql-quoted-word {
+  color: #680;
+}
+
+span.sql-function {
+  color: darkorange;
+}
+
+span.sql-type {
+  color: purple;
+}
+
+span.sql-separator {
+  color: #666666;
+}
+
+span.sql-number {
+  color: darkcyan;
+}

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/sql/index.html

@@ -0,0 +1,56 @@
+<html xmlns="http://www.w3.org/1999/xhtml">
+  <head>
+    <script src="../../js/codemirror.js" type="text/javascript"></script>
+    <title>CodeMirror: SQL demonstration</title>
+    <link rel="stylesheet" type="text/css" href="../../css/docs.css"/>
+  </head>
+  <body style="padding: 20px;">
+
+<p>Demonstration of <a href="../../index.html">CodeMirror</a>'s SQL
+highlighter.</p>
+
+<p>Written by John Benediktsson (<a href="LICENSE">license</a>).</p>
+
+<div style="border-top: 1px solid black; border-bottom: 1px solid black;">
+<textarea id="code" cols="120" rows="50">
+create table if not exists table1(
+  a  bigint(13) not null primary key,
+  b  char(4)    not null,
+  c  char(50)   not null,
+  d  int(9)     not null,
+);
+
+insert into table1 values (1234567890123, "b", "c", 0);
+
+select from_unixtime(a/1000), b, c, min(d) as `using`
+  from table1 t1
+  left join table2 t2 using (a)
+  -- inner join table3 t3 on t3._a = t1.a
+  join (
+    select a, b, c
+    from data
+  ) as foo on foo.a = t1.a
+
+  where a &gt; 10
+  and b like '%foo'
+  or c = 3.14159
+  and d &lt; -15.7
+  order by 1 desc
+;
+
+select @total := sum(d) from data;
+</textarea>
+</div>
+
+<script type="text/javascript">
+  var editor = CodeMirror.fromTextArea('code', {
+    height: "450px",
+    parserfile: "../contrib/sql/js/parsesql.js",
+    stylesheet: "css/sqlcolors.css",
+    path: "../../js/",
+    textWrapping: false
+  });
+</script>
+
+  </body>
+</html>

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/sql/js/parsesql.js

@@ -0,0 +1,267 @@
+var SqlParser = Editor.Parser = (function() {
+
+  function wordRegexp(words) {
+    return new RegExp("^(?:" + words.join("|") + ")$", "i");
+  }
+
+  var functions = wordRegexp([
+    "abs", "acos", "adddate", "aes_encrypt", "aes_decrypt", "ascii",
+    "asin", "atan", "atan2", "avg", "benchmark", "bin", "bit_and",
+    "bit_count", "bit_length", "bit_or", "cast", "ceil", "ceiling",
+    "char_length", "character_length", "coalesce", "concat", "concat_ws",
+    "connection_id", "conv", "convert", "cos", "cot", "count", "curdate",
+    "current_date", "current_time", "current_timestamp", "current_user",
+    "curtime", "database", "date_add", "date_format", "date_sub",
+    "dayname", "dayofmonth", "dayofweek", "dayofyear", "decode", "degrees",
+    "des_encrypt", "des_decrypt", "elt", "encode", "encrypt", "exp",
+    "export_set", "extract", "field", "find_in_set", "floor", "format",
+    "found_rows", "from_days", "from_unixtime", "get_lock", "greatest",
+    "group_unique_users", "hex", "ifnull", "inet_aton", "inet_ntoa", "instr",
+    "interval", "is_free_lock", "isnull", "last_insert_id", "lcase", "least",
+    "left", "length", "ln", "load_file", "locate", "log", "log2", "log10",
+    "lower", "lpad", "ltrim", "make_set", "master_pos_wait", "max", "md5",
+    "mid", "min", "mod", "monthname", "now", "nullif", "oct", "octet_length",
+    "ord", "password", "period_add", "period_diff", "pi", "position",
+    "pow", "power", "quarter", "quote", "radians", "rand", "release_lock",
+    "repeat", "reverse", "right", "round", "rpad", "rtrim", "sec_to_time",
+    "session_user", "sha", "sha1", "sign", "sin", "soundex", "space", "sqrt",
+    "std", "stddev", "strcmp", "subdate", "substring", "substring_index",
+    "sum", "sysdate", "system_user", "tan", "time_format", "time_to_sec",
+    "to_days", "trim", "ucase", "unique_users", "unix_timestamp", "upper",
+    "user", "version", "week", "weekday", "yearweek"
+  ]);
+
+  var keywords = wordRegexp([
+    "alter", "grant", "revoke", "primary", "key", "table", "start", "top",
+    "transaction", "select", "update", "insert", "delete", "create", "describe",
+    "from", "into", "values", "where", "join", "inner", "left", "natural", "and",
+    "or", "in", "not", "xor", "like", "using", "on", "order", "group", "by",
+    "asc", "desc", "limit", "offset", "union", "all", "as", "distinct", "set",
+    "commit", "rollback", "replace", "view", "database", "separator", "if",
+    "exists", "null", "truncate", "status", "show", "lock", "unique", "having",
+    "drop", "procedure", "begin", "end", "delimiter", "call", "else", "leave", 
+    "declare", "temporary", "then"
+  ]);
+
+  var types = wordRegexp([
+    "bigint", "binary", "bit", "blob", "bool", "char", "character", "date",
+    "datetime", "dec", "decimal", "double", "enum", "float", "float4", "float8",
+    "int", "int1", "int2", "int3", "int4", "int8", "integer", "long", "longblob",
+    "longtext", "mediumblob", "mediumint", "mediumtext", "middleint", "nchar",
+    "numeric", "real", "set", "smallint", "text", "time", "timestamp", "tinyblob",
+    "tinyint", "tinytext", "varbinary", "varchar", "year"
+  ]);
+
+  var operators = wordRegexp([
+    ":=", "<", "<=", "==", "<>", ">", ">=", "like", "rlike", "in", "xor", "between"
+  ]);
+
+  var operatorChars = /[*+\-<>=&|:\/]/;
+
+  var CFG = {};
+
+  var tokenizeSql = (function() {
+    function normal(source, setState) {
+      var ch = source.next();
+      if (ch == "@" || ch == "$") {
+        source.nextWhileMatches(/[\w\d]/);
+        return "sql-var";
+      }
+      else if (ch == "["){
+	    setState(inAlias(ch))
+	  	return null;
+      }
+      else if (ch == "\"" || ch == "'" || ch == "`") {
+        setState(inLiteral(ch));
+        return null;
+      }
+      else if (ch == "," || ch == ";") {
+        return "sql-separator"
+      }
+      else if (ch == '#') {
+        while (!source.endOfLine()) source.next();
+        return "sql-comment";
+      }
+      else if (ch == '-') {
+        if (source.peek() == "-") {
+          while (!source.endOfLine()) source.next();
+          return "sql-comment";
+        }
+        else if (/\d/.test(source.peek())) {
+          source.nextWhileMatches(/\d/);
+          if (source.peek() == '.') {
+            source.next();
+            source.nextWhileMatches(/\d/);
+          }
+          return "sql-number";
+        }
+        else
+          return "sql-operator";
+      }
+      else if (operatorChars.test(ch)) {
+
+        if(ch == "/" && source.peek() == "*"){
+          setState(inBlock("sql-comment", "*/"));
+          return null;
+        }
+        else{
+          source.nextWhileMatches(operatorChars);
+          return "sql-operator";
+        }
+        
+      }
+      else if (/\d/.test(ch)) {
+        source.nextWhileMatches(/\d/);
+        if (source.peek() == '.') {
+          source.next();
+          source.nextWhileMatches(/\d/);
+        }
+        return "sql-number";
+      }
+      else if (/[()]/.test(ch)) {
+        return "sql-punctuation";
+      }
+      else {
+        source.nextWhileMatches(/[_\w\d]/);
+        var word = source.get(), type;
+        if (operators.test(word))
+          type = "sql-operator";
+        else if (keywords.test(word))
+          type = "sql-keyword";
+        else if (functions.test(word))
+          type = "sql-function";
+        else if (types.test(word))
+          type = "sql-type";
+        else
+          type = "sql-word";
+        return {style: type, content: word};
+      }
+    }
+
+    function inAlias(quote) {
+	  return function(source, setState) {
+	    while (!source.endOfLine()) {
+		  var ch = source.next();
+		  if (ch == ']') {
+		    setState(normal);
+		    break;
+		  }
+	    }
+	    return "sql-word";
+	  }
+    }
+
+    function inLiteral(quote) {
+      return function(source, setState) {
+        var escaped = false;
+        while (!source.endOfLine()) {
+          var ch = source.next();
+          if (ch == quote && !escaped) {
+            setState(normal);
+            break;
+          }
+          escaped = CFG.extension == 'T-SQL' ?
+                                  !escaped && quote == ch && source.equals(quote) :
+                                  !escaped && ch == "\\";
+        }        
+        return quote == "`" ? "sql-quoted-word" : "sql-literal";
+      };
+    }
+
+    function inBlock(style, terminator) {
+      return function(source, setState) {
+        while (!source.endOfLine()) {
+          if (source.lookAhead(terminator, true)) {
+            setState(normal);
+            break;
+          }
+          source.next();
+        }
+        return style;
+      };
+    }
+
+    return function(source, startState) {
+      return tokenizer(source, startState || normal);
+    };
+  })();
+
+  function indentSql(context) {
+    return function(nextChars) {
+      var firstChar = nextChars && nextChars.charAt(0);
+      var closing = context && firstChar == context.type;
+      if (!context)
+        return 0;
+      else if (context.align)
+        return context.col - (closing ? context.width : 0);
+      else
+        return context.indent + (closing ? 0 : indentUnit);
+    }
+  }
+
+  function parseSql(source) {
+    var tokens = tokenizeSql(source);
+    var context = null, indent = 0, col = 0;
+    function pushContext(type, width, align) {
+      context = {prev: context, indent: indent, col: col, type: type, width: width, align: align};
+    }
+    function popContext() {
+      context = context.prev;
+    }
+
+    var iter = {
+      next: function() {
+        var token = tokens.next();
+        var type = token.style, content = token.content, width = token.value.length;
+
+        if (content == "\n") {
+          token.indentation = indentSql(context);
+          indent = col = 0;
+          if (context && context.align == null) context.align = false;
+        }
+        else if (type == "whitespace" && col == 0) {
+          indent = width;
+        }
+        else if (!context && type != "sql-comment") {
+          pushContext(";", 0, false);
+        }
+
+        if (content != "\n") col += width;
+
+        if (type == "sql-punctuation") {
+          if (content == "(")
+            pushContext(")", width);
+          else if (content == ")")
+            popContext();
+        }
+        else if (type == "sql-separator" && content == ";" && context && !context.prev) {
+          popContext();
+        }
+
+        return token;
+      },
+
+      copy: function() {
+        var _context = context, _indent = indent, _col = col, _tokenState = tokens.state;
+        return function(source) {
+          tokens = tokenizeSql(source, _tokenState);
+          context = _context;
+          indent = _indent;
+          col = _col;
+          return iter;
+        };
+      }
+    };
+    return iter;
+  }
+
+  function configure (parserConfig) {
+    for (var p in parserConfig) {
+      if (parserConfig.hasOwnProperty(p)) {
+        CFG[p] = parserConfig[p];
+      }
+    }
+  }
+
+  return {make: parseSql, electricChars: ")", configure: configure};
+})();

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/xquery/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010 Mike Brevoort
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.