gibbler 0.5.4 → 0.6.0

data/CHANGES.txt

@@ -1,11 +1,21 @@
 GIBBLER, CHANGES
 
 
+#### 0.6.0 (2009-07-20) #################################
+
+NOTE: Digest calculation for Proc and Class objects have changed.
+Digests created for these types will not match previous releases. 
+
+* FIXED: Proc digests no longer refer to Proc#binding
+* CHANGE: The Gibbler module now raises an exception if it's included
+* CHANGE: Module and Class now use the default Gibbler::Object digest
+* ADDED: Gibbler::Object now contains a default digest method
+
+
 #### 0.5.4 (2009-07-17) #################################
 
 * FIXED: Improved support for Symbol and Fixnum objects with Attic 0.4
   
-
 #### 0.5.3 (2009-07-12) #################################
 
 * FIXED: Updated gemspec to fix missing files (aliases)

data/README.rdoc

@@ -1,9 +1,8 @@
-= Gibbler - v0.5 ALPHA
+= Gibbler - v0.6 ALPHA
 
-Git-like hashes and history for Ruby objects.
-
-NOTE: Gibbler supports Ruby 1.8, 1.9 and JRuby. 
+Git-like hashes and history for Ruby objects for Ruby 1.8, 1.9 and JRuby. 
 
+<b>NOTE: Digests changed in the 0.6 release for Class, Module, and Proc objects. See "News" below for more info.</b>
 
 == Example 1 -- Basic Usage
     
@@ -122,26 +121,34 @@ Gibbler::String creates a digest based on the name of the class and the output o
 
 == ALPHA Notice
 
-This code is hella fresh (est 2009-06-25). It's barely tested and the interface may change, but it's fun to play with. I'll happily accept patches. 
+This code is hella fresh (est 2009-06-25). It's barely tested and the interface may change, but it's fun to play with. I'll happily accept patches. Some things to keep in mind:
 
-NOTE: Gibbler history is not suitable for very large objects since it keeps complete copies of the object in memory. This is a very early implementation of this feature so don't rely on it for production code. 
+* Gibbler history is not suitable for very large objects since it keeps complete copies of the object in memory. This is a very early implementation of this feature so don't rely on it for production code. 
+* Digest calculation may change between non-trivial releases. 
+* There has been very little testing for concurrency issues. (Anyone interested?)
 
 
 == News
 
-=== 2009-07-17: Improved support for Symbol and Fixnum
+=== 2009-07-20: Digest change for instances of Class, Module, and Proc
 
-With the upgrade to Attic 0.4, the gibbled? method and object history is now available for Symbol and Fixnum objects. 
+Digest calculation has changed for Class, Module, and Proc objects. Digests created with Gibbler 0.5.x and earlier will not match the ones created by 0.6. 
 
+* Class and Module objects were calculating digests based on the output of <tt>self.to_s</tt>. This was a problem because that string contains a memory address which can change arbitrarily. The new calculation is based on the object class, the length of name, and the name itself. e.g. <tt>"Class:6:Object" # => '5620e4a8b10ec6830fece61d33f5d3e9a349b4c2'</tt>
+* Proc objects were including the return value of <tt>self.binding</tt> in the digest calculation. This is not reliable because the binding includes an arbitrary address. The new calculation is based on the class name, the arity, and whether it was created with a lambda. 
 
-=== 2009-07-13: Fixed Attic gem
+Also note that this change affects the digests for Hashes and Arrays that contain instances of Class, Module, or Proc. 
 
-Cripes! I added the Attic dependency but there was a problem with the attic gem (the gemspec was outdated). It's <i>all</i> good now, the attic-0.3.1 gem should be available on all Rubyforge mirrors and and gems.github.com soon. 
+=== 2009-07-17: Improved support for Symbol and Fixnum
+
+With the upgrade to Attic 0.4, the gibbled? method and object history is now available for Symbol and Fixnum objects. 
 
 
 == Known Issues
 
 * gibbler or gibbled? must be called at least once before gibbled? will be able to return a useful value (otherwise there is no previous digest value to compare to)
+* Digests for Bignum objects are different between (MRI) Ruby and JRuby. Does anyone know why?
+* Digests for Proc objects are different between Ruby 1.8 and 1.9 because Proc.arity returns different values and 1.8 has no lambda? method.
 
 
 == Installation

data/gibbler.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "gibbler"
   s.rubyforge_project = "gibbler"
