RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/{representer.rb.~1.2.~ → representer.rb.~1.5.~}

@@ -8,11 +8,12 @@ module RbYAML
   class RepresenterError < YAMLError
   end
 
-  module BaseRepresenter
+  class BaseRepresenter
     @@yaml_representers = {}
     @@yaml_multi_representers = {}
 
-    def initialize_representer(default_style=nil, default_flow_style=nil)
+    def initialize(serializer, default_style=nil, default_flow_style=nil)
+      @serializer = serializer
       @default_style = default_style
       @default_flow_style = default_flow_style
       @represented_objects = {}
@@ -20,7 +21,7 @@ module RbYAML
 
     def represent(data)
       node = represent_data(data)
-      serialize(node)
+      @serializer.serialize(node)
       represented_objects = {}
     end
     
@@ -93,14 +94,14 @@ module RbYAML
     
     def represent_scalar(tag, value, style=nil)
       style ||= @default_style
-      ScalarNode.new(tag, value, style)
+      ScalarNode.new(tag,value,nil,nil,style)
     end
 
     def represent_sequence(tag, sequence, flow_style=nil)
       best_style = true
       value = sequence.map {|item| 
         node_item = represent_data(item)
-        best_style = false if !ScalarNode === node_item && !node_item.style
+        best_style = false if !node_item.__is_scalar && !node_item.flow_style
         node_item
       }
       flow_style ||= (@flow_default_style || best_style)
@@ -114,8 +115,8 @@ module RbYAML
         for item_key,item_value in mapping
           node_key = represent_data(item_key)
           node_value = represent_data(item_value)
-          best_style = false if !ScalarNode === node_key && !node_key.style
-          best_style = false if !ScalarNode === node_value && !node_value.style
+          best_style = false if !node_key.__is_scalar && !node_key.flow_style
+          best_style = false if !node_value.__is_scalar && !node_value.flow_style
           value[node_key] = node_value
         end
       else
@@ -123,8 +124,8 @@ module RbYAML
         for item_key, item_value in mapping
           node_key = represent_data(item_key)
           node_value = represent_data(item_value)
-          best_style = false if !ScalarNode === node_key && !node_key.style
-          best_style = false if !ScalarNode === node_value && !node_value.style
+          best_style = false if !node_key.__is_scalar && !node_key.flow_style
+          best_style = false if !node_value.__is_scalar && !node_value.flow_style
           value << [node_key, node_value]
         end
       end
@@ -137,28 +138,39 @@ module RbYAML
     end
   end
 
-  module SafeRepresenter
-    include BaseRepresenter
+  class SafeRepresenter < BaseRepresenter
 
     def ignore_aliases(data)
-      data.nil? || String === data || TrueClass === data || FalseClass === data || Integer === data || Float === data
+      data.nil? || data.__is_str || TrueClass === data || FalseClass === data || data.__is_int || Float === data
     end
 
     def represent_none(data)
-      represent_scalar(data.taguri,"null")
+#      represent_scalar(data.taguri,"null")
+      represent_scalar('tag:yaml.org,2002:str',"")
     end
 
+    NON_PRINTABLE = /[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\xFF]/
     def represent_str(data)
-      represent_scalar(data.taguri,data,nil)
+      style = nil
+      if NON_PRINTABLE =~ data
+        data = Base64.encode64(data)
+        data.taguri ="tag:yaml.org,2002:binary"
+        style = "|"
+      end
+      represent_scalar(data.taguri,data,style)
     end
 
     def represent_symbol(data)
       represent_scalar(data.taguri,data.to_s)
     end
 
+    def represent_private_type(data)
+      represent_scalar(data.type_id,data.value)
+    end
+
     def represent_bool(data)
       value = data ? "true" : "false"
-      represent_scalar(data.taguri,value)
+      represent_scalar('tag:yaml.org,2002:bool',value)
     end
 
     def represent_int(data)
@@ -196,25 +208,46 @@ module RbYAML
     end
     
     def represent_datetime(data)
