scratch

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 74  →  ?path2? @ 75
/bower_components/yaml.js/test/spec/YamlSpec.coffee
@@ -0,0 +1,1471 @@
 
unless YAML?
YAML = require '../../src/Yaml'
 
 
# Parsing
#
 
describe 'Parsed YAML Collections', ->
 
it 'can be simple sequence', ->
 
expect YAML.parse """
- apple
- banana
- carrot
"""
.toEqual ['apple', 'banana', 'carrot']
 
 
it 'can be nested sequences', ->
 
expect YAML.parse """
-
- foo
- bar
- baz
"""
.toEqual [['foo', 'bar', 'baz']]
 
 
it 'can be mixed sequences', ->
 
expect YAML.parse """
- apple
-
- foo
- bar
- x123
- banana
- carrot
"""
.toEqual ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot']
 
 
it 'can be deeply nested sequences', ->
 
expect YAML.parse """
-
-
- uno
- dos
"""
.toEqual [[['uno', 'dos']]]
 
 
it 'can be simple mapping', ->
 
expect YAML.parse """
foo: whatever
bar: stuff
"""
.toEqual foo: 'whatever', bar: 'stuff'
 
 
it 'can be sequence in a mapping', ->
 
expect YAML.parse """
foo: whatever
bar:
- uno
- dos
"""
.toEqual foo: 'whatever', bar: ['uno', 'dos']
 
 
it 'can be nested mappings', ->
 
expect YAML.parse """
foo: whatever
bar:
fruit: apple
name: steve
sport: baseball
"""
.toEqual foo: 'whatever', bar: (fruit: 'apple', name: 'steve', sport: 'baseball')
 
 
it 'can be mixed mapping', ->
 
expect YAML.parse """
foo: whatever
bar:
-
fruit: apple
name: steve
sport: baseball
- more
-
python: rocks
perl: papers
ruby: scissorses
"""
.toEqual foo: 'whatever', bar: [
(fruit: 'apple', name: 'steve', sport: 'baseball'),
'more',
(python: 'rocks', perl: 'papers', ruby: 'scissorses')
]
 
 
it 'can have mapping-in-sequence shortcut', ->
 
expect YAML.parse """
- work on YAML.py:
- work on Store
"""
.toEqual [('work on YAML.py': ['work on Store'])]
 
 
it 'can have unindented sequence-in-mapping shortcut', ->
 
expect YAML.parse """
allow:
- 'localhost'
- '%.sourceforge.net'
- '%.freepan.org'
"""
.toEqual (allow: ['localhost', '%.sourceforge.net', '%.freepan.org'])
 
 
it 'can merge key', ->
 
expect YAML.parse """
mapping:
name: Joe
job: Accountant
<<:
age: 38
"""
.toEqual mapping:
name: 'Joe'
job: 'Accountant'
age: 38
 
it 'can ignore trailing empty lines for smallest indent', ->
 
expect YAML.parse """ trailing: empty lines\n"""
.toEqual trailing: 'empty lines'
 
describe 'Parsed YAML Inline Collections', ->
 
it 'can be simple inline array', ->
 
expect YAML.parse """
---
seq: [ a, b, c ]
"""
.toEqual seq: ['a', 'b', 'c']
 
 
it 'can be simple inline hash', ->
 
expect YAML.parse """
---
hash: { name: Steve, foo: bar }
"""
.toEqual hash: (name: 'Steve', foo: 'bar')
 
 
it 'can be nested inline hash', ->
 
expect YAML.parse """
---
hash: { val1: "string", val2: { v2k1: "v2k1v" } }
"""
.toEqual hash: (val1: 'string', val2: (v2k1: 'v2k1v'))
 
 
it 'can be multi-line inline collections', ->
 
expect YAML.parse """
languages: [ Ruby,
Perl,
Python ]
websites: { YAML: yaml.org,
Ruby: ruby-lang.org,
Python: python.org,
Perl: use.perl.org }
"""
.toEqual (
languages: ['Ruby', 'Perl', 'Python']
websites:
YAML: 'yaml.org'
Ruby: 'ruby-lang.org'
Python: 'python.org'
Perl: 'use.perl.org'
)
 
 
 
describe 'Parsed YAML Basic Types', ->
 
it 'can be strings', ->
 
expect YAML.parse """
---
String
"""
.toEqual 'String'
 
 
it 'can be double-quoted strings with backslashes', ->
 
expect YAML.parse """
str:
"string with \\\\ inside"
"""
.toEqual str: 'string with \\ inside'
 
 
it 'can be single-quoted strings with backslashes', ->
 
expect YAML.parse """
str:
'string with \\\\ inside'
"""
.toEqual str: 'string with \\\\ inside'
 
 
it 'can be double-quoted strings with line breaks', ->
 
expect YAML.parse """
str:
"string with \\n inside"
"""
.toEqual str: 'string with \n inside'
 
 
it 'can be single-quoted strings with escaped line breaks', ->
 
expect YAML.parse """
str:
'string with \\n inside'
"""
.toEqual str: 'string with \\n inside'
 
 
it 'can be double-quoted strings with line breaks and backslashes', ->
 
expect YAML.parse """
str:
"string with \\n inside and \\\\ also"
"""
.toEqual str: 'string with \n inside and \\ also'
 
 
it 'can be single-quoted strings with line breaks and backslashes', ->
 
expect YAML.parse """
str:
'string with \\n inside and \\\\ also'
"""
.toEqual str: 'string with \\n inside and \\\\ also'
 
 
it 'can have string characters in sequences', ->
 
expect YAML.parse """
- What's Yaml?
- It's for writing data structures in plain text.
- And?
- And what? That's not good enough for you?
- No, I mean, "And what about Yaml?"
- Oh, oh yeah. Uh.. Yaml for JavaScript.
"""
.toEqual [
"What's Yaml?",
"It's for writing data structures in plain text.",
"And?",
"And what? That's not good enough for you?",
"No, I mean, \"And what about Yaml?\"",
"Oh, oh yeah. Uh.. Yaml for JavaScript."
]
 
 
it 'can have indicators in strings', ->
 
expect YAML.parse """
the colon followed by space is an indicator: but is a string:right here
same for the pound sign: here we have it#in a string
the comma can, honestly, be used in most cases: [ but not in, inline collections ]
"""
.toEqual (
'the colon followed by space is an indicator': 'but is a string:right here',
'same for the pound sign': 'here we have it#in a string',
'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
)
 
 
it 'can force strings', ->
 
expect YAML.parse """
date string: !str 2001-08-01
number string: !str 192
date string 2: !!str 2001-08-01
number string 2: !!str 192
"""
.toEqual (
'date string': '2001-08-01',
'number string': '192' ,
'date string 2': '2001-08-01',
'number string 2': '192'
)
 
 
it 'can be single-quoted strings', ->
 
expect YAML.parse """
all my favorite symbols: '#:!/%.)'
a few i hate: '&(*'
why do i hate them?: 'it''s very hard to explain'
"""
.toEqual (
'all my favorite symbols': '#:!/%.)',
'a few i hate': '&(*',
'why do i hate them?': 'it\'s very hard to explain'
)
 
 
it 'can be double-quoted strings', ->
 
expect YAML.parse """
i know where i want my line breaks: "one here\\nand another here\\n"
"""
.toEqual (
'i know where i want my line breaks': "one here\nand another here\n"
)
 
 
it 'can be null', ->
 
expect YAML.parse """
name: Mr. Show
hosted by: Bob and David
date of next season: ~
"""
.toEqual (
'name': 'Mr. Show'
'hosted by': 'Bob and David'
'date of next season': null
)
 
 
it 'can be boolean', ->
 
expect YAML.parse """
Is Gus a Liar?: true
Do I rely on Gus for Sustenance?: false
"""
.toEqual (
'Is Gus a Liar?': true
'Do I rely on Gus for Sustenance?': false
)
 
 
it 'can be integers', ->
 