-	s.version = "0.5.4"
+	s.version = "0.6.0"
 	s.summary = "Gibbler: Git-like hashes for Ruby objects"
 	s.description = s.summary
 	s.author = "Delano Mandelbaum"

data/lib/gibbler/object.rb

@@ -4,6 +4,11 @@ module Gibbler
   
   module Object
     
+    def self.included(obj)
+      obj.extend Attic
+      obj.attic :__gibbler_cache
+    end
+    
     # Calculates a digest for the current object instance. 
     # Objects that are a kind of Hash or Array are processed
     # recursively. The length of the returned String depends 
@@ -31,6 +36,23 @@ module Gibbler
       p args
     end
     
+    # Creates a digest for the current state of self based on:
+    # * Object#class
+    # * Length of Object#name || ''
+    # * Object#name || ''
+    # 
+    # e.g. Digest::SHA1.hexdigest "Class:6:Object" #=> 
+    #
+    # <b>This is a default method appropriate for only the most 
+    # basic objects like Class and Module.</b>
+    #
+    def __gibbler(h=self)
+      klass = h.class
+      nom = h.name || ''
+      a = Gibbler.digest '%s:%s:%s' % [klass, nom.size, nom]
+      gibbler_debug klass, a, [klass, nom.size, nom]
+      a
+    end
   end
   
 end

data/lib/gibbler.rb

@@ -13,7 +13,7 @@ module Gibbler
   #include Attic
   extend Attic
   
-  VERSION = "0.5.4"
+  VERSION = "0.6.0"
   
   require 'gibbler/object'
   require 'gibbler/digest'
@@ -53,6 +53,33 @@ module Gibbler
     p args
   end
   
+  # Raises an exception. The correct usage is to include a Gibbler::Object:
+  # * Gibbler::Complex
+  # * Gibbler::String
+  # * Gibbler::Object
+  # * etc ...
+  def self.included(obj)
+    raise "You probably want to include Gibbler::Complex or Gibbler::Object"
+  end
+  
+  # Creates a digest based on: 
+  # * An Array of instance variable names and values in the format: <tt>CLASS:LENGTH:VALUE</tt>
+  #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
+  #     will be parsed recursively according to the gibbler method for that class type.
+  # * Digest the Array of digests  
+  # * Return the digest for <tt>class:length:value</tt> where:
+  #   * "class" is equal to the current object class (e.g. FullHouse).
+  #   * "length" is the size of the Array of digests (which should equal
+  #     the number of instance variables in the object).
+  #   * "value" is the Array of digests joined with a colon (":").
+  #
+  # This method can be used by any class which stores values in instance variables. 
+  #
+  #     class Episodes
+  #       include Gibbler::Complex
+  #       attr_accessor :season, :year, :cast
+  #     end
+  #
   module Complex
     include Gibbler::Object
     
@@ -61,19 +88,7 @@ module Gibbler
       obj.attic :__gibbler_cache
     end
     
-    # Creates a digest based on: 
-    # * An Array of instance variable names and values in the format: <tt>CLASS:LENGTH:VALUE</tt>
-    #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
-    #     will be parsed recursively according to the gibbler method for that class type.
-    # * Digest the Array of digests  
-    # * Return the digest for <tt>class:length:value</tt> where:
-    #   * "class" is equal to the current object class (e.g. FullHouse).
-    #   * "length" is the size of the Array of digests (which should equal
-    #     the number of instance variables in the object).
-    #   * "value" is the Array of digests joined with a colon (":").
-    #
-    # This method can be used by any class which stores values in instance variables. 
-    #
+    # Creates a digest for the current state of self. 
     def __gibbler(h=self)
       klass = h.class
       d = []
@@ -97,6 +112,21 @@ module Gibbler
     
   end
   
+  # Creates a digest based on: <tt>CLASS:LENGTH:VALUE</tt>. 
+  # This method can be used for any class where the <tt>to_s</tt>
+  # method returns an appropriate unique value for this instance. 
+  # It's used by default for Symbol, Class, Fixnum, and Bignum.
+  # e.g.
+  # 
+  #     "str" => String:3:str => 509a839ca1744c72e37759e7684ff0daa3b61427
+  #     :sym  => Symbol:3:sym => f3b7b3ca9529002c6826b1ef609d3583c356c8c8
+  #
+  # To use use method in other classes simply:
+  #
+  #     class MyStringLikeClass 
+  #       include Gibbler::String
+  #     end
+  #
   module String
     include Gibbler::Object
     
@@ -105,21 +135,7 @@ module Gibbler
       obj.attic :__gibbler_cache
     end
     
