ya2yaml 0.23

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2006 Akira FUNAI <funai.akira@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the "Software"), 
+to deal in the Software without restriction, including without limitation 
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,107 @@
+= Ya2YAML - An UTF8 safe YAML dumper
+
+Project Contact: Akira FUNAI <mailto:funai.akira@gmail.com>
+
+Ya2YAML is "yet another to_yaml". It emits YAML document with complete UTF8 support (string/binary detection, "\u" escape sequences and Unicode specific line breaks). I hope someone might find it useful until Syck/RbYAML come out with UTF8/16 support.
+
+== Usage
+
+*code*:
+
+  $KCODE = 'UTF8'
+  require 'ya2yaml'
+  
+  obj = [
+    "abc\nxyz\n",
+    "日本語\n文字列\n",
+    "\xfd\xfe\xff",
+  ]
+  puts obj.ya2yaml(:syck_compatible => true)
+
+*output*:
+
+  --- 
+  - |
+      abc
+      xyz
+  - |
+      日本語
+      文字列
+  - !binary |
+      /f7/
+
+== Method and Objects
+
+When you require 'ya2yaml', public method 'Object#ya2yaml' is defined. Currently these Objects are supported.
+
+as YAML generic types:
+  - Array
+  - Hash
+  - NilClass
+  - String
+  - TrueClass
+  - FalseClass
+  - Fixnum
+  - Float
+  - Date
+  - Time
+
+as Ruby specific types:
+  - Symbol
+  - Range
+  - Regexp
+  - Struct
+  - everything else as a generic Object (serializes instance variables)
+
+A String which contains any non-UTF8 character will be regarded as "binary" and encoded in BASE64.
+
+== Options
+
+  # set them individually
+  obj.ya2yaml(
+    :indent_size          => 4,
+    :minimum_block_length => 16,
+    :printable_with_syck  => true,
+    :escape_b_specific    => true,
+    :escape_as_utf8       => true
+  )
+
+  # or simply set this for a safe roundtrip with Syck.
+  obj.ya2yaml(:syck_compatible => true)
+
+**CAUTION** Some of these options are to avoid compatibility issue with Syck. When you set these options to false, the emitted YAML document might not be loadable with YAML.load() although the syntax is valid.
+
+- :indent_size
+  - default: 2
+  - Number of indentation spaces for a level.
+
+- :minimum_block_length
+  - default: 0
+  - Minimum length of a string emitted in block scalar style. If a string is shorter than this value, it will be emitted in one line.
+
+- :printable_with_syck
+  - default: false
+  - When set to true, Ya2YAML will regard some kind of strings (which cause Syck roundtrip failures) as "non-printable" and double-quote them.
+
+- :escape_b_specific
+  - default: false
+  - When set to true, Ya2YAML will regard Unicode specific line breaks (LS and PS) as "non-printable" and escape them.
+
+- :escape_as_utf8
+  - default: false
+  - When set to true, Ya2YAML uses Ruby-like escape sequences in UTF8 code instead of "\uXXXX" style in UCS code. It also suppresses use of "\L" and "\P" (escape sequences for LS and PS).
+
+- :syck_compatible
+  - default: false
+  - When set to true, These options are set to true at once. You have to set this to false when you set them individually.
+    - :printable_with_syck
+    - :escape_b_specific
+    - :escape_as_utf8
+
+== More information
+
+Visit http://rubyforge.org/projects/ya2yaml
+
+== License
+
+Ya2YAML is distributed with a MIT license, which can be found in the file LICENSE.

data/lib/ya2yaml.rb

