| /bower_components/yaml_2/Readme.md |
|---|
| @@ -0,0 +1,75 @@ |
|---|
| |
| # YAML2 |
| <a href='https://travis-ci.org/apigee/yaml2'><img src='https://travis-ci.org/apigee/yaml2.svg'/></a> |
| |
| YAML2 is a fork of [JS-YAML](https://github.com/visionmedia/js-yaml) which adds functionality to get an abstract syntax tree out of a YAML string. |
| |
| CommonJS JavaScript YAML parser, fast and tiny. Although this implementation |
| does not currently support the entire YAML specification, feel free to |
| fork the project and submit a patch :) |
| |
| # Usage |
| |
| |
| #### Get JavaScript object out of a YAML string |
| require('yaml2').eval(string_of_yaml) |
| #### Get Abstract Syntax Tree(AST) out of a YAML string |
| require('yaml2').ast(string_of_yaml) |
| |
| # Currently Supports |
| |
| * Comments |
| * Sequences (arrays) |
| * Maps (hashes) |
| * Inline sequences |
| * Inline maps |
| * Nesting |
| * Primitive scalars (integers, floats, booleans, etc) |
| * Extended bools (enabled, disabled, yes, no, on, off, true, false) |
| |
| ## Installation |
| |
| |
| ### Via NPM |
| $ npm install yaml2 |
| |
| ### Via Bower |
| $ bower install yaml_2 |
| |
| # Testing |
| |
| Run: |
| |
| $ npm test |
| |
| ### Known bugs and missing features |
| |
| * Inline commnets: `key: value # this is value` |
| * Inline hash with key quoted: `hash: {"me": 1}` |
| |
| # License |
| |
| (The MIT License) |
| |
| Copyright (c) 2009 TJ Holowaychuk <tj@vision-media.ca> |
| |
| Copyright (c) 2014 Mohsen Azimi(Apigee) <mazimi@apigee.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. |
| /bower_components/yaml_2/lib/browser.js |
|---|
| @@ -0,0 +1,602 @@ |
|---|
| (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
| function assemble(ast) { |
| var result; |
| |
| if (!ast) { |
| return ast; |
| } |
| |
| if (!ast.constructor || !ast.constructor.name) { |
| return ast.value; |
| } |
| |
| switch (ast.constructor.name){ |
| case 'String': |
| result = ast; |
| break; |
| case 'YAMLDoc': |
| result = assemble(ast.value); |
| break; |
| case 'YAMLHash': |
| result = {}; |
| ast.keys.forEach(function (key){ |
| result[key.keyName] = assemble(key.value); |
| }); |
| break; |
| case 'YAMLList': |
| result = []; |
| ast.items.forEach(function (item){ |
| result.push(assemble(item)); |
| }); |
| break; |
| default: |
| result = ast.value; |
| |
| } |
| |
| return result; |
| } |
| |
| |
| module.exports = assemble; |
| },{}],2:[function(require,module,exports){ |
| var helpers = require('./helpers'); |
| |
| // --- AST |
| |
| /** |
| * Initialize with _tokens_. |
| */ |
| |
| function AST(tokens, str) { |
| this.tokens = tokens; |
| |
| // Windows new line support (CR+LF, \r\n) |
| str = str.replace(/\r\n/g, '\n'); |
| |
| // Use a regex to do this magic |
| this.lines = str.split(/\n/g).map(function(i){ return i + '\n'}); |
| this.strLength = str.length; |
| } |
| |
| /** |
| * Look-ahead a single token. |
| * |
| * @return {array} |
| * @api public |
| */ |
| |
| AST.prototype.peek = function() { |
| return this.tokens[0] |
| } |
| |
| /** |
| * Advance by a single token. |
| * |
| * @return {array} |
| * @api public |
| */ |
| |
| AST.prototype.advance = function() { |
| return this.tokens.shift() |
| } |
| |
| /** |
| * Advance and return the token's value. |
| * |
| * @return {mixed} |
| * @api private |
| */ |
| |
| AST.prototype.advanceValue = function() { |
| return this.advance()[1][1] |
| } |
| |
| /** |
| * Accept _type_ and advance or do nothing. |
| * |
| * @param {string} type |
| * @return {bool} |
| * @api private |
| */ |
| |
| AST.prototype.accept = function(type) { |
| if (this.peekType(type)) |
| return this.advance() |
| } |
| |
| /** |
| * Expect _type_ or throw an error _msg_. |
| * |
| * @param {string} type |
| * @param {string} msg |
| * @api private |
| */ |
| |
| AST.prototype.expect = function(type, msg) { |
| if (this.accept(type)) return |
| throw new Error(msg + ', ' + helpers.context(this.peek()[1].input)) |
| } |
| |
| /** |
| * Return the next token type. |
| * |
| * @return {string} |
| * @api private |
| */ |
| |
| AST.prototype.peekType = function(val) { |
| return this.tokens[0] && |
| this.tokens[0][0] === val |
| } |
| |
| /** |
| * space* |
| */ |
| |
| AST.prototype.ignoreSpace = function() { |
| while (this.peekType('space')) |
| this.advance() |
| } |
| |
| /** |
| * (space | indent | dedent)* |
| */ |
| |
| AST.prototype.ignoreWhitespace = function() { |
| while (this.peekType('space') || |
| this.peekType('indent') || |
| this.peekType('dedent')) |
| this.advance() |
| } |
| |
| // constructor functions |
| function YAMLDoc() { |
| this.node = 'YAMLDoc'; |
| } |
| function YAMLHash() { |
| this.node = 'YAMLHash'; |
| this.keys = []; |
| } |
| function YAMLHashKey(id) { |
| this.node = 'YAMLHashKey'; |
| this.keyName = id[1][0] |
| } |
| function YAMLList() { |
| this.node = 'YAMLList'; |
| this.items = []; |
| } |
| function YAMLInt(token){ |
| this.node = 'YAMLInt'; |
| this.raw = token[1][0]; |
| this.value = parseInt(token[1][0]); |
| } |
| function YAMLFloat(token) { |
| this.node = 'YAMLFloat'; |
| this.raw = token[1][0]; |
| this.value = parseFloat(token[1][0]); |
| } |
| function YAMLString(token) { |
| var raw = token[1][0]; |
| |
| this.raw = raw; |
| this.node = 'YAMLString'; |
| |
| if (raw[0] === raw[raw.length - 1] && (raw[0] === '"' || raw[0] === '\'')){ |
| // Remove quotation marks |
| this.value = raw.substring(1, raw.length - 1); |
| } else { |
| this.value = token[1][0]; |
| } |
| } |
| function YAMLTrue(token) { |
| this.node = 'YAMLTrue'; |
| this.raw = token[1][0]; |
| this.value = true |
| } |
| function YAMLFalse(token) { |
| this.node = 'YAMLFalse'; |
| this.raw = token[1][0]; |
| this.value = false; |
| } |
| function YAMLNull(token) { |
| this.node = 'YAMLNull'; |
| this.raw = token[1][0]; |
| this.value = null; |
| } |
| function YAMLDate(token) { |
| this.node = 'YAMLDate'; |
| this.raw = token[1][0]; |
| this.value = helpers.parseTimestamp(token[1]); |
| } |
| |
| AST.prototype.parse = function() { |
| switch (this.peek()[0]) { |
| case 'doc': |
| return this.parseDoc(); |
| case '-': |
| return this.parseList(); |
| case '{': |
| return this.parseInlineHash(); |
| case '[': |
| return this.parseInlineList(); |
| case 'id': |
| return this.parseHash(); |
| case 'string': |
| return this.parseValue(YAMLString); |
| case 'timestamp': |
| return this.parseValue(YAMLDate); |
| case 'float': |
| return this.parseValue(YAMLFloat); |
| case 'int': |
| return this.parseValue(YAMLInt); |
| case 'true': |
| return this.parseValue(YAMLTrue); |
| case 'false': |
| return this.parseValue(YAMLFalse); |
| case 'null': |
| return this.parseValue(YAMLNull); |
| } |
| }; |
| |
| AST.prototype.parseDoc = function() { |
| this.accept('doc'); |
| this.expect('indent', 'expected indent after document'); |
| var val = this.parse(); |
| this.expect('dedent', 'document not properly dedented'); |
| var yamlDoc = new YAMLDoc(); |
| yamlDoc.value = val; |
| yamlDoc.start = this.indexToRowCol(0); |
| yamlDoc.end = this.indexToRowCol(this.strLength - 1); |
| return yamlDoc; |
| } |
| |
| AST.prototype.parseHash = function() { |
| var id, hash = new YAMLHash(); |
| while (this.peekType('id') && (id = this.advance())) { |
| this.expect(':', 'expected semi-colon after id'); |
| this.ignoreSpace(); |
| var hashKey = new YAMLHashKey(id); |
| this.assignStartEnd(hashKey, id); |
| if (this.accept('indent')) { |
| hashKey.value = this.parse(); |
| if (this.tokens.length){ |
| this.expect('dedent', 'hash not properly dedented'); |
| } |
| } else { |
| hashKey.value = this.parse(); |
| } |
| hash.keys.push(hashKey); |
| this.ignoreSpace(); |
| } |
| |
| // Add start and end to the hash based on start of the first key |
| // and end of the last key |
| hash.start = hash.keys[0].start; |
| hash.end = hash.keys[hash.keys.length - 1].value.end; |
| |
| return hash; |
| } |
| |
| AST.prototype.parseInlineHash = function() { |
| var hash = new YAMLHash(), id, i = 0; |
| this.accept('{'); |
| |
| while (!this.accept('}')) { |
| this.ignoreSpace(); |
| |
| if (i) { |
| this.expect(',', 'expected comma'); |
| } |
| this.ignoreWhitespace(); |
| |
| if (this.peekType('id') && (id = this.advance())) { |
| var hashKey = new YAMLHashKey(id); |
| this.assignStartEnd(hashKey, id); |
| this.expect(':', 'expected semi-colon after id'); |
| this.ignoreSpace(); |
| hashKey.value = this.parse(); |
| hash.keys.push(hashKey); |
| this.ignoreWhitespace(); |
| } |
| ++i; |
| } |
| |
| // Add start and end to the hash based on start of the first key |
| // and end of the last key |
| hash.start = hash.keys[0].start; |
| hash.end = hash.keys[hash.keys.length - 1].value.end; |
| |
| return hash; |
| } |
| |
| AST.prototype.parseList = function() { |
| var list = new YAMLList(); |
| var begining, end; |
| |
| begining = this.accept('-'); |
| while (true) { |
| this.ignoreSpace(); |
| |
| if (this.accept('indent')) { |
| list.items.push(this.parse()); |
| this.expect('dedent', 'list item not properly dedented'); |
| } else{ |
| list.items.push(this.parse()); |
| } |
| |
| this.ignoreSpace(); |
| |
| end = this.accept('-'); |
| |
| if (end){ |
| // Keep a copy of last end to use it for list.end |
| endBuffer = end; |
| } else { |
| end = endBuffer; |
| break; |
| } |
| } |
| |
| list.start = begining[2]; |
| list.end = end[3]; |
| |
| return list; |
| } |
| |
| AST.prototype.parseInlineList = function() { |
| var list = new YAMLList(), i = 0; |
| var begining = this.accept('['); |
| var end = this.accept(']'); |
| |
| while (!end) { |
| this.ignoreSpace(); |
| if (i) this.expect(',', 'expected comma'); |
| this.ignoreSpace(); |
| list.items.push(this.parse()); |
| this.ignoreSpace(); |
| ++i; |
| end = this.accept(']'); |
| } |
| |
| list.start = begining[2]; |
| list.end = end[3]; |
| |
| return list |
| } |
| |
| AST.prototype.parseValue = function(constructorFn) { |
| var token = this.advance(); |
| var value = new constructorFn(token); |
| this.assignStartEnd(value, token); |
| return value; |
| } |
| |
| |
| AST.prototype.assignStartEnd = function (node, token) { |
| node.start = this.indexToRowCol(token[2]); |
| node.end = this.indexToRowCol(token[3]); |
| } |
| |
| AST.prototype.indexToRowCol = function (index) { |
| if (!this.lines) return null; |
| |
| for (var l = 0; l < this.lines.length; l++) { |
| if (index >= this.lines[l].length){ |
| index -= this.lines[l].length; |
| } else { |
| break; |
| } |
| } |
| |
| return { |
| row: l, |
| column: index |
| }; |
| } |
| |
| module.exports = AST; |
| |
| },{"./helpers":3}],3:[function(require,module,exports){ |
| // --- Helpers |
| |
| /** |
| * Return 'near "context"' where context |
| * is replaced by a chunk of _str_. |
| * |
| * @param {string} str |
| * @return {string} |
| * @api public |
| */ |
| |
| function context(str) { |
| if (typeof str !== 'string') |
| return ''; |
| |
| str = str |
| .slice(0, 25) |
| .replace(/\n/g, '\\n') |
| .replace(/"/g, '\\\"'); |
| |
| return 'near "' + str + '"'; |
| } |
| |
| /** |
| * Return a UTC time from a time token |
| * |
| * @param {mixed} token |
| * @return {Date} |
| * @api public |
| */ |
| |
| function parseTimestamp(token) { |
| var date = new Date |
| var year = token[2], |
| month = token[3], |
| day = token[4], |
| hour = token[5] || 0, |
| min = token[6] || 0, |
| sec = token[7] || 0; |
| |
| date.setUTCFullYear(year, month-1, day); |
| date.setUTCHours(hour); |
| date.setUTCMinutes(min); |
| date.setUTCSeconds(sec); |
| date.setUTCMilliseconds(0); |
| |
| return date; |
| } |
| |
| |
| module.exports = { |
| context: context, |
| parseTimestamp: parseTimestamp |
| }; |
| |
| },{}],4:[function(require,module,exports){ |
| var helpers = require('./helpers'); |
| // --- Lexer |
| |
| /** |
| * YAML grammar tokens. |
| */ |
| |
| var tokens = [ |
| ['comment', /^#[^\n]*/], |
| ['indent', /^\n( *)/], |
| ['space', /^ +/], |
| ['true', /^\b(enabled|true|yes|on)\b/], |
| ['false', /^\b(disabled|false|no|off)\b/], |
| ['null', /^\b(null|Null|NULL|~)\b/], |
| ['string', /^"(.*?)"/], |
| ['string', /^'(.*?)'/], |
| ['timestamp', /^((\d{4})-(\d\d?)-(\d\d?)(?:(?:[ \t]+)(\d\d?):(\d\d)(?::(\d\d))?)?)/], |
| ['float', /^(\d+\.\d+)/], |
| ['int', /^(\d+)/], |
| ['doc', /^---/], |
| [',', /^,/], |
| ['{', /^\{(?![^\n\}]*\}[^\n]*[^\s\n\}])/], |
| ['}', /^\}/], |
| ['[', /^\[(?![^\n\]]*\][^\n]*[^\s\n\]])/], |
| [']', /^\]/], |
| ['-', /^\-/], |
| [':', /^[:]/], |
| ['string', /^(?![^:\n\s]*:[^\/]{2})(([^:,\]\}\n\s]|(?!\n)\s(?!\s*?\n)|:\/\/|,(?=[^\n]*\s*[^\]\}\s\n]\s*\n)|[\]\}](?=[^\n]*\s*[^\]\}\s\n]\s*\n))*)(?=[,:\]\}\s\n]|$)/], |
| ['id', /^([\w|\/|\$][\w -]*)/ ] |
| ] |
| |
| |
| /** |
| * Tokenize the given _str_. |
| * |
| * @param {string} str |
| * @return {array} |
| * @api private |
| */ |
| |
| exports.tokenize = function (str) { |
| var token, captures, ignore, input, |
| index = 0, |
| indents = 0, lastIndents = 0, |
| stack = [], indentAmount = -1 |
| |
| // Windows new line support (CR+LF, \r\n) |
| str = str.replace(/\r\n/g, "\n"); |
| |
| while (str.length) { |
| for (var i = 0, len = tokens.length; i < len; ++i) |
| if (captures = tokens[i][1].exec(str)) { |
| // token format: [tokenType, capturedToken, startIndex, endIndex] |
| token = [tokens[i][0], captures, index, index + captures[0].length - 1]; |
| str = str.replace(tokens[i][1], ''); |
| index += captures[0].length; |
| switch (token[0]) { |
| case 'comment': |
| ignore = true; |
| break; |
| case 'indent': |
| lastIndents = indents; |
| // determine the indentation amount from the first indent |
| if (indentAmount == -1) { |
| indentAmount = token[1][1].length; |
| } |
| |
| indents = token[1][1].length / indentAmount; |
| |
| if (indents === lastIndents || isNaN(indents)) { |
| ignore = true; |
| } |
| else if (indents > lastIndents + 1){ |
| throw new SyntaxError('invalid indentation, got ' + indents + ' instead of ' + (lastIndents + 1)); |
| } |
| else if (indents < lastIndents) { |
| input = token[1].input; |
| token = ['dedent']; |
| token.input = input; |
| while (--lastIndents > indents){ |
| stack.push(token) |
| } |
| } |
| } |
| break |
| } |
| if (!ignore) |
| if (token) |
| stack.push(token), |
| token = null |
| else |
| throw new SyntaxError(helpers.context(str)) |
| ignore = false |
| } |
| return stack |
| } |
| |
| },{"./helpers":3}],5:[function(require,module,exports){ |
| // YAML - Core - |
| // Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed) |
| // Copyright Mohsen Azimi <mohsen@mohsenweb.com> (MIT Licensed) |
| |
| var assemble = require('./assembler'); |
| var AST = require('./ast'); |
| var tokenize = require('./lexer').tokenize; |
| |
| /** |
| * Version triplet. |
| */ |
| |
| exports.version = '0.3.0'; |
| |
| |
| /** |
| * Evaluate a _str_ of yaml. |
| * |
| * @param {string} str |
| * @return {mixed} |
| * @api public |
| */ |
| |
| var eval = function(str) { |
| return assemble(exports.ast(str)); |
| } |
| |
| /** |
| * Evaluate a _str_ of yaml to an Abstract Syntax Tree (AST). |
| * |
| * @param {string} str |
| * @return {mixed} |
| * @api public |
| */ |
| var ast = function(str) { |
| return (new AST(tokenize(str), str)).parse() |
| } |
| |
| if (typeof window !== 'undefined') { |
| window.yaml2 = window.yaml2 || { |
| eval: eval, |
| ast: ast |
| }; |
| } |
| |
| exports.eval = eval; |
| exports.ast = ast; |
| },{"./assembler":1,"./ast":2,"./lexer":4}]},{},[5]); |
| /bower_components/yaml_2/src/ast.js |
|---|
| @@ -0,0 +1,356 @@ |
|---|
| var helpers = require('./helpers'); |
| |
| // --- AST |
| |
| /** |
| * Initialize with _tokens_. |
| */ |
| |
| function AST(tokens, str) { |
| this.tokens = tokens; |
| |
| // Windows new line support (CR+LF, \r\n) |
| str = str.replace(/\r\n/g, '\n'); |
| |
| // Use a regex to do this magic |
| this.lines = str.split(/\n/g).map(function(i){ return i + '\n'}); |
| this.strLength = str.length; |
| } |
| |
| /** |
| * Look-ahead a single token. |
| * |
| * @return {array} |
| * @api public |
| */ |
| |
| AST.prototype.peek = function() { |
| return this.tokens[0] |
| } |
| |
| /** |
| * Advance by a single token. |
| * |
| * @return {array} |
| * @api public |
| */ |
| |
| AST.prototype.advance = function() { |
| return this.tokens.shift() |
| } |
| |
| /** |
| * Advance and return the token's value. |
| * |
| * @return {mixed} |
| * @api private |
| */ |
| |
| AST.prototype.advanceValue = function() { |
| return this.advance()[1][1] |
| } |
| |
| /** |
| * Accept _type_ and advance or do nothing. |
| * |
| * @param {string} type |
| * @return {bool} |
| * @api private |
| */ |
| |
| AST.prototype.accept = function(type) { |
| if (this.peekType(type)) |
| return this.advance() |
| } |
| |
| /** |
| * Expect _type_ or throw an error _msg_. |
| * |
| * @param {string} type |
| * @param {string} msg |
| * @api private |
| */ |
| |
| AST.prototype.expect = function(type, msg) { |
| if (this.accept(type)) return |
| throw new Error(msg + ', ' + helpers.context(this.peek()[1].input)) |
| } |
| |
| /** |
| * Return the next token type. |
| * |
| * @return {string} |
| * @api private |
| */ |
| |
| AST.prototype.peekType = function(val) { |
| return this.tokens[0] && |
| this.tokens[0][0] === val |
| } |
| |
| /** |
| * space* |
| */ |
| |
| AST.prototype.ignoreSpace = function() { |
| while (this.peekType('space')) |
| this.advance() |
| } |
| |
| /** |
| * (space | indent | dedent)* |
| */ |
| |
| AST.prototype.ignoreWhitespace = function() { |
| while (this.peekType('space') || |
| this.peekType('indent') || |
| this.peekType('dedent')) |
| this.advance() |
| } |
| |
| // constructor functions |
| function YAMLDoc() { |
| this.node = 'YAMLDoc'; |
| } |
| function YAMLHash() { |
| this.node = 'YAMLHash'; |
| this.keys = []; |
| } |
| function YAMLHashKey(id) { |
| this.node = 'YAMLHashKey'; |
| this.keyName = id[1][0] |
| } |
| function YAMLList() { |
| this.node = 'YAMLList'; |
| this.items = []; |
| } |
| function YAMLInt(token){ |
| this.node = 'YAMLInt'; |
| this.raw = token[1][0]; |
| this.value = parseInt(token[1][0]); |
| } |
| function YAMLFloat(token) { |
| this.node = 'YAMLFloat'; |
| this.raw = token[1][0]; |
| this.value = parseFloat(token[1][0]); |
| } |
| function YAMLString(token) { |
| var raw = token[1][0]; |
| |
| this.raw = raw; |
| this.node = 'YAMLString'; |
| |
| if (raw[0] === raw[raw.length - 1] && (raw[0] === '"' || raw[0] === '\'')){ |
| // Remove quotation marks |
| this.value = raw.substring(1, raw.length - 1); |
| } else { |
| this.value = token[1][0]; |
| } |
| } |
| function YAMLTrue(token) { |
| this.node = 'YAMLTrue'; |
| this.raw = token[1][0]; |
| this.value = true |
| } |
| function YAMLFalse(token) { |
| this.node = 'YAMLFalse'; |
| this.raw = token[1][0]; |
| this.value = false; |
| } |
| function YAMLNull(token) { |
| this.node = 'YAMLNull'; |
| this.raw = token[1][0]; |
| this.value = null; |
| } |
| function YAMLDate(token) { |
| this.node = 'YAMLDate'; |
| this.raw = token[1][0]; |
| this.value = helpers.parseTimestamp(token[1]); |
| } |
| |
| AST.prototype.parse = function() { |
| switch (this.peek()[0]) { |
| case 'doc': |
| return this.parseDoc(); |
| case '-': |
| return this.parseList(); |
| case '{': |
| return this.parseInlineHash(); |
| case '[': |
| return this.parseInlineList(); |
| case 'id': |
| return this.parseHash(); |
| case 'string': |
| return this.parseValue(YAMLString); |
| case 'timestamp': |
| return this.parseValue(YAMLDate); |
| case 'float': |
| return this.parseValue(YAMLFloat); |
| case 'int': |
| return this.parseValue(YAMLInt); |
| case 'true': |
| return this.parseValue(YAMLTrue); |
| case 'false': |
| return this.parseValue(YAMLFalse); |
| case 'null': |
| return this.parseValue(YAMLNull); |
| } |
| }; |
| |
| AST.prototype.parseDoc = function() { |
| this.accept('doc'); |
| this.expect('indent', 'expected indent after document'); |
| var val = this.parse(); |
| this.expect('dedent', 'document not properly dedented'); |
| var yamlDoc = new YAMLDoc(); |
| yamlDoc.value = val; |
| yamlDoc.start = this.indexToRowCol(0); |
| yamlDoc.end = this.indexToRowCol(this.strLength - 1); |
| return yamlDoc; |
| } |
| |
| AST.prototype.parseHash = function() { |
| var id, hash = new YAMLHash(); |
| while (this.peekType('id') && (id = this.advance())) { |
| this.expect(':', 'expected semi-colon after id'); |
| this.ignoreSpace(); |
| var hashKey = new YAMLHashKey(id); |
| this.assignStartEnd(hashKey, id); |
| if (this.accept('indent')) { |
| hashKey.value = this.parse(); |
| if (this.tokens.length){ |
| this.expect('dedent', 'hash not properly dedented'); |
| } |
| } else { |
| hashKey.value = this.parse(); |
| } |
| hash.keys.push(hashKey); |
| this.ignoreSpace(); |
| } |
| |
| // Add start and end to the hash based on start of the first key |
| // and end of the last key |
| hash.start = hash.keys[0].start; |
| hash.end = hash.keys[hash.keys.length - 1].value.end; |
| |
| return hash; |
| } |
| |
| AST.prototype.parseInlineHash = function() { |
| var hash = new YAMLHash(), id, i = 0; |
| this.accept('{'); |
| |
| while (!this.accept('}')) { |
| this.ignoreSpace(); |
| |
| if (i) { |
| this.expect(',', 'expected comma'); |
| } |
| this.ignoreWhitespace(); |
| |
| if (this.peekType('id') && (id = this.advance())) { |
| var hashKey = new YAMLHashKey(id); |
| this.assignStartEnd(hashKey, id); |
| this.expect(':', 'expected semi-colon after id'); |
| this.ignoreSpace(); |
| hashKey.value = this.parse(); |
| hash.keys.push(hashKey); |
| this.ignoreWhitespace(); |
| } |
| ++i; |
| } |
| |
| // Add start and end to the hash based on start of the first key |
| // and end of the last key |
| hash.start = hash.keys[0].start; |
| hash.end = hash.keys[hash.keys.length - 1].value.end; |
| |
| return hash; |
| } |
| |
| AST.prototype.parseList = function() { |
| var list = new YAMLList(); |
| var begining, end; |
| |
| begining = this.accept('-'); |
| while (true) { |
| this.ignoreSpace(); |
| |
| if (this.accept('indent')) { |
| list.items.push(this.parse()); |
| this.expect('dedent', 'list item not properly dedented'); |
| } else{ |
| list.items.push(this.parse()); |
| } |
| |
| this.ignoreSpace(); |
| |
| end = this.accept('-'); |
| |
| if (end){ |
| // Keep a copy of last end to use it for list.end |
| endBuffer = end; |
| } else { |
| end = endBuffer; |
| break; |
| } |
| } |
| |
| list.start = begining[2]; |
| list.end = end[3]; |
| |
| return list; |
| } |
| |
| AST.prototype.parseInlineList = function() { |
| var list = new YAMLList(), i = 0; |
| var begining = this.accept('['); |
| var end = this.accept(']'); |
| |
| while (!end) { |
| this.ignoreSpace(); |
| if (i) this.expect(',', 'expected comma'); |
| this.ignoreSpace(); |
| list.items.push(this.parse()); |
| this.ignoreSpace(); |
| ++i; |
| end = this.accept(']'); |
| } |
| |
| list.start = begining[2]; |
| list.end = end[3]; |
| |
| return list |
| } |
| |
| AST.prototype.parseValue = function(constructorFn) { |
| var token = this.advance(); |
| var value = new constructorFn(token); |
| this.assignStartEnd(value, token); |
| return value; |
| } |
| |
| |
| AST.prototype.assignStartEnd = function (node, token) { |
| node.start = this.indexToRowCol(token[2]); |
| node.end = this.indexToRowCol(token[3]); |
| } |
| |
| AST.prototype.indexToRowCol = function (index) { |
| if (!this.lines) return null; |
| |
| for (var l = 0; l < this.lines.length; l++) { |
| if (index >= this.lines[l].length){ |
| index -= this.lines[l].length; |
| } else { |
| break; |
| } |
| } |
| |
| return { |
| row: l, |
| column: index |
| }; |
| } |
| |
| module.exports = AST; |
| /bower_components/yaml_2/src/lexer.js |
|---|
| @@ -0,0 +1,96 @@ |
|---|
| var helpers = require('./helpers'); |
| // --- Lexer |
| |
| /** |
| * YAML grammar tokens. |
| */ |
| |
| var tokens = [ |
| ['comment', /^#[^\n]*/], |
| ['indent', /^\n( *)/], |
| ['space', /^ +/], |
| ['true', /^\b(enabled|true|yes|on)\b/], |
| ['false', /^\b(disabled|false|no|off)\b/], |
| ['null', /^\b(null|Null|NULL|~)\b/], |
| ['string', /^"(.*?)"/], |
| ['string', /^'(.*?)'/], |
| ['timestamp', /^((\d{4})-(\d\d?)-(\d\d?)(?:(?:[ \t]+)(\d\d?):(\d\d)(?::(\d\d))?)?)/], |
| ['float', /^(\d+\.\d+)/], |
| ['int', /^(\d+)/], |
| ['doc', /^---/], |
| [',', /^,/], |
| ['{', /^\{(?![^\n\}]*\}[^\n]*[^\s\n\}])/], |
| ['}', /^\}/], |
| ['[', /^\[(?![^\n\]]*\][^\n]*[^\s\n\]])/], |
| [']', /^\]/], |
| ['-', /^\-/], |
| [':', /^[:]/], |
| ['string', /^(?![^:\n\s]*:[^\/]{2})(([^:,\]\}\n\s]|(?!\n)\s(?!\s*?\n)|:\/\/|,(?=[^\n]*\s*[^\]\}\s\n]\s*\n)|[\]\}](?=[^\n]*\s*[^\]\}\s\n]\s*\n))*)(?=[,:\]\}\s\n]|$)/], |
| ['id', /^([\w|\/|\$][\w -]*)/ ] |
| ] |
| |
| |
| /** |
| * Tokenize the given _str_. |
| * |
| * @param {string} str |
| * @return {array} |
| * @api private |
| */ |
| |
| exports.tokenize = function (str) { |
| var token, captures, ignore, input, |
| index = 0, |
| indents = 0, lastIndents = 0, |
| stack = [], indentAmount = -1 |
| |
| // Windows new line support (CR+LF, \r\n) |
| str = str.replace(/\r\n/g, "\n"); |
| |
| while (str.length) { |
| for (var i = 0, len = tokens.length; i < len; ++i) |
| if (captures = tokens[i][1].exec(str)) { |
| // token format: [tokenType, capturedToken, startIndex, endIndex] |
| token = [tokens[i][0], captures, index, index + captures[0].length - 1]; |
| str = str.replace(tokens[i][1], ''); |
| index += captures[0].length; |
| switch (token[0]) { |
| case 'comment': |
| ignore = true; |
| break; |
| case 'indent': |
| lastIndents = indents; |
| // determine the indentation amount from the first indent |
| if (indentAmount == -1) { |
| indentAmount = token[1][1].length; |
| } |
| |
| indents = token[1][1].length / indentAmount; |
| |
| if (indents === lastIndents || isNaN(indents)) { |
| ignore = true; |
| } |
| else if (indents > lastIndents + 1){ |
| throw new SyntaxError('invalid indentation, got ' + indents + ' instead of ' + (lastIndents + 1)); |
| } |
| else if (indents < lastIndents) { |
| input = token[1].input; |
| token = ['dedent']; |
| token.input = input; |
| while (--lastIndents > indents){ |
| stack.push(token) |
| } |
| } |
| } |
| break |
| } |
| if (!ignore) |
| if (token) |
| stack.push(token), |
| token = null |
| else |
| throw new SyntaxError(helpers.context(str)) |
| ignore = false |
| } |
| return stack |
| } |
