Ron 0.1.1 → 0.1.2

data/History.txt

@@ -1,4 +1,30 @@
-=== 0.1.1 / 2009-08-05
+=== 0.1.2 / 21dec2009
+* 5 Major Bugfixes:
+  * preserve modules an object was extended by 
+    * (but not Recursive, which is an artifact of using ron)
+  * single quote and backslash now handled right in String
+  * all significant digits now preserved in Float (really)
+  * many small improvements to object graph copying (see below)
+  * ported to MRI 1.9
+
+* 2 Minor Bugfixes:
+  * preserve classes of descendants Regexp, Range, Array and Hash
+  * many changes to tests to improve coverage and correctness
+    * also, tests now work around bugs in yaml
+
+* 1 Minor Enhancement:
+  * reworked build/gem scripts
+
+* Improvements to object graph copying:
+  * depth-first copying is now available
+  * call may pass in a hash of objects to replace
+  * replacements when parent is nil or false are now an error
+  * protect against changes to hash, set, or array during traversal
+  * avoid inf-loop if replacing item with many items
+  * now possible to replace an object with another that contains the first
+  * in depth_graphcopy, delay all changes til right before the end
+
+=== 0.1.1 / 5aug2009
 * 1 Major Enhancement:
   * significant improvements and bugfixes in graphcopy 
 
@@ -7,7 +33,7 @@
   * ported to ruby 1.9
   * rewrote Class#- to be more compatible with Reg
 
-=== 0.1.0 / 2006-10-07
+=== 0.1.0 / 7oct2006
 
 * 1 major enhancement
   * Birthday!

data/Makefile

@@ -1,3 +1,12 @@
+name=Ron
+lname=ron
+gemname=Ron
+
+#everything after this line is generic
+
+version=$(shell ruby -r ./lib/$(lname)/version.rb -e "puts $(name)::VERSION")
+filelist=$(shell git ls-files)
+
 .PHONY: all test docs gem tar pkg email
 all: test
 
@@ -10,23 +19,25 @@ docs:
 pkg: gem tar
 
 gem:
-	gem build ron.gemspec
+	gem build $(lname).gemspec
 
 tar:
-	tar czf Ron-`ruby -r ./lib/ron/version.rb -e 'puts Ron::VERSION'`.tar.gz `git ls-files`
+	tar cf - $(filelist) | ( mkdir $(gemname)-$(version); cd $(gemname)-$(version); tar xf - )
+	tar czf $(gemname)-$(version).tar.gz $(gemname)-$(version)
+	rm -rf $(gemname)-$(version)
 
 email: README.txt History.txt
 	ruby -e ' \
   require "rubygems"; \
-  load "./ron.gemspec"; \
-  spec= Gem::Specification.list.find{|x| x.name=="Ron"}; \
+  load "./$(lname).gemspec"; \
+  spec= Gem::Specification.list.find{|x| x.name=="$(gemname)"}; \
   puts "\
-Subject: [ANN] Ron #{spec.version} Released \
-\n\nRon version #{spec.version} has been released! \n\n\
+Subject: [ANN] $(name) #{spec.version} Released \
+\n\n$(name) version #{spec.version} has been released! \n\n\
 #{Array(spec.homepage).map{|url| " * #{url}\n" }} \
  \n\
-#{Ron::Description} \
+#{$(name)::Description} \
 \n\nChanges:\n\n \
-#{Ron::Latest_changes} \
+#{$(name)::Latest_changes} \
 "\
 '

data/lib/ron.rb

@@ -4,6 +4,7 @@
 #require 'warning'
 require 'ron/graphedge'
 require 'continuation' unless defined? Continuation
+require 'ron/float_accurate_to_s'
 
 #to_ron
 
@@ -41,8 +42,15 @@ module Ron
   def self.load str
     eval str
   end
+
+  def self.extension_modules_of(obj)
+    ancs=class<<obj; ancestors end
+    ancs=ancs[0...ancs.index(obj.class)]
+    return ancs
+  rescue TypeError
+    return []
+  end
   
-  CaptureCtx=[]
 =begin  
   def self.recurse_safe_objects_equal?(o1,o2,session={})
     pair=[o1.__id__,o2.__id__]
@@ -51,13 +59,13 @@ module Ron
   
     o1.class==o2.class and
       case o1
-      when Array: 
+      when Array 
         o1.size==o2.size and
         o1.each_with_index{|i1,idx|
           recurse_safe_objects_equal?(i1,o2[idx],session) or return
         }
       
-      when Hash:
+      when Hash
         #oops, this depends on #== and #hash working right for recursive structures, which they don't.
         o1.size==o2.size or return      
         recurse_safe_objects_equal? o1.default,o2.default,session or return
@@ -65,28 +73,28 @@ module Ron
           return unless (o2.key? idx and recurse_safe_objects_equal? i1, o2[idx],session)
         }
 