expect YAML.parse """
zero: 0
simple: 12
one-thousand: 1,000
negative one-thousand: -1,000
"""
.toEqual (
'zero': 0
'simple': 12
'one-thousand': 1000
'negative one-thousand': -1000
)
 
 
it 'can be integers as map keys', ->
 
expect YAML.parse """
1: one
2: two
3: three
"""
.toEqual (
1: 'one'
2: 'two'
3: 'three'
)
 
 
it 'can be floats', ->
 
expect YAML.parse """
a simple float: 2.00
larger float: 1,000.09
scientific notation: 1.00009e+3
"""
.toEqual (
'a simple float': 2.0
'larger float': 1000.09
'scientific notation': 1000.09
)
 
 
it 'can be time', ->
 
iso8601Date = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
iso8601Date.setTime iso8601Date.getTime() - 5 * 3600 * 1000
 
spaceSeparatedDate = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
spaceSeparatedDate.setTime spaceSeparatedDate.getTime() - 5 * 3600 * 1000
 
withDatesToTime = (input) ->
res = {}
for key, val of input
res[key] = Math.round(val.getTime() / 1000) * 1000
return res
 
expect withDatesToTime(YAML.parse """
iso8601: 2001-12-14t21:59:43.10-05:00
space seperated: 2001-12-14 21:59:43.10 -05:00
""")
.toEqual withDatesToTime (
'iso8601': iso8601Date
'space seperated': spaceSeparatedDate
)
 
 
it 'can be date', ->
 
aDate = new Date Date.UTC(1976, 7-1, 31, 0, 0, 0, 0)
 
withDatesToTime = (input) ->
return input
res = {}
for key, val of input
res[key] = Math.round(val.getTime() / 1000) * 1000
return res
 
expect withDatesToTime(YAML.parse """
date: 1976-07-31
""")
.toEqual withDatesToTime (
'date': aDate
)
 
 
 
describe 'Parsed YAML Blocks', ->
 
it 'can be single ending newline', ->
 
expect YAML.parse """
---
this: |
Foo
Bar
"""
.toEqual 'this': "Foo\nBar\n"
 
 
it 'can be single ending newline with \'+\' indicator', ->
 
expect YAML.parse """
normal: |
extra new lines not kept
 
preserving: |+
extra new lines are kept
 
 
dummy: value
"""
.toEqual (
'normal': "extra new lines not kept\n"
'preserving': "extra new lines are kept\n\n\n"
'dummy': 'value'
)
 
 
it 'can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', ->
 
expect YAML.parse """
clipped: |
This has one newline.
 
 
 
same as "clipped" above: "This has one newline.\\n"
 
stripped: |-
This has no newline.
 
 
 
same as "stripped" above: "This has no newline."
 
kept: |+
This has four newlines.
 
 
 
same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
"""
.toEqual (
'clipped': "This has one newline.\n"
'same as "clipped" above': "This has one newline.\n"
'stripped':'This has no newline.'
'same as "stripped" above': 'This has no newline.'
'kept': "This has four newlines.\n\n\n\n"
'same as "kept" above': "This has four newlines.\n\n\n\n"
)
 
 
it 'can be folded block in a sequence', ->
 
expect YAML.parse """
---
- apple
- banana
- >
can't you see
the beauty of yaml?
hmm
- dog
"""
.toEqual [
'apple',
'banana',
"can't you see the beauty of yaml? hmm\n",
'dog'
]
 
 
it 'can be folded block as a mapping value', ->
 
expect YAML.parse """
---
quote: >
Mark McGwire's
year was crippled
by a knee injury.
source: espn
"""
.toEqual (
'quote': "Mark McGwire's year was crippled by a knee injury.\n"
'source': 'espn'
)
 
 
it 'can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', ->
 
expect YAML.parse """
clipped: >
This has one newline.
 
 
 
same as "clipped" above: "This has one newline.\\n"
 
stripped: >-
This has no newline.
 
 
 
same as "stripped" above: "This has no newline."
 
kept: >+
This has four newlines.
 
 
 
same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
"""
.toEqual (
'clipped': "This has one newline.\n"
'same as "clipped" above': "This has one newline.\n"
'stripped': 'This has no newline.'
'same as "stripped" above': 'This has no newline.'
'kept': "This has four newlines.\n\n\n\n"
'same as "kept" above': "This has four newlines.\n\n\n\n"
)
 
 
it 'can be the whole document as intented block', ->
 
expect YAML.parse """
---
foo: "bar"
baz:
- "qux"
- "quxx"
corge: null
"""
.toEqual (
'foo': "bar"
'baz': ['qux', 'quxx']
'corge': null
)
 
 
 
 
describe 'Parsed YAML Comments', ->
 
it 'can begin the document', ->
 
expect YAML.parse """
# This is a comment
hello: world
"""
.toEqual (
hello: 'world'
)
 
 
it 'can be less indented in mapping', ->
 
expect YAML.parse """
parts:
a: 'b'
# normally indented comment
c: 'd'
# less indented comment
e: 'f'
"""
.toEqual (
parts: {a: 'b', c: 'd', e: 'f'}
)
 
 
it 'can be less indented in sequence', ->
 
expect YAML.parse """
list-header:
- item1
# - item2
- item3
# - item4
"""
.toEqual (
'list-header': ['item1', 'item3']
)
 
 
it 'can finish a line', ->
 
expect YAML.parse """
hello: world # This is a comment
"""
.toEqual (
hello: 'world'
)
 
 
it 'can end the document', ->
 
expect YAML.parse """
hello: world
# This is a comment
"""
.toEqual (
hello: 'world'
)
 
 
 
describe 'Parsed YAML Aliases and Anchors', ->
 
it 'can be simple alias', ->
 
expect YAML.parse """
- &showell Steve
- Clark
- Brian
- Oren
- *showell
"""
.toEqual ['Steve', 'Clark', 'Brian', 'Oren', 'Steve']
 
 
it 'can be alias of a mapping', ->
 
expect YAML.parse """
- &hello
Meat: pork
Starch: potato
- banana
- *hello
"""
.toEqual [
Meat: 'pork', Starch: 'potato'
,
'banana'
,
Meat: 'pork', Starch: 'potato'
]
 
 
 
describe 'Parsed YAML Documents', ->
 
it 'can have YAML header', ->
 
expect YAML.parse """
--- %YAML:1.0
foo: 1
bar: 2
"""
.toEqual (
foo: 1
bar: 2
)
 
 
it 'can have leading document separator', ->
 
expect YAML.parse """
---
- foo: 1
bar: 2
"""
.toEqual [(
foo: 1
bar: 2
)]
 
 
it 'can have multiple document separators in block', ->
 
expect YAML.parse """
foo: |
---
foo: bar
---
yo: baz
bar: |
fooness
"""
.toEqual (
foo: "---\nfoo: bar\n---\nyo: baz\n"
bar: "fooness\n"
)
 
 
# Dumping
#
 
describe 'Dumped YAML Collections', ->
 
it 'can be simple sequence', ->
 
expect YAML.parse """
- apple
- banana
- carrot
"""
.toEqual YAML.parse YAML.dump ['apple', 'banana', 'carrot']
 
 
it 'can be nested sequences', ->
 
expect YAML.parse """
-
- foo
- bar
- baz
"""
.toEqual YAML.parse YAML.dump [['foo', 'bar', 'baz']]
 
 
it 'can be mixed sequences', ->
 
expect YAML.parse """
- apple
-
- foo
- bar
- x123
- banana
- carrot
"""
.toEqual YAML.parse YAML.dump ['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot']
 
 
it 'can be deeply nested sequences', ->
 
expect YAML.parse """
-
-
- uno
- dos
"""
.toEqual YAML.parse YAML.dump [[['uno', 'dos']]]
 
 
it 'can be simple mapping', ->
 