-      value = "%04d-%02d-%02d %02d:%02d:%02d" % [data.year, data.month, data.day, data.hour, data.min, data.sec]
-      if data.usec != 0
-        value += "." + (data.usec/1000000.0).to_s.split(/\./)[1]
+      tz = "Z"
+      # from the tidy Tobias Peters <t-peters@gmx.de> Thanks!
+      unless data.utc?
+        utc_same_instant = data.dup.utc
+        utc_same_writing = Time.utc(data.year,data.month,data.day,data.hour,data.min,data.sec,data.usec)
+        difference_to_utc = utc_same_writing - utc_same_instant
+        if (difference_to_utc < 0) 
+          difference_sign = '-'
+          absolute_difference = -difference_to_utc
+        else
+          difference_sign = '+'
+          absolute_difference = difference_to_utc
+        end
+        difference_minutes = (absolute_difference/60).round
+        tz = "%s%02d:%02d" % [ difference_sign, difference_minutes / 60, difference_minutes % 60]
       end
-      if data.utc_offset != 0
-        value += data.utc_offset.to_s
+      standard = data.strftime( "%Y-%m-%d %H:%M:%S" )
+      standard += ".%06d" % [data.usec] if data.usec.nonzero?
+      standard += " %s" % [tz]
+      represent_scalar(data.taguri, standard)
+    end
+    
+    def represent_ruby(data)
+      state = data.to_yaml_properties
+      map = {}
+      state.each do |m|
+        map[m[1..-1]] = data.instance_variable_get(m)
       end
-      represent_scalar(data.taguri, value)
+      represent_mapping("!ruby/object:#{data.class.yaml_tag_class_name}", map,nil)
     end
     
     def represent_yaml_object(tag, data, flow_style=nil)
       state = data.to_yaml_properties
-      mapping = {}
+      map = {}
       state.each do |m|
         map[m[1..-1]] = data.instance_variable_get(m)
       end
-      represent_mapping(tag, mapping, flow_style)
+      represent_mapping(tag, map, flow_style)
     end
-    
+
     def represent_undefined(data)
       raise RepresenterError.new("cannot represent an object: #{data}")
     end
@@ -231,9 +264,10 @@ module RbYAML
   BaseRepresenter.add_representer(Hash,:represent_dict)
   BaseRepresenter.add_representer(Set,:represent_set)
   BaseRepresenter.add_representer(Time,:represent_datetime)
+  BaseRepresenter.add_representer(PrivateType,:represent_private_type)
+  BaseRepresenter.add_representer(Object,:represent_ruby)
   BaseRepresenter.add_representer(nil,:represent_undefined)
   
-  module Representer
-    include SafeRepresenter
+  class Representer < SafeRepresenter
   end
 end

data/lib/rbyaml/resolver.rb

@@ -3,7 +3,7 @@ require 'rbyaml/nodes'
 require 'rbyaml/error'
   
 module RbYAML
-  class ResolverError < MarkedYAMLError
+  class ResolverError < YAMLError
   end
 
   DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
@@ -11,7 +11,7 @@ module RbYAML
   DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
   
   class BaseResolver
-    @@yaml_implicit_resolvers = {}
+    @@yaml_implicit_resolvers = {""=>[['tag:yaml.org,2002:null',/^$/]]}
     @@yaml_path_resolvers = {}
 
     def initialize
@@ -86,7 +86,7 @@ module RbYAML
           end
         end
       else
-        for path, kind in @@yaml_path_resolvers
+        for path, kind in @@yaml_path_resolvers.keys
           if !path
             exact_paths[kind] = @@yaml_path_resolvers[[path, kind]]
           else