-    # Creates a digest based on: <tt>CLASS:LENGTH:VALUE</tt>. 
-    # This method can be used for any class where the <tt>to_s</tt>
-    # method returns an appropriate unique value for this instance. 
-    # It's used by default for Symbol, Class, Fixnum, and Bignum.
-    # e.g.
-    # 
-    #     "str" => String:3:str => 509a839ca1744c72e37759e7684ff0daa3b61427
-    #     :sym  => Symbol:3:sym => f3b7b3ca9529002c6826b1ef609d3583c356c8c8
-    #
-    # To use use method in other classes simply:
-    #
-    #     class MyClass
-    #       include Gibbler::String
-    #     end
-    #
+    # Creates a digest for the current state of self. 
     def __gibbler(h=self)
       klass = h.class
       value = h.nil? ? "\0" : h.to_s
@@ -128,7 +144,24 @@ module Gibbler
       a
     end
   end
-      
+  
+  # Creates a digest based on: 
+  # * parse each key, value pair into an Array containing keys: <tt>CLASS:KEY:VALUE.__gibbler</tt>
+  #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
+  #     will be parsed recursively according to the gibbler method for that class type.
+  # * Digest the Array of digests  
+  # * Return the digest for <tt>class:length:value</tt> where:
+  #   * "class" is equal to the current object class (e.g. Hash).
+  #   * "length" is the size of the Array of digests (which should equal
+  #     the number of keys in the original Hash object).
+  #   * "value" is the Array of digests joined with a colon (":").
+  #
+  # This method can be used by any class with a <tt>keys</tt> method. 
+  #
+  #     class MyOrderedHash
+  #       include Gibbler::Hash
+  #     end
+  #
   module Hash 
     include Gibbler::Object
     
@@ -137,25 +170,7 @@ module Gibbler
       obj.attic :__gibbler_cache
     end
     
-    # Creates a digest based on: 
-    # * parse each key, value pair into an Array containing keys: <tt>CLASS:KEY:VALUE.__gibbler</tt>
-    #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
-    #     will be parsed recursively according to the gibbler method for that class type.
-    # * Digest the Array of digests  
-    # * Return the digest for <tt>class:length:value</tt> where:
-    #   * "class" is equal to the current object class (e.g. Hash).
-    #   * "length" is the size of the Array of digests (which should equal
-    #     the number of keys in the original Hash object).
-    #   * "value" is the Array of digests joined with a colon (":").
-    #
-    # This method can be used by any class with a <tt>keys</tt> method. 
-    #
-    # e.g. 
-    #
-    #     class OrderedHash
-    #       include Gibbler::Hash
-    #     end
-    #
+    # Creates a digest for the current state of self. 
     def __gibbler(h=self)
       klass = h.class
       d = h.keys.sort { |a,b| a.inspect <=> b.inspect }
@@ -170,6 +185,23 @@ module Gibbler
     end
   end
   
+  # Creates a digest based on:
+  # * parse each element into an Array of digests like: <tt>CLASS:INDEX:VALUE.__gibbler</tt>
+  #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
+  #     will be parsed recursively according to the gibbler method for that class type. 
+  # * Digest the Array of digests 
+  # * Return the digest for <tt>class:length:value</tt> where:
+  #   * "class" is equal to the current object class (e.g. Array).
+  #   * "length" is the size of the Array of digests (which should equal
+  #     the number of elements in the original Array object).
+  #   * "value" is the Array of digests joined with a colon (":").
+  #
+  # This method can be used by any class with an <tt>each</tt> method.
+  #
+  #     class MyNamedArray 
+  #       include Gibbler::Array
+  #     end
+  #
   module Array
     include Gibbler::Object
     
@@ -178,25 +210,7 @@ module Gibbler
       obj.attic :__gibbler_cache
     end
     
-    # Creates a digest based on:
-    # * parse each element into an Array of digests like: <tt>CLASS:INDEX:VALUE.__gibbler</tt>
-    #   * The gibbler method is called on each element so if it is a Hash or Array etc it 
-    #     will be parsed recursively according to the gibbler method for that class type. 
-    # * Digest the Array of digests 
-    # * Return the digest for <tt>class:length:value</tt> where:
-    #   * "class" is equal to the current object class (e.g. Array).
-    #   * "length" is the size of the Array of digests (which should equal
-    #     the number of elements in the original Array object).
-    #   * "value" is the Array of digests joined with a colon (":").
-    #
-    # This method can be used by any class with an <tt>each</tt> method.
-    #
-    # e.g.
-    #
-    #     class NamedArray 
-    #       include Gibbler::Array
-    #     end
-    #
+    # Creates a digest for the current state of self. 
     def __gibbler(h=self)
       klass = h.class
       d, index = [], 0
