km-psych 0.1.0

data/test/psych/test_null.rb

@@ -0,0 +1,19 @@
+require_relative 'helper'
+
+module Psych
+  ###
+  # Test null from YAML spec:
+  # http://yaml.org/type/null.html
+  class TestNull < TestCase
+    def test_null_list
+      assert_equal [nil] * 5, Psych.load(<<-eoyml)
+---
+- ~
+- null
+- 
+- Null
+- NULL
+      eoyml
+    end
+  end
+end

data/test/psych/test_object.rb

@@ -0,0 +1,27 @@
+require_relative 'helper'
+
+module Psych
+  class Tagged
+    yaml_tag '!foo'
+
+    attr_accessor :baz
+
+    def initialize
+      @baz = 'bar'
+    end
+  end
+
+  class TestObject < TestCase
+    def test_dump_with_tag
+      tag = Tagged.new
+      assert_match('foo', Psych.dump(tag))
+    end
+
+    def test_tag_round_trip
+      tag   = Tagged.new
+      tag2  = Psych.load(Psych.dump(tag))
+      assert_equal tag.baz, tag2.baz
+      assert_instance_of(Tagged, tag2)
+    end
+  end
+end

data/test/psych/test_omap.rb

@@ -0,0 +1,68 @@
+require_relative 'helper'
+
+module Psych
+  class TestOmap < TestCase
+    def test_self_referential
+      map = Psych::Omap.new
+      map['foo'] = 'bar'
+      map['self'] = map
+      assert_equal(map, Psych.load(Psych.dump(map)))
+    end
+
+    def test_keys
+      map = Psych::Omap.new
+      map['foo'] = 'bar'
+      assert_equal 'bar', map['foo']
+    end
+
+    def test_order
+      map = Psych::Omap.new
+      map['a'] = 'b'
+      map['b'] = 'c'
+      assert_equal [%w{a b}, %w{b c}], map.to_a
+    end
+
+    def test_square
+      list = [["a", "b"], ["b", "c"]]
+      map = Psych::Omap[*list.flatten]
+      assert_equal list, map.to_a
+      assert_equal 'b', map['a']
+      assert_equal 'c', map['b']
+    end
+
+    def test_dump
+      map = Psych::Omap['a', 'b', 'c', 'd']
+      yaml = Psych.dump(map)
+      assert_match('!omap', yaml)
+      assert_match('- a: b', yaml)
+      assert_match('- c: d', yaml)
+    end
+
+    def test_round_trip
+      list = [["a", "b"], ["b", "c"]]
+      map = Psych::Omap[*list.flatten]
+      assert_cycle(map)
+    end
+
+    def test_load
+      list = [["a", "b"], ["c", "d"]]
+      map = Psych.load(<<-eoyml)
+--- !omap
+- a: b
+- c: d
+      eoyml
+      assert_equal list, map.to_a
+    end
+
+    # NOTE: This test will not work with Syck
+    def test_load_shorthand
+      list = [["a", "b"], ["c", "d"]]
+      map = Psych.load(<<-eoyml)
+--- !!omap
+- a: b
+- c: d
+      eoyml
+      assert_equal list, map.to_a
+    end
+  end
+end

data/test/psych/test_parser.rb

@@ -0,0 +1,216 @@
+# coding: utf-8
+
+require_relative 'helper'
+
+module Psych
+  class TestParser < TestCase
+    class EventCatcher < Handler
+      attr_reader :calls
+      def initialize
+        @calls = []
+      end
+
+      (Handler.instance_methods(true) -
+       Object.instance_methods).each do |m|
+        class_eval %{
+          def #{m} *args
+            super
+            @calls << [:#{m}, args]
+          end
+        }
+      end
+    end
+
+    def setup
+      super
+      @parser = Psych::Parser.new EventCatcher.new
+    end
+
+    def test_set_encoding_twice
+      @parser.external_encoding = Psych::Parser::UTF16LE
+
+      e = assert_raises(Psych::Exception) do
+        @parser.external_encoding = Psych::Parser::UTF16LE
+      end
+      assert_equal "don't set the encoding twice!", e.message
+    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.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_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

@@ -0,0 +1,133 @@
+require_relative 'helper'
+
+require 'stringio'
+require 'tempfile'
+
+class TestPsych < Psych::TestCase
+  def teardown
+    Psych.domain_types.clear
+  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.open('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
+    t = Tempfile.new(['yikes', 'yml'])
+    t.binmode
+    t.write('--- hello world')
+    t.close
+    assert_equal 'hello world', Psych.load_file(t.path)
+    t.close(true)
+  end
+
+  def test_parse_file
+    t = Tempfile.new(['yikes', 'yml'])
+    t.binmode
+    t.write('--- hello world')
+    t.close
+    assert_equal 'hello world', Psych.parse_file(t.path).transform
+    t.close(true)
+  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