psych 2.1.0 → 2.1.1

data/test/psych/test_stream.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: false
-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

@@ -1,227 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: false
-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_string_with_newline
-      assert_equal "1\n2", Psych.load("--- ! '1\n\n  2'\n")
-    end
-
-    def test_no_doublequotes_with_special_characters
-      assert_equal 2, Psych.dump(%Q{<%= ENV["PATH"] %>}).count('"')
-    end
-
-    def test_no_quotes_when_start_with_non_ascii_character
-      yaml = Psych.dump 'Český non-ASCII'.encode(Encoding::UTF_8)
-      assert_match(/---\s*[^"'!]+$/, yaml)
-    end
-
-    def test_doublequotes_when_there_is_a_single
-      str = "@123'abc"
-      yaml = Psych.dump str
-      assert_match /---\s*"/, yaml
-      assert_equal str, Psych.load(yaml)
-    end
-
-    def test_plain_when_shorten_than_line_width_and_no_final_line_break
-      str = "Lorem ipsum"
-      yaml = Psych.dump str, line_width: 12
-      assert_match /---\s*[^>|]+\n/, yaml
-      assert_equal str, Psych.load(yaml)
-    end
-
-    def test_plain_when_shorten_than_line_width_and_with_final_line_break
-      str = "Lorem ipsum\n"
-      yaml = Psych.dump str, line_width: 12
-      assert_match /---\s*[^>|]+\n/, yaml
-      assert_equal str, Psych.load(yaml)
-    end
-
-    def test_folded_when_longer_than_line_width_and_with_final_line_break
-      str = "Lorem ipsum dolor sit\n"
-      yaml = Psych.dump str, line_width: 12
-      assert_match /---\s*>\n(.*\n){2}\Z/, yaml
-      assert_equal str, Psych.load(yaml)
-    end
-
-    # http://yaml.org/spec/1.2/2009-07-21/spec.html#id2593651
-    def test_folded_strip_when_longer_than_line_width_and_no_newlines
-      str = "Lorem ipsum dolor sit amet, consectetur"
-      yaml = Psych.dump str, line_width: 12
-      assert_match /---\s*>-\n(.*\n){3}\Z/, yaml
-      assert_equal str, Psych.load(yaml)
-    end
-
-    def test_literal_when_inner_and_final_line_break
-      [
-        "Lorem ipsum\ndolor\n",
-        "Lorem ipsum\nZolor\n",
-      ].each do |str|
-        yaml = Psych.dump str, line_width: 12
-        assert_match /---\s*\|\n(.*\n){2}\Z/, yaml
-        assert_equal str, Psych.load(yaml)
-      end
-    end
-
-    # http://yaml.org/spec/1.2/2009-07-21/spec.html#id2593651
-    def test_literal_strip_when_inner_line_break_and_no_final_line_break
-      [
-        "Lorem ipsum\ndolor",
-        "Lorem ipsum\nZolor",
-      ].each do |str|
-        yaml = Psych.dump str, line_width: 12
-        assert_match /---\s*\|-\n(.*\n){2}\Z/, yaml
-        assert_equal str, Psych.load(yaml)
-      end
-    end
-
-    def test_cycle_x
-      str = X.new 'abc'
-      assert_cycle str
-    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)
-
-      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

data/test/psych/test_struct.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-class PsychStructWithIvar < Struct.new(:foo)
-  attr_reader :bar
-  def initialize *args
-    super
-    @bar = 'hello'
-  end
-end
-
-module Psych
-  class TestStruct < TestCase
-    class StructSubclass < Struct.new(:foo)
-      def initialize foo, bar
-        super(foo)
-        @bar = bar
-      end
-    end
-
-    def test_self_referential_struct
-      ss = StructSubclass.new(nil, 'foo')
-      ss.foo = ss
-
-      loaded = Psych.load(Psych.dump(ss))
-      assert_instance_of(StructSubclass, loaded.foo)
-
-      assert_equal(ss, loaded)
-    end
-
-    def test_roundtrip
-      thing = PsychStructWithIvar.new('bar')
-      struct = Psych.load(Psych.dump(thing))
-
-      assert_equal 'hello', struct.bar
-      assert_equal 'bar', struct.foo
-    end
-
-    def test_load
-      obj = Psych.load(<<-eoyml)
---- !ruby/struct:PsychStructWithIvar
-:foo: bar
-:@bar: hello
-      eoyml
-
-      assert_equal 'hello', obj.bar
-      assert_equal 'bar', obj.foo
-    end
-  end
-end

data/test/psych/test_symbol.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestSymbol < TestCase
-    def test_cycle_empty
-      assert_cycle :''
-    end
-
-    def test_cycle_colon
-      assert_cycle :':'
-    end
-
-    def test_cycle
-      assert_cycle :a
-    end
-
-    def test_stringy
-      assert_cycle :"1"
-    end
-
-    def test_load_quoted
-      assert_equal :"1", Psych.load("--- :'1'\n")
-    end
-  end
-end

data/test/psych/test_tainted.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: false
-require_relative 'helper'
-
-module Psych
-  class TestStringTainted < TestCase
-    class Tainted < Handler
-      attr_reader :tc
-
-      def initialize tc
-        @tc = tc
-      end
-
-      def start_document version, tags, implicit
-        tags.flatten.each do |tag|
-          assert_taintedness tag
-        end
-      end
-
-      def alias name
-        assert_taintedness name
-      end
-
-      def scalar value, anchor, tag, plain, quoted, style
-        assert_taintedness value
-        assert_taintedness tag if tag
-        assert_taintedness anchor if anchor
-      end
-
-      def start_sequence anchor, tag, implicit, style
-        assert_taintedness tag if tag
-        assert_taintedness anchor if anchor
-      end
-
-      def start_mapping anchor, tag, implicit, style
-        assert_taintedness tag if tag
-        assert_taintedness anchor if anchor
-      end
-
-      def assert_taintedness thing, message = "'#{thing}' should be tainted"
-        tc.assert thing.tainted?, message
-      end
-    end
-
-    class Untainted < Tainted
-      def assert_taintedness thing, message = "'#{thing}' should not be tainted"
-        tc.assert !thing.tainted?, message
-      end
-    end
-
-
-    def setup
-      handler = Tainted.new self
-      @parser = Psych::Parser.new handler
-    end
-
-    def test_tags_are_tainted
-      assert_taintedness "%TAG !yaml! tag:yaml.org,2002:\n---\n!yaml!str \"foo\""
-    end
-
-    def test_alias
-      assert_taintedness  "--- &ponies\n- foo\n- *ponies"
-    end
-
-    def test_scalar
-      assert_taintedness "--- ponies"
-    end
-
-    def test_anchor
-      assert_taintedness "--- &hi ponies"
-    end
-
-    def test_scalar_tag
-      assert_taintedness "--- !str ponies"
-    end
-
-    def test_seq_start_tag
-      assert_taintedness "--- !!seq [ a ]"
-    end
-
-    def test_seq_start_anchor
-      assert_taintedness "--- &zomg [ a ]"
-    end
-
-    def test_seq_mapping_tag
-      assert_taintedness "--- !!map { a: b }"
-    end
-
-    def test_seq_mapping_anchor
-      assert_taintedness "--- &himom { a: b }"
-    end
-
-    def assert_taintedness string
-      @parser.parse string.taint
-    end
-  end
-
-  class TestStringUntainted < TestStringTainted
-    def setup
-      handler = Untainted.new self
-      @parser = Psych::Parser.new handler
-    end
-
-    def assert_taintedness string
-      @parser.parse string
-    end
-  end
-
-  class TestStringIOUntainted < TestStringTainted
-    def setup
-      handler = Untainted.new self
-      @parser = Psych::Parser.new handler
-    end
-
-    def assert_taintedness string
-      @parser.parse StringIO.new(string)
-    end
-  end
-
-  class TestIOTainted < TestStringTainted
-    def assert_taintedness string
-      Tempfile.create(['something', 'yml']) {|t|
-        t.binmode
-        t.write string
-        t.close
-        File.open(t.path, 'r:bom|utf-8') { |f|
-          @parser.parse f
-        }
-      }
-    end
-  end
-end