gibbler 0.6.3 → 0.7.0

data/CHANGES.txt

@@ -1,6 +1,29 @@
 GIBBLER, CHANGES
 
 
+#### 0.7.0 (2009-10-07) #################################
+
+NOTE: Digest calculation for Proc objects has changed. Procs
+or objects containing Procs will have different digests than
+those created in previous releases.
+
+* CHANGE: Proc digests are now based on the values of obj.class 
+  and obj.name (if available).
+  
+
+#### 0.6.4 (2009-10-07) #################################
+
+* FIXED: Now using correct superclass for DateTime (Date)
+* CHANGE: aliases.rb will now require gibbler so you don't need to specify both. 
+  i.e. require 'gibbler'
+       require 'gibbler/aliases'
+* CHANGE: Gibbler::Object#gibbler returns the value of gibbler_cache when
+  the object is frozen, without calculation. 
+* ADDED: Gibbler::Object#freeze to create digest before freezing.
+* ADDED: Out of the box support for Regexp (Gibbler::String)
+* ADDED: Gibbler::Object#digest_cache alias for gibbler_cache
+
+
 #### 0.6.3 (2009-09-30) #################################
 
 * FIXED: Won't save digest to cache if the object is frozen

data/README.rdoc

@@ -1,11 +1,13 @@
-= Gibbler - v0.6 ALPHA
+= Gibbler - v0.7 ALPHA
 
 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>
-
 Check out the screencast[http://www.rubypulse.com/episode-0.3-gibbler.html] created by Alex Peuchert.
 
+=== Important Information Regarding Your Digests
+
+<i>Digest calculation changed in the 0.7 release for Proc objects. See "News" below for more info.</i>
+
 
 == Example 1 -- Basic Usage
     
@@ -70,8 +72,7 @@ http://delano.github.com/gibbler/img/whoababy.gif
 == Example 3 -- Method Aliases
 
 If you have control over the namespaces of your objects, you can use the method aliases to tighten up your code a bit. The "gibbler" and "gibbled?" methods can be accessed via "digest" and "changed?", respectively. (The reason they're not enabled by default is to avoid conflicts.)
-
-    require 'gibbler'
+  
     require 'gibbler/aliases'
     
     "kimmy".digest               # => c8027100ecc54945ab15ddac529230e38b1ba6a1
@@ -84,11 +85,9 @@ If you have control over the namespaces of your objects, you can use the method
 
 
 The history methods also have aliases which remove the "gibbler_".
-
-    require 'gibbler'
-    require 'gibbler/history'
-    require 'gibbler/aliases'
     
+    require 'gibbler/aliases'
+    require 'gibbler/history'
     
     a = { :magic => :original }     
     a.commit                     
@@ -121,18 +120,36 @@ If you want to support all Ruby objects, add the following to your application:
 
 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).
 
+As of 0.7 all Proc objects have the same digest: <tt>12075835e94be34438376cd7a54c8db7e746f15d</tt>. 
+
 
 == 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. Some things to keep in mind:
+This code is fresh so the interface may change. Some things to keep in mind:
 
 * 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?)
+* Digest calculation may change between minor releases (e.g. 0.6 to 0.7, etc)
+* Don't forget to enjoy what you do!
 
 
 == News
 
+=== 2009-10-07: Digest calculation for Proc objects has changed.
+
+Proc digests are now based on the name of the class and the value of Proc#name (if available). Procs or objects containing Procs will have different digests than those created in previous releases.
+
+After much deliberation, I realized that Gibbler cares about the data and not the code. Procs are code, but a reference to a Proc in an instance variable is data. With this change all Proc objects have the same digest. This decision has the side benefit of increasing compatibility between Ruby 1.8, 1.9 & JRuby. 
+
+This is the only change between 0.6.4 and 0.7.0 so if you prefer the previous calculation for Procs you can find it in that version. 
+
+Happy Digesting!
+
+=== 2009-10-07: Support for freezing and Regexp
+
+In 0.6.4, all Gibbler objects will create a new digest when <tt>obj.freeze</tt> is called. All subsequent calls to <tt>obj.gibbler</tt> will return the most recent digest without having to run the calculation again. 
+
+I've also added support for Regexp out of the box. 
+
 === 2009-07-20: Digest change for instances of Class, Module, and Proc
 
 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. 
@@ -142,15 +159,11 @@ Digest calculation has changed for Class, Module, and Proc objects. Digests crea
 
 Also note that this change affects the digests for Hashes and Arrays that contain instances of Class, Module, or Proc. 
 
-=== 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 Ruby 1.8, 1.9, and JRuby. Does anyone know why?
+* Digests for Bignum objects are different between 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.
 
 

data/gibbler.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "gibbler"
   s.rubyforge_project = "gibbler"
-	s.version = "0.6.3"
+	s.version = "0.7.0"
 	s.summary = "Gibbler: Git-like hashes for Ruby objects"
 	s.description = s.summary
 	s.author = "Delano Mandelbaum"
@@ -41,9 +41,14 @@
   lib/gibbler/mixins/string.rb
   lib/gibbler/object.rb
   tryouts/01_mixins_tryouts.rb
+  tryouts/02_compat_tryouts.rb
   tryouts/05_gibbler_digest_tryouts.rb
   tryouts/10_basic_tryouts.rb
   tryouts/11_basic_sha256_tryouts.rb
+  tryouts/14_extended_tryouts.rb
+  tryouts/15_file_tryouts.rb
+  tryouts/16_uri_tryouts.rb
+  tryouts/20_time_tryouts.rb
   tryouts/50_history_tryouts.rb
   tryouts/51_hash_history_tryouts.rb
   tryouts/52_array_history_tryouts.rb

data/lib/gibbler/aliases.rb

@@ -1,11 +1,13 @@
 
+require 'gibbler'
 
 module Gibbler
   
-
   module Object
-    alias :digest       :gibbler
-    alias :changed?     :gibbled?
+    alias :digest           :gibbler
+    alias :changed?         :gibbled?
+    # The cache is in the Attic.
+    def    digest_cache;     gibbler_cache;  end
   end
   
   #--

data/lib/gibbler/object.rb

@@ -14,12 +14,21 @@ module Gibbler
     # 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 
-    # on the digest type. 
+    # on the digest type. Also stores the value in the attic.
+    # 
+    #     obj.gibbler          # => a5b1191a
+    #     obj.gibbler_cache    # => a5b1191a
+    # 
+    # Calling gibbler_cache returns the most recent digest
+    # without calculation.
+    #
+    # If the object is frozen, this will return the value of
+    # <tt>gibbler_cache</tt>.
+    #
     def gibbler
       gibbler_debug :GIBBLER, self.class, self
-      digest = Gibbler::Digest.new self.__gibbler
-      self.gibbler_cache = digest unless self.frozen?
-      digest
+      return self.gibbler_cache if self.frozen?
+      self.gibbler_cache = Gibbler::Digest.new self.__gibbler
     end
 
     # Has this object been modified?
@@ -42,7 +51,7 @@ module Gibbler
     
     # Creates a digest for the current state of self based on:
     # * Object#class
-    # * Length of Object#name || ''
+    # * Length of Object#name || 0
     # * Object#name || ''
     # 
     # e.g. Digest::SHA1.hexdigest "Class:6:Object" #=> 
@@ -52,11 +61,19 @@ module Gibbler
     #
     def __gibbler(h=self)
       klass = h.class
-      nom = h.name || ''
+      nom = h.name if h.respond_to?(:name)
+      nom ||= ''
       a = Gibbler.digest '%s:%s:%s' % [klass, nom.size, nom]
       gibbler_debug klass, a, [klass, nom.size, nom]
       a
     end
+    
+    # A simple override on Object#freeze to create a digest
+    # before the object is frozen. Once the object is frozen
+    # <tt>obj.gibbler</tt> will return the cached value with
+    # out calculation.
+    def freeze() self.gibbler; super; self end
+    
   end
   
 end

data/lib/gibbler.rb

@@ -1,22 +1,18 @@
 
