psych 1.1.0

data/test/psych/json/test_stream.rb

@@ -0,0 +1,109 @@
+require 'psych/helper'
+
+module Psych
+  module JSON
+    class TestStream < TestCase
+      def setup
+        @io     = StringIO.new
+        @stream = Psych::JSON::Stream.new(@io)
+        @stream.start
+      end
+
+      def test_explicit_documents
+        @io     = StringIO.new
+        @stream = Psych::JSON::Stream.new(@io)
+        @stream.start
+
+        @stream.push({ 'foo' => 'bar' })
+
+        assert !@stream.finished?, 'stream not finished'
+        @stream.finish
+        assert @stream.finished?, 'stream finished'
+
+        assert_match(/^---/, @io.string)
+        assert_match(/\.\.\.$/, @io.string)
+      end
+
+      def test_null
+        @stream.push(nil)
+        assert_match(/^--- null/, @io.string)
+      end
+
+      def test_string
+        @stream.push "foo"
+        assert_match(/(["])foo\1/, @io.string)
+      end
+
+      def test_symbol
+        @stream.push :foo
+        assert_match(/(["])foo\1/, @io.string)
+      end
+
+      def test_int
+        @stream.push 10
+        assert_match(/^--- 10/, @io.string)
+      end
+
+      def test_float
+        @stream.push 1.2
+        assert_match(/^--- 1.2/, @io.string)
+      end
+
+      def test_hash
+        hash = { 'one' => 'two' }
+        @stream.push hash
+
+        json = @io.string
+        assert_match(/}$/, json)
+        assert_match(/^--- \{/, json)
+        assert_match(/["]one['"]/, json)
+        assert_match(/["]two['"]/, json)
+      end
+
+      def test_list_to_json
+        list = %w{ one two }
+        @stream.push list
+
+        json = @io.string
+        assert_match(/]$/, json)
+        assert_match(/^--- \[/, json)
+        assert_match(/["]one["]/, json)
+        assert_match(/["]two["]/, json)
+      end
+
+      class Foo; end
+
+      def test_json_dump_exclude_tag
+        @stream << Foo.new
+        json = @io.string
+        refute_match('Foo', 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
+        @stream << Bar.new
+        json = @io.string
+        refute_match('omg', json)
+      end
+
+      def test_time
+        time = Time.utc(2010, 10, 10)
+        @stream.push({'a' => time })
+        json = @io.string
+        assert_match "{\"a\": \"2010-10-10 00:00:00.000000000Z\"}\n", json
+      end
+
+      def test_datetime
+        time = Time.new(2010, 10, 10).to_datetime
+        @stream.push({'a' => time })
+        json = @io.string
+        assert_match "{\"a\": \"#{time.strftime("%Y-%m-%d %H:%M:%S.%9N %:z")}\"}\n", json
+      end
+    end
+  end
+end

data/test/psych/nodes/test_enumerable.rb

@@ -0,0 +1,43 @@
+require 'psych/helper'
+
+module Psych
+  module Nodes
+    class TestEnumerable < TestCase
+      def test_includes_enumerable
+        yaml = '--- hello'
+        assert_equal 3, Psych.parse_stream(yaml).to_a.length
+      end
+
+      def test_returns_enumerator
+        yaml = '--- hello'
+        assert_equal 3, Psych.parse_stream(yaml).each.map { |x| x }.length
+      end
+
+      def test_scalar
+        assert_equal 3, calls('--- hello').length
+      end
+
+      def test_sequence
+        assert_equal 4, calls("---\n- hello").length
+      end
+
+      def test_mapping
+        assert_equal 5, calls("---\nhello: world").length
+      end
+
+      def test_alias
+        assert_equal 5, calls("--- &yay\n- foo\n- *yay\n").length
+      end
+
+      private
+
+      def calls yaml
+        calls = []
+        Psych.parse_stream(yaml).each do |node|
+          calls << node
+        end
+        calls
+      end
+    end
+  end
+end

data/test/psych/test_alias_and_anchor.rb

@@ -0,0 +1,26 @@
+require 'psych/helper'
+
+module Psych
+ class TestAliasAndAnchor < TestCase
+   def test_mri_compatibility
+     yaml = <<EOYAML
+---
+- &id001 !ruby/object {}
+
+- *id001
+- *id001
+EOYAML
+     result = Psych.load yaml
+     result.each {|el| assert_same(result[0], el) }
+   end
+
+   def test_anchor_alias_round_trip
+     o = Object.new
+     original = [o,o,o]
+
+     yaml = Psych.dump original
+     result = Psych.load yaml
+     result.each {|el| assert_same(result[0], el) }
+   end
+ end
+end

data/test/psych/test_array.rb

@@ -0,0 +1,19 @@
+require 'psych/helper'
+
+module Psych
+  class TestArray < TestCase
+    def setup
+      super
+      @list = [{ :a => 'b' }, 'foo']
+    end
+
+    def test_self_referential
+      @list << @list
+      assert_cycle(@list)
+    end
+
+    def test_cycle
+      assert_cycle(@list)
+    end
+  end
+end

data/test/psych/test_boolean.rb

@@ -0,0 +1,36 @@
+require 'psych/helper'
+
+module Psych
+  ###
+  # Test booleans from YAML spec:
+  # http://yaml.org/type/bool.html
+  class TestBoolean < TestCase
+    %w{ yes Yes YES true True TRUE on On ON }.each do |truth|
+      define_method(:"test_#{truth}") do
+        assert_equal true, Psych.load("--- #{truth}")
+      end
+    end
+
+    %w{ no No NO false False FALSE off Off OFF }.each do |truth|
+      define_method(:"test_#{truth}") do
+        assert_equal false, Psych.load("--- #{truth}")
+      end
+    end
+
+    ###
+    # YAML spec says "y" and "Y" may be used as true, but Syck treats them
+    # as literal strings
+    def test_y
+      assert_equal "y", Psych.load("--- y")
+      assert_equal "Y", Psych.load("--- Y")
+    end
+
+    ###
+    # YAML spec says "n" and "N" may be used as false, but Syck treats them
+    # as literal strings
+    def test_n
+      assert_equal "n", Psych.load("--- n")
+      assert_equal "N", Psych.load("--- N")
+    end
+  end
+end

data/test/psych/test_class.rb

@@ -0,0 +1,17 @@
+require 'psych/helper'
+
+module Psych
+  class TestClass < TestCase
+    def test_cycle
+      assert_raises(::TypeError) do
+        assert_cycle(TestClass)
+      end
+    end
+
+    def test_dump
+      assert_raises(::TypeError) do
+        Psych.dump TestClass
+      end
+    end
+  end
+end

data/test/psych/test_coder.rb

@@ -0,0 +1,184 @@
+require 'psych/helper'
+
+module Psych
+  class TestCoder < TestCase
+    class InitApi
+      attr_accessor :implicit
+      attr_accessor :style
+      attr_accessor :tag
+      attr_accessor :a, :b, :c
+
+      def initialize
+        @a = 1
+        @b = 2
+        @c = 3
+      end
+
+      def init_with coder
+        @a = coder['aa']
+        @b = coder['bb']
+        @implicit = coder.implicit
+        @tag      = coder.tag
+        @style    = coder.style
+      end
+
+      def encode_with coder
+        coder['aa'] = @a
+        coder['bb'] = @b
+      end
+    end
+
+    class TaggingCoder < InitApi
+      def encode_with coder
+        super
+        coder.tag       = coder.tag.sub(/!/, '!hello')
+        coder.implicit  = false
+        coder.style     = Psych::Nodes::Mapping::FLOW
+      end
+    end
+
+    class ScalarCoder
+      def encode_with coder
+        coder.scalar = "foo"
+      end
+    end
+
+    class Represent
+      yaml_tag 'foo'
+      def encode_with coder
+        coder.represent_scalar 'foo', 'bar'
+      end
+    end
+
+    class RepresentWithInit
+      yaml_tag name
+      attr_accessor :str
+
+      def init_with coder
+        @str = coder.scalar
+      end
+
+      def encode_with coder
+        coder.represent_scalar self.class.name, 'bar'
+      end
+    end
+
+    class RepresentWithSeq
+      yaml_tag name
+      attr_accessor :seq
+
+      def init_with coder
+        @seq = coder.seq
+      end
+
+      def encode_with coder
+        coder.represent_seq self.class.name, %w{ foo bar }
+      end
+    end
+
+    class RepresentWithMap
+      yaml_tag name
+      attr_accessor :map
+
+      def init_with coder
+        @map = coder.map
+      end
+
+      def encode_with coder
+        coder.represent_map self.class.name, { 'a' => 'b' }
+      end
+    end
+
+    class RepresentWithObject
+      def encode_with coder
+        coder.represent_object self.class.name, 20
+      end
+    end
+
+    def test_represent_with_object
+      thing = Psych.load(Psych.dump(RepresentWithObject.new))
+      assert_equal 20, thing
+    end
+
+    def test_json_dump_exclude_tag
+      refute_match('TestCoder::InitApi', Psych.to_json(InitApi.new))
+    end
+
+    def test_map_takes_block
+      coder = Psych::Coder.new 'foo'
+      tag = coder.tag
+      style = coder.style
+      coder.map { |map| map.add 'foo', 'bar' }
+      assert_equal 'bar', coder['foo']
+      assert_equal tag, coder.tag
+      assert_equal style, coder.style
+    end
+
+    def test_map_with_tag
+      coder = Psych::Coder.new 'foo'
+      coder.map('hello') { |map| map.add 'foo', 'bar' }
+      assert_equal 'bar', coder['foo']
+      assert_equal 'hello', coder.tag
+    end
+
+    def test_map_with_tag_and_style
+      coder = Psych::Coder.new 'foo'
+      coder.map('hello', 'world') { |map| map.add 'foo', 'bar' }
+      assert_equal 'bar', coder['foo']
+      assert_equal 'hello', coder.tag
+      assert_equal 'world', coder.style
+    end
+
+    def test_represent_map
+      thing = Psych.load(Psych.dump(RepresentWithMap.new))
+      assert_equal({ 'a' => 'b' }, thing.map)
+    end
+
+    def test_represent_sequence
+      thing = Psych.load(Psych.dump(RepresentWithSeq.new))
+      assert_equal %w{ foo bar }, thing.seq
+    end
+
+    def test_represent_with_init
+      thing = Psych.load(Psych.dump(RepresentWithInit.new))
+      assert_equal 'bar', thing.str
+    end
+
+    def test_represent!
+      assert_match(/foo/, Psych.dump(Represent.new))
+      assert_instance_of(Represent, Psych.load(Psych.dump(Represent.new)))
+    end
+
+    def test_scalar_coder
+      foo = Psych.load(Psych.dump(ScalarCoder.new))
+      assert_equal 'foo', foo
+    end
+
+    def test_load_dumped_tagging
+      foo = InitApi.new
+      bar = Psych.load(Psych.dump(foo))
+      assert_equal false, bar.implicit
+      assert_equal "!ruby/object:Psych::TestCoder::InitApi", bar.tag
+      assert_equal Psych::Nodes::Mapping::BLOCK, bar.style
+    end
+
+    def test_dump_with_tag
+      foo = TaggingCoder.new
+      assert_match(/hello/, Psych.dump(foo))
+      assert_match(/\{aa/, Psych.dump(foo))
+    end
+
+    def test_dump_encode_with
+      foo = InitApi.new
+      assert_match(/aa/, Psych.dump(foo))
+    end
+
+    def test_dump_init_with
+      foo = InitApi.new
+      bar = Psych.load(Psych.dump(foo))
+      assert_equal foo.a, bar.a
+      assert_equal foo.b, bar.b
+      assert_nil bar.c
+    end
+  end
+end

data/test/psych/test_date_time.rb

@@ -0,0 +1,17 @@
+require 'psych/helper'
+require 'date'
+
+module Psych
+  class TestDateTime < TestCase
+    def test_string_tag
+      dt = DateTime.now
+      yaml = Psych.dump dt
+      assert_match(/DateTime/, yaml)
+    end
+
+    def test_round_trip
+      dt = DateTime.now
+      assert_cycle dt
+    end
+  end
+end