gibbler 0.4 → 0.5.0

data/CHANGES.txt

@@ -1,9 +1,23 @@
 GIBBLER, CHANGES
 
 
+#### 0.5 (2009-07-01) #################################
+
+NOTE: This is a significant change from 0.4. Many method names  
+have been modified so this release is not backwards compatible. 
+
+* CHANGE: Now refer to "gibble" as "digest" in all docs and methods. 
+* CHANGE: Gibbler#gibble -> Gibbler#gibbler
+* CHANGE: Gibble is now Gibbler::Digest
+* ADDED: Gibbler::History, supporting gibbler_snapshots and gibbler_revert
+  for the following objects: Array, Hash
+* ADDED: Support for short, 8-character digests
+* ADDED: Expanded test coverage
+
+
 #### 0.4 (2009-06-30) #################################
 
-NOTE: Calculated gibbles have changed since 0.3. Most gibbles created with 
+NOTE: Calculated digests have changed since 0.3. Most digests created with 
 0.3 and earlier will not match those created in 0.4 for the same object
 
 * FIXED: Hash and Array now use the class of the value for hashing

data/README.rdoc

@@ -1,25 +1,64 @@
-= Gibbler - v0.4
+= Gibbler - v0.5 ALPHA
 
-Git-like hashes for Ruby objects.
+Git-like hashes and history for Ruby objects.
 
-== Examples
-
-    config = {}
-    config.gibble              # => 4fdcadc66a38feb9c57faf3c5a18d5e76a6d29bf
-    config.gibbled?            # => false
+== Example 1 -- Basic Usage
     
-    config[:server] = { 
-      :users => [:dave, :ali], 
-      :ports => [22, 80, 443]
-    }
-    config.gibbled?            # => true
-    config.gibble              # => ef23d605f8c4fc80a8e580f9a0e8dab8426454a8 
+    require 'gibbler'
+    
+    config = {}
+    config.gibbler               # => 4fdcadc66a38feb9c57faf3c5a18d5e76a6d29bf
+    config.gibbled?              # => false
+                                 
+    config[:server] = {          
+      :users => [:dave, :ali],   
+      :ports => [22, 80, 443]    
+    }                            
+    config.gibbled?              # => true
+    config.gibbler               # => ef23d605f8c4fc80a8e580f9a0e8dab8426454a8 
     
     config[:server][:users] << :yanni
     
-    config.gibble              # => 4c558a56bc2abf5f8a845a69e47ceb5e0003683f
+    config.gibbler               # => 4c558a56bc2abf5f8a845a69e47ceb5e0003683f
+    
+    config.gibbler.short         # => 4c558a56
+
 
+== Example 2 -- Object History 
+    
+Gibbler can also keep track of the history of changes to an object. By default Gibbler supports history for Hash, Array, and String objects. The <tt>gibbler_commit</tt> method creates a clone of the current object and stores in an instance variable using the current hash digest as the key. 
 
