/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 |
} |