psych 1.1.0

data/test/psych/test_engine_manager.rb

@@ -0,0 +1,57 @@
+require 'psych/helper'
+require 'yaml'
+
+module Psych
+ class TestEngineManager < TestCase
+   def teardown
+     YAML::ENGINE.yamler = 'syck'
+   end
+
+   def test_bad_engine
+     assert_raises(ArgumentError) do
+       YAML::ENGINE.yamler = 'foooo'
+     end
+   end
+
+   def test_set_psych
+     YAML::ENGINE.yamler = 'psych'
+     assert_equal Psych, YAML
+     assert_equal 'psych', YAML::ENGINE.yamler
+   end
+
+   def test_set_syck
+     YAML::ENGINE.yamler = 'syck'
+     assert_equal Syck, YAML
+     assert_equal 'syck', YAML::ENGINE.yamler
+   end
+
+   A = Struct.new(:name)
+
+   def test_dump_types
+     YAML::ENGINE.yamler = 'psych'
+
+     assert_to_yaml ::Object.new
+     assert_to_yaml Time.now
+     assert_to_yaml Date.today
+     assert_to_yaml('a' => 'b')
+     assert_to_yaml A.new('foo')
+     assert_to_yaml %w{a b}
+     assert_to_yaml Exception.new('foo')
+     assert_to_yaml "hello!"
+     assert_to_yaml :fooo
+     assert_to_yaml(1..10)
+     assert_to_yaml(/hello!~/)
+     assert_to_yaml 1
+     assert_to_yaml 1.2
+     assert_to_yaml Rational(1, 2)
+     assert_to_yaml Complex(1, 2)
+     assert_to_yaml true
+     assert_to_yaml false
+     assert_to_yaml nil
+   end
+
+   def assert_to_yaml obj
+     assert obj.to_yaml, "#{obj.class} to_yaml works"
+   end
+ end
+end

data/test/psych/test_exception.rb

@@ -0,0 +1,39 @@
+require 'psych/helper'
+
+module Psych
+  class TestException < TestCase
+    class Wups < Exception
+      attr_reader :foo, :bar
+      def initialize *args
+        super
+        @foo = 1
+        @bar = 2
+      end
+    end
+
+    def setup
+      super
+      @wups = Wups.new
+    end
+
+    def test_convert
+      w = Psych.load(Psych.dump(@wups))
+      assert_equal @wups, w
+      assert_equal 1, w.foo
+      assert_equal 2, w.bar
+    end
+
+    def test_to_yaml_properties
+      class << @wups
+        def to_yaml_properties
+          [:@foo]
+        end
+      end
+
+      w = Psych.load(Psych.dump(@wups))
+      assert_equal @wups, w
+      assert_equal 1, w.foo
+      assert_nil w.bar
+    end
+  end
+end

data/test/psych/test_hash.rb

@@ -0,0 +1,30 @@
+require 'psych/helper'
+
+module Psych
+  class TestHash < TestCase
+    def setup
+      super
+      @hash = { :a => 'b' }
+    end
+
+    def test_self_referential
+      @hash['self'] = @hash
+      assert_cycle(@hash)
+    end
+
+    def test_cycles
+      assert_cycle(@hash)
+    end
+
+    def test_ref_append
+      hash = Psych.load(<<-eoyml)
+---
+foo: &foo
+  hello: world
+bar:
+  <<: *foo
+eoyml
+      assert_equal({"foo"=>{"hello"=>"world"}, "bar"=>{"hello"=>"world"}}, hash)
+    end
+  end
+end

data/test/psych/test_json_tree.rb

