psych 2.0.12 → 5.2.3

data/test/psych/test_parser.rb

@@ -1,339 +0,0 @@
-# coding: utf-8
-
-require_relative '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_ast_roundtrip
-      parser = Psych.parser
-      parser.parse('null')
-      ast = parser.handler.root
-      assert_match(/^null/, ast.yaml)
-    end
-
-    def test_exception_memory_leak
-      yaml = <<-eoyaml
-%YAML 1.1
-%TAG ! tag:tenderlovemaking.com,2009:
---- &ponies
-- first element
-- *ponies
-- foo: bar
-...
-      eoyaml
-
-      [:start_stream, :start_document, :end_document, :alias, :scalar,
-       :start_sequence, :end_sequence, :start_mapping, :end_mapping,
-       :end_stream].each do |method|
-
-        klass = Class.new(Psych::Handler) do
-          define_method(method) do |*args|
-            raise
-          end
-        end
-
-        parser = Psych::Parser.new klass.new
-        2.times {
-          assert_raises(RuntimeError, method.to_s) do
-            parser.parse yaml
-          end
-        }
-      end
-    end
-
-    def test_multiparse
-      3.times do
-        @parser.parse '--- foo'
-      end
-    end
-
-    def test_filename
-      ex = assert_raises(Psych::SyntaxError) do
-        @parser.parse '--- `', 'omg!'
-      end
-      assert_match 'omg!', ex.message
-    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_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.external_encoding; nil end
-      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

data/test/psych/test_psych.rb

@@ -1,168 +0,0 @@
-require_relative 'helper'
-
-require 'stringio'
-require 'tempfile'
-
-class TestPsych < Psych::TestCase
-  def teardown
-    Psych.domain_types.clear
-  end
-
-  def test_line_width
-    yml = Psych.dump('123456 7', { :line_width => 5 })
-    assert_match(/^\s*7/, yml)
-  end
-
-  def test_indent
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:indentation => 5})
-    assert_match(/^[ ]{5}b/, yml)
-  end
-
-  def test_canonical
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:canonical => true})
-    assert_match(/\? "b/, yml)
-  end
-
-  def test_header
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:header => true})
-    assert_match(/YAML/, yml)
-  end
-
-  def test_version_array
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:version => [1,1]})
-    assert_match(/1.1/, yml)
-  end
-
-  def test_version_string
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:version => '1.1'})
-    assert_match(/1.1/, yml)
-  end
-
-  def test_version_bool
-    yml = Psych.dump({:a => {'b' => 'c'}}, {:version => true})
-    assert_match(/1.1/, yml)
-  end
-
-  def test_load_argument_error
-    assert_raises(TypeError) do
-      Psych.load nil
-    end
-  end
-
-  def test_non_existing_class_on_deserialize
-    e = assert_raises(ArgumentError) do
-      Psych.load("--- !ruby/object:NonExistent\nfoo: 1")
-    end
-    assert_equal 'undefined class/module NonExistent', e.message
-  end
-
-  def test_dump_stream
-    things = [22, "foo \n", {}]
-    stream = Psych.dump_stream(*things)
-    assert_equal things, Psych.load_stream(stream)
-  end
-
-  def test_dump_file
-    hash = {'hello' => 'TGIF!'}
-    Tempfile.create('fun.yml') do |io|
-      assert_equal io, Psych.dump(hash, io)
-      io.rewind
-      assert_equal Psych.dump(hash), io.read
-    end
-  end
-
-  def test_dump_io
-    hash = {'hello' => 'TGIF!'}
-    stringio = StringIO.new ''
-    assert_equal stringio, Psych.dump(hash, stringio)
-    assert_equal Psych.dump(hash), stringio.string
-  end
-
-  def test_simple
-    assert_equal 'foo', Psych.load("--- foo\n")
-  end
-
-  def test_libyaml_version
-    assert Psych.libyaml_version
-    assert_equal Psych.libyaml_version.join('.'), Psych::LIBYAML_VERSION
-  end
-
-  def test_load_documents
-    docs = Psych.load_documents("--- foo\n...\n--- bar\n...")
-    assert_equal %w{ foo bar }, docs
-  end
-
-  def test_parse_stream
-    docs = Psych.parse_stream("--- foo\n...\n--- bar\n...")
-    assert_equal %w{ foo bar }, docs.children.map { |x| x.transform }
-  end
-
-  def test_add_builtin_type
-    got = nil
-    Psych.add_builtin_type 'omap' do |type, val|
-      got = val
-    end
-    Psych.load('--- !!omap hello')
-    assert_equal 'hello', got
-  ensure
-    Psych.remove_type 'omap'
-  end
-
-  def test_domain_types
-    got = nil
-    Psych.add_domain_type 'foo.bar,2002', 'foo' do |type, val|
-      got = val
-    end
-
-    Psych.load('--- !foo.bar,2002/foo hello')
-    assert_equal 'hello', got
-
-    Psych.load("--- !foo.bar,2002/foo\n- hello\n- world")
-    assert_equal %w{ hello world }, got
-
-    Psych.load("--- !foo.bar,2002/foo\nhello: world")
-    assert_equal({ 'hello' => 'world' }, got)
-  end
-
-  def test_load_file
-    Tempfile.create(['yikes', 'yml']) {|t|
-      t.binmode
-      t.write('--- hello world')
-      t.close
-      assert_equal 'hello world', Psych.load_file(t.path)
-    }
-  end
-
-  def test_parse_file
-    Tempfile.create(['yikes', 'yml']) {|t|
-      t.binmode
-      t.write('--- hello world')
-      t.close
-      assert_equal 'hello world', Psych.parse_file(t.path).transform
-    }
-  end
-
-  def test_degenerate_strings
-    assert_equal false, Psych.load('    ')
-    assert_equal false, Psych.parse('   ')
-    assert_equal false, Psych.load('')
-    assert_equal false, Psych.parse('')
-  end
-
-  def test_callbacks
-    types = []
-    appender = lambda { |*args| types << args }
-
-    Psych.add_builtin_type('foo', &appender)
-    Psych.add_domain_type('example.com,2002', 'foo', &appender)
-    Psych.load <<-eoyml
-- !tag:yaml.org,2002:foo bar
-- !tag:example.com,2002:foo bar
-    eoyml
-
-    assert_equal [
-      ["tag:yaml.org,2002:foo", "bar"],
-      ["tag:example.com,2002:foo", "bar"]
-    ], types
-  end
-end

data/test/psych/test_safe_load.rb

@@ -1,97 +0,0 @@
-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

@@ -1,11 +0,0 @@
-# -*- 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

@@ -1,106 +0,0 @@
-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