Initial commitHEADmane

7 files changed, 647 insertions, 0 deletions

diff --git a/node_modules/yamlparser/LICENSE b/node_modules/yamlparser/LICENSE
new file mode 100644
index 0000000..2cabafc
--- /dev/null
+++ b/node_modules/yamlparser/LICENSE
@@ -0,0 +1,21 @@
+This program is released under the MIT License as follows:
+
+Copyright (c) 2011 Diogo Costa (costa.h4evr@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
diff --git a/node_modules/yamlparser/README.markdown b/node_modules/yamlparser/README.markdown
new file mode 100644
index 0000000..25bbefe
--- /dev/null
+++ b/node_modules/yamlparser/README.markdown
@@ -0,0 +1,48 @@
+YAML Parser for Javascript
+==========================
+
+Author: Diogo Costa (<costa.h4evr@gmail.com>)
+
+Date: 8th August 2011
+
+Description
+-----------
+
+This is CommonJS port of my Javascript YAML Parser, available at:
+http://code.google.com/p/javascript-yaml-parser/
+
+The same as the original project, this project intends to implement a simple YAML 
+parser. It does not intend to implement all the aspects formalized in the YAML 
+specs, but rather to implement a robust parser in Javascript, enough to load 
+simply structured YAML files.
+
+Installation
+------------
+
+The parser is available as a NPM module, this is the recommended way of installation.
+
+Run the following command and you should be ready to go:
+
+    npm install yamlparser
+
+Documentation
+-------------
+
+ToDo
+
+Disclaimer
+----------
+
+I try to deliver high quality products, but I do not guarantee that the product
+is free from defects. My software is provided "as is", and you use the software
+at your own risk.
+
+I make no warranties as to performance, merchantability, fitness for a 
+particular purpose, or any other warranties whether expressed or implied.
+
+Under no circumstances shall I be liable for direct, indirect, special, 
+incidental, or consequential damages resulting from the use, misuse, or 
+inability to use this software, even if I have been advised of the possibility 
+of such damages.
+
+Please consult the license file for more information.
diff --git a/node_modules/yamlparser/package.json b/node_modules/yamlparser/package.json
new file mode 100644
index 0000000..abf9006
--- /dev/null
+++ b/node_modules/yamlparser/package.json
@@ -0,0 +1,11 @@
+{
+  "author": "Diogo Costa <costa.h4evr@gmail.com> (http://diogocosta.pt.tl/)",
+  "name": "yamlparser",
+  "description": "A YAML parser written in javascript. This is the port to CommonJS. Client-side script is available at http://code.google.com/p/javascript-yaml-parser/",
+  "version": "0.0.2",
+  "repository": {
+  "type": "git",
+    "url": "git://github.com/h4evr/commonjs-javascript-yaml-parser.git"
+  },
+  "main": "yamlparser"
+}
diff --git a/node_modules/yamlparser/tests/example.yml b/node_modules/yamlparser/tests/example.yml
new file mode 100644
index 0000000..8bd9375
--- /dev/null
+++ b/node_modules/yamlparser/tests/example.yml
@@ -0,0 +1,62 @@
+---
+# Hello World!
+
+chart:    
+    - {x: 1993, y: 5}
+
+    - {x: 1994, y: 5}
+
+    - {x: 1995, y: 5}
+    
+    - {x: 1996, y: 5}
+
+multi-level:
+    - array1:
+        - 1
+        - 2
+        - 3
+        - 4
+        - 5
+    - array2: { teste: ah,  bah: 123 }
+    - array3:
+      - array31:
+        - array311: [0, 1, 2, 3]
+        
+receipt:     Oz-Ware Purchase Invoice # isto é um comentário
+date:        2007-08-06
+customer:
+    given:   Dorothy
+    family:  Gale
+    pessoa:
+        married: false
+        money: .NaN
+        name: {first: "Diogo", last: "Costa"}
+        surname: Costa
+
+items:
+    - part_no:   A4786
+      descrip:   Water Bucket (Filled)
+      price:     1.47
+      quantity:  4
+
+    - part_no:   E1628
+      descrip:   High Heeled "Ruby" Slippers
+      size:       8
+      price:     100.27
+      quantity:  1
+
+bill-to:  &id001
+    street: |
+            123 Tornado Alley
+            Suite 16
+    city:   East Centerville
+    state:  KS
+
+ship-to:  *id001
+        
+specialDelivery:  >
+    Follow the Yellow Brick
+    Road to the Emerald City.
+    Pay no attention to the man 
+    behind the curtain.
+...
diff --git a/node_modules/yamlparser/tests/index.html b/node_modules/yamlparser/tests/index.html
new file mode 100644
index 0000000..450f672
--- /dev/null
+++ b/node_modules/yamlparser/tests/index.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML>
+<html lang="en-US">
+<head>
+    <meta charset="UTF-8">
+    <title>YAML Parser</title>
+    <script type="text/javascript" src="../src/yamlparser.js"></script>
+    <script type="text/javascript">
+        window.onload = function() {
+            var test1 = YAML.eval("---\n- one\n- two");
+            var test2 = YAML.eval("---\none: two");
+        
+            YAML.fromURL("example.yml", function(data) {
+                var errors = YAML.getErrors();
+                if(errors.length == 0)
+                    document.getElementById("out").innerHTML = "Done! Took " + YAML.getProcessingTime() + " miliseconds.";
+                else {
+                    document.getElementById("out").innerHTML = errors.join("<br>");
+                }
+            });
+        };
+    </script>
+</head>
+<body>
+	<pre id="out"></pre>
+</body>
+</html>
diff --git a/node_modules/yamlparser/tests/server.js b/node_modules/yamlparser/tests/server.js
new file mode 100644
index 0000000..82db54d
--- /dev/null
+++ b/node_modules/yamlparser/tests/server.js
@@ -0,0 +1,13 @@
+var http = require('http');
+var yaml = require('yamlparser');
+
+http.createServer(function(req, res) {
+	res.writeHead(200, {'Content-Type' : 'text/plain' });
+	
+	var fs = require('fs');
+	var fileContents = fs.readFileSync('example.yml', 'utf8');
+	var data = yaml.eval(fileContents);
+	res.end(JSON.stringify(data));
+}).listen(8080, "127.0.0.1");
+
+console.log('Server running at http://127.0.0.1:8080');
\ No newline at end of file
diff --git a/node_modules/yamlparser/yamlparser.js b/node_modules/yamlparser/yamlparser.js
new file mode 100644
index 0000000..dd2cf17
--- /dev/null
+++ b/node_modules/yamlparser/yamlparser.js
@@ -0,0 +1,466 @@
+/*
+YAML parser for Javascript
+Author: Diogo Costa
+
+This program is released under the MIT License as follows:
+
+Copyright (c) 2011 Diogo Costa (costa.h4evr@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+/**
+ * @name YAML
+ * @namespace
+*/
+
+var YAML = 
+(function() {
+    var errors = [],
+        reference_blocks = [],
+        processing_time = 0,
+        regex =
+        {
+            "regLevel" : new RegExp("^([\\s\\-]+)"),
+            "invalidLine" : new RegExp("^\\-\\-\\-|^\\.\\.\\.|^\\s*#.*|^\\s*$"),
+            "dashesString" : new RegExp("^\\s*\\\"([^\\\"]*)\\\"\\s*$"),
+            "quotesString" : new RegExp("^\\s*\\\'([^\\\']*)\\\'\\s*$"),
+            "float" : new RegExp("^[+-]?[0-9]+\\.[0-9]+(e[+-]?[0-9]+(\\.[0-9]+)?)?$"),
+            "integer" : new RegExp("^[+-]?[0-9]+$"),
+            "array" : new RegExp("\\[\\s*(.*)\\s*\\]"),
+            "map" : new RegExp("\\{\\s*(.*)\\s*\\}"),
+            "key_value" : new RegExp("([a-z0-9_-][ a-z0-9_-]*):( .+)", "i"),
+            "single_key_value" : new RegExp("^([a-z0-9_-][ a-z0-9_-]*):( .+?)$", "i"),
+            "key" : new RegExp("([a-z0-9_-][ a-z0-9_-]*):( .+)?", "i"),
+            "item" : new RegExp("^-\\s+"),
+            "trim" : new RegExp("^\\s+|\\s+$"),
+            "comment" : new RegExp("([^\\\'\\\"#]+([\\\'\\\"][^\\\'\\\"]*[\\\'\\\"])*)*(#.*)?")
+        };
+ 
+     /**
+      * @class A block of lines of a given level.
+      * @param {int} lvl The block's level.
+      * @private
+      */
+    function Block(lvl) {
+        return {
+            /* The block's parent */
+            parent: null,
+            /* Number of children */
+            length: 0,
+            /* Block's level */
+            level: lvl,
+            /* Lines of code to process */
+            lines: [],
+            /* Blocks with greater level */
+            children : [],
+            /* Add a block to the children collection */
+            addChild : function(obj) {
+                this.children.push(obj);
+                obj.parent = this;
+                ++this.length;
+            }
+        };
+    }
+
+    function parser(str) {
+        var regLevel = regex["regLevel"];
+        var invalidLine = regex["invalidLine"];
+        var lines = str.split("\n");
+        var m;
+        var level = 0, curLevel = 0;
+        
+        var blocks = [];
+        
+        var result = new Block(-1);
+        var currentBlock = new Block(0);
+        result.addChild(currentBlock);
+        var levels = [];
+        var line = "";
+        
+        blocks.push(currentBlock);
+        levels.push(level);
+        
+        for(var i = 0, len = lines.length; i < len; ++i) {
+            line = lines[i];
+            
+            if(line.match(invalidLine)) {
+                continue;
+            }
+        
+            if(m = regLevel.exec(line)) {
+                level = m[1].length;
+            } else
+                level = 0;
+            
+            if(level > curLevel) {
+                var oldBlock = currentBlock;
+                currentBlock = new Block(level);
+                oldBlock.addChild(currentBlock);
+                blocks.push(currentBlock);
+                levels.push(level);
+            } else if(level < curLevel) {                
+                var added = false;
+
+                var k = levels.length - 1;
+                for(; k >= 0; --k) {
+                    if(levels[k] == level) {
+                        currentBlock = new Block(level);
+                        blocks.push(currentBlock);
+                        levels.push(level);
+                        if(blocks[k].parent!= null)
+                            blocks[k].parent.addChild(currentBlock);
+                        added = true;
+                        break;
+                    }
+                }
+                
+                if(!added) {
+                    errors.push("Error: Invalid indentation at line " + i + ": " + line);
+                    return;
+                }
+            }
+            
+            currentBlock.lines.push(line.replace(regex["trim"], ""));
+            curLevel = level;
+        }
+        
+        return result;
+    }
+    
+    function processValue(val) {
+        val = val.replace(regex["trim"], "");
+        var m = null;
+
+        if(val == 'true') {
+            return true;
+        } else if(val == 'false') {
+            return false;
+        } else if(val == '.NaN') {
+            return Number.NaN;
+        } else if(val == 'null') {
+            return null;
+        } else if(val == '.inf') {
+            return Number.POSITIVE_INFINITY;
+        } else if(val == '-.inf') {
+            return Number.NEGATIVE_INFINITY;
+        } else if(m = val.match(regex["dashesString"])) {
+            return m[1];
+        } else if(m = val.match(regex["quotesString"])) {
+            return m[1];
+        } else if(m = val.match(regex["float"])) {
+            return parseFloat(m[0]);
+        } else if(m = val.match(regex["integer"])) {
+            return parseInt(m[0]);
+        } else if( !isNaN(m = Date.parse(val))) {
+            return new Date(m);
+        } else if(m = val.match(regex["single_key_value"])) {
+            var res = {};
+            res[m[1]] = processValue(m[2]);
+            return res;
+        } else if(m = val.match(regex["array"])){
+            var count = 0, c = ' ';
+            var res = [];
+            var content = "";
+            var str = false;
+            for(var j = 0, lenJ = m[1].length; j < lenJ; ++j) {
+                c = m[1][j];
+                if(c == '\'' || c == '"') {
+                    if(str === false) {
+                        str = c;
+                        content += c;
+                        continue;
+                    } else if((c == '\'' && str == '\'') || (c == '"' && str == '"')) {
+                        str = false;
+                        content += c;
+                        continue;
+                    }
+                } else if(str === false && (c == '[' || c == '{')) {
+                    ++count;
+                } else if(str === false && (c == ']' || c == '}')) {
+                    --count;
+                } else if(str === false && count == 0 && c == ',') {
+                    res.push(processValue(content));
+                    content = "";
+                    continue;
+                }
+                
+                content += c;
+            }
+            
+            if(content.length > 0)
+                res.push(processValue(content));
+            return res;
+        } else if(m = val.match(regex["map"])){
+            var count = 0, c = ' ';
+            var res = [];
+            var content = "";
+            var str = false;
+            for(var j = 0, lenJ = m[1].length; j < lenJ; ++j) {
+                c = m[1][j];
+                if(c == '\'' || c == '"') {
+                    if(str === false) {
+                        str = c;
+                        content += c;
+                        continue;
+                    } else if((c == '\'' && str == '\'') || (c == '"' && str == '"')) {
+                        str = false;
+                        content += c;
+                        continue;
+                    }
+                } else if(str === false && (c == '[' || c == '{')) {
+                    ++count;
+                } else if(str === false && (c == ']' || c == '}')) {
+                    --count;
+                } else if(str === false && count == 0 && c == ',') {
+                    res.push(content);
+                    content = "";
+                    continue;
+                }
+                
+                content += c;
+            }
+            
+            if(content.length > 0)
+                res.push(content);
+                
+            var newRes = {};
+            for(var j = 0, lenJ = res.length; j < lenJ; ++j) {
+                if(m = res[j].match(regex["key_value"])) {
+                    newRes[m[1]] = processValue(m[2]);
+                }
+            }
+            
+            return newRes;
+        } else 
+            return val;
+    }
+    
+    function processFoldedBlock(block) {
+        var lines = block.lines;
+        var children = block.children;
+        var str = lines.join(" ");
+        var chunks = [str];
+        for(var i = 0, len = children.length; i < len; ++i) {
+            chunks.push(processFoldedBlock(children[i]));
+        }
+        return chunks.join("\n");
+    }
+    
+    function processLiteralBlock(block) {
+        var lines = block.lines;
+        var children = block.children;
+        var str = lines.join("\n");
+        for(var i = 0, len = children.length; i < len; ++i) {
+            str += processLiteralBlock(children[i]);
+        }
+        return str;
+    }
+    
+    function processBlock(blocks) {
+        var m = null;
+        var res = {};
+        var lines = null;
+        var children = null;
+        var currentObj = null;
+        
+        var level = -1;
+        
+        var processedBlocks = [];
+        
+        var isMap = true;
+        
+        for(var j = 0, lenJ = blocks.length; j < lenJ; ++j) {
+            
+            if(level != -1 && level != blocks[j].level)
+                continue;
+        
+            processedBlocks.push(j);
+        
+            level = blocks[j].level;
+            lines = blocks[j].lines;
+            children = blocks[j].children;
+            currentObj = null;
+        
+            for(var i = 0, len = lines.length; i < len; ++i) {
+                var line = lines[i];
+
+                if(m = line.match(regex["key"])) {
+                    var key = m[1];
+                    
+                    if(key[0] == '-') {
+                        key = key.replace(regex["item"], "");
+                        if (isMap) { 
+                            isMap = false;
+                            if (typeof(res.length) === "undefined") {
+                                res = [];
+                            } 
+                        }
+                        if(currentObj != null) res.push(currentObj);
+                        currentObj = {};
+                        isMap = true;
+                    }
+                    
+                    if(typeof m[2] != "undefined") {
+                        var value = m[2].replace(regex["trim"], "");
+                        if(value[0] == '&') {
+                            var nb = processBlock(children);
+                            if(currentObj != null) currentObj[key] = nb;
+                            else res[key] = nb;
+                            reference_blocks[value.substr(1)] = nb;
+                        } else if(value[0] == '|') {
+                            if(currentObj != null) currentObj[key] = processLiteralBlock(children.shift());
+                            else res[key] = processLiteralBlock(children.shift());
+                        } else if(value[0] == '*') {
+                            var v = value.substr(1);
+                            var no = {};
+                            
+                            if(typeof reference_blocks[v] == "undefined") {
+                                errors.push("Reference '" + v + "' not found!");
+                            } else {
+                                for(var k in reference_blocks[v]) {
+                                    no[k] = reference_blocks[v][k];
+                                }
+                                
+                                if(currentObj != null) currentObj[key] = no;
+                                else res[key] = no;
+                            }
+                        } else if(value[0] == '>') {
+                            if(currentObj != null) currentObj[key] = processFoldedBlock(children.shift());
+                            else res[key] = processFoldedBlock(children.shift());
+                        } else {
+                            if(currentObj != null) currentObj[key] = processValue(value);
+                            else res[key] = processValue(value);
+                        }
+                    } else {
+                        if(currentObj != null) currentObj[key] = processBlock(children);
+                        else res[key] = processBlock(children);                        
+                    }
+                } else if(line.match(/^-\s*$/)) {
+                    if (isMap) { 
+                        isMap = false;
+                        if (typeof(res.length) === "undefined") {
+                            res = [];
+                        } 
+                    }
+                    if(currentObj != null) res.push(currentObj);
+                    currentObj = {};
+                    isMap = true;
+                    continue;
+                } else if(m = line.match(/^-\s*(.*)/)) {
+                    if(currentObj != null) 
+                        currentObj.push(processValue(m[1]));
+                    else {
+                        if (isMap) { 
+                            isMap = false;
+                            if (typeof(res.length) === "undefined") {
+                                res = [];
+                            } 
+                        }
+                        res.push(processValue(m[1]));
+                    }
+                    continue;
+                }
+            }
+            
+            if(currentObj != null) {
+                if (isMap) { 
+                    isMap = false;
+                    if (typeof(res.length) === "undefined") {
+                        res = [];
+                    } 
+                }
+                res.push(currentObj);
+            }
+        }
+        
+        for(var j = processedBlocks.length - 1; j >= 0; --j) {
+            blocks.splice.call(blocks, processedBlocks[j], 1);
+        }
+
+        return res;
+    }
+        
+    function semanticAnalysis(blocks) {
+        var res = processBlock(blocks.children);
+        return res;
+    }
+    
+    function preProcess(src) {
+        var m;
+        var lines = src.split("\n");
+        
+        var r = regex["comment"];
+        
+        for(var i in lines) {
+            if(m = (typeof lines[i] === 'string' && lines[i].match(r))) {
+/*                var cmt = "";
+                if(typeof m[3] != "undefined")
+                    lines[i] = m[1];
+                else if(typeof m[3] != "undefined")
+                    lines[i] = m[3]; 
+                else
+                    lines[i] = "";
+                    */
+                if(typeof m[3] !== "undefined") {
+                    lines[i] = m[0].substr(0, m[0].length - m[3].length);
+                }
+            }
+        }
+        
+        return lines.join("\n");
+    }
+    
+    function eval(str) {
+        errors = [];
+        reference_blocks = [];
+        processing_time = (new Date()).getTime();
+        var pre = preProcess(str)
+        var doc = parser(pre);
+        var res = semanticAnalysis(doc);
+        processing_time = (new Date()).getTime() - processing_time;
+        
+        return res;
+    }
+        
+    return {        
+        /**
+         * Parse a YAML file from a string.
+         * @param {String} str String with the YAML file contents.
+         * @function
+         */
+        eval : eval,
+        
+        /**
+         * Get errors found when parsing the last file.
+         * @function
+         * @returns Errors found when parsing the last file.
+         */
+        getErrors : function() { return errors; },
+        
+        /**
+         * Get the time it took to parse the last file.
+         * @function
+         * @returns Time in milliseconds.
+         */
+        getProcessingTime : function() { return processing_time; }
+    }
+})();
+
+module.exports = YAML;
\ No newline at end of file