psych-shopifork 2.0.0

data/test/psych/test_safe_load.rb

@@ -0,0 +1,97 @@
+require 'psych/helper'
+
+module Psych
+  class TestSafeLoad < TestCase
+    class Foo; end
+
+    [1, 2.2, {}, [], "foo"].each do |obj|
+      define_method(:"test_basic_#{obj.class}") do
+        assert_safe_cycle obj
+      end
+    end
+
+    def test_no_recursion
+      x = []
+      x << x
+      assert_raises(Psych::BadAlias) do
+        Psych.safe_load Psych.dump(x)
+      end
+    end
+
+    def test_explicit_recursion
+      x = []
+      x << x
+      assert_equal(x, Psych.safe_load(Psych.dump(x), [], [], true))
+    end
+
+    def test_symbol_whitelist
+      yml = Psych.dump :foo
+      assert_raises(Psych::DisallowedClass) do
+        Psych.safe_load yml
+      end
+      assert_equal(:foo, Psych.safe_load(yml, [Symbol], [:foo]))
+    end
+
+    def test_symbol
+      assert_raises(Psych::DisallowedClass) do
+        assert_safe_cycle :foo
+      end
+      assert_raises(Psych::DisallowedClass) do
+        Psych.safe_load '--- !ruby/symbol foo', []
+      end
+      assert_safe_cycle :foo, [Symbol]
+      assert_safe_cycle :foo, %w{ Symbol }
+      assert_equal :foo, Psych.safe_load('--- !ruby/symbol foo', [Symbol])
+    end
+
+    def test_foo
+      assert_raises(Psych::DisallowedClass) do
+        Psych.safe_load '--- !ruby/object:Foo {}', [Foo]
+      end
+      assert_raises(Psych::DisallowedClass) do
+        assert_safe_cycle Foo.new
+      end
+      assert_kind_of(Foo, Psych.safe_load(Psych.dump(Foo.new), [Foo]))
+    end
+
+    X = Struct.new(:x)
+    def test_struct_depends_on_sym
+      assert_safe_cycle(X.new, [X, Symbol])
+      assert_raises(Psych::DisallowedClass) do
+        cycle X.new, [X]
+      end
+    end
+
+    def test_anon_struct
+      assert Psych.safe_load(<<-eoyml, [Struct, Symbol])
+--- !ruby/struct
+  foo: bar
+                      eoyml
+
+      assert_raises(Psych::DisallowedClass) do
+        Psych.safe_load(<<-eoyml, [Struct])
+--- !ruby/struct
+  foo: bar
+                      eoyml
+      end
+
+      assert_raises(Psych::DisallowedClass) do
+        Psych.safe_load(<<-eoyml, [Symbol])
+--- !ruby/struct
+  foo: bar
+                      eoyml
+      end
+    end
+
+    private
+
+    def cycle object, whitelist = []
+      Psych.safe_load(Psych.dump(object), whitelist)
+    end
+
+    def assert_safe_cycle object, whitelist = []
+      other = cycle object, whitelist
+      assert_equal object, other
+    end
+  end
+end

data/test/psych/test_scalar.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'helper'
+
+module Psych
+  class TestScalar < TestCase
+    def test_utf_8
+      assert_equal "日本語", Psych.load("--- 日本語")
+    end
+  end
+end

data/test/psych/test_scalar_scanner.rb

