psych 2.0.12 → 5.2.3

data/lib/psych/deprecated.rb

@@ -1,85 +0,0 @@
-require 'date'
-
-module Psych
-  DEPRECATED = __FILE__ # :nodoc:
-
-  module DeprecatedMethods # :nodoc:
-    attr_accessor :taguri
-    attr_accessor :to_yaml_style
-  end
-
-  def self.quick_emit thing, opts = {}, &block # :nodoc:
-    warn "#{caller[0]}: YAML.quick_emit is deprecated" if $VERBOSE && !caller[0].start_with?(File.dirname(__FILE__))
-    target = eval 'self', block.binding
-    target.extend DeprecatedMethods
-    metaclass = class << target; self; end
-    metaclass.send(:define_method, :encode_with) do |coder|
-      target.taguri        = coder.tag
-      target.to_yaml_style = coder.style
-      block.call coder
-    end
-    target.psych_to_yaml unless opts[:nodump]
-  end
-
-  # This method is deprecated, use Psych.load_stream instead.
-  def self.load_documents yaml, &block
-    if $VERBOSE
-      warn "#{caller[0]}: load_documents is deprecated, use load_stream"
-    end
-    list = load_stream yaml
-    return list unless block_given?
-    list.each(&block)
-  end
-
-  def self.detect_implicit thing
-    warn "#{caller[0]}: detect_implicit is deprecated" if $VERBOSE
-    return '' unless String === thing
-    return 'null' if '' == thing
-    ss = ScalarScanner.new(ClassLoader.new)
-    ss.tokenize(thing).class.name.downcase
-  end
-
-  def self.add_ruby_type type_tag, &block
-    warn "#{caller[0]}: add_ruby_type is deprecated, use add_domain_type" if $VERBOSE
-    domain = 'ruby.yaml.org,2002'
-    key = ['tag', domain, type_tag].join ':'
-    @domain_types[key] = [key, block]
-  end
-
-  def self.add_private_type type_tag, &block
-    warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE
-    domain = 'x-private'
-    key = [domain, type_tag].join ':'
-    @domain_types[key] = [key, block]
-  end
-
-  def self.tagurize thing
-    warn "#{caller[0]}: add_private_type is deprecated, use add_domain_type" if $VERBOSE
-    return thing unless String === thing
-    "tag:yaml.org,2002:#{thing}"
-  end
-
-  def self.read_type_class type, reference
-    warn "#{caller[0]}: read_type_class is deprecated" if $VERBOSE
-    _, _, type, name = type.split ':', 4
-
-    reference = name.split('::').inject(reference) do |k,n|
-      k.const_get(n.to_sym)
-    end if name
-    [type, reference]
-  end
-
-  def self.object_maker klass, hash
-    warn "#{caller[0]}: object_maker is deprecated" if $VERBOSE
-    klass.allocate.tap do |obj|
-      hash.each { |k,v| obj.instance_variable_set(:"@#{k}", v) }
-    end
-  end
-end
-
-class Object
-  undef :to_yaml_properties rescue nil
-  def to_yaml_properties # :nodoc:
-    instance_variables
-  end
-end

data/test/psych/handlers/test_recorder.rb

@@ -1,25 +0,0 @@
-require 'psych/helper'
-require 'psych/handlers/recorder'
-
-module Psych
-  module Handlers
-    class TestRecorder < TestCase
-      def test_replay
-        yaml   = "--- foo\n...\n"
-        output = StringIO.new
-
-        recorder = Psych::Handlers::Recorder.new
-        parser   = Psych::Parser.new recorder
-        parser.parse yaml
-
-        assert_equal 5, recorder.events.length
-
-        emitter = Psych::Emitter.new output
-        recorder.events.each do |m, args|
-          emitter.send m, *args
-        end
-        assert_equal yaml, output.string
-      end
-    end
-  end
-end

data/test/psych/helper.rb