-local_libs = %w{attic}
-local_libs.each { |dir| $:.unshift File.join(File.dirname(__FILE__), '..', '..', dir, 'lib') }
-
-require 'digest/sha1'
+require 'thread'
 require 'attic'
+require 'digest/sha1'
 
 # = Gibbler
 # 
 # "Hola, Tanneritos"
 #
 module Gibbler
-  #include Attic
-  extend Attic
   
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
   
-  require 'gibbler/object'
   require 'gibbler/digest'
+  require 'gibbler/object'
   require 'gibbler/mixins'
   
   class Error < RuntimeError
@@ -225,40 +221,6 @@ module Gibbler
     end
   end
   
-  # 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>
-  # * value of lambda? if available (Ruby 1.9) or false otherwise
-  #
-  # This method can be used by any subclass of Proc.
-  #
-  # NOTE: This is named "Block" because for some reason if this is 
-  # named "Proc" (as in Gibbler::Proc) and the Rye library is also
-  # required, a runtime error is raised (Ruby 1.9.1 only):
-  #
-  #     undefined method `new' for Gibbler::Proc:Module
-  #     /usr/local/lib/ruby/1.9.1/tempfile.rb:169:in `callback'
-  #     /usr/local/lib/ruby/1.9.1/tempfile.rb:61:in `initialize'
-  #     /Users/delano/Projects/opensource/rye/lib/rye.rb:210:in `new'
-  #
-  module Block
-    include Gibbler::Object
-    
-    def self.included(obj)
-      obj.extend Attic
-      obj.attic :gibbler_cache
-    end
-    
-    # Creates a digest for the current state of self.
-    def __gibbler(h=self)
-      klass = h.class
-      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
-  
   # Creates a digest based on: <tt>CLASS:LENGTH:TIME</tt>. 
   # Times are calculated based on the equivalent time in UTC. 
   # e.g.
@@ -439,84 +401,32 @@ module Gibbler
     
 end
 
-class Proc
-  include Gibbler::Block
-end
-
-class Hash
-  include Gibbler::Hash
-end
-
-class Array
-  include Gibbler::Array
-end
-
-class String
-  include Gibbler::String
-end
-
-class Symbol
-  include Gibbler::String
-end
-
-class Class
-  include Gibbler::Object
-end
-
-class Module
-  include Gibbler::Object
-end
-
-class Fixnum
-  include Gibbler::String
-end
-
-class Bignum
-  include Gibbler::String
-end
-
-class TrueClass
-  include Gibbler::String
-end
-
-class FalseClass
-  include Gibbler::String
-end
-
-class Float
-  include Gibbler::String
-end
-
-class Time
-  include Gibbler::Time
-end
-
-class Date
-  include Gibbler::String
-end
+class NilClass;            include Gibbler::Nil;       end
+class Class;               include Gibbler::Object;    end
+class Module;              include Gibbler::Object;    end
+class Proc;                include Gibbler::Object;    end
+class String;              include Gibbler::String;    end
+class Regexp;              include Gibbler::String;    end
+class Fixnum;              include Gibbler::String;    end
+class Bignum;              include Gibbler::String;    end
+class TrueClass;           include Gibbler::String;    end
+class FalseClass;          include Gibbler::String;    end
+class Float;               include Gibbler::String;    end
+class Symbol;              include Gibbler::String;    end
+class Date;                include Gibbler::String;    end
+class Hash;                include Gibbler::Hash;      end
+class Array;               include Gibbler::Array;     end
+class Time;                include Gibbler::Time;      end
+class DateTime < Date;     include Gibbler::DateTime;  end
+class Range;               include Gibbler::Range;     end
+class File;                include Gibbler::File;      end
+class TempFile;            include Gibbler::File;      end
 
-class DateTime
-  include Gibbler::DateTime
-end
+# URI::Generic must be included towards the 
+# end b/c it runs Object#freeze statically.
+module URI; class Generic; include Gibbler::String;    end; end
 
-class Range
-  include Gibbler::Range
-end
 
-class NilClass
-  include Gibbler::Nil
-end
 
-module URI
-  class Generic
-    include Gibbler::String
-  end
-end
 
-class File
-  include Gibbler::File
-end
 
-class TempFile
-  include Gibbler::File
-end

data/tryouts/02_compat_tryouts.rb

@@ -0,0 +1,25 @@
+
+library :gibbler, 'lib'
+
+group "Gibbler::Digest"
+
+tryouts "Backwards compatability" do
+  
+  dream true
+  drill "Gibbler Objects have gibbler_cache method" do
+    "kimmy".respond_to? :gibbler_cache
+  end
+  
+  dream true
+  drill "Gibbler Objects have __gibbler_cache method" do
+    "kimmy".respond_to? :__gibbler_cache
+  end
+  
+  dream true
+  drill "__gibbler_cache returns the same value as gibbler_cache" do
+    a = "kimmy" and a.gibbler
+    a.__gibbler_cache == a.gibbler_cache
+  end
+
+end
+

data/tryouts/10_basic_tryouts.rb

@@ -39,7 +39,7 @@ tryouts "Basic syntax with SHA1" do
     1
   end
   
-  dream :gibbler, '259afadb4ef8abaeb367db97d0c3015c8a4a504a'
+  dream :gibbler, '608256db120251843843bba57e9b2c7adb7342aa'
   drill "Bignum instance" do
     100000000000
   end
@@ -103,6 +103,15 @@ tryouts "Basic syntax with SHA1" do
     Hash.attic_vars
   end
   
+  drill "Freezing an object will update the digest", true do
+    a = { :a => 1 }
+    pre  = a.gibbler; 
+    a[:a] = 2 
+    post = a.freeze.gibbler
+    stash :pre, pre
+    stash :post, post
+    pre != post && post == a.gibbler_cache
+  end
   
   dream :gibbler, "6ea546919dc4caa2bab69799b71d48810a1b48fa"
   drill "works on arbitrary objects" do

data/tryouts/14_extended_tryouts.rb

@@ -0,0 +1,97 @@
+
+library :gibbler, 'lib'
+group "Gibbler Gazette"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+Gibbler.digest_type = Digest::SHA1
+
+tryouts "Extended object tryouts" do
+
+  dream :gibbler, 'f2b0150c84c5c834406ec9cdec989a0fa938b4ad' 
+  drill "true can gibbler", true
+  
+  dream :gibbler, 'abee839edf5f9c101c505c28987ca35c31c7fc8d' 
+  drill "false can gibbler", false
+  
+  dream :gibbler, '583fb214ec50d2c4a123cc52de0c65e801d13516' 
+  drill "TrueClass can gibbler", TrueClass
+  
+  dream :gibbler, '11f262be475ddf38a25888e9f6ec82f384a7c58b' 
+  drill "FalseClass can gibbler", FalseClass
+  
+  dream :gibbler, '25ac269ae3ef18cdb4143ad02ca315afb5026de9' 
+  drill "Class can gibbler", Class
+  
+  dream :gibbler, '5620e4a8b10ec6830fece61d33f5d3e9a349b4c2' 
+  drill "Object can gibbler", Object
+  
+  dream :gibbler, '083feec632e6cd5347e3fb3c7048365c3a0d710e' 
+  drill "Class instance can gibbler", Class.new
+  
+  dream :gibbler, '7295241e929ffd7cc974cf8d4481291e070937fc' 
+  drill "Module can gibbler", Module
+  
+  dream :gibbler, '6b5a192fd377dfc5c2828a3ad6105b68b6db33d5' 
+  drill "Module instance can gibbler", Module.new
+  
+  dream :gibbler, '8640f7abcbcb80e3825ed827bf36819e26119e16' 
+  drill "Proc can gibbler", Proc
+  
+  dream :gibbler, 'd73ae2a7bc2058b05dbc1952d8abf004167109e0' 
+  drill "Range instance (..) can gibbler", 1..100
+  
+  dream :gibbler, '46c8a7d0163144819c440bf6734a8101cd72c04a' 
+  drill "Range instance (...) can gibbler", 1...100
+  
+  drill "Range (..) doesn't equal range (...)", true do
+     ('a'..'e').gibbler != ('a'...'e').gibbler
+  end
+  
+  dream '06fdf26b2a64e90cd35ea9162d9cc48c9f6bb13c'
+  drill "nil has a gibbler", nil.gibbler
+  
+  
+  dream :gibbler, '7295241e929ffd7cc974cf8d4481291e070937fc' 
+  drill "Module can gibbler", Module
+
+  dream :gibbler, '6b5a192fd377dfc5c2828a3ad6105b68b6db33d5' 
+  drill "Module instance can gibbler", Module.new
+
+  dream :gibbler, '25ac269ae3ef18cdb4143ad02ca315afb5026de9' 
+  drill "Class can gibbler", Class
+
+end
+
+
+tryouts "Proc" do
+  
+  setup do
+    class ::MyProc < Proc; end
+  end
+  
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "Proc.new can gibbler", Proc.new() { }
+  
+  dream :gibbler, '8640f7abcbcb80e3825ed827bf36819e26119e16' 
+  drill "Proc can gibbler", Proc
+    
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "proc can gibbler", proc {}
+
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "lambda can gibbler", lambda {}
+  
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "lambda gibbler is not aware of arity", lambda { |v| }
+  
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "proc gibbler is not aware of arity", proc { |v| }
+  
+  dream :gibbler, '12075835e94be34438376cd7a54c8db7e746f15d' 
+  drill "Proc gibbler is not aware of proc payload", proc { |v| 1; }
+  
+  dream :gibbler, "c979a45653acaddcb9c1581a7de49c94ac96e128"
+  drill "MyProc has a different digest" do
+    MyProc.new() { }
+  end
+end

