Ron 0.1.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2006-10-07
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,9 @@
+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/README.txt

@@ -0,0 +1,84 @@
+Well, who needed another serialization format? Not me, but that's
+what I've made. Ruby Object Graph (Ron) is a textual format for
+the representation of Ruby data structures. It's somewhat like
+YAML, XML, or (most of all) JSON. However, since it is defined 
+entirely within and as a subset of Ruby, it has the slick 
+property that Ron expressions are legal Ruby. Thus it is very
+like JSON, except that it's Ruby-centered instead of being 
+JavaScript-centered.
+
+Another way to look at Ron is as a purely declarative language 
+for creating (almost) any type of Ruby data structure.
+
+Ruby already has formats for representing a literal Array, Hash,
+Set, String, Symbol, Integer, etc. Ron simply reuses the same
+notations for those data types. The major new feature of Ron is
+that it provides a literal syntax for representing arbitrary 
+Ruby Objects. 
+
+Say you have a class that looks like this:
+
+  class K
+    attr :a
+    attr :b
+  end
+
+A Ron literal that represents a K instance might look like this:
+
+  K-{:@a=>1, :@b=>2}
+
+Better yet, if you provide setters as well as getters, you can 
+leave off the @ signs:
+
+  class K 
+    attr_accessor :a,:b
+  end
+
+  K-{:a=>1, :b=>2}
+
+
+This construct breaks encapsulation, so use the capability with 
+moderation and prudence, please. 
+
+An existing object can be rendered into Ron form with a call to 
+Ron.dump:
+
+  Ron.dump([1,2,3])   #=>"[1, 2, 3]"
+
+Ron.load is the inverse operation; it takes a Ron-formatted
+string and converts it back to a live Ruby object. (This is
+just an alias of eval.):
+
+  Ron.load("K-{:@a=>1, :@b=>2}")  #=> #<K:@a=2, @b=2>
+
+
+Most objects also have a #to_ron method which works just like
+Ron.dump; however, Ron.dump is the preferred form.
+
+In order to facilitate the dumping of bindings, two methods are 
+provided that rip out the guts of a Binding and stuff them back 
+in again: Binding#to_h and Binding.from_h.
+
+bugs and limitations
+Currently, some types of ruby object cannot be dumped. In some 
+cases, this is because it is impossible to (correctly) dump those
+objects. In others, it's merely difficult. Here are the ones I 
+think I should eventually be doing, mostly with ParseTree help:
+
+(anonymous) Class and Module
+Method
+UnboundMethod
+Proc
+
+These are very difficult, and I don't see how to approach them 
+correctly (but it would be very nice...):
+
+Thread
+Continuation
+
+These are more or less impossible:
+
+File
+Dir
+Process
+IO

data/Rakefile

@@ -0,0 +1,27 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'rubygems'
+require 'hoe'
+require 'lib/ron/version.rb'
+ 
+ 
+ 
+ 
+   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
+

data/lib/ron.rb