@@ -1,114 +0,0 @@
-require 'minitest/autorun'
-require 'stringio'
-require 'tempfile'
-require 'date'
-require 'psych'
-
-module Psych
-  class TestCase < MiniTest::Unit::TestCase
-    def self.suppress_warning
-      verbose, $VERBOSE = $VERBOSE, nil
-      yield
-    ensure
-      $VERBOSE = verbose
-    end
-
-    def with_default_external(enc)
-      verbose, $VERBOSE = $VERBOSE, nil
-      origenc, Encoding.default_external = Encoding.default_external, enc
-      $VERBOSE = verbose
-      yield
-    ensure
-      verbose, $VERBOSE = $VERBOSE, nil
-      Encoding.default_external = origenc
-      $VERBOSE = verbose
-    end
-
-    def with_default_internal(enc)
-      verbose, $VERBOSE = $VERBOSE, nil
-      origenc, Encoding.default_internal = Encoding.default_internal, enc
-      $VERBOSE = verbose
-      yield
-    ensure
-      verbose, $VERBOSE = $VERBOSE, nil
-      Encoding.default_internal = origenc
-      $VERBOSE = verbose
-    end
-
-    #
-    # Convert between Psych and the object to verify correct parsing and
-    # emitting
-    #
-    def assert_to_yaml( obj, yaml )
-      assert_equal( obj, Psych::load( yaml ) )
-      assert_equal( obj, Psych::parse( yaml ).transform )
-      assert_equal( obj, Psych::load( obj.psych_to_yaml ) )
-      assert_equal( obj, Psych::parse( obj.psych_to_yaml ).transform )
-      assert_equal( obj, Psych::load(
-        obj.psych_to_yaml(
-          :UseVersion => true, :UseHeader => true, :SortKeys => true
-        )
-      ))
-    end
-
-    #
-    # Test parser only
-    #
-    def assert_parse_only( obj, yaml )
-      assert_equal( obj, Psych::load( yaml ) )
-      assert_equal( obj, Psych::parse( yaml ).transform )
-    end
-
-    def assert_cycle( obj )
-      v = Visitors::YAMLTree.create
-      v << obj
-      assert_equal(obj, Psych.load(v.tree.yaml))
-      assert_equal( obj, Psych::load(Psych.dump(obj)))
-      assert_equal( obj, Psych::load( obj.psych_to_yaml ) )
-    end
-
-    #
-    # Make a time with the time zone
-    #
-    def mktime( year, mon, day, hour, min, sec, usec, zone = "Z" )
-      usec = Rational(usec.to_s) * 1000000
-      val = Time::utc( year.to_i, mon.to_i, day.to_i, hour.to_i, min.to_i, sec.to_i, usec )
-      if zone != "Z"
-        hour = zone[0,3].to_i * 3600
-        min = zone[3,2].to_i * 60
-        ofs = (hour + min)
-        val = Time.at( val.tv_sec - ofs, val.tv_nsec / 1000.0 )
-      end
-      return val
-    end
-  end
-end
-
-# backport so that tests will run on 1.9 and 2.0.0
-unless Tempfile.respond_to? :create
-  def Tempfile.create(basename, *rest)
-    tmpfile = nil
-    Dir::Tmpname.create(basename, *rest) do |tmpname, n, opts|
-      mode = File::RDWR|File::CREAT|File::EXCL
-      perm = 0600
-      if opts
-        mode |= opts.delete(:mode) || 0
-        opts[:perm] = perm
-        perm = nil
-      else
-        opts = perm
-      end
-      tmpfile = File.open(tmpname, mode, opts)
-    end
-    if block_given?
-      begin
-        yield tmpfile
-      ensure
-        tmpfile.close if !tmpfile.closed?
-        File.unlink tmpfile
-      end
-    else
-      tmpfile
-    end
-  end
-end

data/test/psych/json/test_stream.rb

