psych-shopifork 2.0.0

data/test/psych/test_boolean.rb

@@ -0,0 +1,36 @@
+require_relative '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,36 @@
+require_relative 'helper'
+
+module Psych
+  class TestClass < TestCase
+    module Foo
+    end
+
+    def test_cycle_anonymous_class
+      assert_raises(::TypeError) do
+        assert_cycle(Class.new)
+      end
+    end
+
+    def test_cycle_anonymous_module
+      assert_raises(::TypeError) do
+        assert_cycle(Module.new)
+      end
+    end
+
+    def test_cycle
+      assert_cycle(TestClass)
+    end
+
+    def test_dump
+      Psych.dump TestClass
+    end
+
+    def test_cycle_module
+      assert_cycle(Foo)
+    end
+
+    def test_dump_module
+      Psych.dump Foo
+    end
+  end
+end

data/test/psych/test_coder.rb

@@ -0,0 +1,184 @@
+require_relative '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, { "string" => 'a', :symbol => '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({ "string" => 'a', :symbol => '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,25 @@
+require_relative '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
+
+    def test_alias_with_time
+      t    = Time.now
+      h    = {:a => t, :b => t}
+      yaml = Psych.dump h
+      assert_match('&', yaml)
+      assert_match('*', yaml)
+    end
+  end
+end

data/test/psych/test_deprecated.rb

@@ -0,0 +1,214 @@
+require_relative 'helper'
+
+module Psych
+  class TestDeprecated < TestCase
+    def teardown
+      $VERBOSE = @orig_verbose
+      Psych.domain_types.clear
+    end
+
+    class QuickEmitter
+      attr_reader :name
+      attr_reader :value
+
+      def initialize
+        @name  = 'hello!!'
+        @value = 'Friday!'
+      end
+
+      def to_yaml opts = {}
+        Psych.quick_emit object_id, opts do |out|
+          out.map taguri, to_yaml_style do |map|
+            map.add 'name', @name
+            map.add 'value', nil
+          end
+        end
+      end
+    end
+
+    def setup
+      @qe = QuickEmitter.new
+      @orig_verbose, $VERBOSE = $VERBOSE, false
+    end
+
+    def test_quick_emit
+      qe2 = Psych.load @qe.to_yaml
+      assert_equal @qe.name, qe2.name
+      assert_instance_of QuickEmitter, qe2
+      assert_nil qe2.value
+    end
+
+    def test_recursive_quick_emit
+      hash  = { :qe => @qe }
+      hash2 = Psych.load Psych.dump hash
+      qe    = hash2[:qe]
+
+      assert_equal @qe.name, qe.name
+      assert_instance_of QuickEmitter, qe
+      assert_nil qe.value
+    end
+
+    class QuickEmitterEncodeWith
+      attr_reader :name
+      attr_reader :value
+
+      def initialize
+        @name  = 'hello!!'
+        @value = 'Friday!'
+      end
+
+      def encode_with coder
+        coder.map do |map|
+          map.add 'name', @name
+          map.add 'value', nil
+        end
+      end
+
+      def to_yaml opts = {}
+        raise
+      end
+    end
+
+    ###
+    # An object that defines both to_yaml and encode_with should only call
+    # encode_with.
+    def test_recursive_quick_emit_encode_with
+      qeew = QuickEmitterEncodeWith.new
+      hash  = { :qe => qeew }
+      hash2 = Psych.load Psych.dump hash
+      qe    = hash2[:qe]
+
+      assert_equal qeew.name, qe.name
+      assert_instance_of QuickEmitterEncodeWith, qe
+      assert_nil qe.value
+    end
+
+    class YamlInit
+      attr_reader :name
+      attr_reader :value
+
+      def initialize
+        @name  = 'hello!!'
+        @value = 'Friday!'
+      end
+
+      def yaml_initialize tag, vals
+        vals.each { |ivar, val| instance_variable_set "@#{ivar}", 'TGIF!' }
+      end
+    end
+
+    def test_yaml_initialize
+      hash  = { :yi => YamlInit.new }
+      hash2 = Psych.load Psych.dump hash
+      yi    = hash2[:yi]
+
+      assert_equal 'TGIF!', yi.name
+      assert_equal 'TGIF!', yi.value
+      assert_instance_of YamlInit, yi
+    end
+
+    class YamlInitAndInitWith
+      attr_reader :name
+      attr_reader :value
+
+      def initialize
+        @name  = 'shaners'
+        @value = 'Friday!'
+      end
+
+      def init_with coder
+        coder.map.each { |ivar, val| instance_variable_set "@#{ivar}", 'TGIF!' }
+      end
+
+      def yaml_initialize tag, vals
+        raise
+      end
+    end
+
+    ###
+    # An object that implements both yaml_initialize and init_with should not
+    # receive the yaml_initialize call.
+    def test_yaml_initialize_and_init_with
+      hash  = { :yi => YamlInitAndInitWith.new }
+      hash2 = Psych.load Psych.dump hash
+      yi    = hash2[:yi]
+
+      assert_equal 'TGIF!', yi.name
+      assert_equal 'TGIF!', yi.value
+      assert_instance_of YamlInitAndInitWith, yi
+    end
+
+    def test_coder_scalar
+      coder = Psych::Coder.new 'foo'
+      coder.scalar('tag', 'some string', :plain)
+      assert_equal 'tag', coder.tag
+      assert_equal 'some string', coder.scalar
+      assert_equal :scalar, coder.type
+    end
+
+    class YamlAs
+      TestCase.suppress_warning do
+        psych_yaml_as 'helloworld' # this should be yaml_as but to avoid syck
+      end
+    end
+
+    def test_yaml_as
+      assert_match(/helloworld/, Psych.dump(YamlAs.new))
+    end
+
+    def test_ruby_type
+      types = []
+      appender = lambda { |*args| types << args }
+
+      Psych.add_ruby_type('foo', &appender)
+      Psych.load <<-eoyml
+- !ruby.yaml.org,2002/foo bar
+      eoyml
+
+      assert_equal [["tag:ruby.yaml.org,2002:foo", "bar"]], types
+    end
+
+    def test_detect_implicit
+      assert_equal '', Psych.detect_implicit(nil)
+      assert_equal '', Psych.detect_implicit(Object.new)
+      assert_equal '', Psych.detect_implicit(1.2)
+      assert_equal 'null', Psych.detect_implicit('')
+      assert_equal 'string', Psych.detect_implicit('foo')
+    end
+
+    def test_private_type
+      types = []
+      Psych.add_private_type('foo') { |*args| types << args }
+      Psych.load <<-eoyml
+- !x-private:foo bar
+      eoyml
+
+      assert_equal [["x-private:foo", "bar"]], types
+    end
+
+    def test_tagurize
+      assert_nil Psych.tagurize nil
+      assert_equal Psych, Psych.tagurize(Psych)
+      assert_equal 'tag:yaml.org,2002:foo', Psych.tagurize('foo')
+    end
+
+    def test_read_type_class
+      things = Psych.read_type_class 'tag:yaml.org,2002:int:Psych::TestDeprecated::QuickEmitter', Object
+      assert_equal 'int', things.first
+      assert_equal Psych::TestDeprecated::QuickEmitter, things.last
+    end
+
+    def test_read_type_class_no_class
+      things = Psych.read_type_class 'tag:yaml.org,2002:int', Object
+      assert_equal 'int', things.first
+      assert_equal Object, things.last
+    end
+
+    def test_object_maker
+      thing = Psych.object_maker(Object, { 'a' => 'b', 'c' => 'd' })
+      assert_instance_of(Object, thing)
+      assert_equal 'b', thing.instance_variable_get(:@a)
+      assert_equal 'd', thing.instance_variable_get(:@c)
+    end
+  end
+end