@@ -0,0 +1,356 @@
+#!/usr/bin/env ruby
+
+# $Id: ya2yaml.rb,v 0.23 2006-09-14 05:42:04+09 funai Exp funai $
+#
+# Author::    Akira FUNAI
+# Copyright:: Copyright (c) 2006 Akira FUNAI
+# License::   MIT License
+
+class Ya2YAML
+
+	def initialize(options = {})
+		options[:indent_size] = 2          if options[:indent_size].to_i <= 0
+		options[:minimum_block_length] = 0 if options[:minimum_block_length].to_i <= 0
+		options.update(
+			{
+				:printable_with_syck  => true,
+				:escape_b_specific    => true,
+				:escape_as_utf8       => true,
+			}
+		) if options[:syck_compatible]
+
+		@options = options
+	end
+
+	def _ya2yaml(obj)
+		throw 'set $KCODE to "UTF8".' if $KCODE != 'UTF8'
+		'--- ' + emit(obj,1) + "\n"
+	end
+
+	private
+
+	def emit(obj,level)
+		case obj.class.to_s
+			when 'Array'
+				if (obj.length == 0)
+					'[]'
+				else
+					indent = "\n" + s_indent(level - 1)
+					obj.collect {|o|
+						indent + '- ' + emit(o,level + 1)
+					}.join('')
+				end
+			when 'Hash'
+				if (obj.length == 0)
+					'{}'
+				else
+					indent = "\n" + s_indent(level - 1)
+					obj.keys.sort {|x,y| x.to_s <=> y.to_s }.collect {|k|
+						key = emit(k,level + 1)
+						if (
+							is_one_plain_line?(key) ||
+							key =~ /\A(#{REX_BOOL}|#{REX_FLOAT}|#{REX_INT}|#{REX_NULL})\z/x
+						)
+							indent + key + ': ' + emit(obj[k],level + 1)
+						else
+							indent + '? ' + key +
+							indent + ': ' + emit(obj[k],level + 1)
+						end
+					}.join('')
+				end
+			when 'NilClass'
+				'~'
+			when 'String'
+				emit_string(obj,level)
+			when 'TrueClass','FalseClass'
+				obj.to_s
+			when 'Fixnum','Float'
+				obj.to_s
+			when 'Date'
+				obj.to_s
+			when 'Time'
+				offset = obj.gmtoff
+				off_hm = sprintf(
+					'%+.2d:%.2d',
+					(offset / 3600.0).to_i,
+					(offset % 3600.0) / 60
+				)
+				u_sec = (obj.usec != 0) ? sprintf(".%.6d",obj.usec) : ''
+				obj.strftime("%Y-%m-%d %H:%M:%S#{u_sec} #{off_hm}")
+			when 'Symbol'
+				'!ruby/symbol ' + obj.to_s
+			when 'Range'
+				'!ruby/range ' + obj.to_s
+			when 'Regexp'
+				'!ruby/regexp ' + obj.inspect
+			else
+				case
+					when obj.is_a?(Struct)
+						struct_members = {}
+						obj.each_pair{|k,v| struct_members[k.to_s] = v }
+						'!ruby/struct:' + obj.class.to_s.sub(/^Struct::/,'') + ' ' +
+						emit(struct_members,level + 1)
+					else
+						# serialized as a generic object
+						object_members = {}
+						obj.instance_variables.each{|k,v|
+							object_members[k.sub(/^@/,'')] = obj.instance_variable_get(k)
+						}
+						'!ruby/object:' + obj.class.to_s + ' ' +
+						emit(object_members,level + 1)
+				end
+		end
+	end
+
+	def emit_string(str,level)
+		(is_string,is_printable,is_one_line,is_one_plain_line) = string_type(str)
+		if is_string
+			if is_printable
+				if is_one_plain_line
+					emit_simple_string(str,level)
+				else
+					(is_one_line || str.length < @options[:minimum_block_length]) ?
+						emit_quoted_string(str,level) :
+						emit_block_string(str,level)
+				end
+			else
+				emit_quoted_string(str,level)
+			end
+		else
+			emit_base64_binary(str,level)
+		end
+	end
+
+	def emit_simple_string(str,level)
+		str
+	end
+
+	def emit_block_string(str,level)
+		str = normalize_line_break(str)
+
+		indent = s_indent(level)
+		indentation_indicator = (str =~ /\A /) ? indent.size.to_s : ''
+		str =~ /(#{REX_NORMAL_LB}*)\z/
+		chomping_indicator = case $1.length
+			when 0
+				'-'
+			when 1
+				''
+			else
+				'+'
+		end
+
+		str.chomp!
+		str.gsub!(/#{REX_NORMAL_LB}/) {
+			$1 + indent
+		}
+		'|' + indentation_indicator + chomping_indicator + "\n" + indent + str
+	end
+
+	def emit_quoted_string(str,level)
+		str = yaml_escape(normalize_line_break(str))
+		if (str.length < @options[:minimum_block_length])
+			str.gsub!(/#{REX_NORMAL_LB}/) { ESCAPE_SEQ_LB[$1] }
+		else
+			str.gsub!(/#{REX_NORMAL_LB}$/) { ESCAPE_SEQ_LB[$1] }
+			str.gsub!(/(#{REX_NORMAL_LB}+)(.)/) {
+				trail_c = $3
+				$1 + trail_c.sub(/([\t ])/) { ESCAPE_SEQ_WS[$1] }
+			}
+			indent = s_indent(level)
+			str.gsub!(/#{REX_NORMAL_LB}/) {
+				ESCAPE_SEQ_LB[$1] + "\\\n" + indent
+			}
+		end
+		'"' + str + '"'
+	end
+
+	def emit_base64_binary(str,level)
+		indent = "\n" + s_indent(level)
+		base64 = [str].pack('m')
+		'!binary |' + indent + base64.gsub(/\n(?!\z)/,indent)
+	end
+
+	def string_type(str)
+		(ucs_codes = str.unpack('U*')) rescue (
+			# ArgumentError -> binary data
+			return false,false,false,false
+		)
+		if (
+			@options[:printable_with_syck] &&
+			str =~ /\A#{REX_ANY_LB}* | #{REX_ANY_LB}*\z|#{REX_ANY_LB}{2}\z/
+		)
+			# detour Syck bug
+			return true,false,is_one_line?(str),false
+		end
+		ucs_codes.each {|ucs_code|
+			return true,false,is_one_line?(str),false unless is_printable?(ucs_code)
+		}
+		return true,true,is_one_line?(str),is_one_plain_line?(str)
+	end
+
+	def is_printable?(ucs_code)
+		# YAML 1.1 / 4.1.1.
+		(
+			[0x09,0x0a,0x0d,0x85].include?(ucs_code)      ||
+			(ucs_code <=     0x7e && ucs_code >=    0x20) ||
+			(ucs_code <=   0xd7ff && ucs_code >=    0xa0) ||
+			(ucs_code <=   0xfffd && ucs_code >=  0xe000) ||
+			(ucs_code <= 0x10ffff && ucs_code >= 0x10000)
+		) &&
+		!(
+			# treat LS/PS as non-printable characters
+			@options[:escape_b_specific] &&
+			(ucs_code == 0x2028 || ucs_code == 0x2029)
+		)
+	end
+
+	def is_one_line?(str)
+		str !~ /#{REX_ANY_LB}(?!\z)/
+	end
+
+	def is_one_plain_line?(str)
+		# YAML 1.1 / 4.6.11.
+		str !~ /^([\-\?:,\[\]\{\}\#&\*!\|>'"%@`\s]|---|\.\.\.)/    &&
+		str !~ /[:\#\s\[\]\{\},]/                                  &&
+		str !~ /#{REX_ANY_LB}/                                     &&
+		str !~ /^(#{REX_BOOL}|#{REX_FLOAT}|#{REX_INT}|#{REX_MERGE}
+			|#{REX_NULL}|#{REX_TIMESTAMP}|#{REX_VALUE})$/x
+	end
+
+	def s_indent(level)
+		# YAML 1.1 / 4.2.2.
+		' ' * (level * @options[:indent_size])
+	end
+
+	def normalize_line_break(str)
+		# YAML 1.1 / 4.1.4.
+		str.gsub(/(#{REX_CRLF}|#{REX_CR}|#{REX_NEL})/,"\n")
+	end
+
+	def yaml_escape(str)
+		# YAML 1.1 / 4.1.6.
+		str.gsub(/[^a-zA-Z0-9]/u) {|c|
+			ucs_code, = (c.unpack('U') rescue [??])
+			case
+				when ESCAPE_SEQ[c]
+					ESCAPE_SEQ[c]
+				when is_printable?(ucs_code)
+					c
+				when @options[:escape_as_utf8]
+					'\\x' + c.unpack('H2' * c.size).join('\\x')
+				when ucs_code == 0x2028 || ucs_code == 0x2029
+					ESCAPE_SEQ_LB[c]
+				when ucs_code <= 0x7f
+					sprintf('\\x%.2x',ucs_code)
+				when ucs_code <= 0xffff
+					sprintf('\\u%.4x',ucs_code)
+				else
+					sprintf('\\U%.8x',ucs_code)
+			end
+		}
+	end
+
+	module Constants
+		UCS_0X85   = [0x85].pack('U')   #   c285@UTF8 Unicode next line
+		UCS_0XA0   = [0xa0].pack('U')   #   c2a0@UTF8 Unicode non-breaking space
+		UCS_0X2028 = [0x2028].pack('U') # e280a8@UTF8 Unicode line separator
+		UCS_0X2029 = [0x2029].pack('U') # e280a9@UTF8 Unicode paragraph separator
+
+		# non-break characters
+		ESCAPE_SEQ = {
+			"\x00" => '\\0',
+			"\x07" => '\\a',
+			"\x08" => '\\b',
+			"\x0b" => '\\v',
+			"\x0c" => '\\f',
+			"\x1b" => '\\e',
+			"\""   => '\\"',
+			"\\"   => '\\\\',
+		}
+
+		# non-breaking space
+		ESCAPE_SEQ_NS = {
+			UCS_0XA0 => '\\_',
+		}
+
+		# white spaces
+		ESCAPE_SEQ_WS = {
+			"\x09" => '\\t',
+			" "    => '\\x20',
+		}
+
+		# line breaks
+		ESCAPE_SEQ_LB ={
+			"\x0a"     => '\\n',
+			"\x0d"     => '\\r',
+			UCS_0X85   => '\\N',
+			UCS_0X2028 => '\\L',
+			UCS_0X2029 => '\\P',
+		}
+
+		# regexps for line breaks
+		REX_LF   = Regexp.escape("\x0a")
+		REX_CR   = Regexp.escape("\x0d")
+		REX_CRLF = Regexp.escape("\x0d\x0a")
+		REX_NEL  = Regexp.escape(UCS_0X85)
+		REX_LS   = Regexp.escape(UCS_0X2028)
+		REX_PS   = Regexp.escape(UCS_0X2029)
+
+		REX_ANY_LB    = /(#{REX_LF}|#{REX_CR}|#{REX_NEL}|#{REX_LS}|#{REX_PS})/
+		REX_NORMAL_LB = /(#{REX_LF}|#{REX_LS}|#{REX_PS})/
+
+		# regexps for language-Independent types for YAML1.1
+		REX_BOOL = /
+			 y|Y|yes|Yes|YES|n|N|no|No|NO
+			|true|True|TRUE|false|False|FALSE
+			|on|On|ON|off|Off|OFF
+		/x
+		REX_FLOAT = /
+			 [-+]?([0-9][0-9_]*)?\.[0-9.]*([eE][-+][0-9]+)? # (base 10)
+			|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\.[0-9_]*      # (base 60)
+			|[-+]?\.(inf|Inf|INF)                           # (infinity)
+			|\.(nan|NaN|NAN)                                # (not a number)
+		/x
+		REX_INT = /
+			 [-+]?0b[0-1_]+                   # (base 2)
+			|[-+]?0[0-7_]+                    # (base 8)
+			|[-+]?(0|[1-9][0-9_]*)            # (base 10)
+			|[-+]?0x[0-9a-fA-F_]+             # (base 16)
+			|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+ # (base 60)
+		/x
+		REX_MERGE = /
+			<<
+		/x
+		REX_NULL = /
+			 ~              # (canonical)
+			|null|Null|NULL # (English)
+			|               # (Empty)
+		/x
+		REX_TIMESTAMP = /
+			 [0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] # (ymd)
+			|[0-9][0-9][0-9][0-9]                       # (year)
+			 -[0-9][0-9]?                               # (month)
+			 -[0-9][0-9]?                               # (day)
+			 ([Tt]|[ \t]+)[0-9][0-9]?                   # (hour)
+			 :[0-9][0-9]                                # (minute)
+			 :[0-9][0-9]                                # (second)
+			 (\.[0-9]*)?                                # (fraction)
+			 (([ \t]*)Z|[-+][0-9][0-9]?(:[0-9][0-9])?)? # (time zone)
+		/x
+		REX_VALUE = /
+			=
+		/x
+	end
+
+	include Constants
+
+end
+
+class Object
+	def ya2yaml(options = {})
+		Ya2YAML.new(options)._ya2yaml(self)
+	end
+end
+
+__END__

data/test/t.yaml

@@ -0,0 +1,5 @@
+--- 
+list: 
+- perl
+- ruby
+- python

data/test/test.rb

@@ -0,0 +1,341 @@
+#!/usr/bin/env ruby
+
+# $Id: test.rb,v 1.2 2006-10-03 01:04:35+09 funai Exp funai $
+
+$: << (File.dirname(__FILE__) + '/../lib')
+
+Dir.chdir(File.dirname(__FILE__))
+
+$KCODE = 'UTF8'
+require 'ya2yaml'
+
+require 'yaml'
+require 'test/unit'
+
+class TC_Ya2YAML < Test::Unit::TestCase
+
+	@@struct_klass = Struct::new('Foo',:bar,:buz)
+	class Moo
+		attr_accessor :val1,:val2
+		def initialize(val1,val2)
+			@val1 = val1
+			@val2 = val2
+		end
+		def ==(k) 
+			(k.class == self.class) &&
+			(k.val1 == self.val1) &&
+			(k.val2 == self.val2)
+		end 
+	end
+	puts "test may take minutes. please wait.\n"
+
+	def setup
+		@text = ''
+		@gif  = ''
+		File.open('./t.yaml','r') {|f| @text = f.read}
+		File.open('./t.gif','r') {|f| @gif = f.read}
+
+		@struct = @@struct_klass.new('barbarbar',@@struct_klass.new('baaaar',12345))
+		@klass  = Moo.new('boobooboo',Time.new())
+	end
+
+	def test_options
+		[
+			[
+				{},
+				"--- \n- \"\\u0086\"\n- |-\n    a\xe2\x80\xa8    b\xe2\x80\xa9    c\n- |4-\n     abc\n    xyz\n",
+			],
+			[
+				{:indent_size => 4},
+				"--- \n- \"\\u0086\"\n- |-\n        a\xe2\x80\xa8        b\xe2\x80\xa9        c\n- |8-\n         abc\n        xyz\n",
+			],
+			[
+				{:minimum_block_length => 16},
+				"--- \n- \"\\u0086\"\n- \"a\\Lb\\Pc\"\n- \" abc\\nxyz\"\n",
+			],
+#			[
+#				{:emit_c_document_end => true},
+#				"--- \n- \"\\u0086\"\n- |-\n    a\xe2\x80\xa8    b\xe2\x80\xa9    c\n- |4-\n     abc\n    xyz\n...\n",
+#			],
+			[
+				{:printable_with_syck => true},
+				"--- \n- \"\\u0086\"\n- |-\n    a\xe2\x80\xa8    b\xe2\x80\xa9    c\n- \" abc\\n\\\n    xyz\"\n",
+			],
+			[
+				{:escape_b_specific => true},
+				"--- \n- \"\\u0086\"\n- \"a\\Lb\\Pc\"\n- |4-\n     abc\n    xyz\n",
+			],
+			[
+				{:escape_as_utf8 => true},
+				"--- \n- \"\\xc2\\x86\"\n- |-\n    a\xe2\x80\xa8    b\xe2\x80\xa9    c\n- |4-\n     abc\n    xyz\n",
+			],
+			[
+				{:syck_compatible => true},
+				"--- \n- \"\\xc2\\x86\"\n- \"a\\xe2\\x80\\xa8b\\xe2\\x80\\xa9c\"\n- \" abc\\n\\\n    xyz\"\n",
+			],
+		].each {|opt,yaml|
+			y = ["\xc2\x86","a\xe2\x80\xa8b\xe2\x80\xa9c"," abc\nxyz"].ya2yaml(opt)
+#			puts y
+
+			assert_equal(y,yaml)
+		}
+	end
+
+	def test_normalize_line_breaks
+		[
+			["\n\n\n\n",          "--- \"\\n\\n\\n\\n\"\n",],
+			["\r\n\r\n\r\n",      "--- \"\\n\\n\\n\"\n",],
+			["\r\n\n\n",          "--- \"\\n\\n\\n\"\n",],
+			["\n\r\n\n",          "--- \"\\n\\n\\n\"\n",],
+			["\n\n\r\n",          "--- \"\\n\\n\\n\"\n",],
+			["\n\n\n\r",          "--- \"\\n\\n\\n\\n\"\n",],
+			["\r\r\n\r",          "--- \"\\n\\n\\n\"\n",],
+			["\r\r\r\r",          "--- \"\\n\\n\\n\\n\"\n",],
+			["\r\xc2\x85\r\n",    "--- \"\\n\\n\\n\"\n",],
+			["\r\xe2\x80\xa8\r\n","--- \"\\n\\L\\n\"\n",],
+			["\r\xe2\x80\xa9\r\n","--- \"\\n\\P\\n\"\n",],
+		].each {|src,yaml|
+			y = src.ya2yaml(
+				:minimum_block_length => 16
+			)
+#			p y
+			assert_equal(y,yaml)
+		}
+	end
+
+	def test_roundtrip_single_byte_char
+		 ("\x00".."\x7f").each {|c|
+			y = c.ya2yaml()
+#			puts y
+			r = YAML.load(y)
+			assert_equal((c == "\r" ? "\n" : c),r) # "\r" is normalized as "\n".
+		}
+	end
+
+	def test_roundtrip_multi_byte_char
+		[
+			0x80,
+			0x85,
+			0xa0,
+			0x07ff,
+			0x0800,
+			0x0fff,
+			0x1000,
+			0x2028,
+			0x2029,
+			0xcfff,
+			0xd000,
+			0xd7ff,
+			0xe000,
+			0xfffd,
+			0x10000,
+			0x3ffff,
+			0x40000,
+			0xfffff,
+			0x100000,
+			0x10ffff,
+		].each {|ucs_code|
+			[-1,0,1].each {|ofs|
+				(c = [ucs_code + ofs].pack('U')) rescue next
+				c_hex = c.unpack('H8')
+				y = c.ya2yaml(
+					:escape_b_specific => true,
+					:escape_as_utf8    => true
+				)
+#				puts y
+				r = YAML.load(y)
+				assert_equal(
+					[c_hex,(c =~ /\xc2\x85/u ? "\n" : c)],
+					[c_hex,r]
+				) # "\N" is normalized as "\n".
+			}
+		}
+	end
+
+	def test_roundtrip_ambiguous_string
+		 [
+		 	'true',
+			 'false',
+			 'TRUE',
+			 'FALSE',
+			 'Y',
+			 'N',
+			 'y',
+			 'n',
+			 'on',
+			 'off',
+			 true,
+			 false,
+			 '0b0101',
+			 '-0b0101',
+			 0b0101,
+			 -0b0101,
+			 '031',
+			 '-031',
+			 031,
+			 -031,
+			 '123.001e-1',
+			 '123.01',
+			 '123',
+			 123.001e-1,
+			 123.01,
+			 123,
+			 '-123.001e-1',
+			 '-123.01',
+			 '-123',
+			 -123.001e-1,
+			 -123.01,
+			 -123,
+			 'INF',
+			 'inf',
+			 'NaN',
+			 'nan',
+			 '0xfe2a',
+			 '-0xfe2a',
+			 0xfe2a,
+			 -0xfe2a,
+			 '1:23:32.0200',
+			 '1:23:32',
+			 '-1:23:32.0200',
+			 '-1:23:32',
+			 '<<',
+			 '~',
+			 'null',
+			 'nUll',
+			 'Null',
+			 'NULL',
+			 '',
+			 nil,
+			 '2006-09-12',
+			 '2006-09-11T17:28:07Z',
+			 '2006-09-11T17:28:07+09:00',
+			 '2006-09-11 17:28:07.662694 +09:00',
+			 '=',
+		 ].each {|c|
+		 	['','hoge'].each {|ext|
+			 	src = c.class == String ? (c + ext) : c
+				y = src.ya2yaml(
+					:escape_as_utf8 => true
+				)
+#				puts y
+				r = YAML.load(y)
+				assert_equal(src,r)
+			}
+		}
+	end
+
+	def test_roundtrip_string
+		chars = "aあ\t\-\?,\[\{\#&\*!\|>'\"\%\@\`.\\ \n\xc2\xa0\xe2\x80\xa8".split('')
+		
+		chars.each {|i|
+			chars.each {|j|
+				chars.each {|k|
+					chars.each {|l|
+						src = i + j + k + l
+						y =  src.ya2yaml(
+							:printable_with_syck => true,
+							:escape_b_specific   => true,
+							:escape_as_utf8      => true
+						)
+#						puts y
+						r = YAML.load(y)
+						assert_equal(src,r)
+					}
+				}
+			}
+		}
+	end
+
+	def test_roundtrip_types
+		objects = [
+			[],
+			[1],
+			{},
+			{'foo' => 'bar'},
+			nil,
+			'hoge',
+			"abc\nxyz\n",
+			"\xff\xff",
+			true,
+			false,
+			1000,
+			1000.1,
+			-1000,
+			-1000.1,
+			Date.today(),
+			Time.new(),
+			:foo,
+			1..10,
+			/abc\nxyz/i,
+			@struct,
+			@klass,
+		]
+
+		objects.each {|obj|
+			src = case obj.class.to_s
+				when 'Array'
+					(obj.length) == 0 ? [] : objects
+				when 'Hash'
+					if (obj.length) == 0
+						{}
+					else
+						h = {}
+						c = 0
+						objects.each {|val|
+							h[c] = {}
+							objects.each {|key|
+								h[c][key] = val unless (key.class == Hash || key.class == Moo)
+							}
+							c += 1
+						}
+						h
+					end
+				else
+					obj
+			end
+			y = src.ya2yaml(
+				:syck_compatible => true
+			)
+#			puts y
+
+			r = YAML.load(y)
+			assert_equal(src,r)
+		}
+	end
+
+	def test_roundtrip_various
+		[
+			[1,2,['c','d',[[['e']],[]],'f'],3,Time.new(),[[:foo]],nil,true,false,[],{},{[123,223]=>456},{[1]=>2,'a'=>'b','c' => [9,9,9],Time.new() => 'hoge'},],
+			[],
+			{[123,223]=>456},
+			{},
+			{'foo' => {1 => {2=>3,4=>5},6 => [7,8]}},
+			"abc",
+			" abc\n def\ndef\ndef\ndef\ndef\n",
+			"abc\n def\ndef\n",
+			"abc\n def\ndef\n\n",
+			"abc\n def\ndef\n\n ",
+			"abc\n def\ndef\n \n",
+			"abc\n def\ndef \n \n",
+			"abc\n def\ndef \n \n ",
+			' ほげほげほげ',
+			{"ほげ\nほげ\n ほげ" => 123},
+			[["ほげ\nほげ\n ほげ"]],
+			"ほげh\x4fge\nほげ\nほげ",
+			[{'ほげ'=>'abc',"ほげ\nほげ"=>'ほげ'},'ほげ',@text],
+			[Date.today,-9.011,0.023,4,-5,{1=>-2,-1=>@text,'_foo'=>'bar','ぬお-ぬお'=>321}],
+			{1=>-2,-1=>@gif,'_foo'=>'bar','ぬお-ぬお'=>321},
+		].each {|src|
+			y = src.ya2yaml(
+				:syck_compatible => true
+			)
+#			puts y
+
+			r = YAML.load(y)
+			assert_equal(src,r)
+		}
+	end
+
+end
+
+__END__

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ya2yaml
+version: !ruby/object:Gem::Version 
+  version: "0.23"
+date: 2006-10-03 00:00:00 +09:00
+summary: An UTF8 safe YAML dumper.
+require_paths: 
+- lib
+email: funai.akira@gmail.com
+homepage: http://rubyforge.org/projects/ya2yaml/
+rubyforge_project: 
+description: 
+autorequire: ya2yaml
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Akira FUNAI
+files: 
+- lib/ya2yaml.rb
+- README
+- LICENSE
+- test/t.gif
+- test/t.yaml
+- test/test.rb
+test_files: 
+- test/test.rb
+rdoc_options: 
+- --main
+- README
+- --charset
+- UTF8
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+