expect YAML.parse """
foo: whatever
bar: stuff
"""
.toEqual YAML.parse YAML.dump foo: 'whatever', bar: 'stuff'
 
 
it 'can be sequence in a mapping', ->
 
expect YAML.parse """
foo: whatever
bar:
- uno
- dos
"""
.toEqual YAML.parse YAML.dump foo: 'whatever', bar: ['uno', 'dos']
 
 
it 'can be nested mappings', ->
 
expect YAML.parse """
foo: whatever
bar:
fruit: apple
name: steve
sport: baseball
"""
.toEqual YAML.parse YAML.dump foo: 'whatever', bar: (fruit: 'apple', name: 'steve', sport: 'baseball')
 
 
it 'can be mixed mapping', ->
 
expect YAML.parse """
foo: whatever
bar:
-
fruit: apple
name: steve
sport: baseball
- more
-
python: rocks
perl: papers
ruby: scissorses
"""
.toEqual YAML.parse YAML.dump foo: 'whatever', bar: [
(fruit: 'apple', name: 'steve', sport: 'baseball'),
'more',
(python: 'rocks', perl: 'papers', ruby: 'scissorses')
]
 
 
it 'can have mapping-in-sequence shortcut', ->
 
expect YAML.parse """
- work on YAML.py:
- work on Store
"""
.toEqual YAML.parse YAML.dump [('work on YAML.py': ['work on Store'])]
 
 
it 'can have unindented sequence-in-mapping shortcut', ->
 
expect YAML.parse """
allow:
- 'localhost'
- '%.sourceforge.net'
- '%.freepan.org'
"""
.toEqual YAML.parse YAML.dump (allow: ['localhost', '%.sourceforge.net', '%.freepan.org'])
 
 
it 'can merge key', ->
 
expect YAML.parse """
mapping:
name: Joe
job: Accountant
<<:
age: 38
"""
.toEqual YAML.parse YAML.dump mapping:
name: 'Joe'
job: 'Accountant'
age: 38
 
 
 
describe 'Dumped YAML Inline Collections', ->
 
it 'can be simple inline array', ->
 
expect YAML.parse """
---
seq: [ a, b, c ]
"""
.toEqual YAML.parse YAML.dump seq: ['a', 'b', 'c']
 
 
it 'can be simple inline hash', ->
 
expect YAML.parse """
---
hash: { name: Steve, foo: bar }
"""
.toEqual YAML.parse YAML.dump hash: (name: 'Steve', foo: 'bar')
 
 
it 'can be multi-line inline collections', ->
 
expect YAML.parse """
languages: [ Ruby,
Perl,
Python ]
websites: { YAML: yaml.org,
Ruby: ruby-lang.org,
Python: python.org,
Perl: use.perl.org }
"""
.toEqual YAML.parse YAML.dump (
languages: ['Ruby', 'Perl', 'Python']
websites:
YAML: 'yaml.org'
Ruby: 'ruby-lang.org'
Python: 'python.org'
Perl: 'use.perl.org'
)
 
it 'can be dumped empty sequences in mappings', ->
 
expect YAML.parse(YAML.dump({key:[]}))
.toEqual({key:[]})
 
 
 
describe 'Dumped YAML Basic Types', ->
 
it 'can be strings', ->
 
expect YAML.parse """
---
String
"""
.toEqual YAML.parse YAML.dump 'String'
 
 
it 'can be double-quoted strings with backslashes', ->
 
expect YAML.parse """
str:
"string with \\\\ inside"
"""
.toEqual YAML.parse YAML.dump str: 'string with \\ inside'
 
 
it 'can be single-quoted strings with backslashes', ->
 
expect YAML.parse """
str:
'string with \\\\ inside'
"""
.toEqual YAML.parse YAML.dump str: 'string with \\\\ inside'
 
 
it 'can be double-quoted strings with line breaks', ->
 
expect YAML.parse """
str:
"string with \\n inside"
"""
.toEqual YAML.parse YAML.dump str: 'string with \n inside'
 
 
it 'can be double-quoted strings with line breaks and backslashes', ->
 
expect YAML.parse """
str:
"string with \\n inside and \\\\ also"
"""
.toEqual YAML.parse YAML.dump str: 'string with \n inside and \\ also'
 
 
it 'can be single-quoted strings with line breaks and backslashes', ->
 
expect YAML.parse """
str:
'string with \\n inside and \\\\ also'
"""
.toEqual YAML.parse YAML.dump str: 'string with \\n inside and \\\\ also'
 
 
it 'can be single-quoted strings with escaped line breaks', ->
 
expect YAML.parse """
str:
'string with \\n inside'
"""
.toEqual YAML.parse YAML.dump str: 'string with \\n inside'
 
 
it 'can have string characters in sequences', ->
 
expect YAML.parse """
- What's Yaml?
- It's for writing data structures in plain text.
- And?
- And what? That's not good enough for you?
- No, I mean, "And what about Yaml?"
- Oh, oh yeah. Uh.. Yaml for JavaScript.
"""
.toEqual YAML.parse YAML.dump [
"What's Yaml?",
"It's for writing data structures in plain text.",
"And?",
"And what? That's not good enough for you?",
"No, I mean, \"And what about Yaml?\"",
"Oh, oh yeah. Uh.. Yaml for JavaScript."
]
 
 
it 'can have indicators in strings', ->
 
expect YAML.parse """
the colon followed by space is an indicator: but is a string:right here
same for the pound sign: here we have it#in a string
the comma can, honestly, be used in most cases: [ but not in, inline collections ]
"""
.toEqual YAML.parse YAML.dump (
'the colon followed by space is an indicator': 'but is a string:right here',
'same for the pound sign': 'here we have it#in a string',
'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
)
 
 
it 'can force strings', ->
 
expect YAML.parse """
date string: !str 2001-08-01
number string: !str 192
date string 2: !!str 2001-08-01
number string 2: !!str 192
"""
.toEqual YAML.parse YAML.dump (
'date string': '2001-08-01',
'number string': '192' ,
'date string 2': '2001-08-01',
'number string 2': '192'
)
 
 
it 'can be single-quoted strings', ->
 
expect YAML.parse """
all my favorite symbols: '#:!/%.)'
a few i hate: '&(*'
why do i hate them?: 'it''s very hard to explain'
"""
.toEqual YAML.parse YAML.dump (
'all my favorite symbols': '#:!/%.)',
'a few i hate': '&(*',
'why do i hate them?': 'it\'s very hard to explain'
)
 
 
it 'can be double-quoted strings', ->
 
expect YAML.parse """
i know where i want my line breaks: "one here\\nand another here\\n"
"""
.toEqual YAML.parse YAML.dump (
'i know where i want my line breaks': "one here\nand another here\n"
)
 
 
it 'can be null', ->
 
expect YAML.parse """
name: Mr. Show
hosted by: Bob and David
date of next season: ~
"""
.toEqual YAML.parse YAML.dump (
'name': 'Mr. Show'
'hosted by': 'Bob and David'
'date of next season': null
)
 
 
it 'can be boolean', ->
 
expect YAML.parse """
Is Gus a Liar?: true
Do I rely on Gus for Sustenance?: false
"""
.toEqual YAML.parse YAML.dump (
'Is Gus a Liar?': true
'Do I rely on Gus for Sustenance?': false
)
 
 
it 'can be integers', ->
 
expect YAML.parse """
zero: 0
simple: 12
one-thousand: 1,000
negative one-thousand: -1,000
"""
.toEqual YAML.parse YAML.dump (
'zero': 0
'simple': 12
'one-thousand': 1000
'negative one-thousand': -1000
)
 
 
it 'can be integers as map keys', ->
 
expect YAML.parse """
1: one
2: two
3: three
"""
.toEqual YAML.parse YAML.dump (
1: 'one'
2: 'two'
3: 'three'
)
 
 
it 'can be floats', ->
 