+    require 'gibbler'
+    require 'gibbler/history'
+    
+    a = { :magic => :original }     
+    a.gibbler_commit             # => d7049916ddb25e6cc438b1028fb957e5139f9910
+    
+    a[:magic] = :updated           
+    a.gibbler_commit             # => b668098e16d08898532bf3aa33ce2253a3a4150e
+    
+    a[:magic] = :changed 
+    a.gibbler_commit             # => 0b11c377fccd44554a601e5d2b135c46dc1c4cb1
+    
+    a.gibbler_history            # => d7049916, b668098e, 0b11c377
+    
+    a.gibbler_revert 'd7049916'  # Return to a specific commit
+    a.gibbler                    # => d7049916ddb25e6cc438b1028fb957e5139f9910
+    a                            # => { :magic => :original } 
+    
+    a.delete :magic
+    
+    a.gibbler_revert             # Return to the previous commit  
+    a.gibbler                    # => 0b11c377fccd44554a601e5d2b135c46dc1c4cb1
+    a                            # => { :magic => :changed }
+        
+    
+    a.gibbler_object 'b668098e'  # => { :magic => :updated }
+    a.gibbler_stamp              # => 2009-07-01 18:56:52 -0400
+    
+http://delano.github.com/gibbler/img/whoababy.gif
+
+    
 == Supported Classes
 
 Gibbler methods are available only to the classes which explicitly include them (see RDocs[http://delano.github.com/gibbler] for details on which classes are supported by default). You can also extend custom objects:
@@ -30,10 +69,10 @@ Gibbler methods are available only to the classes which explicitly include them
     end
     
     a = FullHouse.new
-    a.gibble                   # => 4192d4cb59975813f117a51dcd4454ac16df6703
+    a.gibbler                    # => 4192d4cb59975813f117a51dcd4454ac16df6703
     
     a.roles = [:jesse, :joey, :danny, :kimmy, :michelle, :dj, :stephanie]
-    a.gibble                   # => 6ea546919dc4caa2bab69799b71d48810a1b48fa
+    a.gibbler                    # => 6ea546919dc4caa2bab69799b71d48810a1b48fa
     
 Gibbler::Complex creates a digest based on the name of the class and the names and values of the instance variables. See the RDocs[http://delano.github.com/gibbler] for other Gibbler::* types. 
 
@@ -43,19 +82,31 @@ If you want to support all Ruby objects, add the following to your application:
       include Gibbler::String
     end
 
-Gibbler::String creates a digest based on the output of the to_s method. This is a reasonable default for more objects however any object that includes the object address in to_s (e.g. "<Object:0x0x4ac9f0...") will produce unreliable gibbles (because the address can change).
+Gibbler::String creates a digest based on the name of the class and the output of the to_s method. This is a reasonable default for most objects however any object that includes the object address in to_s (e.g. "<Object:0x0x4ac9f0...") will produce unreliable digests (because the address can change).
+
+
+== 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. 
+
+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. 
+
+
+== News
+
+=== 2009-07-01: Major namespace reorganization
 
+Many method names have been modified so this release is not backwards compatible with previous releases. This clears up ambiguity regarding "gibbles". They're now rightly referred to as digests. 
 
-== ALPHA NOTICE (2009-06-30)
 
-This code is hella fresh. It's ugly and barely tested, but it's fun to play with. I'll happily accept patches. 
+=== 2009-06-30: Digests have changed in 0.4
 
-NOTE: Gibbles have changed between 0.3 and 0.4. Ones created with 0.3 and earlier will not match ones created with 0.4 for the same object. 
+Digests have changed between 0.3 and 0.4. Ones created with 0.3 and earlier will not match ones created with 0.4 for the same object. 
 
 
 == Known Issues
 
-* The gibble method or gibbled? must be called at least once before gibbled? will be able to return a useful value (otherwise there is no previous gibble value to compare to)
+* 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)
 
 
 == More Info

data/gibbler.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "gibbler"
   s.rubyforge_project = "gibbler"
-	s.version = "0.4"
+	s.version = "0.5.0"
 	s.summary = "Gibbler: Git-like hashes for Ruby objects"
 	s.description = s.summary
 	s.author = "Delano Mandelbaum"
@@ -25,12 +25,28 @@
   
   # = MANIFEST =
   s.files = %w(
-  README.rdoc
   CHANGES.txt
   LICENSE.txt
+  README.rdoc
   Rakefile
   gibbler.gemspec
   lib/gibbler.rb
+  lib/gibbler/digest.rb
+  lib/gibbler/history.rb
+  lib/gibbler/mixins.rb
+  lib/gibbler/mixins/string.rb
+  tryouts/01_mixins_tryouts.rb
+  tryouts/05_gibbler_digest_tryouts.rb
+  tryouts/10_basic_tryouts.rb
+  tryouts/11_basic_sha256_tryouts.rb
+  tryouts/50_history_tryouts.rb
+  tryouts/51_hash_history_tryouts.rb
+  tryouts/52_array_history_tryouts.rb
+  tryouts/53_string_history_tryouts.rb
+  tryouts/57_arbitrary_history_tryouts.rb
+  tryouts/59_history_exceptions_tryouts.rb
+  tryouts/80_performance_tryouts.rb
+  tryouts/object_hash_demo.rb
   )
   
   s.has_rdoc = true

data/lib/gibbler.rb

@@ -6,10 +6,17 @@ require 'digest/sha1'
 # "Hola, Tanneritos"
 #
 module Gibbler
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
+  
+  require 'gibbler/digest'
+  require 'gibbler/mixins'
+  
+  class Error < RuntimeError
+    def initialize(obj); @obj = obj; end
+  end
   
   @@gibbler_debug = false
-  @@gibbler_digest_type = Digest::SHA1
+  @@gibbler_digest_type = ::Digest::SHA1
   
   # Specify a different digest class. The default is +Digest::SHA1+. You 
   # could try +Digest::SHA256+ by doing this: 
@@ -30,7 +37,7 @@ module Gibbler
   # Objects that are a kind of Hash or Array are processed
   # recursively. The length of the returned String depends 
   # on the digest type. 
-  def gibble
+  def gibbler
     #if h.respond_to? :__custom_gibbler
     #  d = h.__custom_gibbler
     #  a = __gibbler '%s:%s:%s' % [klass, d.size, d]
@@ -38,7 +45,8 @@ module Gibbler
     #  a
     #end
     gibbler_debug :GIBBLER, self.class, self
-    @__gibble__ = self.__gibbler
+    @__gibbler_digest__ = Gibbler::Digest.new self.__gibbler
+    @__gibbler_digest__
   end
   
   # Sends +str+ to Digest::SHA1.hexdigest. If another digest class
@@ -50,12 +58,12 @@ module Gibbler
   
   # Has this object been modified?
   #
-  # This method compares the return value from gibble with the 
-  # previous value returned by gibble (the value is stored in
-  # <tt>@__gibble__</tt>)
+  # This method compares the return value from digest with the 
+  # previous value returned by gibbler (the value is stored in
+  # <tt>@__gibbler_digest__</tt>)
   def gibbled?
-    @__gibble__ ||= self.gibble
-    was, now = @__gibble__.clone, self.gibble
+    @__gibbler_digest__ ||= self.gibbler
+    was, now = @__gibbler_digest__.clone, self.gibbler
     gibbler_debug :gibbled?, was, now
     was != now
   end
@@ -70,28 +78,34 @@ module Gibbler
   end
   
   # Gets the list of instance variables from the standard implementation
-  # of the instance_variables method and removes <tt>@__gibble__</tt>. 
+  # of the instance_variables method and removes all that 
+  # begin with <tt>@__gibbler</tt>. 
   # Any class the includes Gibbler or Gibbler::* will use this version of
   # instance_variables. It's important because we don't want the current
-  # gibble value to affect the next gibble. 
+  # digest value to affect the next gibble.
+  # 
+  # This is also critical for objects that include Gibbler::Complex b/c
+  # it deals explicitly with instance variables. If it sees the __gibbler
+  # variables it will go bananas. 
+  #
   def instance_variables
     vars = super
-    vars.reject! { |x| x.to_s == '@__gibble__' }
+    vars.reject! { |e| e.to_s =~ /^@__gibble/ }
     vars
   end
 
   module Complex
     include Gibbler
-    # Creates a gibble based on: 
+    # Creates a digest based on: 
     # * An Array of instance variable names and values in the format: <tt>CLASS:LENGTH:VALUE</tt>
-    #   * The gibble method is called on each element so if it is a Hash or Array etc it 
+    #   * 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.
-    # * Gibble the Array of gibbles 
+    # * 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 gibbles (which should equal
+    #   * "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 gibbles joined with a colon (":").
+    #   * "value" is the Array of digests joined with a colon (":").
     #
     # This method can be used by any class which stores values in instance variables. 
     #
@@ -107,11 +121,20 @@ module Gibbler
       gibbler_debug klass, a, [klass, d.size, d]
       a
     end
+    
+    def __gibbler_revert
+      state = self.gibbler_object @__gibbler_digest__
+      state.instance_variables do |n|
+        v = state.instance_variable_get n
+        self.instance_variable_set v
+      end
+    end
+    
   end
   
   module String
     include Gibbler
-    # Creates a gibble based on: <tt>CLASS:LENGTH:VALUE</tt>. 
+    # 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.
@@ -138,16 +161,16 @@ module Gibbler
   module Hash 
     include Gibbler
     
-    # Creates a gibble based on: 
+    # Creates a digest based on: 
     # * parse each key, value pair into an Array containing keys: <tt>CLASS:KEY:VALUE.__gibbler</tt>
-    #   * The gibble method is called on each element so if it is a Hash or Array etc it 
+    #   * 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.
-    # * Gibble the Array of gibbles 
+    # * 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 gibbles (which should equal
+    #   * "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 gibbles joined with a colon (":").
+    #   * "value" is the Array of digests joined with a colon (":").
     #
     # This method can be used by any class with a <tt>keys</tt> method. 
     #
@@ -174,16 +197,16 @@ module Gibbler
   module Array
     include Gibbler
     
-    # Creates a gibble based on:
-    # * parse each element into an Array of gibbles like: <tt>CLASS:INDEX:VALUE.__gibbler</tt>
-    #   * The gibble method is called on each element so if it is a Hash or Array etc it 
+    # 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. 
-    # * Gibble the Array of gibbles
+    # * 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 gibbles (which should equal
+    #   * "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 gibbles joined with a colon (":").
+    #   * "value" is the Array of digests joined with a colon (":").
     #
     # This method can be used by any class with an <tt>each</tt> method.
     #
@@ -228,8 +251,8 @@ module Gibbler
   ##  
   ##end
   ##++
-  
-  
+
+    
 end
 
 class Hash

data/lib/gibbler/digest.rb

@@ -0,0 +1,27 @@
+
+# = Gibbler::Digest
+#
+# A tiny subclass of String which adds a
+# few digest related convenience methods.
+#
+class Gibbler::Digest < String
+  
+  # Returns the first 8 characters of itself (the digest).
+  #
+  # e.g. 
+  #
+  #     "kimmy".gibbler         # => c8027100ecc54945ab15ddac529230e38b1ba6a1
+  #     "kimmy".gibbler.short   # => c8027100
+  #
+  def short
+    self[0..7]
+  end
+  
+  
+  def ==(g)
+    return true if self.to_s == g.to_s
+    return true if self.short.to_s == g.to_s
+    false
+  end
+  
+end

data/lib/gibbler/history.rb

@@ -0,0 +1,170 @@
+
+
+
+module Gibbler
+  class NoRevert < Gibbler::Error
+    def message; "Revert not implemented for #{@obj}" end
+  end
+  class NoHistory < Gibbler::Error
+    def message; "No history for #{@obj}"; end
+  end
+  class BadDigest < Gibbler::Error
+    def message; "Unknown digest: #{@obj}"; end
+  end
+    
+  module History
+    
+    @@mutex = Mutex.new
+    
+    def self.mutex; @@mutex; end
+    
+    # Returns an Array of digests in the order they were committed. 
+    # If +short+ is anything but false, the digests will be converted
+    # to the short 8 character digests.
+    def gibbler_history(short=false)
+      # Only a single thread should attempt to initialize the store.
+      if @__gibbler_history__.nil?
+        @@mutex.synchronize {
+          @__gibbler_history__ ||= { :history => [], :objects => {}, :stamp => {} }
+        }
+      end
+      if short == false
+        @__gibbler_history__[:history]
+      else
+        @__gibbler_history__[:history].collect { |g| g.short }
+      end
+    end
+    
+    # Returns the object stored under the given digest +g+.
+    # If +g+ is not a valid digest, returns nil. 
+    def gibbler_object(g=nil) 
+      g = gibbler_find_long g
+      g = self.gibbler_history.last if g.nil?
+
+      return unless gibbler_valid? g
+      @__gibbler_history__[:objects][ g ]
+    end
+    
+    # Returns the timestamp (a Time object) when the digest +g+ was committed. 
+    # If +g+ is not a valid gibble, returns nil. 
+    def gibbler_stamp(g=nil)
+      g = gibbler_find_long g
+      g = self.gibbler_history.last if g.nil?
+      return unless gibbler_valid? g
+      @__gibbler_history__[:stamp][ g ]
+    end
+    
+    # Stores a clone of the current object instance using the current
+    # digest value. If the object was not changed, this method does
+    # nothing but return the gibble. 
+    #
+    # NOTE: This method is not fully thread safe. It uses a Mutex.synchronize
+    # but there's a race condition where two threads can attempt to commit at 
+    # near the same time. The first will get the lock and create the commit. 
+    # The second will get the lock and create another commit immediately 
+    # after. What we probably want is for the second thread to return the 
+    # digest for that first snapshot, but how do we know this was a result
+    # of the race conditioon rather than two legitimate calls for a snapshot?
+    def gibbler_commit
+      now, digest, point = nil,nil,nil
+      
+      if @__gibbler_history__.nil?
+        @@mutex.synchronize {
+          @__gibbler_history__ ||= { :history => [], :objects => {}, :stamp => {} }
+        }
+      end
+      
+      @@mutex.synchronize {
+        now, digest, point = Time.now, self.gibbler, self.clone
+        @__gibbler_history__[:history] << digest
+        @__gibbler_history__[:stamp][digest] = now
+        @__gibbler_history__[:objects][digest] = point
+      }
+      
+      digest
+    end
+    
+    # Revert this object to a previously known state. If called without arguments
+    # it will revert to the most recent commit. If a digest is specified +g+, it
+    # will revert to that point. 
+    #
+    # Ruby does not support replacing self (<tt>self = previous_self</tt>) so each 
+    # object type needs to implement its own __gibbler_revert method. This default
+    # run some common checks and then defers to self.__gibbler_revert. 
+    # 
+    # Raise the following exceptions:
+    # * NoRevert: if this object doesn't have a __gibbler_revert method
+    # * NoHistory: This object has no commits
+    # * BadDigest: The given digest is not in the history for this object
+    #
+    # If +g+ matches the current digest value this method does nothing. 
+    #
+    # Returns the new digest (+g+). 
+    def gibbler_revert(g=nil)
+      raise NoRevert unless self.respond_to?(:__gibbler_revert)
+      raise NoHistory, self.class unless gibbler_history?
+      raise BadDigest, g if !g.nil? && !gibbler_valid?(g)
+      
+      g = self.gibbler_history.last if g.nil?
+      g = gibbler_find_long g 
+      
+      # Do nothing if the given digest matches the current gibble. 
+      # NOTE: We use __gibbler b/c it doesn't update @@__gibbler_digest__.
+      unless self.__gibbler == g
+        @@mutex.synchronize {
+          # Always make sure @__gibbler_digest__ is a Gibbler::Digest 
+          @__gibbler_digest__ = g.is_a?(Gibbler::Digest) ? g : Gibbler::Digest.new(g)
+          self.__gibbler_revert
+        }
+      end
+      
+      @__gibbler_digest__
+    end
+    
+    # Is the given digest +g+ contained in the history for this object?
+    def gibbler_valid?(g)
+      return false unless gibbler_history?
+      gibbler_history.member? gibbler_find_long(g)
+    end
+    
+    # Does the current object have any history?
+    def gibbler_history?
+      !gibbler_history.empty?
+    end
+    
+    # Returns the long digest associated to the short digest +g+.
+    # If g is longer than 8 characters it returns the value of +g+.
+    def gibbler_find_long(g)
+      return if g.nil?
+      return g if g.size > 8
+      gibbler_history.select { |d| d.match /\A#{g}/ }.first
+    end
+  end
+  
+end
+
+class Hash
+  include Gibbler::History
+  def __gibbler_revert
+    self.clear
+    self.merge! self.gibbler_object @__gibbler_digest__
+  end
+end
+
+class Array
+  include Gibbler::History
+  def __gibbler_revert
+    self.clear
+    self.push *(self.gibbler_object @__gibbler_digest__)
+  end
+end
+  
+class String
+  include Gibbler::History
+  def __gibbler_revert
+    self.clear
+    self << (self.gibbler_object @__gibbler_digest__)
+  end
+end
+      
+

data/lib/gibbler/mixins.rb

@@ -0,0 +1,4 @@
+
+
+require 'gibbler/mixins/string'
+

data/lib/gibbler/mixins/string.rb

@@ -0,0 +1,9 @@
+
+
+class String
+  unless method_defined? :clear
+    def clear
+      replace ""
+    end
+  end
+end

data/tryouts/01_mixins_tryouts.rb

@@ -0,0 +1,13 @@
+
+library :gibbler, 'lib'
+
+group "Mixins"
+
+tryouts "String" do
+  
+  drill "has String#clear" do
+    "".respond_to? :clear
+  end
+  
+end
+

data/tryouts/05_gibbler_digest_tryouts.rb

@@ -0,0 +1,26 @@
+
+library :gibbler, 'lib'
+
+group "Gibbler::Digest"
+
+tryouts "All methods" do
+  
+  
+  dream :class, Gibbler::Digest
+  dream 'c8027100'  
+  drill "has short method" do
+    "kimmy".gibbler.short
+  end
+  
+  dream :class, Gibbler::Digest
+  dream "12345678"
+  drill "can Gibbler::Digest#short" do
+    Gibbler::Digest.new("1234567890").short
+  end
+  
+  drill "can return true if compared with short", true do
+    Gibbler::Digest.new("1234567890") == "12345678"
+  end
+  
+end
+

data/tryouts/10_basic_tryouts.rb

@@ -0,0 +1,92 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+group "Gibbler Gazette"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+tryouts "Basic syntax with SHA1" do
+  
+  dream :respond_to?, :gibbler
+  dream :gibbler, '52be7494a602d85ff5d8a8ab4ffe7f1b171587df' 
+  drill "Symbol can gibbler", :kimmy
+  
+  dream :respond_to?, :gibbler
+  dream :gibbler, 'c8027100ecc54945ab15ddac529230e38b1ba6a1' 
+  drill "String can gibbler" do
+    "kimmy"
+  end
+  
+  drill "String and Symbol return different digests", true do
+    :kimmy.gibbler != "kimmy"
+  end
+  
+  dream :respond_to?, :gibbler
+  dream :gibbler, '25ac269ae3ef18cdb4143ad02ca315afb5026de9' 
+  drill "Class can gibbler", Class
+  
+  dream :respond_to?, :gibbler
+  dream :gibbler, '4fdcadc66a38feb9c57faf3c5a18d5e76a6d29bf' 
+  drill "Empty Hash instance", Hash.new
+  
+  dream :gibbler, 'a9cad665549bd22a4346fcf602d9d3c3b0482bbe'
+  drill "Fixnum instance" do
+    1
+  end
+  
+  dream :gibbler, '259afadb4ef8abaeb367db97d0c3015c8a4a504a'
+  drill "Bignum instance" do
+    100000000000
+  end
+  
+  dream :gibbler, "1d4b62e1e9f2c097b0cefb6877bf47c2015cdd21"
+  drill "Populated Hash instance" do
+    {
+      :a => [1,2,3, [4,5,6]],
+      :b => { :c => Class }
+    }
+  end
+  
+  dream :respond_to?, :gibbler
+  dream :gibbler, '48fda57c05684c9e5c3259557851943572183a21' 
+  drill "Empty Array instance", Array.new
+  
+  dream :gibbler, "884e5713aa70468333459f80aea1bb05394ca4ba"
+  drill "Populated Array instance" do
+    [1, 22222222222, :runtime, [2, "three", [Object, true]]]
+  end 
+  
+  drill "Knows when a Hash has not changed", false do
+    a = { :magic => true }
+    a.gibbler
+    a[:magic] = true
+    a.gibbled?
+  end
+  
+  drill "Knows when a Hash has changed", true do
+    a = { :magic => true }
+    a.gibbler
+    a[:magic] = false
+    a.gibbled?
+  end
+  
+  dream :gibbler, "6ea546919dc4caa2bab69799b71d48810a1b48fa"
+  drill "works on arbitrary objects" do
+    class ::FullHouse
+      include Gibbler::Complex
+      attr_accessor :roles
+    end
+    a = FullHouse.new
+    a.roles = [:jesse, :joey, :danny, :kimmy, :michelle, :dj, :stephanie]
+    a
+  end
+  
+  drill "doesn't reveal @__gibbler_digest__ instance variable", false do
+    a = {}
+    a.gibbler  # We need to gibbler first so it sets a value to the instance var
+    val = Tryouts.sysinfo.ruby[1] == 9 ? :'@__gibbler_digest__' : '@__gibbler_digest__'
+    a.instance_variables.member? val
+  end
+  
+  
+end
+

data/tryouts/11_basic_sha256_tryouts.rb

@@ -0,0 +1,40 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+group "Gibbler Gazette"
+
+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
+      Gibbler.digest_type = OpenSSL::Digest::SHA256
+    end
+  else
+    drill "Can change Digest type", Digest::SHA256 do
+      Gibbler.digest_type = Digest::SHA256
+    end
+  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, '88d2bcbd68ce593fd2e0e06f276f7301357516291b95c0c53038e61a9bf091e5' 
+  drill "Empty Hash instance", {}
+  
+  drill "Can return Digest type", Digest::SHA1 do
+    Gibbler.digest_type = Digest::SHA1
+  end
+  
+end
+
+
+

data/tryouts/50_history_tryouts.rb

@@ -0,0 +1,42 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+tryouts "Basics" do
+  
+  dream "d7049916ddb25e6cc438b1028fb957e5139f9910"
+  drill "can convert short digest into long" do
+    a = { :magic => :original }
+    g = a.gibbler_commit.short
+      stash :short, g
+    a.gibbler_find_long g
+  end
+  
+  dream :class, Time
+  drill "can return most recent stamp" do
+    a = { :magic => :original }
+    a.gibbler_commit
+      stash :hist, a.gibbler_history
+    a.gibbler_stamp
+  end
+  
+  dream ["d7049916ddb25e6cc438b1028fb957e5139f9910", "0b11c377fccd44554a601e5d2b135c46dc1c4cb1"]
+  drill "can return history" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :changed
+    a.gibbler_commit
+    a.gibbler_history
+  end
+  
+  dream ["d7049916", "0b11c377"]
+  drill "can return history (short)" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :changed
+    a.gibbler_commit
+    a.gibbler_history(:short)
+  end
+end

data/tryouts/51_hash_history_tryouts.rb

@@ -0,0 +1,91 @@
+
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+
+tryouts "Hash History" do
+  
+  drill "Setup Hash class", Hash do
+    class ::Hash
+      include Gibbler::History
+    end
+  end
+  
+  drill "doesn't reveal @__gibbler_history__ instance variable", false do
+    a = {}
+    a.gibbler  # We need to gibbler first so it sets a value to the instance var
+    val = Tryouts.sysinfo.ruby[1] == 9 ? :'@__gibbler_history__' : '@__gibbler_history__'
+    a.instance_variables.member? val
+  end
+  
+  drill "can take a Hash snapshot", 'd7049916ddb25e6cc438b1028fb957e5139f9910' do
+    a = { :magic => :original }
+    a.gibbler_commit
+  end
+  
+  dream :class, Array
+  dream :size, 2
+  dream ['d7049916ddb25e6cc438b1028fb957e5139f9910', 'b668098e16d08898532bf3aa33ce2253a3a4150e']
+  drill "return a Hash history" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :updated
+    a.gibbler_commit
+    a.gibbler_history
+  end
+  
+  dream 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+  drill "can revert Hash" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :updated
+    a.gibbler_revert
+  end
+  
+  drill "knows a valid gibble", true do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a.gibbler_valid? 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+  end
+  
+  drill "knows an invalid gibble", false do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a.gibbler_valid? '2222222222222222222222222222222222222222'
+  end
+  
+  dream Hash[:magic => :original]
+  drill "can revert to any valid gibble" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :updated
+    a.gibbler_commit
+    a[:magic] = :changed
+    a.gibbler_commit
+    a.gibbler_revert 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+    a
+  end
+  
+  dream Hash[:magic => :original]
+  dream :gibbler, 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+  drill "revert does nothing if digest is the same as current one" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a.gibbler_revert
+    a
+  end
+  
+  dream 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+  drill "can revert using short gibble" do
+    a = { :magic => :original }
+    a.gibbler_commit
+    a[:magic] = :updated
+    a.gibbler_revert 'd7049916'
+  end
+  
+end

data/tryouts/52_array_history_tryouts.rb

@@ -0,0 +1,44 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+
+tryouts "Array History" do
+  
+  drill "Setup Array class", Array do
+    class ::Array
+      include Gibbler::History
+    end
+  end
+  
+  drill "can take a Array snapshot", 'd95fcabb498ae282f356eba63da541e4f72c6efa' do
+    a = [:jesse]
+    a.gibbler_commit
+  end
+  
+  dream :class, Array
+  dream :size, 2
+  dream ['d95fcabb498ae282f356eba63da541e4f72c6efa', 'eebcb2e84e828b1a7207af4d588cf41fd4c6393a']
+  drill "return an Array history" do
+    a = [:jesse]
+    a.gibbler_commit
+    a << :joey
+    a.gibbler_commit
+    a.gibbler_history
+  end
+  
+  dream 'd95fcabb498ae282f356eba63da541e4f72c6efa'
+  drill "can revert Array" do
+    a = [:jesse]
+    stash :original, a.gibbler_commit
+    a << :joey
+    stash :updated, a.gibbler
+    a.gibbler_revert
+  end
+  
+  
+end

data/tryouts/53_string_history_tryouts.rb

@@ -0,0 +1,43 @@
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+
+tryouts "String History" do
+  
+  drill "Setup String class", String do
+    class ::String
+      include Gibbler::History
+    end
+  end
+  
+  drill "can take a String snapshot", 'c8027100ecc54945ab15ddac529230e38b1ba6a1' do
+    a = "kimmy"
+    a.gibbler_commit
+  end
+  
+  dream :class, Array
+  dream :size, 2
+  dream ['c8027100ecc54945ab15ddac529230e38b1ba6a1', '692c05d3186baf2da36e87b7bc5fe53ef13b902e']
+  drill "return a String history" do
+    a = "kimmy"
+    a.gibbler_commit
+    a << " gibbler"
+    a.gibbler_commit
+    a.gibbler_history
+  end
+  
+  dream 'c8027100ecc54945ab15ddac529230e38b1ba6a1'
+  drill "can revert String" do
+    a = "kimmy"
+    stash :original, a.gibbler_commit
+    a << " gibbler"
+    stash :updated, a.gibbler
+    a.gibbler_revert
+  end
+  
+end
+

data/tryouts/57_arbitrary_history_tryouts.rb

@@ -0,0 +1,45 @@
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+
+
+tryouts "Arbitrary Object History" do
+  
+  drill "Setup String class", 'FullHouse' do
+    class ::FullHouse
+      include Gibbler::Complex
+      include Gibbler::History
+      attr_accessor :roles
+    end
+    FullHouse.to_s
+  end
+  
+  drill "can take a FullHouse snapshot", '4192d4cb59975813f117a51dcd4454ac16df6703' do
+    a = FullHouse.new
+    a.gibbler_commit
+  end
+  
+  dream ['4192d4cb59975813f117a51dcd4454ac16df6703', '2c6957aa1e734d2a3a71caf569a7461a3bf26f11']
+  drill "return a FullHouse history" do
+    a = FullHouse.new
+    a.gibbler_commit
+    a.roles = [:jesse]
+    a.gibbler_commit
+    a.gibbler_history
+  end
+  
+  dream '4192d4cb59975813f117a51dcd4454ac16df6703'
+  drill "can revert FullHouse" do
+    a = FullHouse.new
+    stash :original, a.gibbler_commit
+    a.roles = [:jesse]
+    stash :updated, a.gibbler
+    a.gibbler_revert
+  end
+  
+end
+

data/tryouts/59_history_exceptions_tryouts.rb

@@ -0,0 +1,30 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+library 'gibbler/history', File.dirname(__FILE__), '..', 'lib'
+
+group "History"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+
+
+tryouts "Exceptions" do
+  
+  dream :exception, Gibbler::BadDigest
+  drill "raises exception when reverting to unknown gibble" do
+    a = {}
+    a.gibbler_commit
+    a.gibbler_revert '2222222222222222222222222222222222222222'
+  end
+  
+  dream :exception, Gibbler::NoHistory
+  drill "raises exception when reverting and there's no history" do
+    a = []
+    a.gibbler_revert
+  end
+  
+  dream :exception, NoMethodError
+  drill "raises exception when reverting an unsupported object" do
+    :kimmy.gibbler_revert
+  end
+  
+end

data/tryouts/80_performance_tryouts.rb

@@ -0,0 +1,80 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+group "Performance"
+
+tryouts "Speed", :benchmark do
+  # NOTE: gibbler is slower when history is enabled. 
+  drill "Setup variables" do
+    @@array = (1..10000).map { rand }
+    values = (1..10000).map { rand }
+    zipped = @@array.zip(values)
+    @@hash = Hash[*zipped]
+  end
+  
+  drill "Array#hash", 5 do
+    @@array.hash
+  end 
+  
+  
+  dream :mean, 0.21
+  drill "Array#gibbler", 5 do
+    @@array.gibbler 
+  end
+  
+  drill "Hash#hash", 5 do
+    @@hash.hash
+  end
+  
+  dream :mean, 1.1
+  drill "Hash#gibbler", 5 do
+    @@hash.gibbler 
+  end
+  
+end
+
+repetitions = 100         # at 100_000 hash shows errors
+sample_size = 1..100
+
+tryouts "Uniqueness", :api do
+  
+  drill "Array#hash, all unique", 0 do
+    seen = []
+    repetitions.times do
+      srand
+      seen << ((sample_size).map { rand }).hash
+    end
+    seen.size - seen.uniq.size
+  end
+  
+  drill "Hash#hash, all unique", 0 do
+    seen = []
+    repetitions.times do
+      srand
+      seen << Hash[*(sample_size).map { rand }.zip((sample_size).map { rand })].hash
+    end
+    seen.size - seen.uniq.size
+  end
+  
+  drill "Array#gibbler, all unique", 0 do
+    seen = []
+    repetitions.times do
+      srand
+      seen << ((sample_size).map { rand }).gibbler 
+    end
+    seen.size - seen.uniq.size
+  end
+  
+  drill "Hash#gibbler, all unique", 0 do
+    seen = []
+    repetitions.times do
+      srand
+      seen << Hash[*(sample_size).map { rand }.zip((sample_size).map { rand })].gibbler 
+    end
+    seen.size - seen.uniq.size
+  end
+  
+  
+  
+  
+  
+end

data/tryouts/object_hash_demo.rb

@@ -0,0 +1,30 @@
+
+library :gibbler, File.dirname(__FILE__), '..', 'lib'
+group "Object#hash"
+
+tryout "Object#hash (Ruby 1.9 only)", :api do
+    
+  drill "Object", Object.hash, 1892070
+  drill "Class", Class.hash, 1892030
+  drill "Array", Array.hash, 1866770
+  drill "Hash", Hash.hash, 1863840
+  
+end
+
+tryouts "Object#hash (Ruby 1.8 only)", :api do
+  
+  drill "Object", Object.hash, 118420
+  drill "Class", Class.hash, 118400
+  drill "Array", Array.hash, 104100
+  drill "Hash", Hash.hash, 102590
+  
+end
+
+tryouts "Object#hash (JRuby only)", :api do
+  
+  drill "Object", Object.hash, 1
+  drill "Class", Class.hash, 3
+  drill "Array", Array.hash, 46
+  drill "Hash", Hash.hash, 43
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gibbler
 version: !ruby/object:Gem::Version 
-  version: "0.4"
+  version: 0.5.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-30 00:00:00 -04:00
+date: 2009-07-01 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -23,12 +23,28 @@ extra_rdoc_files:
 - README.rdoc
 - LICENSE.txt
 files: 
-- README.rdoc
 - CHANGES.txt
 - LICENSE.txt
+- README.rdoc
 - Rakefile
 - gibbler.gemspec
 - lib/gibbler.rb
+- lib/gibbler/digest.rb
+- lib/gibbler/history.rb
+- lib/gibbler/mixins.rb
+- lib/gibbler/mixins/string.rb
+- tryouts/01_mixins_tryouts.rb
+- tryouts/05_gibbler_digest_tryouts.rb
+- tryouts/10_basic_tryouts.rb
+- tryouts/11_basic_sha256_tryouts.rb
+- tryouts/50_history_tryouts.rb
+- tryouts/51_hash_history_tryouts.rb
+- tryouts/52_array_history_tryouts.rb
+- tryouts/53_string_history_tryouts.rb
+- tryouts/57_arbitrary_history_tryouts.rb
+- tryouts/59_history_exceptions_tryouts.rb
+- tryouts/80_performance_tryouts.rb
+- tryouts/object_hash_demo.rb
 has_rdoc: true
 homepage: http://github.com/delano/gibbler
 licenses: []