data/tryouts/15_file_tryouts.rb

@@ -0,0 +1,47 @@
+require 'tempfile'
+
+library :gibbler, 'lib'
+group "Gibbler Gazette"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+Gibbler.digest_type = Digest::SHA1
+
+tryouts "File object tryouts" do
+  set :tempfile, "tryouts-9000-awesome.txt"
+  
+  clean do
+    File.unlink tempfile if File.exists? tempfile
+  end
+  
+  dream :gibbler, '33027386bd95e91efc4711648d488519062d828f' 
+  drill "File can gibbler" do
+    path = File.join(File.dirname(__FILE__), '..', 'CHANGES.txt')
+    File.new(File.expand_path(path))
+  end
+  
+  dream :gibbler, '4c131b7e5f9e7b841b4501d2d002785d3730ae19' 
+  drill "Gibbler is different for each path" do
+    path = File.join(File.dirname(__FILE__), '..', 'README.rdoc')
+    File.new(File.expand_path(path))
+  end
+  
+  ## JRuby doesn't like to use File.new with directories
+  ##dream :gibbler, '92cbcb7de73d7748b28d9e911f461013de34410f' 
+  ##drill "File gibbler cares about trailing slash (/tmp/)", File.new(__FILE__)
+   
+  dream :respond_to?, :gibbler
+  drill "TempFile can gibbler", Tempfile.new('gibbler')
+  
+  drill "TempFile digests change", false do
+    Tempfile.new('gibbler').gibbler == Tempfile.new('gibbler').gibbler
+  end
+  
+  dream :gibbler, '6d93f752fc23f36bffa5ddf9ee97d04be82efbdb'
+  drill "File doesn't care about file contents" do
+    f = File.open tempfile, 'w'
+    f.puts "World's Finest Number: " << "#{rand}"
+    f.close
+    stash :file_contents, File.read(tempfile)
+    File.new tempfile
+  end
+end

data/tryouts/16_uri_tryouts.rb