@@ -0,0 +1,106 @@
+require_relative 'helper'
+require 'date'
+
+module Psych
+  class TestScalarScanner < TestCase
+    attr_reader :ss
+
+    def setup
+      super
+      @ss = Psych::ScalarScanner.new ClassLoader.new
+    end
+
+    def test_scan_time
+      { '2001-12-15T02:59:43.1Z' => Time.utc(2001, 12, 15, 02, 59, 43, 100000),
+        '2001-12-14t21:59:43.10-05:00' => Time.utc(2001, 12, 15, 02, 59, 43, 100000),
+        '2001-12-14 21:59:43.10 -5' => Time.utc(2001, 12, 15, 02, 59, 43, 100000),
+        '2001-12-15 2:59:43.10' => Time.utc(2001, 12, 15, 02, 59, 43, 100000),
+        '2011-02-24 11:17:06 -0800' => Time.utc(2011, 02, 24, 19, 17, 06)
+      }.each do |time_str, time|
+        assert_equal time, @ss.tokenize(time_str)
+      end
+    end
+
+    def test_scan_bad_time
+      [ '2001-12-15T02:59:73.1Z',
+        '2001-12-14t90:59:43.10-05:00',
+        '2001-92-14 21:59:43.10 -5',
+        '2001-12-15 92:59:43.10',
+        '2011-02-24 81:17:06 -0800',
+      ].each do |time_str|
+        assert_equal time_str, @ss.tokenize(time_str)
+      end
+    end
+
+    def test_scan_bad_dates
+      x = '2000-15-01'
+      assert_equal x, @ss.tokenize(x)
+
+      x = '2000-10-51'
+      assert_equal x, @ss.tokenize(x)
+
+      x = '2000-10-32'
+      assert_equal x, @ss.tokenize(x)
+    end
+
+    def test_scan_good_edge_date
+      x = '2000-1-31'
+      assert_equal Date.strptime(x, '%Y-%m-%d'), @ss.tokenize(x)
+    end
+
+    def test_scan_bad_edge_date
+      x = '2000-11-31'
+      assert_equal x, @ss.tokenize(x)
+    end
+
+    def test_scan_date
+      date = '1980-12-16'
+      token = @ss.tokenize date
+      assert_equal 1980, token.year
+      assert_equal 12, token.month
+      assert_equal 16, token.day
+    end
+
+    def test_scan_inf
+      assert_equal(1 / 0.0, ss.tokenize('.inf'))
+    end
+
+    def test_scan_minus_inf
+      assert_equal(-1 / 0.0, ss.tokenize('-.inf'))
+    end
+
+    def test_scan_nan
+      assert ss.tokenize('.nan').nan?
+    end
+
+    def test_scan_null
+      assert_equal nil, ss.tokenize('null')
+      assert_equal nil, ss.tokenize('~')
+      assert_equal nil, ss.tokenize('')
+    end
+
+    def test_scan_symbol
+      assert_equal :foo, ss.tokenize(':foo')
+    end
+
+    def test_scan_sexagesimal_float
+      assert_equal 685230.15, ss.tokenize('190:20:30.15')
+    end
+
+    def test_scan_sexagesimal_int
+      assert_equal 685230, ss.tokenize('190:20:30')
+    end
+
+    def test_scan_float
+      assert_equal 1.2, ss.tokenize('1.2')
+    end
+
+    def test_scan_true
+      assert_equal true, ss.tokenize('true')
+    end
+
+    def test_scan_strings_starting_with_underscores
+      assert_equal "_100", ss.tokenize('_100')
+    end
+  end
+end

data/test/psych/test_serialize_subclasses.rb

@@ -0,0 +1,38 @@
+require_relative 'helper'
+
+module Psych
+  class TestSerializeSubclasses < TestCase
+    class SomeObject
+      def initialize one, two
+        @one = one
+        @two = two
+      end
+
+      def == other
+        @one == other.instance_eval { @one } &&
+          @two == other.instance_eval { @two }
+      end
+    end
+
+    def test_some_object
+      so = SomeObject.new('foo', [1,2,3])
+      assert_equal so, Psych.load(Psych.dump(so))
+    end
+
+    class StructSubclass < Struct.new(:foo)
+      def initialize foo, bar
+        super(foo)
+        @bar = bar
+      end
+
+      def == other
+        super(other) && @bar == other.instance_eval{ @bar }
+      end
+    end
+
+    def test_struct_subclass
+      so = StructSubclass.new('foo', [1,2,3])
+      assert_equal so, Psych.load(Psych.dump(so))
+    end
+  end
+end

data/test/psych/test_set.rb