expect YAML.parse """
a simple float: 2.00
larger float: 1,000.09
scientific notation: 1.00009e+3
"""
.toEqual YAML.parse YAML.dump (
'a simple float': 2.0
'larger float': 1000.09
'scientific notation': 1000.09
)
 
 
it 'can be time', ->
 
iso8601Date = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
iso8601Date.setTime iso8601Date.getTime() - 5 * 3600 * 1000
 
spaceSeparatedDate = new Date Date.UTC(2001, 12-1, 14, 21, 59, 43, 10)
spaceSeparatedDate.setTime spaceSeparatedDate.getTime() - 5 * 3600 * 1000
 
withDatesToTime = (input) ->
res = {}
for key, val of input
res[key] = Math.round(val.getTime() / 1000) * 1000
return res
 
expect withDatesToTime(YAML.parse """
iso8601: 2001-12-14t21:59:43.10-05:00
space seperated: 2001-12-14 21:59:43.10 -05:00
""")
.toEqual YAML.parse YAML.dump withDatesToTime (
'iso8601': iso8601Date
'space seperated': spaceSeparatedDate
)
 
 
it 'can be date', ->
 
aDate = new Date Date.UTC(1976, 7-1, 31, 0, 0, 0, 0)
 
withDatesToTime = (input) ->
return input
res = {}
for key, val of input
res[key] = Math.round(val.getTime() / 1000) * 1000
return res
 
expect withDatesToTime(YAML.parse """
date: 1976-07-31
""")
.toEqual YAML.parse YAML.dump withDatesToTime (
'date': aDate
)
 
 
 
describe 'Dumped YAML Blocks', ->
 
it 'can be single ending newline', ->
 
expect YAML.parse """
---
this: |
Foo
Bar
"""
.toEqual YAML.parse YAML.dump 'this': "Foo\nBar\n"
 
 
it 'can be single ending newline with \'+\' indicator', ->
 
expect YAML.parse """
normal: |
extra new lines not kept
 
preserving: |+
extra new lines are kept
 
 
dummy: value
"""
.toEqual YAML.parse YAML.dump (
'normal': "extra new lines not kept\n"
'preserving': "extra new lines are kept\n\n\n"
'dummy': 'value'
)
 
 
it 'can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', ->
 
expect YAML.parse """
clipped: |
This has one newline.
 
 
 
same as "clipped" above: "This has one newline.\\n"
 
stripped: |-
This has no newline.
 
 
 
same as "stripped" above: "This has no newline."
 
kept: |+
This has four newlines.
 
 
 
same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
"""
.toEqual YAML.parse YAML.dump (
'clipped': "This has one newline.\n"
'same as "clipped" above': "This has one newline.\n"
'stripped':'This has no newline.'
'same as "stripped" above': 'This has no newline.'
'kept': "This has four newlines.\n\n\n\n"
'same as "kept" above': "This has four newlines.\n\n\n\n"
)
 
 
it 'can be folded block in a sequence', ->
 
expect YAML.parse """
---
- apple
- banana
- >
can't you see
the beauty of yaml?
hmm
- dog
"""
.toEqual YAML.parse YAML.dump [
'apple',
'banana',
"can't you see the beauty of yaml? hmm\n",
'dog'
]
 
 
it 'can be folded block as a mapping value', ->
 
expect YAML.parse """
---
quote: >
Mark McGwire's
year was crippled
by a knee injury.
source: espn
"""
.toEqual YAML.parse YAML.dump (
'quote': "Mark McGwire's year was crippled by a knee injury.\n"
'source': 'espn'
)
 
 
it 'can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', ->
 
expect YAML.parse """
clipped: >
This has one newline.
 
 
 
same as "clipped" above: "This has one newline.\\n"
 
stripped: >-
This has no newline.
 
 
 
same as "stripped" above: "This has no newline."
 
kept: >+
This has four newlines.
 
 
 
same as "kept" above: "This has four newlines.\\n\\n\\n\\n"
"""
.toEqual YAML.parse YAML.dump (
'clipped': "This has one newline.\n"
'same as "clipped" above': "This has one newline.\n"
'stripped': 'This has no newline.'
'same as "stripped" above': 'This has no newline.'
'kept': "This has four newlines.\n\n\n\n"
'same as "kept" above': "This has four newlines.\n\n\n\n"
)
 
 
 
describe 'Dumped YAML Comments', ->
 
it 'can begin the document', ->
 
expect YAML.parse """
# This is a comment
hello: world
"""
.toEqual YAML.parse YAML.dump (
hello: 'world'
)
 
 
it 'can finish a line', ->
 
expect YAML.parse """
hello: world # This is a comment
"""
.toEqual YAML.parse YAML.dump (
hello: 'world'
)
 
 
it 'can end the document', ->
 
expect YAML.parse """
hello: world
# This is a comment
"""
.toEqual YAML.parse YAML.dump (
hello: 'world'
)
 
 
 
describe 'Dumped YAML Aliases and Anchors', ->
 
it 'can be simple alias', ->
 
expect YAML.parse """
- &showell Steve
- Clark
- Brian
- Oren
- *showell
"""
.toEqual YAML.parse YAML.dump ['Steve', 'Clark', 'Brian', 'Oren', 'Steve']
 
 
it 'can be alias of a mapping', ->
 
expect YAML.parse """
- &hello
Meat: pork
Starch: potato
- banana
- *hello
"""
.toEqual YAML.parse YAML.dump [
Meat: 'pork', Starch: 'potato'
,
'banana'
,
Meat: 'pork', Starch: 'potato'
]
 
 
 
describe 'Dumped YAML Documents', ->
 
it 'can have YAML header', ->
 
expect YAML.parse """
--- %YAML:1.0
foo: 1
bar: 2
"""
.toEqual YAML.parse YAML.dump (
foo: 1
bar: 2
)
 
 
it 'can have leading document separator', ->
 
expect YAML.parse """
---
- foo: 1
bar: 2
"""
.toEqual YAML.parse YAML.dump [(
foo: 1
bar: 2
)]
 
 
it 'can have multiple document separators in block', ->
 
expect YAML.parse """
foo: |
---
foo: bar
---
yo: baz
bar: |
fooness
"""
.toEqual YAML.parse YAML.dump (
foo: "---\nfoo: bar\n---\nyo: baz\n"
bar: "fooness\n"
)
 
 
# Loading
# (disable test when running locally from file)
#
url = document?.location?.href
if not(url?) or url.indexOf('file://') is -1
 
examplePath = 'spec/example.yml'
if __dirname?
examplePath = __dirname+'/example.yml'
 
describe 'YAML loading', ->
 
it 'can be done synchronously', ->
 
expect(YAML.load(examplePath)).toEqual (
this: 'is'
a: ['YAML', 'example']
)
 
 
it 'can be done asynchronously', (done) ->
 
YAML.load examplePath, (result) ->
 
expect(result).toEqual (
this: 'is'
a: ['YAML', 'example']
)
 
done()
/bower_components/yaml.js/test/spec/YamlSpec.js
@@ -0,0 +1,757 @@
// Generated by CoffeeScript 1.10.0
var YAML, examplePath, ref, url;
 
if (typeof YAML === "undefined" || YAML === null) {
YAML = require('../../src/Yaml');
}
 
describe('Parsed YAML Collections', function() {
it('can be simple sequence', function() {
return expect(YAML.parse("- apple\n- banana\n- carrot")).toEqual(['apple', 'banana', 'carrot']);
});
it('can be nested sequences', function() {
return expect(YAML.parse("-\n - foo\n - bar\n - baz")).toEqual([['foo', 'bar', 'baz']]);
});
it('can be mixed sequences', function() {
return expect(YAML.parse("- apple\n-\n - foo\n - bar\n - x123\n- banana\n- carrot")).toEqual(['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot']);
});
it('can be deeply nested sequences', function() {
return expect(YAML.parse("-\n -\n - uno\n - dos")).toEqual([[['uno', 'dos']]]);
});
it('can be simple mapping', function() {
return expect(YAML.parse("foo: whatever\nbar: stuff")).toEqual({
foo: 'whatever',
bar: 'stuff'
});
});
it('can be sequence in a mapping', function() {
return expect(YAML.parse("foo: whatever\nbar:\n - uno\n - dos")).toEqual({
foo: 'whatever',
bar: ['uno', 'dos']
});
});
it('can be nested mappings', function() {
return expect(YAML.parse("foo: whatever\nbar:\n fruit: apple\n name: steve\n sport: baseball")).toEqual({
foo: 'whatever',
bar: {
fruit: 'apple',
name: 'steve',
sport: 'baseball'
}
});
});
it('can be mixed mapping', function() {
return expect(YAML.parse("foo: whatever\nbar:\n -\n fruit: apple\n name: steve\n sport: baseball\n - more\n -\n python: rocks\n perl: papers\n ruby: scissorses")).toEqual({
foo: 'whatever',
bar: [
{
fruit: 'apple',
name: 'steve',
sport: 'baseball'
}, 'more', {
python: 'rocks',
perl: 'papers',
ruby: 'scissorses'
}
]
});
});
it('can have mapping-in-sequence shortcut', function() {
return expect(YAML.parse("- work on YAML.py:\n - work on Store")).toEqual([
{
'work on YAML.py': ['work on Store']
}
]);
});
it('can have unindented sequence-in-mapping shortcut', function() {
return expect(YAML.parse("allow:\n- 'localhost'\n- '%.sourceforge.net'\n- '%.freepan.org'")).toEqual({
allow: ['localhost', '%.sourceforge.net', '%.freepan.org']
});
});
it('can merge key', function() {
return expect(YAML.parse("mapping:\n name: Joe\n job: Accountant\n <<:\n age: 38")).toEqual({
mapping: {
name: 'Joe',
job: 'Accountant',
age: 38
}
});
});
return it('can ignore trailing empty lines for smallest indent', function() {
return expect(YAML.parse(" trailing: empty lines\n")).toEqual({
trailing: 'empty lines'
});
});
});
 
describe('Parsed YAML Inline Collections', function() {
it('can be simple inline array', function() {
return expect(YAML.parse("---\nseq: [ a, b, c ]")).toEqual({
seq: ['a', 'b', 'c']
});
});
it('can be simple inline hash', function() {
return expect(YAML.parse("---\nhash: { name: Steve, foo: bar }")).toEqual({
hash: {
name: 'Steve',
foo: 'bar'
}
});
});
it('can be nested inline hash', function() {
return expect(YAML.parse("---\nhash: { val1: \"string\", val2: { v2k1: \"v2k1v\" } }")).toEqual({
hash: {
val1: 'string',
val2: {
v2k1: 'v2k1v'
}
}
});
});
return it('can be multi-line inline collections', function() {
return expect(YAML.parse("languages: [ Ruby,\n Perl,\n Python ]\nwebsites: { YAML: yaml.org,\n Ruby: ruby-lang.org,\n Python: python.org,\n Perl: use.perl.org }")).toEqual({
languages: ['Ruby', 'Perl', 'Python'],
websites: {
YAML: 'yaml.org',
Ruby: 'ruby-lang.org',
Python: 'python.org',
Perl: 'use.perl.org'
}
});
});
});
 
describe('Parsed YAML Basic Types', function() {
it('can be strings', function() {
return expect(YAML.parse("---\nString")).toEqual('String');
});
it('can be double-quoted strings with backslashes', function() {
return expect(YAML.parse("str:\n \"string with \\\\ inside\"")).toEqual({
str: 'string with \\ inside'
});
});
it('can be single-quoted strings with backslashes', function() {
return expect(YAML.parse("str:\n 'string with \\\\ inside'")).toEqual({
str: 'string with \\\\ inside'
});
});
it('can be double-quoted strings with line breaks', function() {
return expect(YAML.parse("str:\n \"string with \\n inside\"")).toEqual({
str: 'string with \n inside'
});
});
it('can be single-quoted strings with escaped line breaks', function() {
return expect(YAML.parse("str:\n 'string with \\n inside'")).toEqual({
str: 'string with \\n inside'
});
});
it('can be double-quoted strings with line breaks and backslashes', function() {
return expect(YAML.parse("str:\n \"string with \\n inside and \\\\ also\"")).toEqual({
str: 'string with \n inside and \\ also'
});
});
it('can be single-quoted strings with line breaks and backslashes', function() {
return expect(YAML.parse("str:\n 'string with \\n inside and \\\\ also'")).toEqual({
str: 'string with \\n inside and \\\\ also'
});
});
it('can have string characters in sequences', function() {
return expect(YAML.parse("- What's Yaml?\n- It's for writing data structures in plain text.\n- And?\n- And what? That's not good enough for you?\n- No, I mean, \"And what about Yaml?\"\n- Oh, oh yeah. Uh.. Yaml for JavaScript.")).toEqual(["What's Yaml?", "It's for writing data structures in plain text.", "And?", "And what? That's not good enough for you?", "No, I mean, \"And what about Yaml?\"", "Oh, oh yeah. Uh.. Yaml for JavaScript."]);
});
it('can have indicators in strings', function() {
return expect(YAML.parse("the colon followed by space is an indicator: but is a string:right here\nsame for the pound sign: here we have it#in a string\nthe comma can, honestly, be used in most cases: [ but not in, inline collections ]")).toEqual({
'the colon followed by space is an indicator': 'but is a string:right here',
'same for the pound sign': 'here we have it#in a string',
'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
});
});
it('can force strings', function() {
return expect(YAML.parse("date string: !str 2001-08-01\nnumber string: !str 192\ndate string 2: !!str 2001-08-01\nnumber string 2: !!str 192")).toEqual({
'date string': '2001-08-01',
'number string': '192',
'date string 2': '2001-08-01',
'number string 2': '192'
});
});
it('can be single-quoted strings', function() {
return expect(YAML.parse("all my favorite symbols: '#:!/%.)'\na few i hate: '&(*'\nwhy do i hate them?: 'it''s very hard to explain'")).toEqual({
'all my favorite symbols': '#:!/%.)',
'a few i hate': '&(*',
'why do i hate them?': 'it\'s very hard to explain'
});
});
it('can be double-quoted strings', function() {
return expect(YAML.parse("i know where i want my line breaks: \"one here\\nand another here\\n\"")).toEqual({
'i know where i want my line breaks': "one here\nand another here\n"
});
});
it('can be null', function() {
return expect(YAML.parse("name: Mr. Show\nhosted by: Bob and David\ndate of next season: ~")).toEqual({
'name': 'Mr. Show',
'hosted by': 'Bob and David',
'date of next season': null
});
});
it('can be boolean', function() {
return expect(YAML.parse("Is Gus a Liar?: true\nDo I rely on Gus for Sustenance?: false")).toEqual({
'Is Gus a Liar?': true,
'Do I rely on Gus for Sustenance?': false
});
});
it('can be integers', function() {
return expect(YAML.parse("zero: 0\nsimple: 12\none-thousand: 1,000\nnegative one-thousand: -1,000")).toEqual({
'zero': 0,
'simple': 12,
'one-thousand': 1000,
'negative one-thousand': -1000
});
});
it('can be integers as map keys', function() {
return expect(YAML.parse("1: one\n2: two\n3: three")).toEqual({
1: 'one',
2: 'two',
3: 'three'
});
});
it('can be floats', function() {
return expect(YAML.parse("a simple float: 2.00\nlarger float: 1,000.09\nscientific notation: 1.00009e+3")).toEqual({
'a simple float': 2.0,
'larger float': 1000.09,
'scientific notation': 1000.09
});
});
it('can be time', function() {
var iso8601Date, spaceSeparatedDate, withDatesToTime;
iso8601Date = new Date(Date.UTC(2001, 12 - 1, 14, 21, 59, 43, 10));
iso8601Date.setTime(iso8601Date.getTime() - 5 * 3600 * 1000);
spaceSeparatedDate = new Date(Date.UTC(2001, 12 - 1, 14, 21, 59, 43, 10));
spaceSeparatedDate.setTime(spaceSeparatedDate.getTime() - 5 * 3600 * 1000);
withDatesToTime = function(input) {
var key, res, val;
res = {};
for (key in input) {
val = input[key];
res[key] = Math.round(val.getTime() / 1000) * 1000;
}
return res;
};
return expect(withDatesToTime(YAML.parse("iso8601: 2001-12-14t21:59:43.10-05:00\nspace seperated: 2001-12-14 21:59:43.10 -05:00"))).toEqual(withDatesToTime({
'iso8601': iso8601Date,
'space seperated': spaceSeparatedDate
}));
});
return it('can be date', function() {
var aDate, withDatesToTime;
aDate = new Date(Date.UTC(1976, 7 - 1, 31, 0, 0, 0, 0));
withDatesToTime = function(input) {
var key, res, val;
return input;
res = {};
for (key in input) {
val = input[key];
res[key] = Math.round(val.getTime() / 1000) * 1000;
}
return res;
};
return expect(withDatesToTime(YAML.parse("date: 1976-07-31"))).toEqual(withDatesToTime({
'date': aDate
}));
});
});
 
describe('Parsed YAML Blocks', function() {
it('can be single ending newline', function() {
return expect(YAML.parse("---\nthis: |\n Foo\n Bar")).toEqual({
'this': "Foo\nBar\n"
});
});
it('can be single ending newline with \'+\' indicator', function() {
return expect(YAML.parse("normal: |\n extra new lines not kept\n\npreserving: |+\n extra new lines are kept\n\n\ndummy: value")).toEqual({
'normal': "extra new lines not kept\n",
'preserving': "extra new lines are kept\n\n\n",
'dummy': 'value'
});
});
it('can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', function() {
return expect(YAML.parse("clipped: |\n This has one newline.\n\n\n\nsame as \"clipped\" above: \"This has one newline.\\n\"\n\nstripped: |-\n This has no newline.\n\n\n\nsame as \"stripped\" above: \"This has no newline.\"\n\nkept: |+\n This has four newlines.\n\n\n\nsame as \"kept\" above: \"This has four newlines.\\n\\n\\n\\n\"")).toEqual({
'clipped': "This has one newline.\n",
'same as "clipped" above': "This has one newline.\n",
'stripped': 'This has no newline.',
'same as "stripped" above': 'This has no newline.',
'kept': "This has four newlines.\n\n\n\n",
'same as "kept" above': "This has four newlines.\n\n\n\n"
});
});
it('can be folded block in a sequence', function() {
return expect(YAML.parse("---\n- apple\n- banana\n- >\n can't you see\n the beauty of yaml?\n hmm\n- dog")).toEqual(['apple', 'banana', "can't you see the beauty of yaml? hmm\n", 'dog']);
});
it('can be folded block as a mapping value', function() {
return expect(YAML.parse("---\nquote: >\n Mark McGwire's\n year was crippled\n by a knee injury.\nsource: espn")).toEqual({
'quote': "Mark McGwire's year was crippled by a knee injury.\n",
'source': 'espn'
});
});
it('can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', function() {
return expect(YAML.parse("clipped: >\n This has one newline.\n\n\n\nsame as \"clipped\" above: \"This has one newline.\\n\"\n\nstripped: >-\n This has no newline.\n\n\n\nsame as \"stripped\" above: \"This has no newline.\"\n\nkept: >+\n This has four newlines.\n\n\n\nsame as \"kept\" above: \"This has four newlines.\\n\\n\\n\\n\"")).toEqual({
'clipped': "This has one newline.\n",
'same as "clipped" above': "This has one newline.\n",
'stripped': 'This has no newline.',
'same as "stripped" above': 'This has no newline.',
'kept': "This has four newlines.\n\n\n\n",
'same as "kept" above': "This has four newlines.\n\n\n\n"
});
});
return it('can be the whole document as intented block', function() {
return expect(YAML.parse("---\n foo: \"bar\"\n baz:\n - \"qux\"\n - \"quxx\"\n corge: null")).toEqual({
'foo': "bar",
'baz': ['qux', 'quxx'],
'corge': null
});
});
});
 
describe('Parsed YAML Comments', function() {
it('can begin the document', function() {
return expect(YAML.parse("# This is a comment\nhello: world")).toEqual({
hello: 'world'
});
});
it('can be less indented in mapping', function() {
return expect(YAML.parse("parts:\n a: 'b'\n # normally indented comment\n c: 'd'\n# less indented comment\n e: 'f'")).toEqual({
parts: {
a: 'b',
c: 'd',
e: 'f'
}
});
});
it('can be less indented in sequence', function() {
return expect(YAML.parse("list-header:\n - item1\n# - item2\n - item3\n # - item4")).toEqual({
'list-header': ['item1', 'item3']
});
});
it('can finish a line', function() {
return expect(YAML.parse("hello: world # This is a comment")).toEqual({
hello: 'world'
});
});
return it('can end the document', function() {
return expect(YAML.parse("hello: world\n# This is a comment")).toEqual({
hello: 'world'
});
});
});
 
describe('Parsed YAML Aliases and Anchors', function() {
it('can be simple alias', function() {
return expect(YAML.parse("- &showell Steve\n- Clark\n- Brian\n- Oren\n- *showell")).toEqual(['Steve', 'Clark', 'Brian', 'Oren', 'Steve']);
});
return it('can be alias of a mapping', function() {
return expect(YAML.parse("- &hello\n Meat: pork\n Starch: potato\n- banana\n- *hello")).toEqual([
{
Meat: 'pork',
Starch: 'potato'
}, 'banana', {
Meat: 'pork',
Starch: 'potato'
}
]);
});
});
 
describe('Parsed YAML Documents', function() {
it('can have YAML header', function() {
return expect(YAML.parse("--- %YAML:1.0\nfoo: 1\nbar: 2")).toEqual({
foo: 1,
bar: 2
});
});
it('can have leading document separator', function() {
return expect(YAML.parse("---\n- foo: 1\n bar: 2")).toEqual([
{
foo: 1,
bar: 2
}
]);
});
return it('can have multiple document separators in block', function() {
return expect(YAML.parse("foo: |\n ---\n foo: bar\n ---\n yo: baz\nbar: |\n fooness")).toEqual({
foo: "---\nfoo: bar\n---\nyo: baz\n",
bar: "fooness\n"
});
});
});
 
describe('Dumped YAML Collections', function() {
it('can be simple sequence', function() {
return expect(YAML.parse("- apple\n- banana\n- carrot")).toEqual(YAML.parse(YAML.dump(['apple', 'banana', 'carrot'])));
});
it('can be nested sequences', function() {
return expect(YAML.parse("-\n - foo\n - bar\n - baz")).toEqual(YAML.parse(YAML.dump([['foo', 'bar', 'baz']])));
});
it('can be mixed sequences', function() {
return expect(YAML.parse("- apple\n-\n - foo\n - bar\n - x123\n- banana\n- carrot")).toEqual(YAML.parse(YAML.dump(['apple', ['foo', 'bar', 'x123'], 'banana', 'carrot'])));
});
it('can be deeply nested sequences', function() {
return expect(YAML.parse("-\n -\n - uno\n - dos")).toEqual(YAML.parse(YAML.dump([[['uno', 'dos']]])));
});
it('can be simple mapping', function() {
return expect(YAML.parse("foo: whatever\nbar: stuff")).toEqual(YAML.parse(YAML.dump({
foo: 'whatever',
bar: 'stuff'
})));
});
it('can be sequence in a mapping', function() {
return expect(YAML.parse("foo: whatever\nbar:\n - uno\n - dos")).toEqual(YAML.parse(YAML.dump({
foo: 'whatever',
bar: ['uno', 'dos']
})));
});
it('can be nested mappings', function() {
return expect(YAML.parse("foo: whatever\nbar:\n fruit: apple\n name: steve\n sport: baseball")).toEqual(YAML.parse(YAML.dump({
foo: 'whatever',
bar: {
fruit: 'apple',
name: 'steve',
sport: 'baseball'
}
})));
});
it('can be mixed mapping', function() {
return expect(YAML.parse("foo: whatever\nbar:\n -\n fruit: apple\n name: steve\n sport: baseball\n - more\n -\n python: rocks\n perl: papers\n ruby: scissorses")).toEqual(YAML.parse(YAML.dump({
foo: 'whatever',
bar: [
{
fruit: 'apple',
name: 'steve',
sport: 'baseball'
}, 'more', {
python: 'rocks',
perl: 'papers',
ruby: 'scissorses'
}
]
})));
});
it('can have mapping-in-sequence shortcut', function() {
return expect(YAML.parse("- work on YAML.py:\n - work on Store")).toEqual(YAML.parse(YAML.dump([
{
'work on YAML.py': ['work on Store']
}
])));
});
it('can have unindented sequence-in-mapping shortcut', function() {
return expect(YAML.parse("allow:\n- 'localhost'\n- '%.sourceforge.net'\n- '%.freepan.org'")).toEqual(YAML.parse(YAML.dump({
allow: ['localhost', '%.sourceforge.net', '%.freepan.org']
})));
});
return it('can merge key', function() {
return expect(YAML.parse("mapping:\n name: Joe\n job: Accountant\n <<:\n age: 38")).toEqual(YAML.parse(YAML.dump({
mapping: {
name: 'Joe',
job: 'Accountant',
age: 38
}
})));
});
});
 
describe('Dumped YAML Inline Collections', function() {
it('can be simple inline array', function() {
return expect(YAML.parse("---\nseq: [ a, b, c ]")).toEqual(YAML.parse(YAML.dump({
seq: ['a', 'b', 'c']
})));
});
it('can be simple inline hash', function() {
return expect(YAML.parse("---\nhash: { name: Steve, foo: bar }")).toEqual(YAML.parse(YAML.dump({
hash: {
name: 'Steve',
foo: 'bar'
}
})));
});
it('can be multi-line inline collections', function() {
return expect(YAML.parse("languages: [ Ruby,\n Perl,\n Python ]\nwebsites: { YAML: yaml.org,\n Ruby: ruby-lang.org,\n Python: python.org,\n Perl: use.perl.org }")).toEqual(YAML.parse(YAML.dump({
languages: ['Ruby', 'Perl', 'Python'],
websites: {
YAML: 'yaml.org',
Ruby: 'ruby-lang.org',
Python: 'python.org',
Perl: 'use.perl.org'
}
})));
});
return it('can be dumped empty sequences in mappings', function() {
return expect(YAML.parse(YAML.dump({
key: []
}))).toEqual({
key: []
});
});
});
 
describe('Dumped YAML Basic Types', function() {
it('can be strings', function() {
return expect(YAML.parse("---\nString")).toEqual(YAML.parse(YAML.dump('String')));
});
it('can be double-quoted strings with backslashes', function() {
return expect(YAML.parse("str:\n \"string with \\\\ inside\"")).toEqual(YAML.parse(YAML.dump({
str: 'string with \\ inside'
})));
});
it('can be single-quoted strings with backslashes', function() {
return expect(YAML.parse("str:\n 'string with \\\\ inside'")).toEqual(YAML.parse(YAML.dump({
str: 'string with \\\\ inside'
})));
});
it('can be double-quoted strings with line breaks', function() {
return expect(YAML.parse("str:\n \"string with \\n inside\"")).toEqual(YAML.parse(YAML.dump({
str: 'string with \n inside'
})));
});
it('can be double-quoted strings with line breaks and backslashes', function() {
return expect(YAML.parse("str:\n \"string with \\n inside and \\\\ also\"")).toEqual(YAML.parse(YAML.dump({
str: 'string with \n inside and \\ also'
})));
});
it('can be single-quoted strings with line breaks and backslashes', function() {
return expect(YAML.parse("str:\n 'string with \\n inside and \\\\ also'")).toEqual(YAML.parse(YAML.dump({
str: 'string with \\n inside and \\\\ also'
})));
});
it('can be single-quoted strings with escaped line breaks', function() {
return expect(YAML.parse("str:\n 'string with \\n inside'")).toEqual(YAML.parse(YAML.dump({
str: 'string with \\n inside'
})));
});
it('can have string characters in sequences', function() {
return expect(YAML.parse("- What's Yaml?\n- It's for writing data structures in plain text.\n- And?\n- And what? That's not good enough for you?\n- No, I mean, \"And what about Yaml?\"\n- Oh, oh yeah. Uh.. Yaml for JavaScript.")).toEqual(YAML.parse(YAML.dump(["What's Yaml?", "It's for writing data structures in plain text.", "And?", "And what? That's not good enough for you?", "No, I mean, \"And what about Yaml?\"", "Oh, oh yeah. Uh.. Yaml for JavaScript."])));
});
it('can have indicators in strings', function() {
return expect(YAML.parse("the colon followed by space is an indicator: but is a string:right here\nsame for the pound sign: here we have it#in a string\nthe comma can, honestly, be used in most cases: [ but not in, inline collections ]")).toEqual(YAML.parse(YAML.dump({
'the colon followed by space is an indicator': 'but is a string:right here',
'same for the pound sign': 'here we have it#in a string',
'the comma can, honestly, be used in most cases': ['but not in', 'inline collections']
})));
});
it('can force strings', function() {
return expect(YAML.parse("date string: !str 2001-08-01\nnumber string: !str 192\ndate string 2: !!str 2001-08-01\nnumber string 2: !!str 192")).toEqual(YAML.parse(YAML.dump({
'date string': '2001-08-01',
'number string': '192',
'date string 2': '2001-08-01',
'number string 2': '192'
})));
});
it('can be single-quoted strings', function() {
return expect(YAML.parse("all my favorite symbols: '#:!/%.)'\na few i hate: '&(*'\nwhy do i hate them?: 'it''s very hard to explain'")).toEqual(YAML.parse(YAML.dump({
'all my favorite symbols': '#:!/%.)',
'a few i hate': '&(*',
'why do i hate them?': 'it\'s very hard to explain'
})));
});
it('can be double-quoted strings', function() {
return expect(YAML.parse("i know where i want my line breaks: \"one here\\nand another here\\n\"")).toEqual(YAML.parse(YAML.dump({
'i know where i want my line breaks': "one here\nand another here\n"
})));
});
it('can be null', function() {
return expect(YAML.parse("name: Mr. Show\nhosted by: Bob and David\ndate of next season: ~")).toEqual(YAML.parse(YAML.dump({
'name': 'Mr. Show',
'hosted by': 'Bob and David',
'date of next season': null
})));
});
it('can be boolean', function() {
return expect(YAML.parse("Is Gus a Liar?: true\nDo I rely on Gus for Sustenance?: false")).toEqual(YAML.parse(YAML.dump({
'Is Gus a Liar?': true,
'Do I rely on Gus for Sustenance?': false
})));
});
it('can be integers', function() {
return expect(YAML.parse("zero: 0\nsimple: 12\none-thousand: 1,000\nnegative one-thousand: -1,000")).toEqual(YAML.parse(YAML.dump({
'zero': 0,
'simple': 12,
'one-thousand': 1000,
'negative one-thousand': -1000
})));
});
it('can be integers as map keys', function() {
return expect(YAML.parse("1: one\n2: two\n3: three")).toEqual(YAML.parse(YAML.dump({
1: 'one',
2: 'two',
3: 'three'
})));
});
it('can be floats', function() {
return expect(YAML.parse("a simple float: 2.00\nlarger float: 1,000.09\nscientific notation: 1.00009e+3")).toEqual(YAML.parse(YAML.dump({
'a simple float': 2.0,
'larger float': 1000.09,
'scientific notation': 1000.09
})));
});
it('can be time', function() {
var iso8601Date, spaceSeparatedDate, withDatesToTime;
iso8601Date = new Date(Date.UTC(2001, 12 - 1, 14, 21, 59, 43, 10));
iso8601Date.setTime(iso8601Date.getTime() - 5 * 3600 * 1000);
spaceSeparatedDate = new Date(Date.UTC(2001, 12 - 1, 14, 21, 59, 43, 10));
spaceSeparatedDate.setTime(spaceSeparatedDate.getTime() - 5 * 3600 * 1000);
withDatesToTime = function(input) {
var key, res, val;
res = {};
for (key in input) {
val = input[key];
res[key] = Math.round(val.getTime() / 1000) * 1000;
}
return res;
};
return expect(withDatesToTime(YAML.parse("iso8601: 2001-12-14t21:59:43.10-05:00\nspace seperated: 2001-12-14 21:59:43.10 -05:00"))).toEqual(YAML.parse(YAML.dump(withDatesToTime({
'iso8601': iso8601Date,
'space seperated': spaceSeparatedDate
}))));
});
return it('can be date', function() {
var aDate, withDatesToTime;
aDate = new Date(Date.UTC(1976, 7 - 1, 31, 0, 0, 0, 0));
withDatesToTime = function(input) {
var key, res, val;
return input;
res = {};
for (key in input) {
val = input[key];
res[key] = Math.round(val.getTime() / 1000) * 1000;
}
return res;
};
return expect(withDatesToTime(YAML.parse("date: 1976-07-31"))).toEqual(YAML.parse(YAML.dump(withDatesToTime({
'date': aDate
}))));
});
});
 
describe('Dumped YAML Blocks', function() {
it('can be single ending newline', function() {
return expect(YAML.parse("---\nthis: |\n Foo\n Bar")).toEqual(YAML.parse(YAML.dump({
'this': "Foo\nBar\n"
})));
});
it('can be single ending newline with \'+\' indicator', function() {
return expect(YAML.parse("normal: |\n extra new lines not kept\n\npreserving: |+\n extra new lines are kept\n\n\ndummy: value")).toEqual(YAML.parse(YAML.dump({
'normal': "extra new lines not kept\n",
'preserving': "extra new lines are kept\n\n\n",
'dummy': 'value'
})));
});
it('can be multi-line block handling trailing newlines in function of \'+\', \'-\' indicators', function() {
return expect(YAML.parse("clipped: |\n This has one newline.\n\n\n\nsame as \"clipped\" above: \"This has one newline.\\n\"\n\nstripped: |-\n This has no newline.\n\n\n\nsame as \"stripped\" above: \"This has no newline.\"\n\nkept: |+\n This has four newlines.\n\n\n\nsame as \"kept\" above: \"This has four newlines.\\n\\n\\n\\n\"")).toEqual(YAML.parse(YAML.dump({
'clipped': "This has one newline.\n",
'same as "clipped" above': "This has one newline.\n",
'stripped': 'This has no newline.',
'same as "stripped" above': 'This has no newline.',
'kept': "This has four newlines.\n\n\n\n",
'same as "kept" above': "This has four newlines.\n\n\n\n"
})));
});
it('can be folded block in a sequence', function() {
return expect(YAML.parse("---\n- apple\n- banana\n- >\n can't you see\n the beauty of yaml?\n hmm\n- dog")).toEqual(YAML.parse(YAML.dump(['apple', 'banana', "can't you see the beauty of yaml? hmm\n", 'dog'])));
});
it('can be folded block as a mapping value', function() {
return expect(YAML.parse("---\nquote: >\n Mark McGwire's\n year was crippled\n by a knee injury.\nsource: espn")).toEqual(YAML.parse(YAML.dump({
'quote': "Mark McGwire's year was crippled by a knee injury.\n",
'source': 'espn'
})));
});
return it('can be folded block handling trailing newlines in function of \'+\', \'-\' indicators', function() {
return expect(YAML.parse("clipped: >\n This has one newline.\n\n\n\nsame as \"clipped\" above: \"This has one newline.\\n\"\n\nstripped: >-\n This has no newline.\n\n\n\nsame as \"stripped\" above: \"This has no newline.\"\n\nkept: >+\n This has four newlines.\n\n\n\nsame as \"kept\" above: \"This has four newlines.\\n\\n\\n\\n\"")).toEqual(YAML.parse(YAML.dump({
'clipped': "This has one newline.\n",
'same as "clipped" above': "This has one newline.\n",
'stripped': 'This has no newline.',
'same as "stripped" above': 'This has no newline.',
'kept': "This has four newlines.\n\n\n\n",
'same as "kept" above': "This has four newlines.\n\n\n\n"
})));
});
});
 
describe('Dumped YAML Comments', function() {
it('can begin the document', function() {
return expect(YAML.parse("# This is a comment\nhello: world")).toEqual(YAML.parse(YAML.dump({
hello: 'world'
})));
});
it('can finish a line', function() {
return expect(YAML.parse("hello: world # This is a comment")).toEqual(YAML.parse(YAML.dump({
hello: 'world'
})));
});
return it('can end the document', function() {
return expect(YAML.parse("hello: world\n# This is a comment")).toEqual(YAML.parse(YAML.dump({
hello: 'world'
})));
});
});
 
describe('Dumped YAML Aliases and Anchors', function() {
it('can be simple alias', function() {
return expect(YAML.parse("- &showell Steve\n- Clark\n- Brian\n- Oren\n- *showell")).toEqual(YAML.parse(YAML.dump(['Steve', 'Clark', 'Brian', 'Oren', 'Steve'])));
});
return it('can be alias of a mapping', function() {
return expect(YAML.parse("- &hello\n Meat: pork\n Starch: potato\n- banana\n- *hello")).toEqual(YAML.parse(YAML.dump([
{
Meat: 'pork',
Starch: 'potato'
}, 'banana', {
Meat: 'pork',
Starch: 'potato'
}
])));
});
});
 
describe('Dumped YAML Documents', function() {
it('can have YAML header', function() {
return expect(YAML.parse("--- %YAML:1.0\nfoo: 1\nbar: 2")).toEqual(YAML.parse(YAML.dump({
foo: 1,
bar: 2
})));
});
it('can have leading document separator', function() {
return expect(YAML.parse("---\n- foo: 1\n bar: 2")).toEqual(YAML.parse(YAML.dump([
{
foo: 1,
bar: 2
}
])));
});
return it('can have multiple document separators in block', function() {
return expect(YAML.parse("foo: |\n ---\n foo: bar\n ---\n yo: baz\nbar: |\n fooness")).toEqual(YAML.parse(YAML.dump({
foo: "---\nfoo: bar\n---\nyo: baz\n",
bar: "fooness\n"
})));
});
});
 
url = typeof document !== "undefined" && document !== null ? (ref = document.location) != null ? ref.href : void 0 : void 0;
 
if (!(url != null) || url.indexOf('file://') === -1) {
examplePath = 'spec/example.yml';
if (typeof __dirname !== "undefined" && __dirname !== null) {
examplePath = __dirname + '/example.yml';
}
describe('YAML loading', function() {
it('can be done synchronously', function() {
return expect(YAML.load(examplePath)).toEqual({
"this": 'is',
a: ['YAML', 'example']
});
});
return it('can be done asynchronously', function(done) {
return YAML.load(examplePath, function(result) {
expect(result).toEqual({
"this": 'is',
a: ['YAML', 'example']
});
return done();
});
});
});
}
/bower_components/yaml.js/test/spec/example.yml
@@ -0,0 +1,4 @@
this: is
a:
- YAML
- example