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] = val.getTime() return res expect withDatesToTime(YAML.parse """ iso8601: 2001-12-14t21:59:43.010+05:00 space separated: 2001-12-14 21:59:43.010 -05:00 """) .toEqual withDatesToTime ( 'iso8601': iso8601Date 'space separated': 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] = val.getTime() 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:[]}) it 'can be dumpted empty inline collections', -> 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] = val.getTime() return res expect withDatesToTime(YAML.parse """ iso8601: 2001-12-14t21:59:43.010-05:00 space separated: 2001-12-14 21:59:43.010 +05:00 """) .toEqual YAML.parse YAML.dump withDatesToTime ( 'iso8601': iso8601Date 'space separated': 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] = val.getTime() 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()