@@ -1,109 +0,0 @@
-require 'psych/helper'
-
-module Psych
-  module JSON
-    class TestStream < TestCase
-      def setup
-        @io     = StringIO.new
-        @stream = Psych::JSON::Stream.new(@io)
-        @stream.start
-      end
-
-      def test_explicit_documents
-        @io     = StringIO.new
-        @stream = Psych::JSON::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_null
-        @stream.push(nil)
-        assert_match(/^--- null/, @io.string)
-      end
-
-      def test_string
-        @stream.push "foo"
-        assert_match(/(["])foo\1/, @io.string)
-      end
-
-      def test_symbol
-        @stream.push :foo
-        assert_match(/(["])foo\1/, @io.string)
-      end
-
-      def test_int
-        @stream.push 10
-        assert_match(/^--- 10/, @io.string)
-      end
-
-      def test_float
-        @stream.push 1.2
-        assert_match(/^--- 1.2/, @io.string)
-      end
-
-      def test_hash
-        hash = { 'one' => 'two' }
-        @stream.push hash
-
-        json = @io.string
-        assert_match(/}$/, json)
-        assert_match(/^--- \{/, json)
-        assert_match(/["]one['"]/, json)
-        assert_match(/["]two['"]/, json)
-      end
-
-      def test_list_to_json
-        list = %w{ one two }
-        @stream.push list
-
-        json = @io.string
-        assert_match(/\]$/, json)
-        assert_match(/^--- \[/, json)
-        assert_match(/["]one["]/, json)
-        assert_match(/["]two["]/, json)
-      end
-
-      class Foo; end
-
-      def test_json_dump_exclude_tag
-        @stream << Foo.new
-        json = @io.string
-        refute_match('Foo', json)
-      end
-
-      class Bar
-        def encode_with coder
-          coder.represent_seq 'omg', %w{ a b c }
-        end
-      end
-
-      def test_json_list_dump_exclude_tag
-        @stream << Bar.new
-        json = @io.string
-        refute_match('omg', json)
-      end
-
-      def test_time
-        time = Time.utc(2010, 10, 10)
-        @stream.push({'a' => time })
-        json = @io.string
-        assert_match "{\"a\": \"2010-10-10 00:00:00.000000000 Z\"}\n", json
-      end
-
-      def test_datetime
-        time = Time.new(2010, 10, 10).to_datetime
-        @stream.push({'a' => time })
-        json = @io.string
-        assert_match "{\"a\": \"#{time.strftime("%Y-%m-%d %H:%M:%S.%9N %:z")}\"}\n", json
-      end
-    end
-  end
-end

data/test/psych/nodes/test_enumerable.rb

@@ -1,43 +0,0 @@
-require 'psych/helper'
-
-module Psych
-  module Nodes
-    class TestEnumerable < TestCase
-      def test_includes_enumerable
-        yaml = '--- hello'
-        assert_equal 3, Psych.parse_stream(yaml).to_a.length
-      end
-
-      def test_returns_enumerator
-        yaml = '--- hello'
-        assert_equal 3, Psych.parse_stream(yaml).each.map { |x| x }.length
-      end
-
-      def test_scalar
-        assert_equal 3, calls('--- hello').length
-      end
-
-      def test_sequence
-        assert_equal 4, calls("---\n- hello").length
-      end
-
-      def test_mapping
-        assert_equal 5, calls("---\nhello: world").length
-      end
-
-      def test_alias
-        assert_equal 5, calls("--- &yay\n- foo\n- *yay\n").length
-      end
-
-      private
-
-      def calls yaml
-        calls = []
-        Psych.parse_stream(yaml).each do |node|
-          calls << node
-        end
-        calls
-      end
-    end
-  end
-end

data/test/psych/test_alias_and_anchor.rb

@@ -1,96 +0,0 @@
-require_relative 'helper'
-
-class ObjectWithInstanceVariables
-  attr_accessor :var1, :var2
-end
-
-class SubStringWithInstanceVariables < String
-  attr_accessor :var1
-end
-
-module Psych
- class TestAliasAndAnchor < TestCase
-   def test_mri_compatibility
-     yaml = <<EOYAML
----
-- &id001 !ruby/object {}
-
-- *id001
-- *id001
-EOYAML
-     result = Psych.load yaml
-     result.each {|el| assert_same(result[0], el) }
-   end
-
-   def test_mri_compatibility_object_with_ivars
-  yaml = <<EOYAML
----
-- &id001 !ruby/object:ObjectWithInstanceVariables
-  var1: test1
-  var2: test2
-- *id001
-- *id001
-EOYAML
-
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test1', el.var1)
-      assert_equal('test2', el.var2)
-    end
-   end
-
-   def test_mri_compatibility_substring_with_ivars
-    yaml = <<EOYAML
----
-- &id001 !str:SubStringWithInstanceVariables
-  str: test
-  "@var1": test
-- *id001
-- *id001
-EOYAML
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test', el.var1)
-    end
-   end
-
-   def test_anchor_alias_round_trip
-     o = Object.new
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each {|el| assert_same(result[0], el) }
-   end
-
-   def test_anchor_alias_round_trip_object_with_ivars
-     o = ObjectWithInstanceVariables.new
-     o.var1 = 'test1'
-     o.var2 = 'test2'
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test1', el.var1)
-      assert_equal('test2', el.var2)
-    end
-   end
-
-   def test_anchor_alias_round_trip_substring_with_ivars
-     o = SubStringWithInstanceVariables.new
-     o.var1 = 'test'
-     original = [o,o,o]
-
-     yaml = Psych.dump original
-     result = Psych.load yaml
-     result.each do |el|
-      assert_same(result[0], el)
-      assert_equal('test', el.var1)
-    end
-   end
- end
-end

data/test/psych/test_array.rb

@@ -1,57 +0,0 @@
-require_relative 'helper'
-
-module Psych
-  class TestArray < TestCase
-    class X < Array
-    end
-
-    class Y < Array
-      attr_accessor :val
-    end
-
-    def setup
-      super
-      @list = [{ :a => 'b' }, 'foo']
-    end
-
-    def test_another_subclass_with_attributes
-      y = Y.new.tap {|y| y.val = 1}
-      y << "foo" << "bar"
-      y = Psych.load Psych.dump y
-
-      assert_equal %w{foo bar}, y
-      assert_equal Y, y.class
-      assert_equal 1, y.val
-    end
-
-    def test_subclass
-      yaml = Psych.dump X.new
-      assert_match X.name, yaml
-
-      list = X.new
-      list << 1
-      assert_equal X, list.class
-      assert_equal 1, list.first
-    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_backwards_with_syck
-      x = Psych.load "--- !seq:#{X.name} []\n\n"
-      assert_equal X, x.class
-    end
-
-    def test_self_referential
-      @list << @list
-      assert_cycle(@list)
-    end
-
-    def test_cycle
-      assert_cycle(@list)
-    end
-  end
-end

data/test/psych/test_boolean.rb

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

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