-      when Range:
+      when Range
         o1.exclude_end?()==o2.exclude_end?() and
         recurse_safe_objects_equal? o1.begin, o2.begin,session and 
         recurse_safe_objects_equal? o1.end, o2.end,session 
 
-      when Struct:
+      when Struct
         (mems=o1.members).size==o2.members.size and 
         mems.each{|i|
           recurse_safe_objects_equal? o1[i], (o2[i] rescue return),session or return
         }
-      when Binding:
+      when Binding
         recurse_safe_objects_equal? o1.to_h, o2.to_h, session
-      when Proc,Integer,Float,String:
+      when Proc,Integer,Float,String
         o1==o2
       when Thread,ThreadGroup,Process,IO,Symbol,
-           Continuation,Class,Module:
+           Continuation,Class,Module
              return o1.equal?(o2)
-      when Exception:
+      when Exception
         o1.message==o2.message
-      when MatchData: 
+      when MatchData 
         o1.to_a==o2.to_a
-      when Time:
+      when Time
         o1.eql? o2
       else true
       end and
@@ -142,40 +150,65 @@ end
 [Fixnum,NilClass,FalseClass,TrueClass,Symbol].each{|k| 
   k.class_eval{ alias to_ron inspect; undef to_ron_list }
 }
-[Bignum,Float,].each{|k| 
-  k.class_eval{ def to_ron_list(session) [inspect] end }
-}
+
+class Bignum
+  def to_ron_list(session) [inspect] end
+end
+
+class Float
+  def to_ron_list(session) 
+    [accurate_to_s]
+  end
+end
 
 class String
     def to_ron_list session