@@ -149,11 +149,11 @@ module RbYAML
   class Resolver < BaseResolver
   end
   
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:bool',/^(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:bool',/^(?:yes|Yes|YES|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?(?:[0-9][0-9_]*)?\.[0-9_]+(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:int',/^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?(?:0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$/,'-+0123456789')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:merge',/^(?:<<)$/,'<')
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:null',/^(?: ~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:null',/^(?:~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:timestamp',/^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]|[0-9][0-9][0-9][0-9]-[0-9][0-9]?-[0-9][0-9]?(?:[Tt]|[ \t]+)[0-9][0-9]?:[0-9][0-9]:[0-9][0-9](?:\.[0-9]*)?(?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$/,'0123456789')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:value',/^(?:=)$/,'=')
   # The following implicit resolver is only for documentation purposes. It cannot work

data/lib/rbyaml/{resolver.rb.~1.1.~ → resolver.rb.~1.6.~}

@@ -1,19 +1,20 @@
+require 'rbyaml/util'
 require 'rbyaml/nodes'
 require 'rbyaml/error'
   
 module RbYAML
-  class ResolverError < MarkedYAMLError
+  class ResolverError < YAMLError
   end
 
   DEFAULT_SCALAR_TAG = 'tag:yaml.org,2002:str'
   DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
   DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
   
-  module BaseResolver
+  class BaseResolver
     @@yaml_implicit_resolvers = {}
     @@yaml_path_resolvers = {}
 
-    def initialize_resolver
+    def initialize
       @resolver_exact_paths = []
       @resolver_prefix_paths = []
     end
@@ -31,7 +32,7 @@ module RbYAML
     def self.add_path_resolver(tag, path, kind=nil)
       new_path = []
       for element in path
-        if Array === element
+        if element.__is_a
           if element.length == 2
             node_check, index_check = element
           elsif element.length == 1
@@ -50,10 +51,10 @@ module RbYAML
           node_check = SequenceNode
         elsif Hash == node_check
           node_check = MappingNode
-        elsif ![ScalarNode, SequenceNode, MappingNode].include?(node_check) && !Symbol === node_check && !node_check.nil?
+        elsif ![ScalarNode, SequenceNode, MappingNode].include?(node_check) && !node_check.__is_sym && !node_check.nil?
           raise ResolverError.new("Invalid node checker: #{node_check}")
         end
-        if !(String === index_check || Integer === index_check) && !index_check.nil?
+        if !(index_check.__is_str || index_check.__is_int) && !index_check.nil?
           raise ResolverError.new("Invalid index checker: #{index_check}")
         end
         new_path << [node_check, index_check]
@@ -85,7 +86,7 @@ module RbYAML
           end
         end
       else
-        for path, kind in @@yaml_path_resolvers
+        for path, kind in @@yaml_path_resolvers.keys
           if !path
             exact_paths[kind] = @@yaml_path_resolvers[[path, kind]]
           else
@@ -104,16 +105,16 @@ module RbYAML
 
     def check_resolver_prefix(depth, path, kind, current_node, current_index)
       node_check, index_check = path[depth-1]
-      if String === node_check
+      if node_check.__is_str
         return false if current_node.tag != node_check
       elsif !node_check.nil?
         return false if !node_check === current_node
       end
       return false if index_check==true && !current_index.nil?
       return false if !index_check && current_index.nil?
-      if String === index_check
-        return false if !(ScalarNode === current_index && index_check == current_index.value)
-      elsif Integer === index_check
+      if index_check.__is_str
+        return false if !(current_index.__is_scalar && index_check == current_index.value)
+      elsif index_check.__is_int
         return false if index_check != current_index
       end
       true
@@ -122,11 +123,11 @@ module RbYAML
     def resolve(kind, value, implicit)
       if ScalarNode == kind && implicit[0]
         if value == ""
-          resolvers = @@yaml_implicit_resolvers.fetch("", [])
+          resolvers = @@yaml_implicit_resolvers.fetch("",[])
         else
-          resolvers = @@yaml_implicit_resolvers.fetch(value[0], [])
+          resolvers = @@yaml_implicit_resolvers.fetch(value[0],[])
         end
-        resolvers += @@yaml_implicit_resolvers.fetch(nil, [])
+        resolvers += @@yaml_implicit_resolvers.fetch(nil,[])
         for tag, regexp in resolvers
           return tag if regexp =~ value
         end
@@ -140,20 +141,19 @@ module RbYAML
       elsif SequenceNode == kind
         return RbYAML::DEFAULT_SEQUENCE_TAG
       elsif MappingNode == kind
-          return RbYAML::DEFAULT_MAPPING_TAG
+        return RbYAML::DEFAULT_MAPPING_TAG
       end
     end
   end
 
-  module Resolver
-    include BaseResolver
+  class Resolver < BaseResolver
   end
   
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:bool',/^(?:y|Y|yes|Yes|YES|n|N|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:bool',/^(?:yes|Yes|YES|no|No|NO|true|True|TRUE|false|False|FALSE|on|On|ON|off|Off|OFF)$/,'yYnNtTfFoO')
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:float',/^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+][0-9]+)?|[-+]?(?:[0-9][0-9_]*)?\.[0-9_]+(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*|[-+]?\.(?:inf|Inf|INF)|\.(?:nan|NaN|NAN))$/,'-+0123456789.')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:int',/^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?(?:0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(?::[0-5]?[0-9])+)$/,'-+0123456789')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:merge',/^(?:<<)$/,'<')
-  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:null',/^(?: ~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
+  BaseResolver.add_implicit_resolver('tag:yaml.org,2002:null',/^(?:~|null|Null|NULL| )$/,'~nN' + ?\0.chr)
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:timestamp',/^(?:[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]|[0-9][0-9][0-9][0-9]-[0-9][0-9]?-[0-9][0-9]?(?:[Tt]|[ \t]+)[0-9][0-9]?:[0-9][0-9]:[0-9][0-9](?:\.[0-9]*)?(?:[ \t]*(?:Z|[-+][0-9][0-9]?(?::[0-9][0-9])?))?)$/,'0123456789')
   BaseResolver.add_implicit_resolver('tag:yaml.org,2002:value',/^(?:=)$/,'=')
   # The following implicit resolver is only for documentation purposes. It cannot work

data/lib/rbyaml/rubytypes.rb

@@ -0,0 +1,391 @@
+require 'date'
+
+class Class
+  def to_yaml( opts = {} )
+    raise RbYAML::TypeError, "can't dump anonymous class %s" % self.class
+  end
+end
+
+class Object
+#  yaml_as "tag:ruby.yaml.org,2002:object"
+  def is_complex_yaml?; true; end
+  def to_yaml_style; end
+  def to_yaml_properties; instance_variables.sort; end
+  def to_yaml( opts = {} )
+    RbYAML::dump(self,nil,opts)
+  end
+  def taguri
+    "!ruby/object:#{self.class.name}"
+  end
+  def to_yaml_node( repre )
+    RbYAML::quick_emit_node( object_id, repre ) do |out|
+      mep = {}
+      to_yaml_properties.each do |m|
+        mep[m[1..-1]] = instance_variable_get(m)
+      end      
+      out.map(taguri,mep,to_yaml_style)
+    end
+  end
+end
+
+class Hash
+  yaml_as "tag:ruby.yaml.org,2002:hash"
+  yaml_as "tag:yaml.org,2002:map"
+  def is_complex_yaml?; true; end
+  def yaml_initialize( tag, val )
+    if Array === val
+      update Hash.[]( *val )		# Convert the map to a sequence
+    elsif Hash === val
+      update val
+    else
+      raise RbYAML::TypeError, "Invalid map explicitly tagged #{ tag }: " + val.inspect
+    end
+  end
+  def to_yaml_node(repre)
+    RbYAML::quick_emit_node(object_id, repre) {|rep|
+      rep.map(taguri,self,to_yaml_style)
+    }
+  end
+end
+
+class Struct
+  yaml_as "tag:ruby.yaml.org,2002:struct"
+  def self.yaml_tag_class_name; self.name.gsub( "Struct::", "" ); end
+  def self.yaml_tag_read_class( name ); "Struct::#{ name }"; end
+  def self.yaml_new( klass, tag, val )
+    if Hash === val
+      struct_type = nil
+      
+      #
+      # Use existing Struct if it exists
+      #
+      props = {}
+      val.delete_if { |k,v| props[k] = v if k =~ /^@/ }
+      begin
+        struct_name, struct_type = RbYAML.read_type_class( tag, Struct )
+      rescue NameError
+      end
+      if !struct_type
+        struct_def = [ tag.split( /:/, 4 ).last ]
+        struct_type = Struct.new( *struct_def.concat( val.keys.collect { |k| k.intern } ) ) 
+      end
+    
+      #
+      # Set the Struct properties
+      #
+      st = RbYAML::object_maker( struct_type, {} )
+      st.members.each do |m|
+        st.send( "#{m}=", val[m] )
+      end
+      props.each do |k,v|
+        st.instance_variable_set(k, v)
+      end
+      st
+    else
+      raise RbYAML::TypeError, "Invalid Ruby Struct: " + val.inspect
+    end
+  end
+  def to_yaml_node( repr)
+    RbYAML::quick_emit_node( object_id, repr ) do |out|
+      mep = {}
+      self.members.each do |m|
+        mep[m] = self[m]
+      end
+      self.to_yaml_properties.each do |m|
+        mep[m]=instance_variable_get( m )
+      end
+      
+      #
+      # Basic struct is passed as a YAML map
+      #
+      out.map( taguri, mep, to_yaml_style )
+    end
+  end
+end
+
+class Array
+  yaml_as "tag:ruby.yaml.org,2002:array"
+  yaml_as "tag:yaml.org,2002:seq"
+  def is_complex_yaml?; true; end
+  def yaml_initialize( tag, val ); concat( val.to_a ); end
+  def to_yaml_node(repre)
+    RbYAML::quick_emit_node(object_id, repre) {|rep|
+      rep.seq(taguri,self,to_yaml_style)
+    }
+  end
+end
+
+class Exception
+  yaml_as "tag:ruby.yaml.org,2002:exception"
+  def Exception.yaml_new( klass, tag, val )
+    o = RbYAML.object_maker( klass, { 'mesg' => val.delete( 'message' ) } )
+    val.each_pair do |k,v|
+      o.instance_variable_set("@#{k}", v)
+    end
+    o
+  end
+  def to_yaml_node( repr )
+    RbYAML::quick_emit_node( object_id, repr ) do |out|
+      mep = {}
+      mep['message'] = message
+      to_yaml_properties.each do |m|
+        mep[m[1..-1]] = instance_variable_get( m )
+      end
+      out.map( taguri, mep, to_yaml_style )
+    end
+  end
+end
+
+class String
+  yaml_as "tag:ruby.yaml.org,2002:string"
+  yaml_as "tag:yaml.org,2002:binary"
+  yaml_as "tag:yaml.org,2002:str"
+  def is_complex_yaml?
+    to_yaml_style or not to_yaml_properties.empty? or self =~ /\n.+/
+  end
+  def is_binary_data?
+    ( self.count( "^ -~", "^\r\n" ) / self.size > 0.3 || self.count( "\x00" ) > 0 ) unless empty?
+  end
+  def String.yaml_new( klass, tag, val )
+    val = val.unpack("m")[0] if tag == "tag:yaml.org,2002:binary"
+    val = { 'str' => val } if String === val
+    if Hash === val
+      s = klass.allocate
+      # Thank you, NaHi
+      String.instance_method(:initialize).
+        bind(s).
+        call( val.delete( 'str' ) )
+      val.each { |k,v| s.instance_variable_set( k, v ) }
+        s
+    else
+      raise RbYAML::TypeError, "Invalid String: " + val.inspect
+    end
+  end
+  def to_yaml_node(repre)
+    RbYAML::quick_emit_node( is_complex_yaml? ? object_id : nil, repre ) do |rep|
+      if is_binary_data?
+        rep.scalar( "tag:yaml.org,2002:binary", [self].pack("m"), "|")
+      elsif to_yaml_properties.empty?
+        rep.scalar(taguri, self, self =~ /^:/ ? '"' : to_yaml_style )
+      else
+        mep = {}
+        mep['str'] = "#{self}"
+        to_yaml_properties.each do |m|
+          mep.put[m] = instance_variable_get( m )
+        end
+        rep.map( taguri, mep, to_yaml_style )
+      end
+    end
+  end
+end
+
+class Symbol
+  yaml_as "tag:ruby.yaml.org,2002:symbol"
+  yaml_as "tag:ruby.yaml.org,2002:sym"
+  def is_complex_yaml?; false; end
+  def Symbol.yaml_new( klass, tag, val )
+    if String === val
+      val.intern
+      else
+      raise RbYAML::TypeError, "Invalid Symbol: " + val.inspect
+    end
+  end
+  def to_yaml_node( repr )
+    RbYAML::quick_emit_node( nil, repr ) do |out|
+      out.scalar( "tag:yaml.org,2002:str", self.inspect, nil )
+    end
+  end
+end
+
+class Range
+  yaml_as "tag:ruby.yaml.org,2002:range"
+  def Range.yaml_new( klass, tag, val )
+    inr = %r'(\w+|[+-]?\d+(?:\.\d+)?(?:e[+-]\d+)?|"(?:[^\\"]|\\.)*")'
+    opts = {}
+    if String === val and val =~ /^#{inr}(\.{2,3})#{inr}$/o
+      r1, rdots, r2 = $1, $2, $3
+      opts = {
+        'begin' => RbYAML.load( "--- #{r1}" ),
+        'end' => RbYAML.load( "--- #{r2}" ),
+        'excl' => rdots.length == 3
+      }
+      val = {}
+    elsif Hash === val
+      opts['begin'] = val.delete('begin')
+      opts['end'] = val.delete('end')
+      opts['excl'] = val.delete('excl')
+    end
+    if Hash === opts
+      r = RbYAML::object_maker( klass, {} )
+      # Thank you, NaHi
+      Range.instance_method(:initialize).
+        bind(r).
+        call( opts['begin'], opts['end'], opts['excl'] )
+      val.each { |k,v| r.instance_variable_set( k, v ) }
+      r
+    else
+      raise RbYAML::TypeError, "Invalid Range: " + val.inspect
+    end
+  end
+  def to_yaml_node( repr )
+    RbYAML::quick_emit_node( object_id, repr ) do |out|
+      mep = {'begin' => self.begin, 'end' => self.end, 'excl' => self.exclude_end?}
+      to_yaml_properties.each do |m|
+        mep[m] = instance_variable_get( m )
+      end
+      out.map( taguri, mep, to_yaml_style )
+    end
+  end
+end
+
+class Regexp
+  yaml_as "tag:ruby.yaml.org,2002:regexp"
+  def Regexp.yaml_new( klass, tag, val )
+    if String === val and val =~ /^\/(.*)\/([mix]*)$/
+      val = { 'regexp' => $1, 'mods' => $2 }
+    end
+    if Hash === val
+      mods = nil
+      unless val['mods'].to_s.empty?
+        mods = 0x00
+        mods |= Regexp::EXTENDED if val['mods'].include?( 'x' )
+        mods |= Regexp::IGNORECASE if val['mods'].include?( 'i' )
+        mods |= Regexp::MULTILINE if val['mods'].include?( 'm' )
+      end
+      val.delete( 'mods' )
+      r = RbYAML::object_maker( klass, {} )
+      Regexp.instance_method(:initialize).
+        bind(r).
+        call( val.delete( 'regexp' ), mods )
+      val.each { |k,v| r.instance_variable_set( k, v ) }
+      r
+    else
+      raise RbYAML::TypeError, "Invalid Regular expression: " + val.inspect
+    end
+  end
+  def to_yaml_node( repr )
+    RbYAML::quick_emit_node( nil, repr ) do |out|
+      if to_yaml_properties.empty?
+        out.scalar( taguri, self.inspect, nil )
+      else
+        mep = { }
+        src = self.inspect
+        if src =~ /\A\/(.*)\/([a-z]*)\Z/
+          mep['regexp']=$1
+          mep['mods']=$2
+        else
+          raise RbYAML::TypeError, "Invalid Regular expression: " + src
+        end
+        to_yaml_properties.each do |m|
+          mep[m] = instance_variable_get( m )
+        end
+        out.map( taguri, mep, to_yaml_style )
+      end
+    end
+  end
+end
+
+class Time
+  yaml_as "tag:ruby.yaml.org,2002:time"
+  yaml_as "tag:yaml.org,2002:timestamp"
+  def is_complex_yaml?; false; end
+  def Time.yaml_new( klass, tag, val )
+    if Hash === val
+      t = val.delete( 'at' )
+      val.each { |k,v| t.instance_variable_set( k, v ) }
+      t
+    else
+      raise RbYAML::TypeError, "Invalid Time: " + val.inspect
+    end
+  end
+  def to_yaml_node(repre)
+    RbYAML::quick_emit_node( object_id, repre ) do |out|
+      tz = "Z"
+      # from the tidy Tobias Peters <t-peters@gmx.de> Thanks!
+      unless utc?
+        utc_same_instant = dup.utc
+        utc_same_writing = Time.utc(year,month,day,hour,min,sec,usec)
+        difference_to_utc = utc_same_writing - utc_same_instant
+        if (difference_to_utc < 0) 
+          difference_sign = '-'
+          absolute_difference = -difference_to_utc
+        else
+          difference_sign = '+'
+          absolute_difference = difference_to_utc
+        end
+        difference_minutes = (absolute_difference/60).round
+        tz = "%s%02d:%02d" % [ difference_sign, difference_minutes / 60, difference_minutes % 60]
+      end
+      standard = strftime( "%Y-%m-%d %H:%M:%S" )
+      standard += ".%06d" % [usec] if usec.nonzero?
+      standard += " %s" % [tz]
+      out.scalar(taguri, standard, nil)
+    end
+  end
+end
+
+class Date
+  yaml_as "tag:yaml.org,2002:timestamp#ymd"
+  def is_complex_yaml?; false; end
+  def to_yaml_node(repre)
+    RbYAML::quick_emit_node( object_id, repre ) do |out|
+      out.scalar( "tag:yaml.org,2002:timestamp", self.to_s, nil )
+    end
+  end
+end
+
+class Numeric
+  def is_complex_yaml?; false; end
+  def to_yaml_node( repre )
+    RbYAML::quick_emit_node( nil, repre ) do |rep|
+      str = self.to_s
+      if str == "Infinity"
+        str = ".inf"
+      elsif str == "-Infinity"
+        str = "-.inf"
+      elsif str == "NaN"
+        str = ".nan"
+      end
+      rep.scalar( taguri, str, nil )
+    end
+  end
+end
+
+class Fixnum
+  yaml_as "tag:yaml.org,2002:int"
+end
+
+class Float
+  yaml_as "tag:yaml.org,2002:float"
+end
+
+class TrueClass
+  yaml_as "tag:yaml.org,2002:bool#yes"
+  def is_complex_yaml?; false; end
+  def to_yaml_node( repre )
+    RbYAML::quick_emit_node( nil, repre ) do |out|
+      out.scalar('tag:yaml.org,2002:bool', "true", nil)
+    end
+  end
+end
+
+class FalseClass
+  yaml_as "tag:yaml.org,2002:bool#no"
+  def is_complex_yaml?; false; end
+  def to_yaml_node( repre )
+    RbYAML::quick_emit_node( nil, repre ) do |out|
+      out.scalar('tag:yaml.org,2002:bool', "false",nil )
+    end
+  end
+end
+
+class NilClass 
+  yaml_as "tag:yaml.org,2002:null"
+  def is_complex_yaml?; false; end
+  def to_yaml_node( repre )
+    RbYAML::quick_emit_node( nil, repre ) do |out|
+      out.scalar(taguri, "", nil )
+    end
+  end
+end
+