@@ -0,0 +1,41 @@
+require 'uri'
+
+library :gibbler, 'lib'
+group "Gibbler Gazette"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+Gibbler.digest_type = Digest::SHA1
+
+tryouts "URI object tryouts" do
+  
+  dream :gibbler, "9efe60a5db66aecf9b5fb8655b0bab0fcc7bd0c5"
+  drill "URI::HTTP can gibbler" do
+    uri = URI.parse "http://localhost:3114/spaceship"
+    uri
+  end
+  
+  dream :gibbler, "b75d3c34e60d6feafa796ddbb51e45710f6b106d"
+  drill "URI::HTTPS can gibbler" do
+    uri = URI.parse "https://localhost:3114/spaceship"
+    uri
+  end
+  
+  dream :gibbler, "191b0072b95ca0c79ed75e6deb5b28562dd9e5b9"
+  drill "URI::HTTP is trailing slash sensitive" do
+    uri = URI.parse "http://localhost:3114/spaceship/"
+    uri
+  end
+  
+  dream :gibbler, "d378372934326947113489d1f36f4853bef90a65"
+  drill "URI::Generic can gibbler" do
+    uri = URI.parse "localhost:3114/spaceship"
+    uri
+  end
+  
+  dream :gibbler, "9d0543b31afebac9e8d38c56a0cf12070779f790"
+  drill "URI::FTP can gibbler" do
+    uri = URI.parse "ftp://localhost:3114/spaceship"
+    uri
+  end
+  
+end

data/tryouts/20_time_tryouts.rb

@@ -0,0 +1,35 @@
+require 'date'
+
+library :gibbler, 'lib'
+group "Gibbler Gazette"
+
+Gibbler.enable_debug if Tryouts.verbose > 3
+Gibbler.digest_type = Digest::SHA1
+
+tryouts "Time tryouts" do
+  
+  dream :gibbler, 'c8403fc35481fdf7f6f4a0e7262b1c9610bdebaa'
+  drill "Date instance can gibbler", Date.parse('2009-08-25')
+  
+  dream :gibbler, '73b4635fc63b8dd32b622776201f98a37478be90'
+  drill "Time instance can gibbler", Time.parse('2009-08-25 16:43:53 UTC')
+  
+  dream :gibbler, 'd35546d6517c02f2a219ecfa2261a5274d217cb7'
+  drill "Time instance can gibbler with single digit values" do 
+    Time.parse('2009-01-01 01:01:01 UTC')
+  end
+  
+  dream :gibbler, 'ad64c7694a50becf55c53485dce5d0013ff65785'
+  drill "DateTime instance can gibbler", DateTime.parse('2009-08-25T17:00:40+00:00')
+  
+  dream Time.parse('2009-08-25 12:43:53 -04:00').gibbler
+  drill "Time digest is based on UTC" do
+    Time.parse('2009-08-25 16:43:53 UTC').gibbler
+  end
+  
+  dream DateTime.parse('2009-08-25T13:00:40-04:00').gibbler
+  drill "DateTime digest is based on UTC" do
+    DateTime.parse('2009-08-25T17:00:40+00:00').gibbler
+  end
+  
+end

data/tryouts/90_alias_tryouts.rb

@@ -11,6 +11,11 @@ tryouts "Gibbler::Object Aliases" do
     :kimmy.gibbler == :kimmy.digest
   end
   
+  drill "has digest_cache", true do
+    a = :kimmy.gibbler
+    a.gibbler_cache == a.digest_cache
+  end
+  
   drill "has changed?", true do
     a = "kimmy"
     a.digest

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gibbler
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-30 00:00:00 -04:00
+date: 2009-10-07 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,9 +45,14 @@ files:
 - lib/gibbler/mixins/string.rb
 - lib/gibbler/object.rb
 - tryouts/01_mixins_tryouts.rb
+- tryouts/02_compat_tryouts.rb
 - tryouts/05_gibbler_digest_tryouts.rb
 - tryouts/10_basic_tryouts.rb
 - tryouts/11_basic_sha256_tryouts.rb
+- tryouts/14_extended_tryouts.rb
+- tryouts/15_file_tryouts.rb
+- tryouts/16_uri_tryouts.rb
+- tryouts/20_time_tryouts.rb
 - tryouts/50_history_tryouts.rb
 - tryouts/51_hash_history_tryouts.rb
 - tryouts/52_array_history_tryouts.rb