@@ -0,0 +1,466 @@
+#require 'warning'
+require 'ron/graphedge'
+
+
+
+#to_ron
+
+class Object
+  #forward decls
+  def to_ron; end
+  def to_ron_list(x=nil); end
+end
+
+module Ron
+  class NotSerializeableError<RuntimeError; end
+  class NotYetSerializeableError<NotSerializeableError; end
+  class NotYetMaybeNeverSerializeableError<NotSerializeableError; end
+  
+  class Session
+    def initialize
+      @objects_seen={} #hash of object id to reference to string in output
+      @objects_in_progress=[]
+      #@output=[] #array of strings of data to be output
+    end    
+    attr_reader :objects_in_progress, :objects_seen
+  end  
+  IGNORED_INSTANCE_VARIABLES=Hash.new{[]}
+  DefaultMarker={}.freeze
+
+  @@local_names_generated=0
+  def Ron.gen_local_name
+    "v#{@@local_names_generated+=1}_"
+  end  
+
+  def self.dump obj
+    obj.to_ron
+  end
+
+  def self.load str
+    eval str
+  end
+  
+  CaptureCtx=[]
+=begin  
+  def self.recurse_safe_objects_equal?(o1,o2,session={})
+    pair=[o1.__id__,o2.__id__]
+    return true if session[pair]
+    session[pair]=1
+  
+    o1.class==o2.class and
+      case o1
+      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:
+        #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
+        o1.each_with_index{|(idx,i1),bogus|
+          return unless (o2.key? idx and recurse_safe_objects_equal? i1, o2[idx],session)
+        }
+
+      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:
+        (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:
+        recurse_safe_objects_equal? o1.to_h, o2.to_h, session
+      when Proc,Integer,Float,String:
+        o1==o2
+      when Thread,ThreadGroup,Process,IO,Symbol,
+           Continuation,Class,Module:
+             return o1.equal?(o2)
+      when Exception:
+        o1.message==o2.message
+      when MatchData: 
+        o1.to_a==o2.to_a
+      when Time:
+        o1.eql? o2
+      else true
+      end and
+      (iv1=o1.instance_variables).size==o2.instance_variables.size and
+      iv1.each{|name| 
+        recurse_safe_objects_equal? \
+          o1.instance_variable_get(name), 
+          (o2.instance_variable_get(name) rescue return),session or return
+      } 
+  end
+=end
+end
+
+SR=Ron::DefaultMarker
+#Recursive([SR]) #recursive array
+#Recursive({SR=>SR}) #doubly recursive hash
+#Recursive(Set[SR]) #recursive Set
+
+module Recursive; end
+SelfReferencing=Recursive        #old name alias
+SelfReferential=SelfReferencing  #old name alias
+
+def Recursive *args #marker='foo',data
+  marker,data=*case args.size
+  when 2: args
+  when 1: [::Ron::DefaultMarker,args.last]
+  else raise ArgumentError
+  end
+
+    ::Ron::GraphWalk.graphwalk(data){|cntr,o,i,ty|
+      if o.equal? marker 
+        ty.new(cntr,i,1){data}.replace
+        data.extend Recursive
+      end
+    }  
+    data
+end
+def SelfReferencing #old name alias
+  Recursive(v=Object.new, yield(v))
+end
+alias SelfReferential SelfReferencing  #old name alias
+
+class Object
+  def with_ivars(hash)
+    hash.each_pair{|k,v|
+      instance_variable_set(k,v)
+    }
+    self
+  end
+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 String
+    def to_ron_list session
+      
+      [ "'", gsub(/['\\]/){ '\\\\'+$&}, "'" ]
+    end
+end
+
+class Regexp
+    def to_ron_list session
+      
+      [ inspect ]
+    end
+end
+
+class Array
+  def to_ron_list session
+    ["["] + 
+     map{|i| 
+          i.to_ron_list2(session)<<', ' 
+        }.flatten<<
+    "]"
+  end
+end
+
+class Hash
+  def to_ron_list session
+    ["{"]+map{|k,v| 
+      Array(k.to_ron_list2(session)).push "=>",
+          v.to_ron_list2(session)<<', ' 
+    }.flatten<<"}"
+  end
+end
+
+class Object
+  undef to_ron, to_ron_list #avoid warnings
+  def to_ron
+    #warning "additional modules not handled"
+      #warning "prettified output not supported"
+    
+    to_ron_list2.to_s
+  end
+  
+  def to_ron_list session
+    self.class.name or raise NotSerializableError
+    [self.class.name,"-{",
+      *instance_variables.map{|ivar| 
+        [ivar.to_ron,"=>",
+          instance_variable_get(ivar).to_ron_list2(session),', ']
+      }.flatten<<
+    "}#end object literal"]
+    #end
+  end
+  
+  def to_ron_list2(session=Ron::Session.new)
+    respond_to? :to_ron_list or return [to_ron]
+    if pair=(session.objects_in_progress.assoc __id__)
+      str=pair[1]
+      if str[/^Recursive\(/]
+        result=pair.last #put var name already generated into result
+      else
+        pair.push result=Ron.gen_local_name
+        str[0,0]="Recursive(#{result}={}, "
+      end
+      result=[result]
+    elsif pair=session.objects_seen[ __id__ ]
+      str=pair.first
+      if str[/^[a-z_0-9]+=[^=]/i] 
+        result=pair.last #put var name already generated into result
+      else
+        pair.push result=Ron.gen_local_name
+        str[0,0]=result+"="
+      end
+      result=[result]
+    else
+      str=''
+      session.objects_in_progress.push [__id__,str]
+      result=to_ron_list(session).unshift str
+      if result.last=="}#end object literal" 
+        result.last.replace "}"
+      else
+        #append instance_eval
+        ivars=instance_variables-::Ron::IGNORED_INSTANCE_VARIABLES[self.class]
+        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
+      result.push ")" if str[/^Recursive\(/]
+      session.objects_seen[__id__]=[session.objects_in_progress.pop[1]]
+      result
+    end
+    result
+  end
+end
+
+class Struct
+  def to_ron_list  session
+    self.class.name or raise NotSerializableError
+    result=[self.class.name,"-{"]+
+      members.map{|memb| 
+        [memb.to_ron_list2(session) , "=>" , self[memb] , ', ']
+      }.flatten<<
+    "}"
+    result=["(",result,")"].flatten unless instance_variables.empty?
+    result
+  end
+end
+
+sets=[:Set,:SortedSet,:WeakRefSet]
+eval sets.map{|k| <<END }.to_s 
+class #{k} #{'< Set' if k==:SortedSet}
+  def to_ron_list session
+    ['#{k}[']+map{|i| i.to_ron_list2(session)<<', ' }.flatten<<"]"
+  end
+end
+END
+Ron::IGNORED_INSTANCE_VARIABLES[Set]=%w[@hash]
+Ron::IGNORED_INSTANCE_VARIABLES[SortedSet]=%w[@hash @keys]
+Ron::IGNORED_INSTANCE_VARIABLES[WeakRefSet]=%w[@ids]
+
+class Range
+  def to_ron_list session
+#    result=
+           ["(",*first.to_ron_list2(session).
+                  push( "..#{'.' if exclude_end?}" )+
+                  last.to_ron_list2(session)<<
+            ")"
+           ]
+#    result.flatten!
+#    result
+  end
+end
+
+
+class Module
+  def to_ron
+    name.empty? and raise ::Ron::NotSerializeableError
+    name
+  end
+  undef to_ron_list
+end
+
+class Class
+  def to_ron
+    name.empty? and raise ::Ron::NotSerializeableError
+    name
+  end
+  undef to_ron_list if methods.include? "to_ron_list"
+end
+
+class Binding
+  def to_h
+    l=Kernel::eval "local_variables", self
+    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
+  end
+  
+  class<<self
+  def - h
+    h=h.dup
+    the_self=h.delete :self
+    the_block=(h.delete :yield) || nil
+    keys=h.keys
+    keys.empty? or
+    code=keys.map{|k| 
+      k.to_s
+    }.join(',')+'=*::Ron::CaptureCtx.last'
+    mname="Ron__capture_binding#{Thread.current.object_id}" #unlikely method name
+    newmname=result=nil
+
+    eval "
+          Thread.critical=true
+           newmname=class<<the_self;
+             mname=oldmname='#{mname}'
+             im=instance_methods(false)
+             mname+='-' while im.include? mname
+             alias_method mname, oldmname
+             def #{mname}
+               #{code}
+               binding
+             end
+             mname
+           end
+         " 
+          ::Ron::CaptureCtx.push h.values
+          result=the_self.send mname, &the_block
+          ::Ron::CaptureCtx.pop
+          class<<the_self;
+             self
+          end.send(*if newmname==mname
+           [:remove_method, mname]
+          else
+           [:alias_method, mname, oldmname]
+          end)
+          Thread.critical=false
+          result
+  end
+  alias from_h -
+  end
+  
+  def to_ron_list session
+    result=to_h.to_ron_list2(session).unshift("Binding-")
+    result=["(",result,")"].flatten unless instance_variables.empty?
+    result
+  end
+end
+
+
+
+
+
+#I might be able to implement these eventually....
+[
+Proc,
+Method,
+UnboundMethod,
+#Binding,  #??
+].each{|k| 
+  k.class_eval do
+    def to_ron(x=nil); raise Ron::NotYetSerializeableError end
+    alias to_ron_list to_ron
+  end
+}
+
+#what about unnamed class and module?
+
+
+#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 
+  k.class_eval do
+    def to_ron(x=nil); raise Ron:: NotYetMaybeNeverSerializeableError end
+    alias to_ron_list to_ron
+  end
+}
+
+
+#not a chance in hell:
+[
+File,
+IO,
+Dir,
+Process,
+
+
+
+].each{|k| 
+  k.class_eval do
+    def to_ron(x=nil); raise Ron::NotSerializeableError end
+    alias to_ron_list to_ron
+  end
+}
+
+=begin Kernel#self_referencing test case
+exp=Reg::const  # or Reg::var
+stmt=Reg::const  # or Reg::var
+
+exp=exp.set! -[exp, '+', exp]|-['(', stmt, ')']|Integer
+stmt=stmt.set! (-[stmt, ';', stmt]|-[exp, "\n"])-1
+    --  or  --
+stmt=Recursive(stmt={}, 
+  (-[stmt, ';', stmt]|
+  -[exp=Recursive(exp={}, 
+    -[exp, '+', exp]|
+    -['(', stmt, ')']|
+    Integer
+   ), "\n"])-1
+)
+=end
+
+#Class#-
+class Class
+  #construct an instance of a class from the data in hash
+  def - hash
+    #name.empty? and huh
+    Array===hash and return make( *hash )
+    allocate.instance_eval{
+      hash.each{|(k,v)| 
+        if ?@==k.to_s[0] 
+          instance_variable_set(k,v) 
+        else
+          send(k+"=",v)
+        end
+      }
+      return self
+    }
+  end
+end
+
+#Struct#-
+class<<Struct
+  alias new__no_minus_op new
+  def new *args
+    result=new__no_minus_op(*args)
+    class<<result
+  def - hash
+    name.empty? and huh
+    result=allocate
+    hash.each{|(k,v)| result[k]=v }
+    result
+  end
+    end
+    result
+  end
+end

data/lib/ron/column_order.rb

@@ -0,0 +1,170 @@
+module AttributeOrder
+  def self.included(othermod)
+    othermod.extend case othermod
+    when Class: ForClass
+    when Module: ForModule
+    else raise ArgumentError    
+    end
+  end
+  
+  class NoMoreSuperMethods<RuntimeError;  end
+  
+  def <=>(other)
+    raise NoMoreSuperMethods
+  end
+
+  def ==(other)
+    raise NoMoreSuperMethods
+  end
+
+  def eql?(other)
+    raise NoMoreSuperMethods
+  end
+
+  def hash
+    raise NoMoreSuperMethods
+  end
+
+module ForModule
+ 
+ 
+  #writes a bunch of comparison/equality/construction methods for you,
+  #all you have to do is define an order for the set of 'columns' or
+  #attributes of the object for use in sorting. the attributes are 
+  #allowed to be instance variables (with @) or properties (pairs of 
+  #setter/getter methods)(without @). 
+  #column_order and subclassing:
+  #The columns that were declared in any a superclass (or module) 
+  #are considered before the columns declared in this class. any
+  #column from a superclass need not be repeated in this class.
+  #the instance methods create by column_order are: 
+  #  #==, #<=>, #eql?, and #hash.
+  #none of these are written if a version already exists in this
+  #subclass (not a module or superclass).
+  
+  #in addition, there are a couple of private utility methods
+  #created: #attributes and #same_kind?.
+  #also, a new constructor method, #make, is written in the class.
+  
+  def attribute_order(*ivars)
+    #get trailing option list, if any (:column_order is only 1 known)
+    @COLUMN_ORDER=ivars.pop[:column_order] if Hash===ivars.last
+    
+    #normalize/type check parameters
+    @REG_ATTRIBUTE_ORDER= ivars.map{|ivar| 
+      ivar=ivar.to_s
+      raise ArgumentError unless #check for malformed names
+        ivar[/^(@|self\.)?[A-Za-z_][A-Za-z0-9_]*$/]    
+      
+      #prepend 'self.' if ivar doesn't start with @ or 'self.'
+      ivar[/^(@|self\.)/] or ivar[0,0]="self."
+      ivar
+    }
+    
+    #normalize column_order
+    @COLUMN_ORDER and 
+      @COLUMN_ORDER.map!{|ivar|
+        ivar=case ivar
+        when Integer: @REG_ATTRIBUTE_ORDER[ivar]
+        when Symbol: ivar.to_s
+        when String: ivar
+        else fail ArgumentError
+        end
+        
+        raise ArgumentError unless #check for malformed names
+          ivar[/^(@|self\.)?[A-Za-z_][A-Za-z0-9_]*$/]    
+        
+        #prepend 'self.' if ivar doesn't start with @ or 'self.'
+        ivar[/^(@|self\.)/] or ivar[0,0]="self."
+        ivar
+      }
+
+
+    #column_order defaults to attribute order if not given
+    cols=(@COLUMN_ORDER if defined? @COLUMN_ORDER) || @REG_ATTRIBUTE_ORDER
+
+    meths=instance_methods(false)
+
+    module_eval <<-"END"
+      private #utility methods
+huh #name collision... these names need to be unique for each module/class
+      def column_list  
+        result=[#{cols.join ','}]
+        result.pop while !result.empty? and result.last.nil?
+        return result
+      end
+      def same_kind?(other)  huh #name collision... these names need to be unique for each module/class
+        other.kind_of?(#{self}) || self.kind_of? other.class 
+      end
+    
+      public
+      #comparison method
+      def <=>(other)
+        (result=super rescue 0).nonzero? and return result
+        same_kind?(other) and
+          column_list<=>other.column_list
+      end unless meths.include?("<=>")
+      
+      #equality/hash methods
+      def ==(other)
+        (super rescue true) and
+        same_kind?(other) and
+          column_list==other.column_list
+      end unless meths.include?("==") 
+      def eql?(other)
+        (super rescue true) and
+        same_kind?(other) and
+          column_list.eql? other.column_list
+      end unless meths.include?("eql?")
+      def hash
+        #{ops=[:^,:+,:^,:-];i=0
+          column_list.inject("(super rescue 0).^ "){|s,o| 
+            s+"#{o}.hash.#{ops[(i+=1)&3]} "
+          }.sub(/\.[+^-] $/,'')
+        }
+      end unless meths.include?("hash")
+    END
+  end
+end
+
+module ForClass
+  include ForModule
+  def attribute_order(*stuff)
+    super    
+    attrs=ancestors.reverse.map{|anc| 
+      anc.instance_variable_get :@REG_ATTRIBUTE_ORDER 
+    }.compact
+    
+    class_eval <<-"END"
+      #raw constructor
+      def self.make(*args)
+        allocate.instance_eval do
+          named_args=if block_given?
+            yield
+          elsif args.size==#{attrs.size+1}
+            args.pop
+          end
+          
+          #array args
+          #{attrs.join(",")+"=*args" unless attrs.empty?}
+          
+          #hash args
+          named_args and
+            eval named_args.to_a.map{|(name,val)|
+              name=name.to_s
+              if name[/^@[a-z_][a-z_0-9]*$/i]
+                instance_variable_set(name,val)
+                nil
+              else
+                #name is allowed to be a complex l-value expression: eg 'foo.bar' or '@baz[44]', etc
+                ["self." unless /^@[^@]/===name,name,"=",val,"\n"]
+              end
+            }
+        end
+      end
+    END
+  end
+
+end
+
+end

data/lib/ron/graphedge.rb

@@ -0,0 +1,320 @@
+require 'forwardable'
+require 'set'
+#require 'assert'
+
+module Ron
+  #--------------------------------
+  #represents a path through the object graph
+  class GraphTrace
+    extend Forwardable
+    def initialize(points=[])
+      @points=points
+    end
+    
+    attr_reader :points
+    def_delegators :@points, :<<
+  end
+
+
+  #--------------------------------
+  module GraphWalk
+    class<<self
+      #--------------------------------
+      def graphcopy(obj)
+        old2new={}
+        root=nil
+        graphwalk(obj){|cntr,o,i,ty|
+          newo= block_given? && (yield cntr,o,i,ty,useit=[false]) 
+          useit.first or newo ||=
+            old2new[o.__id__] ||= root ||= o.dup
+          ty.new(old2new[cntr.__id__],i,1){newo}.replace
+        }
+        return root
+      end
+      
+      #--------------------------------
+      def graphwalk(obj)
+        yield nil,obj,nil,GraphEdge::TopLevel
+        todolist=[obj]
+        donelist=Set[]
+        todolist.each{|o|
+          traverse(o){|cntr,o2,i,ty|
+            unless donelist.include? [cntr.__id__,ty,i]
+              todolist<<o2 
+              donelist<<[cntr.__id__,ty,i]
+              yield cntr,o2,i,ty
+            end
+          }
+        }
+      end
+    
+      #--------------------------------
+      def traverse(obj)
+      #some other container types should be explicitly
+      #supported here: Set, Struct, OpenStruct, SuperStruct, Tree
+      #maybe others i don't know? sparse array/sparse matrix?
+      #ordered hashes?
+        case obj
+        when nil: #do nothing
+        when (Set if defined? Set),(WeakRefSet if defined? WeakRefSet):
+          obj.each{|elem|
+            yield(obj,elem, elem, GraphEdge::SetMember)
+          }
+        when Struct:
+          obj.members.each{|mem|
+            yield(obj,obj[mem],mem, GraphEdge::BracketsValue)
+          }
+        when Hash:
+          obj.each{|(i,elem)| 
+            yield(obj,elem,i, GraphEdge::HashValue)          
+            yield(obj,i,i, GraphEdge::HashKey)
+          }
+        when Array:
+          obj.each_with_index{|elem,i| 
+            yield(obj,elem,i, GraphEdge::Array)
+          }
+        when Range:
+          yield(obj,obj.first, :first, GraphEdge::ObjectMethValue)
+          yield(obj,obj.last, :last, GraphEdge::ObjectMethValue)        
+        #when RBTree:  huh
+        when (ActiveRecord::Base if defined? ActiveRecord::Base): 
+          obj.columns.each{|mem|
+            yield(obj,obj[mem],mem, GraphEdge::BracketsValue)
+          }
+        end
+         #traverse instance vars in any case
+          obj.instance_variables.each{|var|
+            yield obj, (obj.instance_variable_get var), var, GraphEdge::ObjectIvarValue
+          }
+      end
+      
+          
+      #---------------------------
+        #wannabe in class ::Array
+      def recursive_each arr,&block
+        arr.each {|item|
+          if item.respond_to? :to_a
+            recursive_each item.to_a, &block
+          else
+            block[item]
+          end
+        }
+      end
+      
+      #---------------------------
+      def recursive_reverse_each arr,&block
+        arr.reverse_each {|item|
+          if item.respond_to? :to_ary
+            recursive_reverse_each item.to_ary, &block
+          else
+            block[item]
+          end
+        }
+      end
+
+    end
+  end
+  
+  #--------------------------------
+  #represents an edge along the ruby object graph. (Container and position within it.)
+  class GraphEdge 
+    class ContextWasRecycled < Exception; end
+    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))
+    end
+    attr_reader :index,:len,:context
+    
+#    def new_value_set!(&nv) @newval_code=nv end
+    def context_type; self.class end
+    
+    def call; replace; end
+    
+    def context_died
+      @context=nil
+    end
+    
+    def new_value
+      @newval_code[self]
+    end
+  
+    #--------------------------------
+    class Array<GraphEdge
+      def initialize(context,index,len=1)
+        super
+        
+        if Range===@index 
+          @len=@index.last-@index.first
+          @len-=1 if @len.exclude_end?
+          @index=@index.first
+        end
+      end
+
+      def old_value
+        context[@index]
+      end
+      
+      def replace(*newvals)
+        newvals.empty? and newvals=[new_value]
+        context[@index]=*newvals
+      end
+    end
+
+    #--------------------------------
+    class BracketsKey < GraphEdge
+      def old_value
+        @index
+      end
+      #@index is actually a list... so is newkey
+      def replace(*newkey)
+        newkey.empty? and newkey=[new_value]
+        context[*newkey]=context.delete(*@index)
+      end  
+    end
+    
+    #--------------------------------
+    class BracketsValue < GraphEdge
+      def old_value
+        context[*@index]
+      end
+      #@index is actually a list    
+      def replace(newval=new_value)
+        context[*@index]=newval
+      end
+    end
+    
+    #--------------------------------
+    class HashKey<GraphEdge
+      def old_value
+        @index
+      end
+      
+      def replace(newkey=new_value)
+        context[newkey]=context.delete @index
+      end
+    end
+    
+    #--------------------------------
+    class HashValue<GraphEdge
+      def old_value
+        context[@index]
+      end
+      
+      def replace(newval=new_value)
+        context[@index]=newval
+      end
+    end
+
+    #--------------------------------
+    class SetMember<GraphEdge
+      def old_value
+        @index
+      end
+      
+      def replace(newval=new_value)
+        context.delete @index
+        context<<newval
+      end
+    end
+    
+    #--------------------------------
+    class HashDefaultValue<GraphEdge
+      def initialize(context,index=nil,len=1)
+        super
+      end
+      def old_value
+        context.default @index
+      end
+      
+      def replace(newval=nil)
+        raise TypeError
+      end
+  #    def new_value_set!; nil end
+  #    remove_method :new_value_set!
+    end
+    
+   #--------------------------------
+    class HashDefaultKey<GraphEdge
+      def initialize(context,index=nil,len=1)
+        super
+      end
+      def old_value
+        nil
+      end
+      
+      def replace(newval=nil)
+        raise TypeError
+      end
+  #    def new_value_set!; nil end
+  #    remove_method :new_value_set!
+    end
+    
+    #--------------------------------
+    class ObjectName<GraphEdge
+      def initialize(context,index,len=1)
+        super
+      end
+      def old_value
+        @index
+      end
+      
+      def replace(newval=nil)
+        raise TypeError
+      end
+  #    def new_value_set!; nil end
+  #    remove_method :new_value_set!
+    end
+
+    #--------------------------------
+    class ObjectIvarValue<GraphEdge
+      def old_value
+        context.instance_variable_get @index
+      end
+      
+      def replace(newval=new_value)
+        context.instance_variable_set(@index, newval)
+      end
+    end
+    
+    #--------------------------------
+    class ObjectMethValue<GraphEdge
+      def old_value
+        if ::Array===@index
+          if Proc===@index.last then 
+            block=context.pop
+          elsif Literal===@index.last then 
+            @index[-1]=@index[-1].unlit
+          end
+          context.send(*@index, &block)
+        else
+          context.send @index
+        end
+      end
+      
+      def replace(newval=new_value)
+        raise TypeError if ::Array===@index    
+        context.send "#{@index}=", newval
+      end
+    end
+    
+    #--------------------------------
+    class TopLevel<GraphEdge
+      def initialize(context,index=nil,len=1,&newval_code)
+        super
+      end
+      
+      def old_value
+        context
+      end
+      
+      def replace(newval=new_value)
+        huh #can't really replace values in toplevel context...???
+      end
+    
+    end
+    
+    
+  end
+  
+end

data/lib/ron/version.rb

@@ -0,0 +1,3 @@
+module Ron
+  VERSION="0.1.0"
+end

data/test/test_all.rb

@@ -0,0 +1,227 @@
+$VERBOSE=1
+$Debug=1
+require 'test/unit'
+require 'set'
+require 'ostruct'
+require 'yaml'
+
+require 'ron'
+#require 'warning'
+
+def try_require name
+  require name
+rescue Exception
+  nil
+end
+
+try_require 'rubygems' 
+try_require("sequence")
+try_require("weakrefset")
+try_require 'facets/more/superstruct' 
+
+$Verbose=true
+
+=begin
+Object
+Array
+Hash
+Struct
+:SuperStruct  #
+:OpenStruct  
+:Set
+:SortedSet
+:WeakRefSet  
+Binding
+(Object)
+#+self-referencing versions of above
+
+#also need a christmas tree, that incorporates at least one of each
+#datum, as many of them as possible self-referencing.
+#
+#and don't forget repeated data
+=end
+
+class A_Class
+  def initialize
+    @a,@b=1,2
+  end
+  attr_reader :a,:b
+  def ==(other)
+    [@a,@b]==[other.a,other.b]
+  end
+end
+
+class A_Struct < Struct.new(:a,:b)
+  def initialize
+    self.a=1
+    self.b=2
+  end
+end
+
+class BindingMaker
+def get_a_binding
+  a=12
+  binding
+end
+def == bm
+  BindingMaker===bm
+end
+end
+
+class RonTest<Test::Unit::TestCase
+
+def test_ron
+
+s1=1.0
+s2=2.0
+range=s1..s2
+s1.instance_variable_set(:@m, range)
+s2.instance_variable_set(:@m, range)
+ss=Set[s1,s2]
+s1.instance_variable_set(:@n, ss)
+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)
+
+ sss.inspect  #disable this and tests fail...  why?!?!?
+data=[
+
+ 3.14159,
+ 2**2000,
+
+ "string",
+ /regexp/,
+ Enumerable,
+ Class,
+ BindingMaker.new.get_a_binding,
+ A_Struct.new,
+ 
+   (record = OpenStruct.new
+   record.name    = "John Smith"
+   record.age     = 70
+   record.pension = 300
+   record),
+
+ SortedSet[1,2,3],
+ 1..10,
+
+ [1,2,3],
+ {1=>2,3=>4},
+ Set[1,2,3],
+ (WeakRefSet[*%w[a b c]] rescue warn 'weakrefset test disabled'),
+ A_Class.new,
+ 2,
+ :symbol,
+ nil,
+ true,
+ false,
+ 
+ 
+]
+data.each{|datum|
+ # p datum
+  assert_equal datum, datum
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)
+ 
+  if case datum
+     when Fixnum,Symbol,true,false,nil: false
+     else true
+     end
+  datum.instance_eval{@a,@b=1,2}
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)
+
+  datum.instance_eval{@c=self}
+  assert_equal datum, ( dup=eval datum.to_ron )
+  assert_equal internal_state(datum), internal_state(dup)
+  end
+}
+data.each{|datum|
+  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)
+  end
+}
+
+data2=[
+ range,
+ sss,
+ (a=[];a<<a;a),
+ (a=[];a<<a;a<<a;a),
+ (h={};h[0]=h;h),
+ (h={};h[h]=0;h),
+ (h={};h[h]=h;h),
+ (s=Set[];s<<s;s),
+]
+data2.each{|datum|
+ #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
+ 
+  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
+
+  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
+  end
+}
+datum= ((w=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
+
+  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
+}
+end
+
+def internal_state x
+  list=(x.instance_variables-::Ron::IGNORED_INSTANCE_VARIABLES[x.class]).sort
+  [list]+list.map{|iv| x.instance_variable_get(iv)}
+end
+
+end
+
+class Binding
+  def ==(other)
+    Binding===other or return
+    to_h==other.to_h
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: Ron
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-10-09 00:00:00 -07:00
+summary: Ron is a ruby-based serialization format for representing any ruby  object graph.
+require_paths: 
+- lib
+- test
+email: ron-owner @at@ inforadical .dot. net
+homepage: http://rubyforge.org/projects/ron
+rubyforge_project: ron
+description: 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.
+autorequire: 
+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: 
+- Caleb Clausen
+files: 
+- 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
+test_files: 
+- test/test_all.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: