concordia-publishing-house-syck 1.0.0.4

data/lib/syck/ypath.rb

@@ -0,0 +1,54 @@
+#
+# YAML::YPath
+#
+
+warn "#{caller[0]}: YAML::YPath is deprecated" if $VERBOSE
+
+module Syck
+
+    class YPath
+        attr_accessor :segments, :predicates, :flags
+        def initialize( str )
+            @segments = []
+            @predicates = []
+            @flags = nil
+            while str =~ /^\/?(\/|[^\/\[]+)(?:\[([^\]]+)\])?/
+                @segments.push $1
+                @predicates.push $2
+                str = $'
+            end
+            unless str.to_s.empty?
+                @segments += str.split( "/" )
+            end
+            if @segments.length == 0
+                @segments.push "."
+            end
+        end
+        def self.each_path( str )
+            #
+            # Find choices
+            #
+            paths = []
+            str = "(#{ str })"
+            while str.sub!( /\(([^()]+)\)/, "\n#{ paths.length }\n" )
+                paths.push $1.split( '|' )
+            end
+
+            #
+            # Construct all possible paths
+            #
+            all = [ str ]
+            ( paths.length - 1 ).downto( 0 ) do |i|
+                all = all.collect do |a|
+                    paths[i].collect do |p|
+                        a.gsub( /\n#{ i }\n/, p )
+                    end
+                end.flatten.uniq
+            end
+            all.collect do |path|
+                yield YPath.new( path )
+            end
+        end
+    end
+
+end

data/lib/yaml/engine_manager.rb

@@ -0,0 +1,71 @@
+##
+# The YAML module allows you to use one of the two YAML engines that ship with
+# ruby.  By default Psych is used but the old and unmaintained Syck may be
+# chosen.
+#
+# See Psych or Syck for usage and documentation.
+#
+# To set the YAML engine to syck:
+#
+#   YAML::ENGINE.yamler = 'syck'
+#
+# To set the YAML engine back to psych:
+#
+#   YAML::ENGINE.yamler = 'psych'
+
+module YAML
+  class EngineManager # :nodoc:
+    attr_reader :yamler
+
+    def initialize
+      @yamler = nil
+    end
+
+    def syck?
+      'syck' == @yamler
+    end
+
+    def yamler= engine
+      raise(ArgumentError, "bad engine") unless %w{syck psych}.include?(engine)
+
+      require engine unless (engine == 'syck' ? Syck : Psych).const_defined?(:VERSION)
+
+      Object.class_eval <<-eorb, __FILE__, __LINE__ + 1
+        remove_const 'YAML'
+        YAML = #{engine.capitalize}
+        remove_method :to_yaml
+        alias :to_yaml :#{engine}_to_yaml
+      eorb
+
+      @yamler = engine
+      engine
+    end
+  end
+
+  ##
+  # Allows changing the current YAML engine.  See YAML for details.
+
+  remove_const :ENGINE if const_defined? :ENGINE
+  ENGINE = YAML::EngineManager.new
+end
+
+if defined?(Psych)
+  engine = 'psych'
+elsif defined?(Syck)
+  engine = 'syck'
+else
+  begin
+    require 'psych'
+    engine = 'psych'
+  rescue LoadError
+    warn "#{caller[0]}:"
+    warn "It seems your ruby installation is missing psych (for YAML output)."
+    warn "To eliminate this warning, please install libyaml and reinstall your ruby."
+    require 'syck'
+    engine = 'syck'
+  end
+end
+
+module Syck
+  ENGINE = YAML::ENGINE
+end

data/lib/yaml/syck.rb

@@ -0,0 +1,14 @@
+# $Id$
+#
+# = yaml/syck.rb:
+#
+
+require 'stringio'
+require 'syck.so'
+require 'syck/error'
+require 'syck/syck'
+require 'syck/tag'
+require 'syck/stream'
+require 'syck/constants'
+require 'syck/rubytypes'
+require 'syck/types'

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require 'syck'

data/test/test_array.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+module Syck
+  class TestArray < Test::Unit::TestCase
+    def setup
+      @list = [{ :a => 'b' }, 'foo']
+    end
+
+    def test_dump
+      assert_equal @list, Syck.load(Syck.dump(@list))
+    end
+  end
+end

data/test/test_boolean.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+module Syck
+  ###
+  # Test booleans from YAML spec:
+  # http://yaml.org/type/bool.html
+  class TestBoolean < Test::Unit::TestCase
+    %w{ yes Yes YES true True TRUE on On ON }.each do |truth|
+      define_method(:"test_#{truth}") do
+        assert_equal true, Syck.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, Syck.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", Syck.load("--- y")
+      assert_equal "Y", Syck.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", Syck.load("--- n")
+      assert_equal "N", Syck.load("--- N")
+    end
+  end
+end

data/test/test_class.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+module Syck
+  class TestClass < Test::Unit::TestCase
+    def test_dump
+      assert_raises(::TypeError) do
+        Syck.dump TestClass
+      end
+    end
+  end
+end

data/test/test_exception.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+module Syck
+  class TestException < Test::Unit::TestCase
+    class Wups < Exception
+      attr_reader :foo, :bar
+      def initialize *args
+        super
+        @foo = 1
+        @bar = 2
+      end
+    end
+
+    def setup
+      @wups = Wups.new('test_message')
+    end
+
+    def test_to_yaml
+      w = Syck.load(Syck.dump(@wups))
+      assert_equal @wups, w
+      assert_equal 1, w.foo
+      assert_equal 2, w.bar
+    end
+
+    def test_dump
+      w = Syck.load(Syck.dump(@wups))
+      assert_equal @wups, w
+      assert_equal 1, w.foo
+      assert_equal 2, w.bar
+    end
+
+    def test_to_yaml_properties
+      class << @wups
+        def to_yaml_properties
+          [:@foo]
+        end
+      end
+
+      w = Syck.load(Syck.dump(@wups))
+      assert_equal @wups, w
+      assert_equal 1, w.foo
+      assert_nil w.bar
+    end
+  end
+end

data/test/test_hash.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+module Syck
+  class TestHash < Test::Unit::TestCase
+    def setup
+      @hash = { :a => 'b' }
+    end
+
+    def test_dump
+      assert_equal @hash, Syck.load(Syck.dump(@hash))
+    end
+
+    def test_ref_append
+      hash = Syck.load(<<-eoyml)
+---
+foo: &foo
+  hello: world
+bar:
+  <<: *foo
+eoyml
+      assert_equal({"foo"=>{"hello"=>"world"}, "bar"=>{"hello"=>"world"}}, hash)
+    end
+  end
+end

data/test/test_null.rb

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

data/test/test_omap.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+module Syck
+  class TestOmap < Test::Unit::TestCase
+    def test_keys
+      map = Syck::Omap.new
+      map['foo'] = 'bar'
+      assert_equal 'bar', map['foo']
+    end
+
+    def test_order
+      map = Syck::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 = Syck::Omap[*list.flatten]
+      assert_equal list, map.to_a
+      assert_equal 'b', map['a']
+      assert_equal 'c', map['b']
+    end
+
+    def test_to_yaml
+      map = Syck::Omap['a', 'b', 'c', 'd']
+      yaml = map.to_yaml
+      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 = Syck::Omap[*list.flatten]
+      loaded = Syck.load(Syck.dump(map))
+
+      assert_equal map, loaded
+      assert_equal list, loaded.to_a
+    end
+
+    ###
+    # FIXME: Syck should also support !!omap as shorthand
+    def test_load
+      list = [["a", "b"], ["c", "d"]]
+      map = Syck.load(<<-eoyml)
+--- !omap
+- a: b
+- c: d
+      eoyml
+      assert_equal list, map.to_a
+    end
+  end
+end

data/test/test_set.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+module Syck
+  class TestSet < Test::Unit::TestCase
+    def setup
+      @set = Syck::Set.new
+      @set['foo'] = 'bar'
+      @set['bar'] = 'baz'
+    end
+
+    def test_to_yaml
+      assert_match(/!set/, @set.to_yaml)
+    end
+
+    def test_roundtrip
+      assert_equal(@set, Syck.load(Syck.dump(@set)))
+    end
+
+    ###
+    # FIXME: Syck should also support !!set as shorthand
+    def test_load_from_yaml
+      loaded = Syck.load(<<-eoyml)
+--- !set
+foo: bar
+bar: baz
+      eoyml
+      assert_equal(@set, loaded)
+    end
+  end
+end

data/test/test_string.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+module Syck
+  class TestString < Test::Unit::TestCase
+    def test_binary_string_null
+      string = "\x00"
+      yml = Syck.dump string
+      assert_match(/binary/, yml)
+      assert_equal string, Syck.load(yml)
+    end
+
+    def test_binary_string
+      string = binary_string
+      yml = Syck.dump string
+      assert_match(/binary/, yml)
+      assert_equal string, Syck.load(yml)
+    end
+
+    def test_non_binary_string
+      string = binary_string(0.29)
+      yml = Syck.dump string
+      assert_not_match(/binary/, yml)
+      assert_equal string, Syck.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 = Syck.load Syck.dump food
+      assert_equal ivar, food.instance_variable_get(:@we_built_this_city)
+    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/test_struct.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class StructWithIvar < Struct.new(:foo)
+  attr_reader :bar
+  def initialize *args
+    super
+    @bar = 'hello'
+  end
+end
+
+module Syck
+  class TestStruct < MiniTest::Unit::TestCase
+    def test_roundtrip
+      thing = StructWithIvar.new('bar')
+      struct = Syck.load(Syck.dump(thing))
+
+      assert_equal 'hello', struct.bar
+      assert_equal 'bar', struct.foo
+    end
+
+    def test_load
+      obj = Syck.load(<<-eoyml)
+--- !ruby/struct:StructWithIvar
+foo: bar
+@bar: hello
+eoyml
+
+      assert_equal 'hello', obj.bar
+      assert_equal 'bar', obj.foo
+    end
+  end
+end