@@ -0,0 +1,49 @@
+require_relative 'helper'
+
+module Psych
+  class TestSet < TestCase
+    def setup
+      super
+      @set = Psych::Set.new
+      @set['foo'] = 'bar'
+      @set['bar'] = 'baz'
+    end
+
+    def test_dump
+      assert_match(/!set/, Psych.dump(@set))
+    end
+
+    def test_roundtrip
+      assert_cycle(@set)
+    end
+
+    ###
+    # FIXME: Syck should also support !!set as shorthand
+    def test_load_from_yaml
+      loaded = Psych.load(<<-eoyml)
+--- !set
+foo: bar
+bar: baz
+      eoyml
+      assert_equal(@set, loaded)
+    end
+
+    def test_loaded_class
+      assert_instance_of(Psych::Set, Psych.load(Psych.dump(@set)))
+    end
+
+    def test_set_shorthand
+      loaded = Psych.load(<<-eoyml)
+--- !!set
+foo: bar
+bar: baz
+      eoyml
+      assert_instance_of(Psych::Set, loaded)
+    end
+
+    def test_set_self_reference
+      @set['self'] = @set
+      assert_cycle(@set)
+    end
+  end
+end

data/test/psych/test_stream.rb

@@ -0,0 +1,93 @@
+require_relative 'helper'
+
+module Psych
+  class TestStream < TestCase
+    def test_parse_partial
+      rb = Psych.parse("--- foo\n...\n--- `").to_ruby
+      assert_equal 'foo', rb
+    end
+
+    def test_load_partial
+      rb = Psych.load("--- foo\n...\n--- `")
+      assert_equal 'foo', rb
+    end
+
+    def test_parse_stream_yields_documents
+      list = []
+      Psych.parse_stream("--- foo\n...\n--- bar") do |doc|
+        list << doc.to_ruby
+      end
+      assert_equal %w{ foo bar }, list
+    end
+
+    def test_parse_stream_break
+      list = []
+      Psych.parse_stream("--- foo\n...\n--- `") do |doc|
+        list << doc.to_ruby
+        break
+      end
+      assert_equal %w{ foo }, list
+    end
+
+    def test_load_stream_yields_documents
+      list = []
+      Psych.load_stream("--- foo\n...\n--- bar") do |ruby|
+        list << ruby
+      end
+      assert_equal %w{ foo bar }, list
+    end
+
+    def test_load_stream_break
+      list = []
+      Psych.load_stream("--- foo\n...\n--- `") do |ruby|
+        list << ruby
+        break
+      end
+      assert_equal %w{ foo }, list
+    end
+
+    def test_explicit_documents
+      io     = StringIO.new
+      stream = Psych::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_start_takes_block
+      io     = StringIO.new
+      stream = Psych::Stream.new(io)
+      stream.start do |emitter|
+        emitter.push({ 'foo' => 'bar' })
+      end
+
+      assert stream.finished?, 'stream finished'
+      assert_match(/^---/, io.string)
+      assert_match(/\.\.\.$/, io.string)
+    end
+
+    def test_no_backreferences
+      io     = StringIO.new
+      stream = Psych::Stream.new(io)
+      stream.start do |emitter|
+        x = { 'foo' => 'bar' }
+        emitter.push x
+        emitter.push x
+      end
+
+      assert stream.finished?, 'stream finished'
+      assert_match(/^---/, io.string)
+      assert_match(/\.\.\.$/, io.string)
+      assert_equal 2, io.string.scan('---').length
+      assert_equal 2, io.string.scan('...').length
+      assert_equal 2, io.string.scan('foo').length
+      assert_equal 2, io.string.scan('bar').length
+    end
+  end
+end

data/test/psych/test_string.rb