-      
-      [ "'", gsub(/['\\]/){ '\\\\'+$&}, "'" ]
+      result= [ "'", gsub(/['\\]/){ '\\'+$&}, "'" ]
+      if self.class!=String
+        result=[self.class.name, ".new(", result, ")"]
+      end
+      result
     end
 end
 
 class Regexp
     def to_ron_list session
-      
-      [ inspect ]
+      if self.class==Regexp      
+        [ inspect ]
+      else
+        [self.class.name, ".new(", self.source.inspect, ")"]
+      end
     end
 end
 
 class Array
   def to_ron_list session
-    ["["] + 
+    result=["["] + 
      map{|i| 
           i.to_ron_list2(session)<<', ' 
         }.flatten<<
     "]"
+    result.unshift self.class.name unless self.class==Array
+    result
   end
 end
 
 class Hash
   def to_ron_list session
-    ["{"]+map{|k,v| 
-      Array(k.to_ron_list2(session)).push "=>",
+    if self.class==Hash
+      leader="{"
+      trailer="}"
+      sep="=>"
+    else
+      leader=self.class.name+"["
+      trailer="]"
+      sep=","
+    end
+
+    [leader]+map{|k,v| 
+      Array(k.to_ron_list2(session)).push sep,
           v.to_ron_list2(session)<<', ' 
-    }.flatten<<"}"
+    }.flatten<<trailer
   end
 end
 
@@ -185,7 +218,7 @@ class Object
     #warning "additional modules not handled"
       #warning "prettified output not supported"
     
-    to_ron_list2.to_s
+    to_ron_list2.join
   end
   
   def to_ron_list session
@@ -225,13 +258,21 @@ class Object
       result=to_ron_list(session).unshift str
       if result.last=="}#end object literal" 
         result.last.replace "}"
+        was_obj_syntax=true
       else
         #append instance_eval
-        ivars=instance_variables-::Ron::IGNORED_INSTANCE_VARIABLES[self.class.name]
+        ivars=instance_variables
+        ivars.map!{|iv| iv.to_s } if Symbol===ivars.first
+        ivars-=::Ron::IGNORED_INSTANCE_VARIABLES[self.class.name]
         ivars.empty? or result.push ".with_ivars(", *ivars.map{|iv| 
           [":",iv.to_s,"=>",instance_variable_get(iv).to_ron_list2(session),', ']
         }.flatten[0...-1]<<")"
       end
+      extensions=Ron::extension_modules_of(self)
+      unless extensions.empty?
+        result=["(",result,")"] if was_obj_syntax
+        result.push ".extend(",extensions,")"
+      end
       result.push ")" if str[/^Recursive\(/]
       session.objects_seen[__id__]=[session.objects_in_progress.pop[1]]
       result
@@ -268,7 +309,7 @@ Ron::IGNORED_INSTANCE_VARIABLES["Sequence::WeakRefSet"]=%w[@ids]
 class Range
   def to_ron_list session
 #    result=
-           ["Range.new(",first.to_ron_list2(session), ", ",
+           [self.class.name, ".new(",first.to_ron_list2(session), ", ",
                   last.to_ron_list2(session),
                   (", true" if exclude_end?),
             ")"
@@ -301,7 +342,7 @@ class Binding
     l<<"self"
     h={}
     l.each{|i| h[i.to_sym]=Kernel::eval i, self }
-    h[:yield]=Kernel::eval "block_given? and proc{|*a| #,&b\n yield(*a) #,&b\n}", self
+    h[:yield]=Kernel::eval "block_given? and proc{|*a__| #,&b__\n yield(*a__) #,&b__\n}", self
     h
   end
   
@@ -316,17 +357,17 @@ class Binding
     keys.empty? or
     code=keys.map{|k| 
       k.to_s
-    }.join(',')+'=*::Ron::CaptureCtx.last'
+    }.join(',')+',=*Thread.current[:$__Ron__CaptureCtx]'
     mname="Ron__capture_binding#{Thread.current.object_id}" #unlikely method name
-    newmname=result=nil
+    oldmname=newmname=result=nil
 
     eval "
-          Thread.critical=true
            newmname=class<<the_self;
              mname=oldmname='#{mname}'
-             im=instance_methods(false)
+             im=instance_methods
+             im.map!{|sym| sym.to_s} if Symbol===im.first
              mname+='-' while im.include? mname
-             alias_method mname, oldmname
+             alias_method mname, oldmname if im.include? oldmname
              def #{mname}
                #{code}
                binding
@@ -334,9 +375,9 @@ class Binding
              mname
            end
          " 
-          ::Ron::CaptureCtx.push h.values
+          Thread.current[:$__Ron__CaptureCtx]= h.values
           result=the_self.send mname, &the_block
-          ::Ron::CaptureCtx.pop
+          Thread.current[:$__Ron__CaptureCtx]=nil
           class<<the_self;
              self
           end.send(*if newmname==mname
@@ -344,7 +385,6 @@ class Binding
           else
            [:alias_method, mname, oldmname]
           end)
-          Thread.critical=false
           result
   end
   alias from_h -
@@ -378,22 +418,20 @@ UnboundMethod,
 
 
 #not sure about these:
-[
-Continuation,
-:Thread,
-:ThreadGroup,
-
-:Mutex, #??
 #and other interthead communication mechanisms, like
-:Queue,
-:SizedQueue,
-:RingBuffer,
-:ConditionVariable,
-:Semaphore,
-:CountingSemaphore,
-:Multiwait,
-].each{|sym|
-  k=(Object.const_get(sym) rescue nil) and 
+eval("["+%w[
+Continuation
+Thread
+ThreadGroup
+Mutex
+Queue
+SizedQueue
+RingBuffer
+ConditionVariable
+Semaphore
+CountingSemaphore
+Multiwait
+].map{|x| "(#{x} if defined? #{x}), "}.join+"]").compact.each{|k|
   k.class_eval do
     def to_ron(x=nil); raise Ron:: NotYetMaybeNeverSerializeableError end
     alias to_ron_list to_ron

data/lib/ron/column_order.rb

@@ -86,7 +86,7 @@ module ForModule
     #column_order defaults to attribute order if not given
     cols=(@COLUMN_ORDER if defined? @COLUMN_ORDER) || @REG_ATTRIBUTE_ORDER
 
-    meths=instance_methods(false)
+    meths=instance_methods(false).map{|im| im.to_s}
 
     module_eval <<-"END"
       private #utility methods

data/lib/ron/float_accurate_to_s.rb

@@ -0,0 +1,168 @@
+begin #redparse/float_accurate_to_s overrides this one, if present
+  require 'redparse/float_accurate_to_s'
+  overridden=true
+rescue Exception #and ignore
+end
+
+class Float
+  SIZE=[1.1].pack("d").size
+  BITSIZE=SIZE*8
+  BASE10_DIGITS=(2**BITSIZE-1).to_s.size
+  def accurate_to_s
+    return "#{'-' if self<0}Infinity" if infinite?
+    return "NaN" if nan?
+    return "0.0e0" if zero?
+
+    as_str=sprintf("%.#{BASE10_DIGITS+2}e",self)
+
+    #decompose self into sign, mantissa, and exponent (in string form)
+    all,sign,first,digits,exp=*as_str.match(/^([+-]?)(\d)\.(\d+)e(.*)$/)
+    digits=first<<digits
+    exp=exp.to_i+1
+    lead=sign<<"0."
+    return digits=digits if as_str.to_f.zero? #hopeless
+
+    #recompose back to a float
+    result=[lead,digits,"e",exp].join
+    result_f=result.to_f
+    delta=result_f - self
+    return digits=digits if delta.zero? #if representation is exact, return here
+
+    #figure out which direction to go to get toward the right answer
+    if delta<0
+      incr=1
+    else #delta>0
+      incr=-1
+    end
+
+    #keep adding increasing increments to mantissa
+    #until we get to a value on the other side of the correct answer
+    while true
+      while true
+        try_digits=digits.to_i.+(incr).to_s
+        if try_digits.size>digits.size
+          exp+=1
+          digits="0"+digits
+        end
+        fail if try_digits[0]==?- #can't happen... I think?
+        trying=[lead,try_digits,"e",exp].join
+        trying_f=trying.to_f
+        break unless trying_f.zero?
+        digits[-1,1]='' #workaround 1.8 bug
+      end
+      return digits=try_digits if trying_f==self
+      break if self.between?(*[trying_f,result_f].sort) #(trying_f-self)*delta<0
+      incr*=2
+    end
+
+    #we now have lower and upper bounds on the correct answer
+    lower,upper=*[digits.to_i, digits.to_i.+(incr)].sort
+
+    #maybe one of the bounds is already the correct answer?
+    result=[lead,lower,"e",exp].join
+    return digits=lower if result.to_f==self
+    result=[lead,upper,"e",exp].join
+    return digits=upper if result.to_f==self
+
+    #binary search between lower and upper bounds til we find a correct answer
+    digits=nil
+    while true
+      return as_str if upper-lower <= 1 #hopeless
+      mid=(lower+upper)/2
+      mid_s=[lead,mid,"e",exp].join
+      mid_f=mid_s.to_f
+      return digits=mid if mid_f==self
+      if mid_f<self
+        lower=mid
+      else #mid_f>self
+        upper=mid
+      end
+    end
+  ensure
+
+    #try to drop unneeded trailing digits
+    if digits
+      digits=digits.to_s
+      begin
+        last=digits.slice! -1
+        result=[lead,digits,"e",exp].join.to_f
+      end while result==self or result.zero? && digits.size.nonzero?
+      roundup=(digits.to_i+1).to_s
+      if roundup.size>digits.size
+        exp+=1
+        digits="0"+digits
+      end
+      roundup.slice! /0+\Z/
+      roundup=[lead,roundup,"e",exp].join
+      return roundup if roundup.to_f==self
+      return [lead,digits<<last,"e",exp].join
+    end
+  end
+end unless overridden
+
+=begin not quite accurate, tho
+class String
+  def accurate_to_f
+    all,sign,int,frac,exp=*self.match(/\A([+-])?([0-9_]+)(?:\.([0-9_]+))?(?:[eE]([+-]?[0-9_]+))?/)
+    exp=exp.to_i||0
+    exp-=frac.size
+    mantissa=sign<<int<<frac
+    mantissa=mantissa.to_f
+    scale=10.0**exp
+    return mantissa*scale
+  end
+end unless overridden
+=end
+
+eval DATA.read if __FILE__==$0
+__END__
+
+require 'test/unit'
+
+class FloatRoundTripTest<Test::Unit::TestCase
+def float_round_trip f
+  str=f.accurate_to_s
+  if str=="Infinity"
+    return 1.0/0
+  elsif str=="-Infinity"
+    return -1.0/0
+  elsif str=="NaN"
+    return 0.0/0.0
+  else
+    str.to_f
+  end
+end
+alias frt float_round_trip
+
+def rand_float
+  base=rand
+  range=Float::MIN_10_EXP..Float::MAX_10_EXP
+  extent=range.last-range.first
+  offset=rand(extent+1)
+  exp=range.first+offset
+  base*=10**exp
+end
+
+def test_frt
+  data=[0.399891415240566, 0.198188037200931, 0.90302699802093,
+        7.48121345153454520016e-01, 4.11408313999083175005e-02,
+        2.68070684698467065488e-02, 3.85029229764812574999e-01,
+        "\327\237vY\343n\342?".unpack("d")[0], 
+        1.0/0, -1.0/0, 0.0/0.0,
+        "\333\211>4\253Atu".unpack("d")[0],
+        "\2461\220\253\214\267e\021".unpack("d")[0],
+        "\r\032N\f'\336\243\003".unpack("d")[0],
+        "B[\226\001\2175f\021".unpack("d")[0],
+        "%\217\336\362\326\272\026\001".unpack("d")[0],
+        "\312\342\344\206\237\024\"\003".unpack("d")[0],
+  ]
+  1_000_000.times{|i|
+    f=data.shift||rand_float
+    p sprintf("%.#{Float::BASE10_DIGITS}e",f)
+    p [f].pack"d"
+    p f.accurate_to_s
+    f2=frt f
+    warn "failed with i=#{i} f=#{f}, #{[f].pack("d").inspect}; f2=#{f2}, #{[f2].pack("d").inspect}" unless [f].pack("d")==[f2].pack("d")
+  }
+end
+end

data/lib/ron/graphedge.rb

@@ -38,23 +38,69 @@ module Ron
       end
       
       #--------------------------------
-      def graphcopy(obj)
-        old2new={}
+      #
+      #NOTE: breadth_graphcopy has a problem; since graphwalk is not depth-first,
+      #      if a node is replaced, the subnodes of the new node will not be walked.
+      #      Instead, the old nodes will be walked.
+      #      If this causes problems, use depth_graphcopy instead
+      def breadth_graphcopy(obj,old2new={})
         root=nil
-        graphwalk(obj){|cntr,o,i,ty|
+        breadth_graphwalk(obj){|cntr,o,i,ty|
           newo= block_given? && (yield cntr,o,i,ty,useit=[false]) 
-          useit.first or newo= old2new[o.__id__] ||= o.clone rescue o
+          if useit.first 
+            #fail unless newo
+            old2new[o.__id__]=newo
+          else 
+            #fail unless o
+            newo= old2new[o.__id__] ||= (o.clone rescue o)
+          end
           #IO objects really shouldn't be dup'd here
           if Ron::GraphEdge::TopLevel==ty
             root=newo
           else
+            #fail unless old2new.has_key? cntr.__id__
             ty.new(old2new[cntr.__id__],i,1){newo}.replace
           end
         }
         return root
       end
+
+      #--------------------------------
+      def depth_graphcopy(obj,old2new={})
+        root=nil
+        changes=[]
+        depth_graphwalk(obj){|cntr,o,i,ty|
+          newo=yield cntr,o,i,ty,useit=[false] if block_given?
+          if useit.first
+            #p [cntr.id,cntr,o,:>>,newo,newo.last.__id__]
+            old2new[o.__id__]=o #bad, bad... shouldn't be refs to old tree in old2new
+          else
+            begin
+              newo=o.clone
+            rescue Exception
+              newo=o
+            else
+              old2new[o.__id__]=newo
+            end
+          end
+          #IO objects really shouldn't be dup'd here
+          if Ron::GraphEdge::TopLevel==ty
+            root=newo
+          else
+            changes.push ty,cntr.__id__,i,newo
+          end
+        }
+        until changes.empty?
+          ty,cntr_id,i,newo=*changes.slice!(-4,4)
+          new_cntr=old2new[cntr_id]
+          ty.new(new_cntr,i,1){newo}.replace if old2new.has_key? cntr_id
+        end
+        return root
+      end
+      alias graphcopy depth_graphcopy
       
       #--------------------------------
+      #breadth-first walk of an object graph
       def graphwalk(obj)
         yield nil,obj,nil,GraphEdge::TopLevel
         todolist=[obj]
@@ -69,7 +115,18 @@ module Ron
           }
         }
       end
-    
+      alias breadth_graphwalk graphwalk
+
+      #--------------------------------
+      #depth-first walk of an object graph
+      def depth_graphwalk(obj,container=nil,index=nil,type=GraphEdge::TopLevel,seen=Set[],&block)
+        seen<<[container.__id__,type,index]
+        traverse(obj){|cntr,o,i,ty|
+          depth_graphwalk(o,cntr,i,ty,seen,&block) unless seen.include? [cntr.__id__,ty,i]
+        }
+        block[ container,obj,index,type ]
+      end
+
       #--------------------------------
       def abortable_graphwalk(obj)
         return unless yield nil,obj,nil,GraphEdge::TopLevel
@@ -93,7 +150,7 @@ module Ron
         case obj
         when nil; #do nothing
         when (Set if defined? Set)
-          obj.each{|elem|
+          obj.dup.each{|elem|
             yield(obj,elem, elem, GraphEdge::SetMember)
           }
         when Struct;
@@ -101,12 +158,12 @@ module Ron
             yield(obj,obj[mem],mem, GraphEdge::BracketsValue)
           }
         when Hash;
-          obj.each{|(i,elem)| 
+          obj.keys.each{|i| elem=obj[i]
             yield(obj,elem,i, GraphEdge::HashValue)          
             yield(obj,i,i, GraphEdge::HashKey)
           }
         when Array;
-          obj.each_with_index{|elem,i| 
+          (obj.size-1).downto(0){|i| elem=obj[i]
             yield(obj,elem,i, GraphEdge::Array)
           }
         when Range;
@@ -120,7 +177,7 @@ module Ron
         end
          #traverse instance vars in any case
           obj.instance_variables.each{|var|
-            yield obj, (obj.instance_variable_get var), var, GraphEdge::ObjectIvarValue
+            yield obj, (obj.instance_variable_get var), var.to_s, GraphEdge::ObjectIvarValue
           }
       end
       
@@ -158,7 +215,7 @@ module Ron
     def initialize(context,index,len=1,&newval_code)
        len>=0 or raise ArgumentError
       @context,@index,@len,@newval_code=context,index,len,newval_code
-      ObjectSpace.define_finalizer(@context,(method :context_died))
+      fail unless @context
     end
     attr_reader :index,:len,:context
     
@@ -167,9 +224,9 @@ module Ron
     
     def call; replace; end
     
-    def context_died
-      @context=nil
-    end
+#    def context_died
+#      @context=nil
+#    end
     
     def new_value
       @newval_code[self]
@@ -191,9 +248,22 @@ module Ron
         context[@index]
       end
       
-      def replace(*newvals)
-        newvals.empty? and newvals=[new_value]
-        context[@index]=*newvals
+
+      a=[]
+      a[0]=*[1]
+      if a==[1]
+        def replace(*newvals)
+          newvals.empty? and newvals=[new_value]
+          context[@index]=*newvals
+        end
+      elsif a==[[1]] #goddamn 1.9 array multiple assignment semantics!
+        def replace(*newvals)         
+          if newvals.empty? then newvals=new_value
+          elsif newvals.size==1 then newvals=newvals[0]
+          end
+          context[@index]=newvals
+        end
+      else fail
       end
     end
 

data/lib/ron/version.rb

@@ -1,3 +1,3 @@
 module Ron
-  VERSION="0.1.1"
+  VERSION="0.1.2"
 end

data/ron.gemspec

@@ -1,28 +1,29 @@
 # -*- encoding: utf-8 -*-
 
-require './lib/ron/version'
+require "#{File.dirname(__FILE__)}/lib/ron/version"
 Ron::Description=open("README.txt"){|f| f.read[/^==+ ?description[^\n]*?\n *\n?(.*?\n *\n.*?)\n *\n/im,1] }
 Ron::Latest_changes="###"+open("History.txt"){|f| f.read[/\A===(.*?)(?====)/m,1] }
 
 Gem::Specification.new do |s|
   s.name = "Ron"
   s.version = Ron::VERSION
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Caleb Clausen"]
   s.date = Time.now.strftime("%Y-%m-%d")
+  s.authors = ["Caleb Clausen"]
   s.email = %q{caleb (at) inforadical (dot) net}
-  s.extra_rdoc_files = ["README.txt", "COPYING", "GPL"]
-  s.files = `git ls-files`.split
-  s.has_rdoc = true
+  s.summary = "Ruby Object Notation (Ron) is a ruby-based textual format for representing Ruby data."
+  s.description = Ron::Description
   s.homepage = %{http://github.com/coatl/ron}
-  s.rdoc_options = %w[--inline-source --main README.txt]
-  s.require_paths = ["lib"]
   s.rubyforge_project = %q{ron}
-  s.rubygems_version = %q{1.3.0}
+
+  s.files = `git ls-files`.split
   s.test_files = %w[test/test_all.rb]
-  s.summary = "Ruby Object Notation (Ron) is a ruby-based textual format for representing Ruby data."
-  s.description = Ron::Description
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.txt", "COPYING", "GPL"]
+  s.has_rdoc = true
+  s.rdoc_options = %w[--main README.txt]
+
+  s.rubygems_version = %q{1.3.0}
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
 =begin
   if s.respond_to? :specification_version then

data/test/test_all.rb

@@ -18,6 +18,8 @@ try_require 'rubygems'
 try_require("sequence/weakrefset")
 try_require 'facets/more/superstruct' 
 
+require "test/test_graphcopy"
+
 $Verbose=true
 
 =begin
@@ -67,10 +69,33 @@ def == bm
 end
 end
 
+class MyString<String
+  attr_accessor :ivar
+end
+
+class MyRegexp<Regexp
+  attr_accessor :ivar
+end
+
+class MyArray<Array
+  attr_accessor :ivar
+end
+
+class MyHash<Hash
+  attr_accessor :ivar
+end
+
+class MyRange<Range
+  attr_accessor :ivar
+end
+
+module M
+end
+
+
 class RonTest<Test::Unit::TestCase
 
 def test_ron
-
 s1=1.0
 s2=2.0
 range=s1..s2
@@ -83,13 +108,16 @@ s2.instance_variable_set(:@n, ss)
 s1=1.0
 s2=2.0
 sss=SortedSet[s1,s2]
-s1.instance_variable_set(:@n, sss)
-s2.instance_variable_set(:@n, sss)
+s1.instance_variable_set(:@o, sss)
+s2.instance_variable_set(:@o, sss)
 
  sss.inspect  #disable this and tests fail...  why?!?!?
+strongrefs=%w[a b c]
 data=[
-
+ 34565.23458888888*0.5,
+ 45245.765735422567*0.5,
  3.14159,
+ 1.2345678901234567,
  2**2000,
 
  "string",
@@ -111,7 +139,7 @@ data=[
  [1,2,3],
  {1=>2,3=>4},
  Set[1,2,3],
- (Sequence::WeakRefSet[*%w[a b c]] rescue warn 'weakrefset test disabled'),
+ (Sequence::WeakRefSet[*strongrefs] rescue warn 'weakrefset test disabled'),
  A_Class.new,
  2,
  :symbol,
@@ -119,10 +147,18 @@ data=[
  true,
  false,
  
- 
+ MyString.new,
+ MyRegexp.new(//),
+ MyArray.new,
+ MyHash.new,
+ MyRange.new(1,2),
+
+ "\\",
+ "'", 
 ]
 data.each{|datum|
- # p datum
+  GC.disable
+  #p datum
   assert_equal datum, datum
   assert_equal datum, ( dup=eval datum.to_ron )
   assert_equal internal_state(datum), internal_state(dup)
@@ -138,17 +174,30 @@ data.each{|datum|
   datum.instance_eval{@c=self}
   assert_equal datum, ( dup=eval datum.to_ron )
   assert_equal internal_state(datum), internal_state(dup)
+
+  datum.extend(M)
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)  
+  assert M===dup
   end
+  GC.enable
 }
 data.each{|datum|
+  GC.disable
   if case datum
      when Fixnum,Symbol,true,false,nil; false
      else true
      end
   datum.instance_eval{@d=data}
-  assert datum, ( dup=eval datum.to_ron )
-  assert internal_state(datum), internal_state(dup)
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)
+  
+  datum.extend(M)
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)
+  assert M===dup
   end
+  GC.enable
 }
 
 data2=[
@@ -160,35 +209,57 @@ data2=[
  (h={};h[h]=0;h),
  (h={};h[h]=h;h),
  (s=Set[];s<<s;s),
+ (o=MyString.new; o.ivar=o; o),
+ (o=MyArray.new; o.ivar=o; o),
+ (o=MyHash.new; o.ivar=o; o),
+ (o=MyArray.new; o<<o),
+ (o=MyHash.new; o[1]=o; o),
+ (o=MyRange.new(1,2); o.ivar=o; o),
 ]
-data2.each{|datum|
- #p datum
+  data2.each{|datum|
+  GC.disable
+  #p datum
   assert_equal datum.to_yaml, datum.to_yaml
-  assert_equal datum.to_yaml, ( dup=eval datum.to_ron ).to_yaml
-  assert_equal internal_state(datum).to_yaml, internal_state(dup).to_yaml
+  dup=eval datum.to_ron
+  dup.inspect #shouldn't be needed
+  assert_equal datum.to_yaml, dup.to_yaml
+  assert_equal internal_state(datum)[0...2], internal_state(dup)[0...2]
+  assert_equal internal_state(datum)[2..-1].to_yaml, internal_state(dup)[2..-1].to_yaml
  
   if case datum
      when Fixnum,Symbol,true,false,nil; false
      else true
      end
   datum.instance_eval{@a,@b=1,2}
-  assert_equal datum.to_yaml, ( dup=eval datum.to_ron ).to_yaml
-  assert_equal internal_state(datum).to_yaml, internal_state(dup).to_yaml
+  dup=eval datum.to_ron
+  dup.inspect #shouldn't be needed
+  assert_equal datum.to_yaml,  dup.to_yaml
+  assert_equal internal_state(datum)[0...2], internal_state(dup)[0...2]
+  assert_equal internal_state(datum)[2..-1].to_yaml, internal_state(dup)[2..-1].to_yaml
 
   datum.instance_eval{@c=self}
-  assert_equal datum.to_yaml, ( dup=eval datum.to_ron ).to_yaml
-  assert_equal internal_state(datum).to_yaml, internal_state(dup).to_yaml
+  dup=eval datum.to_ron
+  dup.inspect #shouldn't be needed
+  assert_equal datum.to_yaml, dup.to_yaml
+  assert_equal internal_state(datum)[0...2], internal_state(dup)[0...2]
+  assert_equal internal_state(datum)[2..-1].to_yaml, internal_state(dup)[2..-1].to_yaml
+
+  datum.extend(M)
+  dup=eval datum.to_ron
+  dup.inspect #shouldn't be needed
+  assert_equal datum.to_yaml, dup.to_yaml
+  assert_equal internal_state(datum)[0...2], internal_state(dup)[0...2]
+  assert_equal internal_state(datum)[2..-1].to_yaml, internal_state(dup)[2..-1].to_yaml  
+  assert M===dup
   end
-}
-datum= ((w=Sequence::WeakRefSet[];w<<w;w) rescue warn 'weakrefset test disabled')
+  GC.enable
+  }
+  GC.disable
+  datum= ((w=Sequence::WeakRefSet[];w<<w;w) rescue warn 'weakrefset test disabled')
   assert_equal datum.inspect, datum.inspect
   assert_equal datum.inspect, ( dup=eval datum.to_ron ).inspect
   assert_equal internal_state(datum).inspect, internal_state(dup).inspect
  
-  if case datum
-     when Fixnum,Symbol,true,false,nil; false
-     else true
-     end
   datum.instance_eval{@a,@b=1,2}
   assert_equal datum.inspect, ( dup=eval datum.to_ron ).inspect
   assert_equal internal_state(datum).inspect, internal_state(dup).inspect
@@ -196,24 +267,26 @@ datum= ((w=Sequence::WeakRefSet[];w<<w;w) rescue warn 'weakrefset test disabled'
   datum.instance_eval{@c=self}
   assert_equal datum.inspect, ( dup=eval datum.to_ron ).inspect
   assert_equal internal_state(datum).inspect, internal_state(dup).inspect
-  end
 
-data2.each{|datum| 
-  if case datum
-     when Fixnum,Symbol,true,false,nil; false
-     else true
-     end
-  datum.instance_eval{@d=data;@e=data2}
-#breaks yaml
- # assert_equal datum.to_yaml, ( dup=eval datum.to_ron ).to_yaml
- # assert_equal internal_state(datum).to_yaml, internal_state(dup).to_yaml
-  end
-}
+  datum= (o=MyRegexp.new(//); o.ivar=o; o)
+  ron=datum.to_ron
+  assert_match %r"Recursive\(v\d+_=\{\}, MyRegexp\.new\(\"\"\)\.with_ivars\(:@ivar=>v\d+_\)\)", ron
+  assert_equal datum,eval(ron)
+  datum.extend M
+  ron=datum.to_ron
+  assert M===eval(ron)
+  GC.enable
+end
+
+def nonrecursive_ancestors_of x
+  class<<x;ancestors end-[Recursive]
+rescue TypeError
+  []
 end
 
 def internal_state x
-  list=(x.instance_variables-::Ron::IGNORED_INSTANCE_VARIABLES[x.class.name]).sort
-  [list]+list.map{|iv| x.instance_variable_get(iv)}
+  list=(x.instance_variables.map!{|iv| iv.to_s}-::Ron::IGNORED_INSTANCE_VARIABLES[x.class.name]).sort
+  [x.class,nonrecursive_ancestors_of(x),list]+list.map{|iv| x.instance_variable_get(iv)}
 end
 
 end

data/test/test_graphcopy.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'ron'
+require 'ron/graphedge'
+require 'pp'
+
+class TestGraphCopy<Test::Unit::TestCase
+  inner=["foo",nil]
+  TESTDATA=[
+    {:one=>inner, :two=>inner, :three=>nil}
+  ]
+
+  def test_depth
+    TESTDATA.each{|td|
+      copy=Ron::GraphWalk::depth_graphcopy(td){|cntr,o,i,ty,useit|
+        if :one==i and Ron::GraphEdge::HashValue==ty
+          useit[0]=true
+          ["bar"]
+        elsif "foo"==o
+          useit[0]=true
+          "baz"
+        end
+      }
+      assert_equal({:three=>nil, :one=>["bar"], :two=>["baz", nil]}, copy)
+    }
+  end
+
+  def test_breadth
+    TESTDATA.each{|td|
+      copy=Ron::GraphWalk::breadth_graphcopy(td){|cntr,o,i,ty,useit|
+        if :one==i and Ron::GraphEdge::HashValue==ty
+          useit[0]=true
+          ["bar"]
+        elsif "foo"==o
+          useit[0]=true
+          "baz"
+        end
+      }
+      assert_equal({:three=>nil, :one=>["baz", nil], :two=>["baz", nil]}, copy)
+      #?? is that really the right output ??
+    }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Ron
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Caleb Clausen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-05 00:00:00 -07:00
+date: 2010-01-03 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -28,20 +28,19 @@ files:
 - GPL
 - History.txt
 - Makefile
-- Manifest.txt
 - README.txt
-- Rakefile
 - lib/ron.rb
 - lib/ron/column_order.rb
+- lib/ron/float_accurate_to_s.rb
 - lib/ron/graphedge.rb
 - lib/ron/version.rb
 - ron.gemspec
 - test/test_all.rb
+- test/test_graphcopy.rb
 has_rdoc: true
 homepage: http://github.com/coatl/ron
 post_install_message: 
 rdoc_options: 
-- --inline-source
 - --main
 - README.txt
 require_paths: 

data/Manifest.txt

@@ -1,9 +0,0 @@
-History.txt
-Manifest.txt
-README.txt
-Rakefile
-lib/ron.rb
-lib/ron/version.rb
-lib/ron/graphedge.rb
-lib/ron/column_order.rb
-test/test_all.rb

data/Rakefile

@@ -1,37 +0,0 @@
-# Copyright (C) 2006  Caleb Clausen
-# Distributed under the terms of Ruby's license.
-require 'rubygems'
-require 'hoe'
-require 'lib/ron/version.rb'
- 
-if $*==["test"]
-  #hack to get 'rake test' to stay in one process
-  #which keeps netbeans happy
-  $:<<"lib"
-#  require 'ron.rb'
-#  require "test/unit"
-  require "test/test_all.rb"
-  Test::Unit::AutoRunner.run
-  exit
-end
-
- 
- 
-   Hoe.new("Ron", Ron::VERSION) do |_|
-
-     _.author = "Caleb Clausen"
-     _.email = "ron-owner @at@ inforadical .dot. net"
-     _.url = "http://rubyforge.org/projects/ron"
-     _.summary = "Ron is a ruby-based serialization format for representing any ruby 
-object graph."
-
-     _.description = <<'END'
-Ron is very much like JSON, but based around Ruby instead of JavaScript.
-Stardard Ruby literal notation is extended to include an object literal
-and a way to create self-referencing data structures.
-END
-     _.changes='' #1st version, no changes
-   end
-
-   # add other tasks here
-