@@ -214,7 +228,7 @@ module Gibbler
   # Return the digest for <tt>class:arity:binding</tt>, where:
   # * class is the current class name (e.g. Proc)
   # * arity is the value returned by <tt>Proc#arity</tt>
-  # * binding is the value returned by <tt>Proc#binding</tt>
+  # * value of lambda? if available (Ruby 1.9) or false otherwise
   #
   # This method can be used by any subclass of Proc.
   #
@@ -235,14 +249,17 @@ module Gibbler
       obj.attic :__gibbler_cache
     end
     
+    # Creates a digest for the current state of self.
     def __gibbler(h=self)
       klass = h.class
-      a = Gibbler.digest '%s:%s:%s' % [klass, h.arity, h.binding]
-      gibbler_debug klass, a, [klass, h.arity, h.binding]
+      is_lambda = h.respond_to?(:lambda?) ? h.lambda? : false
+      a = Gibbler.digest '%s:%s:%s' % [klass, h.arity, is_lambda]
+      gibbler_debug klass, a, [klass, h.arity, is_lambda]
       a
     end
   end
   
+  
   ##--
   ## NOTE: this was used when Gibbler supported "include Gibbler". We
   ## now recommend the "include Gibbler::String" approach. This was an 
@@ -288,7 +305,11 @@ class Symbol
 end
 
 class Class
-  include Gibbler::String
+  include Gibbler::Object
+end
+
+class Module
+  include Gibbler::Object
 end
 
 class Fixnum

data/tryouts/10_basic_tryouts.rb

@@ -1,11 +1,17 @@
 
-library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library :gibbler, 'lib'
 group "Gibbler Gazette"
 
 Gibbler.enable_debug if Tryouts.verbose > 3
 
 tryouts "Basic syntax with SHA1" do
   
+  dream :exception, RuntimeError
+  drill "include Gibbler raises exception" do
+    a = Class.new
+    a.send :include, Gibbler
+  end
+  
   dream :respond_to?, :gibbler
   dream :gibbler, '52be7494a602d85ff5d8a8ab4ffe7f1b171587df' 
   drill "Symbol can gibbler", :kimmy

data/tryouts/11_basic_sha256_tryouts.rb

@@ -7,33 +7,33 @@ Gibbler.enable_debug if Tryouts.verbose > 3
 
 tryouts "Basic syntax with SHA256" do
   
-  # NOTE: JRuby require that we use OpenSSL::Digest::SHA256
-  if Tryouts.sysinfo.vm == :java 
-    drill "Can change Digest type", OpenSSL::Digest::SHA256 do
+  setup do
+    # NOTE: JRuby requires that we use OpenSSL::Digest::SHA256
+    if Tryouts.sysinfo.vm == :java 
+      require 'openssl'
       Gibbler.digest_type = OpenSSL::Digest::SHA256
-    end
-  else
-    drill "Can change Digest type", Digest::SHA256 do
+    else
       Gibbler.digest_type = Digest::SHA256
     end
+    
+  end
+  
+  clean do
+    Gibbler.digest_type = Digest::SHA1
   end
   
-  dream :respond_to?, :gibbler
   dream :gibbler, '754f87ca720ec256633a286d9270d68478850b2abd7b0ae65021cb769ae70c08' 
   drill "A Symbol can gibbler", :anything
   
-  dream :respond_to?, :gibbler
   dream :gibbler, 'd345c0afb4e8da0133a3946d3bd9b2622b0acdd8d6cc1237470cc637a9e4777f' 
   drill "Class can gibbler", Class
   
-  dream :respond_to?, :gibbler
+  dream :gibbler, 'b7b874a9bff7825caa57750a900652354ac601b77497b694d313f658c69d25b4' 
+  drill "TrueClass can gibbler", TrueClass
+  
   dream :gibbler, '88d2bcbd68ce593fd2e0e06f276f7301357516291b95c0c53038e61a9bf091e5' 
   drill "Empty Hash instance", {}
   
-  drill "Can return Digest type", Digest::SHA1 do
-    Gibbler.digest_type = Digest::SHA1
-  end
-  
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gibbler
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-17 00:00:00 -04:00
+date: 2009-07-20 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency