denet-node-server/node_modules/yamljs/test/spec/YamlSpec.coffee

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()