@@ -0,0 +1,153 @@
+require_relative 'helper'
+
+module Psych
+  class TestString < TestCase
+    class X < String
+    end
+
+    class Y < String
+      attr_accessor :val
+    end
+
+    class Z < String
+      def initialize
+        force_encoding Encoding::US_ASCII
+      end
+    end
+
+    def test_doublequotes_when_there_is_a_single
+      yaml = Psych.dump "@123'abc"
+      assert_match(/---\s*"/, yaml)
+    end
+
+    def test_dash_dot
+      assert_cycle '-.'
+      assert_cycle '+.'
+    end
+
+    def test_string_subclass_with_anchor
+      y = Psych.load <<-eoyml
+---
+body:
+  string: &70121654388580 !ruby/string
+    str: ! 'foo'
+  x:
+    body: *70121654388580
+      eoyml
+      assert_equal({"body"=>{"string"=>"foo", "x"=>{"body"=>"foo"}}}, y)
+    end
+
+    def test_self_referential_string
+      y = Psych.load <<-eoyml
+---
+string: &70121654388580 !ruby/string
+  str: ! 'foo'
+  body: *70121654388580
+      eoyml
+
+      assert_equal({"string"=>"foo"}, y)
+      value = y['string']
+      assert_equal value, value.instance_variable_get(:@body)
+    end
+
+    def test_another_subclass_with_attributes
+      y = Psych.load Psych.dump Y.new("foo").tap {|y| y.val = 1}
+      assert_equal "foo", y
+      assert_equal Y, y.class
+      assert_equal 1, y.val
+    end
+
+    def test_backwards_with_syck
+      x = Psych.load "--- !str:#{X.name} foo\n\n"
+      assert_equal X, x.class
+      assert_equal 'foo', x
+    end
+
+    def test_empty_subclass
+      assert_match "!ruby/string:#{X}", Psych.dump(X.new)
+      x = Psych.load Psych.dump X.new
+      assert_equal X, x.class
+    end
+
+    def test_empty_character_subclass
+      assert_match "!ruby/string:#{Z}", Psych.dump(Z.new)
+      x = Psych.load Psych.dump Z.new
+      assert_equal Z, x.class
+    end
+
+    def test_subclass_with_attributes
+      y = Psych.load Psych.dump Y.new.tap {|y| y.val = 1}
+      assert_equal Y, y.class
+      assert_equal 1, y.val
+    end
+
+    def test_string_with_base_60
+      yaml = Psych.dump '01:03:05'
+      assert_match "'01:03:05'", yaml
+      assert_equal '01:03:05', Psych.load(yaml)
+    end
+
+    def test_nonascii_string_as_binary
+      string = "hello \x80 world!"
+      string.force_encoding 'ascii-8bit'
+      yml = Psych.dump string
+      assert_match(/binary/, yml)
+      assert_equal string, Psych.load(yml)
+    end
+
+    def test_binary_string_null
+      string = "\x00"
+      yml = Psych.dump string
+      assert_match(/binary/, yml)
+      assert_equal string, Psych.load(yml)
+    end
+
+    def test_binary_string
+      string = binary_string
+      yml = Psych.dump string
+      assert_match(/binary/, yml)
+      assert_equal string, Psych.load(yml)
+    end
+
+    def test_non_binary_string
+      string = binary_string(0.29)
+      yml = Psych.dump string
+      refute_match(/binary/, yml)
+      assert_equal string, Psych.load(yml)
+    end
+
+    def test_ascii_only_8bit_string
+      string = "abc".encode(Encoding::ASCII_8BIT)
+      yml = Psych.dump string
+      refute_match(/binary/, yml)
+      assert_equal string, Psych.load(yml)
+    end
+
+    def test_string_with_ivars
+      food = "is delicious"
+      ivar = "on rock and roll"
+      food.instance_variable_set(:@we_built_this_city, ivar)
+
+      str = Psych.load Psych.dump food
+      assert_equal ivar, food.instance_variable_get(:@we_built_this_city)
+    end
+
+    def test_binary
+      string = [0, 123,22, 44, 9, 32, 34, 39].pack('C*')
+      assert_cycle string
+    end
+
+    def test_float_confusion
+      assert_cycle '1.'
+    end
+
+    def binary_string percentage = 0.31, length = 100
+      string = ''
+      (percentage * length).to_i.times do |i|
+        string << "\b"
+      end
+      string << 'a' * (length - string.length)
+      string
+    end
+  end
+end