@@ -0,0 +1,65 @@
+require 'psych/helper'
+
+module Psych
+  class TestJSONTree < TestCase
+    def test_string
+      assert_match(/"foo"/, Psych.to_json("foo"))
+    end
+
+    def test_symbol
+      assert_match(/"foo"/, Psych.to_json(:foo))
+    end
+
+    def test_nil
+      assert_match(/^null/, Psych.to_json(nil))
+    end
+
+    def test_int
+      assert_match(/^10/, Psych.to_json(10))
+    end
+
+    def test_float
+      assert_match(/^1.2/, Psych.to_json(1.2))
+    end
+
+    def test_hash
+      hash = { 'one' => 'two' }
+      json = Psych.to_json(hash)
+      assert_match(/}$/, json)
+      assert_match(/^\{/, json)
+      assert_match(/['"]one['"]/, json)
+      assert_match(/['"]two['"]/, json)
+    end
+
+    class Bar
+      def encode_with coder
+        coder.represent_seq 'omg', %w{ a b c }
+      end
+    end
+
+    def test_json_list_dump_exclude_tag
+      json = Psych.to_json Bar.new
+      refute_match('omg', json)
+    end
+
+    def test_list_to_json
+      list = %w{ one two }
+      json = Psych.to_json(list)
+      assert_match(/]$/, json)
+      assert_match(/^\[/, json)
+      assert_match(/"one"/, json)
+      assert_match(/"two"/, json)
+    end
+
+    def test_time
+      time = Time.utc(2010, 10, 10)
+      assert_equal "{\"a\": \"2010-10-10 00:00:00.000000000Z\"}\n",
+Psych.to_json({'a' => time })
+    end
+
+    def test_datetime
+      time = Time.new(2010, 10, 10).to_datetime
+      assert_equal "{\"a\": \"#{time.strftime("%Y-%m-%d %H:%M:%S.%9N %:z")}\"}\n", Psych.to_json({'a' => time })
+    end
+  end
+end

data/test/psych/test_merge_keys.rb

@@ -0,0 +1,72 @@
+require 'psych/helper'
+
+module Psych
+  class TestMergeKeys < TestCase
+    # [ruby-core:34679]
+    def test_merge_key
+      yaml = <<-eoyml
+foo: &foo
+  hello: world
+bar:
+  << : *foo
+  baz: boo
+      eoyml
+
+      hash = {
+        "foo" => { "hello" => "world"},
+        "bar" => { "hello" => "world", "baz" => "boo" } }
+      assert_equal hash, Psych.load(yaml)
+    end
+
+    def test_multiple_maps
+      yaml = <<-eoyaml
+---
+- &CENTER { x: 1, y: 2 }
+- &LEFT { x: 0, y: 2 }
+- &BIG { r: 10 }
+- &SMALL { r: 1 }
+
+# All the following maps are equal:
+
+- # Merge multiple maps
+  << : [ *CENTER, *BIG ]
+  label: center/big
+      eoyaml
+
+      hash = {
+        'x' => 1,
+        'y' => 2,
+        'r' => 10,
+        'label' => 'center/big'
+      }
+
+      assert_equal hash, Psych.load(yaml)[4]
+    end
+
+    def test_override
+      yaml = <<-eoyaml
+---
+- &CENTER { x: 1, y: 2 }
+- &LEFT { x: 0, y: 2 }
+- &BIG { r: 10 }
+- &SMALL { r: 1 }
+
+# All the following maps are equal:
+
+- # Override
+  << : [ *BIG, *LEFT, *SMALL ]
+  x: 1
+  label: center/big
+      eoyaml
+
+      hash = {
+        'x' => 1,
+        'y' => 2,
+        'r' => 10,
+        'label' => 'center/big'
+      }
+
+      assert_equal hash, Psych.load(yaml)[4]
+    end
+  end
+end

data/test/psych/test_nil.rb

@@ -0,0 +1,18 @@
+require 'psych/helper'
+
+module Psych
+  class TestNil < TestCase
+    def test_nil
+      yml = Psych.dump nil
+      assert_equal "--- \n...\n", yml
+      assert_equal nil, Psych.load(yml)
+    end
+
+    def test_array_nil
+      yml = Psych.dump [nil]
+      assert_equal "---\n- \n", yml
+      assert_equal [nil], Psych.load(yml)
+    end
+
+  end
+end

data/test/psych/test_null.rb

@@ -0,0 +1,19 @@
+require 'psych/helper'
+
+module Psych
+  ###
+  # Test null from YAML spec:
+  # http://yaml.org/type/null.html
+  class TestNull < TestCase
+    def test_null_list
+      assert_equal [nil] * 5, Psych.load(<<-eoyml)
+---
+- ~
+- null
+- 
+- Null
+- NULL
+      eoyml
+    end
+  end
+end

data/test/psych/test_object.rb

@@ -0,0 +1,27 @@
+require 'psych/helper'
+
+module Psych
+  class Tagged
+    yaml_tag '!foo'
+
+    attr_accessor :baz
+
+    def initialize
+      @baz = 'bar'
+    end
+  end
+
+  class TestObject < TestCase
+    def test_dump_with_tag
+      tag = Tagged.new
+      assert_match('foo', Psych.dump(tag))
+    end
+
+    def test_tag_round_trip
+      tag   = Tagged.new
+      tag2  = Psych.load(Psych.dump(tag))
+      assert_equal tag.baz, tag2.baz
+      assert_instance_of(Tagged, tag2)
+    end
+  end
+end

data/test/psych/test_omap.rb

@@ -0,0 +1,68 @@
+require 'psych/helper'
+
+module Psych
+  class TestOmap < TestCase
+    def test_self_referential
+      map = Psych::Omap.new
+      map['foo'] = 'bar'
+      map['self'] = map
+      assert_equal(map, Psych.load(Psych.dump(map)))
+    end
+
+    def test_keys
+      map = Psych::Omap.new
+      map['foo'] = 'bar'
+      assert_equal 'bar', map['foo']
+    end
+
+    def test_order
+      map = Psych::Omap.new
+      map['a'] = 'b'
+      map['b'] = 'c'
+      assert_equal [%w{a b}, %w{b c}], map.to_a
+    end
+
+    def test_square
+      list = [["a", "b"], ["b", "c"]]
+      map = Psych::Omap[*list.flatten]
+      assert_equal list, map.to_a
+      assert_equal 'b', map['a']
+      assert_equal 'c', map['b']
+    end
+
+    def test_dump
+      map = Psych::Omap['a', 'b', 'c', 'd']
+      yaml = Psych.dump(map)
+      assert_match('!omap', yaml)
+      assert_match('- a: b', yaml)
+      assert_match('- c: d', yaml)
+    end
+
+    def test_round_trip
+      list = [["a", "b"], ["b", "c"]]
+      map = Psych::Omap[*list.flatten]
+      assert_cycle(map)
+    end
+
+    def test_load
+      list = [["a", "b"], ["c", "d"]]
+      map = Psych.load(<<-eoyml)
+--- !omap
+- a: b
+- c: d
+      eoyml
+      assert_equal list, map.to_a
+    end
+
+    # NOTE: This test will not work with Syck
+    def test_load_shorthand
+      list = [["a", "b"], ["c", "d"]]
+      map = Psych.load(<<-eoyml)
+--- !!omap
+- a: b
+- c: d
+      eoyml
+      assert_equal list, map.to_a
+    end
+  end
+end

data/test/psych/test_parser.rb

@@ -0,0 +1,297 @@
+# coding: utf-8
+
+require 'psych/helper'
+
+module Psych
+  class TestParser < TestCase
+    class EventCatcher < Handler
+      attr_accessor :parser
+      attr_reader :calls, :marks
+      def initialize
+        @parser = nil
+        @calls  = []
+        @marks  = []
+      end
+
+      (Handler.instance_methods(true) -
+       Object.instance_methods).each do |m|
+        class_eval %{
+          def #{m} *args
+            super
+            @marks << @parser.mark if @parser
+            @calls << [:#{m}, args]
+          end
+        }
+      end
+    end
+
+    def setup
+      super
+      @handler        = EventCatcher.new
+      @parser         = Psych::Parser.new @handler
+      @handler.parser = @parser
+    end
+
+    def test_line_numbers
+      assert_equal 0, @parser.mark.line
+      @parser.parse "---\n- hello\n- world"
+      line_calls = @handler.marks.map(&:line).zip(@handler.calls.map(&:first))
+      assert_equal [[0, :start_stream],
+                    [0, :start_document],
+                    [1, :start_sequence],
+                    [2, :scalar],
+                    [3, :scalar],
+                    [3, :end_sequence],
+                    [3, :end_document],
+                    [3, :end_stream]], line_calls
+
+      assert_equal 3, @parser.mark.line
+    end
+
+    def test_column_numbers
+      assert_equal 0, @parser.mark.column
+      @parser.parse "---\n- hello\n- world"
+      col_calls = @handler.marks.map(&:column).zip(@handler.calls.map(&:first))
+      assert_equal [[0, :start_stream],
+                    [3, :start_document],
+                    [1, :start_sequence],
+                    [0, :scalar],
+                    [0, :scalar],
+                    [0, :end_sequence],
+                    [0, :end_document],
+                    [0, :end_stream]], col_calls
+
+      assert_equal 0, @parser.mark.column
+    end
+
+    def test_index_numbers
+      assert_equal 0, @parser.mark.index
+      @parser.parse "---\n- hello\n- world"
+      idx_calls = @handler.marks.map(&:index).zip(@handler.calls.map(&:first))
+      assert_equal [[0, :start_stream],
+                    [3, :start_document],
+                    [5, :start_sequence],
+                    [12, :scalar],
+                    [19, :scalar],
+                    [19, :end_sequence],
+                    [19, :end_document],
+                    [19, :end_stream]], idx_calls
+
+      assert_equal 19, @parser.mark.index
+    end
+
+    def test_set_encoding_twice
+      @parser.external_encoding = Psych::Parser::UTF16LE
+
+      e = assert_raises(Psych::Exception) do
+        @parser.external_encoding = Psych::Parser::UTF16LE
+      end
+      assert_equal "don't set the encoding twice!", e.message
+    end
+
+    def test_bom
+      tadpole = 'おたまじゃくし'
+
+      # BOM + text
+      yml = "\uFEFF#{tadpole}".encode('UTF-16LE')
+      @parser.parse yml
+      assert_equal tadpole, @parser.handler.calls[2][1].first
+    end
+
+    def test_external_encoding
+      tadpole = 'おたまじゃくし'
+
+      @parser.external_encoding = Psych::Parser::UTF16LE
+      @parser.parse tadpole.encode 'UTF-16LE'
+      assert_equal tadpole, @parser.handler.calls[2][1].first
+    end
+
+    def test_bogus_io
+      o = Object.new
+      def o.read len; self end
+
+      assert_raises(TypeError) do
+        @parser.parse o
+      end
+    end
+
+    def test_parse_io
+      @parser.parse StringIO.new("--- a")
+      assert_called :start_stream
+      assert_called :scalar
+      assert_called :end_stream
+    end
+
+    def test_syntax_error
+      assert_raises(Psych::SyntaxError) do
+        @parser.parse("---\n\"foo\"\n\"bar\"\n")
+      end
+    end
+
+    def test_syntax_error_twice
+      assert_raises(Psych::SyntaxError) do
+        @parser.parse("---\n\"foo\"\n\"bar\"\n")
+      end
+
+      assert_raises(Psych::SyntaxError) do
+        @parser.parse("---\n\"foo\"\n\"bar\"\n")
+      end
+    end
+
+    def test_syntax_error_has_path_for_string
+      e = assert_raises(Psych::SyntaxError) do
+        @parser.parse("---\n\"foo\"\n\"bar\"\n")
+      end
+      assert_match '(<unknown>):', e.message
+    end
+
+    def test_syntax_error_has_path_for_io
+      io = StringIO.new "---\n\"foo\"\n\"bar\"\n"
+      def io.path; "hello!"; end
+
+      e = assert_raises(Psych::SyntaxError) do
+        @parser.parse(io)
+      end
+      assert_match "(#{io.path}):", e.message
+    end
+
+    def test_mapping_end
+      @parser.parse("---\n!!map { key: value }")
+      assert_called :end_mapping
+    end
+
+    def test_mapping_tag
+      @parser.parse("---\n!!map { key: value }")
+      assert_called :start_mapping, ["tag:yaml.org,2002:map", false, Nodes::Mapping::FLOW]
+    end
+
+    def test_mapping_anchor
+      @parser.parse("---\n&A { key: value }")
+      assert_called :start_mapping, ['A', true, Nodes::Mapping::FLOW]
+    end
+
+    def test_mapping_block
+      @parser.parse("---\n  key: value")
+      assert_called :start_mapping, [true, Nodes::Mapping::BLOCK]
+    end
+
+    def test_mapping_start
+      @parser.parse("---\n{ key: value }")
+      assert_called :start_mapping
+      assert_called :start_mapping, [true, Nodes::Mapping::FLOW]
+    end
+
+    def test_sequence_end
+      @parser.parse("---\n&A [1, 2]")
+      assert_called :end_sequence
+    end
+
+    def test_sequence_start_anchor
+      @parser.parse("---\n&A [1, 2]")
+      assert_called :start_sequence, ["A", true, Nodes::Sequence::FLOW]
+    end
+
+    def test_sequence_start_tag
+      @parser.parse("---\n!!seq [1, 2]")
+      assert_called :start_sequence, ["tag:yaml.org,2002:seq", false, Nodes::Sequence::FLOW]
+    end
+
+    def test_sequence_start_flow
+      @parser.parse("---\n[1, 2]")
+      assert_called :start_sequence, [true, Nodes::Sequence::FLOW]
+    end
+
+    def test_sequence_start_block
+      @parser.parse("---\n  - 1\n  - 2")
+      assert_called :start_sequence, [true, Nodes::Sequence::BLOCK]
+    end
+
+    def test_literal_scalar
+      @parser.parse(<<-eoyml)
+%YAML 1.1
+---
+"literal\n\
+        \ttext\n"
+      eoyml
+      assert_called :scalar, ['literal text ', false, true, Nodes::Scalar::DOUBLE_QUOTED]
+    end
+
+    def test_scalar
+      @parser.parse("--- foo\n")
+      assert_called :scalar, ['foo', true, false, Nodes::Scalar::PLAIN]
+    end
+
+    def test_scalar_with_tag
+      @parser.parse("---\n!!str foo\n")
+      assert_called :scalar, ['foo', 'tag:yaml.org,2002:str', false, false, Nodes::Scalar::PLAIN]
+    end
+
+    def test_scalar_with_anchor
+      @parser.parse("---\n&A foo\n")
+      assert_called :scalar, ['foo', 'A', true, false, Nodes::Scalar::PLAIN]
+    end
+
+    def test_scalar_plain_implicit
+      @parser.parse("---\n&A foo\n")
+      assert_called :scalar, ['foo', 'A', true, false, Nodes::Scalar::PLAIN]
+    end
+
+    def test_alias
+      @parser.parse(<<-eoyml)
+%YAML 1.1
+---
+!!seq [
+  !!str "Without properties",
+  &A !!str "Anchored",
+  !!str "Tagged",
+  *A,
+  !!str "",
+]
+      eoyml
+      assert_called :alias, ['A']
+    end
+
+    def test_end_stream
+      @parser.parse("--- foo\n")
+      assert_called :end_stream
+    end
+
+    def test_start_stream
+      @parser.parse("--- foo\n")
+      assert_called :start_stream
+    end
+
+    def test_end_document_implicit
+      @parser.parse("\"foo\"\n")
+      assert_called :end_document, [true]
+    end
+
+    def test_end_document_explicit
+      @parser.parse("\"foo\"\n...")
+      assert_called :end_document, [false]
+    end
+
+    def test_start_document_version
+      @parser.parse("%YAML 1.1\n---\n\"foo\"\n")
+      assert_called :start_document, [[1,1], [], false]
+    end
+
+    def test_start_document_tag
+      @parser.parse("%TAG !yaml! tag:yaml.org,2002\n---\n!yaml!str \"foo\"\n")
+      assert_called :start_document, [[], [['!yaml!', 'tag:yaml.org,2002']], false]
+    end
+
+    def assert_called call, with = nil, parser = @parser
+      if with
+        call = parser.handler.calls.find { |x|
+          x.first == call && x.last.compact == with
+        }
+        assert(call,
+          "#{[call,with].inspect} not in #{parser.handler.calls.inspect}"
+        )
+      else
+        assert parser.handler.calls.any? { |x| x.first == call }
+      end
+    end
+  end
+end