gibbler 0.8.4 → 0.8.5

data/CHANGES.txt

@@ -1,5 +1,10 @@
 GIBBLER, CHANGES
 
+#### 0.8.5 (2010-12-23) ###############################
+
+* CHANGE: Gibbler::Complex will skip fields with no __gibbler method
+* ADDED: Gibbler.debug=
+
 
 #### 0.8.4 (2010-06-19) ###############################
 

data/Rakefile

@@ -1,85 +1,64 @@
-require 'rubygems'
-require 'rake/clean'
-require 'rake/gempackagetask'
-require 'fileutils'
-include FileUtils
+require "rubygems"
+require "rake"
+require "rake/clean"
+require 'yaml'
 
 begin
   require 'hanna/rdoctask'
 rescue LoadError
   require 'rake/rdoctask'
 end
-
-
-task :default => :package
  
-# CONFIG =============================================================
-
-# Change the following according to your needs
-README = "README.rdoc"
-CHANGES = "CHANGES.txt"
-LICENSE = "LICENSE.txt"
-
-# Files and directories to be deleted when you run "rake clean"
-CLEAN.include [ 'pkg', '*.gem', '.config', 'doc']
-
-name = 'gibbler'
-load "#{name}.gemspec"
-version = @spec.version
-
-# That's it! The following defaults should allow you to get started
-# on other things. 
-
-
-# TESTS/SPECS =========================================================
-
-
-
-# INSTALL =============================================================
+config = YAML.load_file("VERSION.yml")
+task :default => ["build"]
+CLEAN.include [ 'pkg', 'doc' ]
+name = "gibbler"
 
-Rake::GemPackageTask.new(@spec) do |p|
-  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}"
+    gem.name = name
+    gem.rubyforge_project = gem.name
+    gem.summary = "Gibbler: Git-like hashes for Ruby objects"
+    gem.description = gem.summary
+    gem.email = "delano@solutious.com"
+    gem.homepage = "http://github.com/delano/gibbler"
+    gem.authors = ["Delano Mandelbaum"]
+    gem.add_dependency("attic",      ">= 0.4.0")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-task :release => [ :rdoc, :package ]
-task :install => [ :rdoc, :package ] do
-	sh %{sudo gem install pkg/#{name}-#{version}.gem}
-end
-task :uninstall => [ :clean ] do
-	sh %{sudo gem uninstall #{name}}
+
+Rake::RDocTask.new do |rdoc|
+  version = "#{config[:MAJOR]}.#{config[:MINOR]}.#{config[:PATCH]}"
+  rdoc.rdoc_dir = "doc"
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("LICENSE.txt")
+  rdoc.rdoc_files.include("bin/*.rb")
+  rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
 
-# RUBYFORGE RELEASE / PUBLISH TASKS ==================================
+# Rubyforge Release / Publish Tasks ==================================
 
-if @spec.rubyforge_project
-  desc 'Publish website to rubyforge'
-  task 'publish:rdoc' => 'doc/index.html' do
-    sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
-  end
+#about 'Publish website to rubyforge'
+task 'publish:rdoc' => 'doc/index.html' do
+  #sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
+end
 
-  desc 'Public release to rubyforge'
-  task 'publish:gem' => [:package] do |t|
-    sh <<-end
-      rubyforge add_release -o Any -a #{CHANGES} -f -n #{README} #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
-      rubyforge add_file -o Any -a #{CHANGES} -f -n #{README} #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
-    end
+#about 'Public release to rubyforge'
+task 'publish:gem' => [:package] do |t|
+  sh <<-end
+    rubyforge add_release -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
+    rubyforge add_file -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
   end
 end
 
 
 
-# RUBY DOCS TASK ==================================
-
-Rake::RDocTask.new do |t|
-	t.rdoc_dir = 'doc'
-	t.title    = @spec.summary
-	t.options << '--line-numbers' 
-	t.options << '--charset' << 'utf-8'
-	t.rdoc_files.include(LICENSE)
-	t.rdoc_files.include(README)
-	t.rdoc_files.include(CHANGES)
-	t.rdoc_files.include('lib/**/*.rb')
-end
-
 

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:MAJOR: 0
+:MINOR: 8
+:PATCH: 5

data/gibbler.gemspec

@@ -1,45 +1,71 @@
-@spec = Gem::Specification.new do |s|
-	s.name = "gibbler"
-  s.rubyforge_project = "gibbler"
-	s.version = "0.8.4"
-	s.summary = "Gibbler: Git-like hashes for Ruby objects"
-	s.description = s.summary
-	s.author = "Delano Mandelbaum"
-	s.email = "delano@solutious.com"
-	s.homepage = "http://github.com/delano/gibbler"
-  
-  # = EXECUTABLES =
-  # The list of executables in your project (if any). Don't include the path, 
-  # just the base filename.
-  s.executables = %w[]
-  
-  # Directories to extract rdocs from
-  s.require_paths = %w[lib]  
-  
-  # Specific files to include rdocs from
-  s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
-  s.has_rdoc = true
-  
-  # Update --main to reflect the default page to display
-  s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
-  
-  # = DEPENDENCIES =
-  s.add_dependency 'attic',   '>= 0.4.0'
-  
-  # = MANIFEST =
-  s.files = %w(
-  CHANGES.txt
-  LICENSE.txt
-  README.rdoc
-  Rakefile
-  gibbler.gemspec
-  lib/gibbler.rb
-  lib/gibbler/aliases.rb
-  lib/gibbler/history.rb
-  lib/gibbler/mixins.rb
-  )
-  
-  s.has_rdoc = true
-  s.rubygems_version = '1.3.0'
-  
-end
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gibbler}
+  s.version = "0.8.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Delano Mandelbaum"]
+  s.date = %q{2010-12-23}
+  s.description = %q{Gibbler: Git-like hashes for Ruby objects}
+  s.email = %q{delano@solutious.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    "CHANGES.txt",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "gibbler.gemspec",
+     "lib/gibbler.rb",
+     "lib/gibbler/aliases.rb",
+     "lib/gibbler/history.rb",
+     "lib/gibbler/mixins.rb",
+     "try/01_mixins_try.rb",
+     "try/02_compat_try.rb",
+     "try/05_gibbler_digest_try.rb",
+     "try/10_basic_try.rb",
+     "try/11_basic_sha256_try.rb",
+     "try/14_extended_try.rb",
+     "try/15_file_try.rb",
+     "try/16_uri_try.rb",
+     "try/17_complex_object_try.rb",
+     "try/18_proc_try.rb",
+     "try/20_time_try.rb",
+     "try/30_secret_try.rb",
+     "try/50_history_try.rb",
+     "try/51_hash_history_try.rb",
+     "try/52_array_history_try.rb",
+     "try/53_string_history_try.rb",
+     "try/57_arbitrary_history_try.rb",
+     "try/59_history_exceptions_try.rb",
+     "try/80_performance_try.rb",
+     "try/90_alias_try.rb"
+  ]
+  s.homepage = %q{http://github.com/delano/gibbler}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{gibbler}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Gibbler: Git-like hashes for Ruby objects}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<attic>, [">= 0.4.0"])
+    else
+      s.add_dependency(%q<attic>, [">= 0.4.0"])
+    end
+  else
+    s.add_dependency(%q<attic>, [">= 0.4.0"])
+  end
+end
+

data/lib/gibbler.rb

@@ -15,7 +15,17 @@ require 'digest/sha1'
 # "Hola, Tanneritos"
 #
 module Gibbler
-  VERSION = "0.8.4"
+  module VERSION
+    def self.to_s
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
+    end
+    alias_method :inspect, :to_s
+    def self.load_config
+      require 'yaml'
+      @version ||= YAML.load_file(File.join(GIBBLER_LIB_HOME, '..', 'VERSION.yml'))
+    end
+  end
   
   @default_base = 16
   @secret = nil
@@ -223,6 +233,7 @@ module Gibbler
   def self.debug?;      @@gibbler_debug; end
   def self.enable_debug;  @@gibbler_debug = true; end
   def self.disable_debug;  @@gibbler_debug = false; end
+  def self.debug=(v);  @@gibbler_debug = v; end
   # Returns the current digest class. 
   def self.digest_type; @@gibbler_digest_type; end
   
@@ -314,6 +325,10 @@ module Gibbler
       gibbler_debug :gibbler_fields, gibbler_fields
       gibbler_fields.each do |n|
         value = instance_variable_get("@#{n}")
+        unless value.respond_to? :__gibbler
+          gibbler_debug klass, :skipping, n
+          next
+        end
         d << '%s:%s:%s' % [value.class, n, value.__gibbler(digest_type)]
       end
       d = d.join(':').__gibbler(digest_type)

data/try/01_mixins_try.rb

@@ -0,0 +1,6 @@
+require 'gibbler'
+
+## has String#clear
+  "".respond_to? :clear
+#=> true
+ 

data/try/02_compat_try.rb

@@ -0,0 +1,14 @@
+require 'gibbler'
+
+## Gibbler Objects have gibbler_cache method
+  "kimmy".respond_to? :gibbler_cache
+#=> true
+
+## Gibbler Objects have __gibbler_cache method
+  "kimmy".respond_to? :__gibbler_cache
+#=> true
+
+## __gibbler_cache returns the same value as gibbler_cache
+  @a = "kimmy" and @a.gibbler
+  @a.gibbler_cache
+#=> @a.__gibbler_cache

data/try/05_gibbler_digest_try.rb

@@ -0,0 +1,41 @@
+require 'gibbler'
+
+## has short method
+  "kimmy".gibbler.short
+#=> Gibbler::Digest.new("c8027100")
+
+# can Gibbler::Digest#short
+  Gibbler::Digest.new("1234567890").short
+#=> Gibbler::Digest.new("12345678")
+
+# == is strict (only exact matches)
+  Gibbler::Digest.new("1234567890") !=  "12345678"
+#=> true
+
+# === is relaxed (allows partial matches)
+  Gibbler::Digest.new("1234567890") === "12345678"
+#=> true
+
+# supports base36 output
+  Gibbler::Digest.new("1234567890").base36
+#=> 'zx2tc40'
+
+# base36 works on digests too
+  "kimmy".gibbler.base36
+#=> 'nd2w8270caslmly0ix3s8ruh0y8yjdt'
+
+# base36 digests can be short too
+  "kimmy".gibbler.base36.short
+#=> 'nd2w8270'
+
+# to_s returns a string and can accept a base
+  "kimmy".gibbler.to_s(16)
+#=> "kimmy".gibbler.base(16).to_s
+
+# base takes a base
+  "kimmy".gibbler.base(17)
+#=> '12gaabd69eg5b32gf69a7a021c22g977d4gf46d6'
+
+# to_s can take a base
+  "kimmy".gibbler.to_s(36)
+#=> "kimmy".gibbler.base36

data/try/10_basic_try.rb

@@ -0,0 +1,130 @@
+require 'gibbler'
+
+#Gibbler.enable_debug
+
+# include Gibbler raises exception
+  begin
+    a = Class.new
+    a.send :include, Gibbler
+  rescue RuntimeError
+    :success
+  end
+#=> :success
+
+# Symbol digests are consistent
+  :kimmy.gibbler
+#=> '52be7494a602d85ff5d8a8ab4ffe7f1b171587df' 
+
+# String digests are consistent
+  'kimmy'.gibbler
+#=> 'c8027100ecc54945ab15ddac529230e38b1ba6a1'
+
+# String and Symbol return different digests
+  :kimmy.gibbler != "kimmy".gibbler
+#=> true
+
+# Class digests are consistent
+  Class.gibbler
+#=> '25ac269ae3ef18cdb4143ad02ca315afb5026de9'
+
+# Fixnum instance digests are consistent
+  1.gibbler
+#=> 'a9cad665549bd22a4346fcf602d9d3c3b0482bbe'
+
+# Bignum instance
+  100000000000.gibbler
+#=> '608256db120251843843bba57e9b2c7adb7342aa'
+
+# Empty Hash instance digests are consistent
+  Hash.new.gibbler
+#=> '4fdcadc66a38feb9c57faf3c5a18d5e76a6d29bf'
+  
+# Populated Hash instance
+  { :a => [1,2,3, [4,5,6]], :b => { :c => Class } }.gibbler
+#=> "1d4b62e1e9f2c097b0cefb6877bf47c2015cdd21"
+  
+# Empty Array instance
+  Array.new.gibbler
+#=> '48fda57c05684c9e5c3259557851943572183a21' 
+
+# Populated Array instance
+  [1, 2, :runtime, [3, "four", [Object, true]]].gibbler
+#=> "3e1d79d113a409a96a13ca3879fc4c42027aa74b"
+
+# Knows when a Hash has not changed
+  a = { :magic => true }
+  a.gibbler
+  a[:magic] = true
+  a.gibbled?
+# => false
+
+# Knows when a Hash has changed
+  a = { :magic => true }
+  a.gibbler
+  a[:magic] = false
+  a.gibbled?
+#=> true
+
+# Two Symbol digests don't cross streams
+  a, b = :something, :anything
+  a.gibbler
+  b.gibbler
+  [a.gibbler_cache.short, b.gibbler_cache.short]
+#=> ["667ce086", "92d5f7cd"]
+
+# Two String digests don't cross streams"
+  a, b = 'something', 'anything'
+  a.gibbler
+  b.gibbler
+  [a.gibbler_cache.short, b.gibbler_cache.short]
+#=> ["ce0c7694", "c13b2f02"]
+
+## DISABLED: If gibbler/history is required, there will be an
+## additional attic_var (:gibbler_history), but only if the
+## gibbler_history method has been called already (the history
+## remains nil by default). The fix is not straightfroward and
+## tests are not important anyway so disabling them is fine. 
+## Symbol has list of attic vars", [:gibbler_cache]
+#  Symbol.attic_vars
+#end
+#
+## String has list of attic vars", [:gibbler_cache]
+#  String.attic_vars
+#end
+#
+## Hash has list of attic vars", [:gibbler_cache]
+#  Hash.attic_vars
+#end
+
+# Freezing an object will update the digest
+  a = { :a => 1 }
+  pre  = a.gibbler; 
+  a[:a] = 2 
+  post = a.freeze.gibbler
+  pre != post && post == a.gibbler_cache
+#=> true
+
+# works on arbitrary objects"
+  class ::FullHouse
+    include Gibbler::Complex
+    attr_accessor :roles
+  end
+  a = FullHouse.new
+  a.roles = [:jesse, :joey, :danny, :kimmy, :michelle, :dj, :stephanie]
+  a.gibbler
+#=> "fa5f741275b6b27932537e1946042b0286286e1d"
+
+# TODO: Update for Attic 0.4
+# doesn't reveal @__gibbler_digest__ instance variable", false
+  a = {}
+  a.gibbler  # We need to gibbler first so it sets a value to the instance var
+  val = RUBY_VERSION >= '1.9' ? :'@__gibbler_digest__' : '@__gibbler_digest__'
+  a.instance_variables.member? val
+#=> false
+
+# previous digest"
+  a = "kimmy"
+  a.gibbler
+  a.gibbler_cache
+#=> 'c8027100ecc54945ab15ddac529230e38b1ba6a1'
+

data/try/11_basic_sha256_try.rb

@@ -0,0 +1,28 @@
+require 'gibbler'
+
+# NOTE: JRuby requires that we use OpenSSL::Digest::SHA256
+if Tryouts.sysinfo.vm == :java 
+  require 'openssl'
+  Gibbler.digest_type = OpenSSL::Digest::SHA256
+else
+  Gibbler.digest_type = Digest::SHA256
+end
+
+## A Symbol can gibbler
+  :anything.gibbler
+#=> '754f87ca720ec256633a286d9270d68478850b2abd7b0ae65021cb769ae70c08' 
+
+## Class can gibbler
+  Class.gibbler
+#=> 'd345c0afb4e8da0133a3946d3bd9b2622b0acdd8d6cc1237470cc637a9e4777f' 
+
+## TrueClass can gibbler
+  TrueClass.gibbler
+#=> 'b7b874a9bff7825caa57750a900652354ac601b77497b694d313f658c69d25b4' 
+
+# Empty Hash instance
+  {}.gibbler
+#=> '88d2bcbd68ce593fd2e0e06f276f7301357516291b95c0c53038e61a9bf091e5' 
+
+Gibbler.digest_type = Digest::SHA1
+

data/try/14_extended_try.rb

@@ -0,0 +1,78 @@
+require 'gibbler'
+
+## true can gibbler
+  true.gibbler
+#=> 'f2b0150c84c5c834406ec9cdec989a0fa938b4ad' 
+
+# false can gibbler
+  false.gibbler
+#=> 'abee839edf5f9c101c505c28987ca35c31c7fc8d' 
+
+# TrueClass can gibbler
+  TrueClass.gibbler
+#=> '583fb214ec50d2c4a123cc52de0c65e801d13516' 
+
+# FalseClass can gibbler
+  FalseClass.gibbler
+#=> '11f262be475ddf38a25888e9f6ec82f384a7c58b' 
+
+# Class can gibbler
+  Class.gibbler
+#=> '25ac269ae3ef18cdb4143ad02ca315afb5026de9' 
+
+# Object can gibbler
+  Object.gibbler
+#=> '5620e4a8b10ec6830fece61d33f5d3e9a349b4c2' 
+
+# Class instance can gibbler
+  Class.new.gibbler
+#=> '083feec632e6cd5347e3fb3c7048365c3a0d710e' 
+
+# Module can gibbler
+  Module.gibbler
+#=> '7295241e929ffd7cc974cf8d4481291e070937fc' 
+
+# Module instance can gibbler
+  Module.new.gibbler
+#=> '6b5a192fd377dfc5c2828a3ad6105b68b6db33d5' 
+
+# Proc can gibbler"
+  Proc.gibbler
+#=> '8640f7abcbcb80e3825ed827bf36819e26119e16' 
+
+# Range instance (..) can gibbler
+  (1..100).gibbler
+#=> '5450635218fd16e594976e87abd0955529e28248' 
+
+# Range ... is different than ..
+  (1...100).gibbler != (1..100).gibbler
+#=> true
+
+# Range instance with Floats can gibbler
+  (0.1...1.5).gibbler
+#=> '9d3cd5a21c17cfa0b4bb685730bd07994c486ba2' 
+
+# Range instance with one Float can gibbler
+  (0.1..1).gibbler
+#=> 'c725659ca0f3fa3c9ab807bb2db4b718e2dca042' 
+
+# Range (..) doesn't equal range (...)"
+  ('a'..'e').gibbler != ('a'...'e').gibbler
+#=> true
+
+# nil has a gibbler
+  nil.gibbler
+#=> '06fdf26b2a64e90cd35ea9162d9cc48c9f6bb13c'
+
+# Module can gibbler
+  Module.gibbler
+#=> '7295241e929ffd7cc974cf8d4481291e070937fc' 
+
+# Module instance can gibbler
+  Module.new.gibbler
+#=> '6b5a192fd377dfc5c2828a3ad6105b68b6db33d5' 
+
+# Class can gibbler
+  Class.gibbler
+#=> '25ac269ae3ef18cdb4143ad02ca315afb5026de9' 
+

data/try/15_file_try.rb

@@ -0,0 +1,36 @@
+require 'tempfile'
+require 'gibbler'
+
+@tempfile = "tryouts-9000-awesome.txt"
+  
+## File can gibbler
+  file = File.new(File.join('.', 'CHANGES.txt'))
+  file.gibbler
+#=>  'c052e87bd0acb7e08c98dad7f8b09b4382a08ef6' 
+ 
+## Gibbler is different for each path
+  file1 = File.new(File.join('.', 'CHANGES.txt'))
+  file2 = File.new(File.join('.', 'README.rdoc'))
+  file1.gibbler == file2.gibbler
+#=> false
+
+# TempFile can gibbler
+  Tempfile.new('gibbler').respond_to? :gibbler
+#=> true
+
+# TempFile digests change
+  Tempfile.new('gibbler').gibbler != Tempfile.new('gibbler').gibbler
+#=> true
+
+# File doesn't care about file contents
+  f = File.open @tempfile, 'w'
+  f.puts "World's Finest Number: " << "#{rand}"
+  f.close
+  File.new(@tempfile).gibbler
+#=>  '6d93f752fc23f36bffa5ddf9ee97d04be82efbdb'
+
+## JRuby doesn't like to use File.new with directories
+###=>  '92cbcb7de73d7748b28d9e911f461013de34410f' 
+### "File gibbler cares about trailing slash (/tmp/)", File.new(__FILE__)
+
+File.unlink @tempfile if File.exists? @tempfile

data/try/16_uri_try.rb

@@ -0,0 +1,28 @@
+require 'uri'
+require 'gibbler'
+
+# "URI::HTTP can gibbler"
+  uri = URI.parse "http://localhost:3114/spaceship"
+  uri.gibbler
+#=> "9efe60a5db66aecf9b5fb8655b0bab0fcc7bd0c5"
+
+# "URI::HTTPS can gibbler"
+  uri = URI.parse "https://localhost:3114/spaceship"
+  uri.gibbler
+#=> "b75d3c34e60d6feafa796ddbb51e45710f6b106d"
+
+# "URI::HTTP is trailing slash sensitive"
+  uri = URI.parse "http://localhost:3114/spaceship/"
+  uri.gibbler
+#=> "191b0072b95ca0c79ed75e6deb5b28562dd9e5b9"
+
+# "URI::Generic can gibbler"
+  uri = URI.parse "localhost:3114/spaceship"
+  uri.gibbler
+#=> "d378372934326947113489d1f36f4853bef90a65"
+
+# "URI::FTP can gibbler"
+  uri = URI.parse "ftp://localhost:3114/spaceship"
+  uri.gibbler
+#=> "9d0543b31afebac9e8d38c56a0cf12070779f790"
+

data/try/17_complex_object_try.rb

@@ -0,0 +1,27 @@
+require 'gibbler'
+
+# arbitrary objects can specify instance variables to gibbler
+  class ::FullHouse
+    include Gibbler::Complex
+    attr_accessor :roles
+    attr_accessor :stamp
+    attr_accessor :ready
+    gibbler :roles
+  end
+  a = FullHouse.new
+  a.roles = [:jesse, :joey, :danny, :kimmy, :michelle, :dj, :stephanie]
+  a.stamp = Time.now
+  a.ready = true
+  a.gibbler
+#=> "fa5f741275b6b27932537e1946042b0286286e1d"
+
+# arbitrary objects can append more instance variables later on
+  class ::FullHouse
+    gibbler :stamp, :ready
+  end
+  a = FullHouse.new
+  a.roles = [:jesse, :joey, :danny, :kimmy, :michelle, :dj, :stephanie]
+  a.stamp = Time.parse('2009-08-25 16:43:53 UTC')
+  a.ready = true
+  a.gibbler
+#=> "fbdce0d97a856e7106bec418d585c914914b8aa5"

data/try/18_proc_try.rb

@@ -0,0 +1,35 @@
+require 'gibbler'
+
+class ::MyProc < Proc; end
+
+## Proc.new can gibbler
+  Proc.new() { }.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# Proc can gibbler
+  Proc.gibbler
+#=> '8640f7abcbcb80e3825ed827bf36819e26119e16' 
+  
+## proc can gibbler
+  proc {}.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# lambda can gibbler
+  lambda {}.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# lambda gibbler is not aware of arity
+  lambda { |v| }.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# proc gibbler is not aware of arity
+  proc { |v| }.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# Proc gibbler is not aware of proc payload"
+  proc { |v| 1; }.gibbler
+#=> '12075835e94be34438376cd7a54c8db7e746f15d' 
+
+# MyProc has a different digest
+  MyProc.new() { }.gibbler
+#=> "c979a45653acaddcb9c1581a7de49c94ac96e128"

data/try/20_time_try.rb

@@ -0,0 +1,27 @@
+require 'date'
+require 'gibbler'
+
+# "Date instance can gibbler
+  Date.parse('2009-08-25').gibbler
+#=> 'c8403fc35481fdf7f6f4a0e7262b1c9610bdebaa'
+
+# "Time instance can gibbler
+  Time.parse('2009-08-25 16:43:53 UTC').gibbler
+#=> '73b4635fc63b8dd32b622776201f98a37478be90'
+
+# "Time instance can gibbler with single digit values
+  Time.parse('2009-01-01 01:01:01 UTC').gibbler
+#=> 'd35546d6517c02f2a219ecfa2261a5274d217cb7'
+
+# "DateTime instance can gibbler
+  DateTime.parse('2009-08-25T17:00:40+00:00').gibbler
+#=> 'ad64c7694a50becf55c53485dce5d0013ff65785'
+
+# "Time digest is based on UTC
+  Time.parse('2009-08-25 16:43:53 UTC').gibbler
+#=> Time.parse('2009-08-25 12:43:53 -04:00').gibbler
+
+# "DateTime digest is based on UTC
+  DateTime.parse('2009-08-25T17:00:40+00:00').gibbler
+#=> DateTime.parse('2009-08-25T13:00:40-04:00').gibbler
+

data/try/30_secret_try.rb

@@ -0,0 +1,21 @@
+require 'uri'
+require 'gibbler'
+
+# "Can set a sexy global secret
+  Gibbler.secret = 'kimmy'.gibbler
+  Gibbler.secret
+#=> "c8027100ecc54945ab15ddac529230e38b1ba6a1"
+
+# "When the secret is set, digests are different
+  'kimmy'.gibbler
+#=> "62e645351505cb89a0b06a0f5df8383ea754f71d"
+
+# "When the secret is set, digests are different (again)
+  Gibbler.secret = :kimmy.gibbler
+  'kimmy'.gibbler
+#=> "e5f8a3d8e4a2dc99717984726efc910dab0c18f4"
+
+# "Reset the secret back to nil
+  Gibbler.secret = nil
+  'kimmy'.gibbler
+#=> "c8027100ecc54945ab15ddac529230e38b1ba6a1"

data/try/50_history_try.rb

@@ -0,0 +1,30 @@
+require 'gibbler'
+require 'gibbler/history'
+
+# can convert short digest into long
+  a = { :magic => :original }
+  g = a.gibbler_commit.short
+  a.gibbler_find_long(g)
+#=> "d7049916ddb25e6cc438b1028fb957e5139f9910"
+
+# can return most recent stamp
+  a = { :magic => :original }
+  a.gibbler_commit
+  a.gibbler_stamp.class
+#=> Time
+
+# can return history
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :changed
+  a.gibbler_commit
+  a.gibbler_history
+#=> ["d7049916ddb25e6cc438b1028fb957e5139f9910", "0b11c377fccd44554a601e5d2b135c46dc1c4cb1"]
+
+# can return history (short)
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :changed
+  a.gibbler_commit
+  a.gibbler_history(:short)
+#=> ["d7049916", "0b11c377"]

data/try/51_hash_history_try.rb

@@ -0,0 +1,71 @@
+require 'gibbler'
+require 'gibbler/history'
+
+class ::Hash
+  include Gibbler::History
+end
+
+## "doesn't reveal self.__gibbler_history instance variable",
+  a = {}
+  a.gibbler  # We need to gibbler first so it sets a value to the instance var
+  val = RUBY_VERSION >= '1.9' ? :'self.__gibbler_history' : 'self.__gibbler_history'
+  a.instance_variables.member? val
+#=> false
+
+# can take a Hash snapshot
+  a = { :magic => :original }
+  a.gibbler_commit
+#=> 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+
+# "return a Hash history"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :updated
+  a.gibbler_commit
+  a.gibbler_history
+#=> ['d7049916ddb25e6cc438b1028fb957e5139f9910', 'b668098e16d08898532bf3aa33ce2253a3a4150e']
+
+# "can revert Hash"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :updated
+  a.gibbler_revert!
+#=> 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+
+# "knows a valid gibble"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a.gibbler_valid? 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+#=> true
+
+# "knows an invalid gibble"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a.gibbler_valid? '2222222222222222222222222222222222222222'
+#=> false
+
+# "can revert to any valid gibble"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :updated
+  a.gibbler_commit
+  a[:magic] = :changed
+  a.gibbler_commit
+  a.gibbler_revert! 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+  a
+#=> Hash[:magic => :original]
+
+# "revert does nothing if digest is the same as current one"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a.gibbler_revert!
+  a
+#=> Hash[:magic => :original]
+
+# "can revert using short gibbler_commit"
+  a = { :magic => :original }
+  a.gibbler_commit
+  a[:magic] = :updated
+  a.gibbler_revert! 'd7049916'
+#=> 'd7049916ddb25e6cc438b1028fb957e5139f9910'
+

data/try/52_array_history_try.rb

@@ -0,0 +1,35 @@
+require 'gibbler'
+require 'gibbler/history'
+
+class Array
+  include Gibbler::History
+end
+
+# "can take a Array snapshot"
+  a = [:jesse]
+  a.gibbler_commit
+#=> 'd95fcabb498ae282f356eba63da541e4f72c6efa'
+
+# "return an Array history"
+  a = [:jesse]
+  a.gibbler_commit
+  a << :joey
+  a.gibbler_commit
+  a.gibbler_history
+#=> ['d95fcabb498ae282f356eba63da541e4f72c6efa', 'eebcb2e84e828b1a7207af4d588cf41fd4c6393a']
+
+# "can revert Array"
+  a = [:jesse]
+  a.gibbler_commit
+  a << :joey
+  a.gibbler_revert!
+#=> 'd95fcabb498ae282f356eba63da541e4f72c6efa'
+
+# Raises exception when no history
+  begin
+  a = [:jesse]
+  a.gibbler_revert!
+  rescue Gibbler::NoHistory
+    :success
+  end
+#=> :success

data/try/53_string_history_try.rb

@@ -0,0 +1,29 @@
+require 'gibbler'
+require 'gibbler/history'
+
+class String
+  include Gibbler::History
+end
+
+# "can take a String snapshot"
+  a = "kimmy"
+  a.gibbler_commit
+#=> 'c8027100ecc54945ab15ddac529230e38b1ba6a1'
+
+# "return a String history"
+  a = "kimmy"
+  a.gibbler_commit
+  a << " gibbler"
+  a.gibbler_commit
+  a.gibbler_history
+#=> ['c8027100ecc54945ab15ddac529230e38b1ba6a1', '692c05d3186baf2da36e87b7bc5fe53ef13b902e']
+
+# "can revert String"
+  a = "kimmy"
+  a.gibbler_commit
+  a << " gibbler"
+  a.gibbler
+  a.gibbler_revert!
+#=> 'c8027100ecc54945ab15ddac529230e38b1ba6a1'
+
+

data/try/57_arbitrary_history_try.rb

@@ -0,0 +1,31 @@
+require 'gibbler'
+require 'gibbler/history'
+
+class ::FullHouse
+  include Gibbler::Complex
+  include Gibbler::History
+  attr_accessor :roles
+end
+
+# "can take a FullHouse snapshot"
+  a = FullHouse.new
+  a.gibbler_commit
+#=> '4192d4cb59975813f117a51dcd4454ac16df6703'
+
+# "return a FullHouse history"
+  a = FullHouse.new
+  a.gibbler_commit
+  a.roles = [:jesse]
+  a.gibbler_commit
+  a.gibbler_history
+#=> ['4192d4cb59975813f117a51dcd4454ac16df6703', '05219bdee8ec6300b579f2ba8ce55d851d10928b']
+
+# "can revert FullHouse"
+  a = FullHouse.new
+  a.gibbler_commit
+  a.roles = [:jesse]
+  a.gibbler
+  a.gibbler_revert!
+#=> '4192d4cb59975813f117a51dcd4454ac16df6703'
+
+

data/try/59_history_exceptions_try.rb

@@ -0,0 +1,31 @@
+require 'gibbler'
+require 'gibbler/history'
+
+
+# "raises exception when reverting to unknown gibble"
+  begin
+    a = {}
+    a.gibbler_commit
+    a.gibbler_revert! '2222222222222222222222222222222222222222'
+  rescue Gibbler::BadDigest
+    :success
+  end
+#=> :success
+
+# "raises exception when reverting and there's no history"
+  begin
+    a = []
+    a.gibbler_revert!
+  rescue Gibbler::NoHistory
+    :success
+  end
+#=> :success
+
+# "raises exception when reverting an unsupported object"
+  begin
+    :kimmy.gibbler_revert!
+  rescue NoMethodError
+    :success
+  end
+#=> :success
+

data/try/80_performance_try.rb

@@ -0,0 +1,82 @@
+## DISABLED. Tryouts 2.0 doesn't do performance
+##
+# 
+# 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..1000).map { rand }
+#     values = (1..1000).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.4
+#   drill "Hash#gibbler", 5 do
+#     @@hash.gibbler 
+#   end
+#   
+# end
+# 
+# repetitions = 10         # 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/try/90_alias_try.rb

@@ -0,0 +1,47 @@
+require 'gibbler/aliases'
+require 'gibbler/history'
+
+
+# "has digest"
+  :kimmy.gibbler == :kimmy.digest
+#=> true
+  
+# "has digest_cache", true
+  a = :kimmy.gibbler
+  a.gibbler_cache == a.digest_cache
+#=> true
+  
+# "has changed?"
+  a = "kimmy"
+  a.digest
+  a << '+ dj'
+  a.gibbled?
+#=> true
+
+# "can convert short digest into long"
+  a = { :magic => :original }
+  g = a.commit.short
+  a.find_long g
+#=> "d7049916ddb25e6cc438b1028fb957e5139f9910"
+
+# "can return most recent stamp"
+  a = { :magic => :original }
+  a.commit
+  a.stamp.class
+#=> Time
+
+# "can return history"
+  a = { :magic => :original }
+  a.commit
+  a[:magic] = :changed
+  a.commit
+  a.history
+#=> ["d7049916ddb25e6cc438b1028fb957e5139f9910", "0b11c377fccd44554a601e5d2b135c46dc1c4cb1"]
+
+# "can return history (short)"
+  a = { :magic => :original }
+  a.commit
+  a[:magic] = :changed
+  a.commit
+  a.history(:short)
+#=> ["d7049916", "0b11c377"]

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gibbler
 version: !ruby/object:Gem::Version 
-  version: 0.8.4
+  hash: 53
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 5
+  version: 0.8.5
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,19 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-19 00:00:00 -04:00
+date: 2010-12-23 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: attic
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
         version: 0.4.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: "Gibbler: Git-like hashes for Ruby objects"
 email: delano@solutious.com
 executables: []
@@ -29,47 +41,70 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.rdoc
 - LICENSE.txt
+- README.rdoc
 files: 
 - CHANGES.txt
 - LICENSE.txt
 - README.rdoc
 - Rakefile
+- VERSION.yml
 - gibbler.gemspec
 - lib/gibbler.rb
 - lib/gibbler/aliases.rb
 - lib/gibbler/history.rb
 - lib/gibbler/mixins.rb
+- try/01_mixins_try.rb
+- try/02_compat_try.rb
+- try/05_gibbler_digest_try.rb
+- try/10_basic_try.rb
+- try/11_basic_sha256_try.rb
+- try/14_extended_try.rb
+- try/15_file_try.rb
+- try/16_uri_try.rb
+- try/17_complex_object_try.rb
+- try/18_proc_try.rb
+- try/20_time_try.rb
+- try/30_secret_try.rb
+- try/50_history_try.rb
+- try/51_hash_history_try.rb
+- try/52_array_history_try.rb
+- try/53_string_history_try.rb
+- try/57_arbitrary_history_try.rb
+- try/59_history_exceptions_try.rb
+- try/80_performance_try.rb
+- try/90_alias_try.rb
 has_rdoc: true
 homepage: http://github.com/delano/gibbler
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --line-numbers
-- --title
-- "Gibbler: Git-like hashes for Ruby objects"
-- --main
-- README.rdoc
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: gibbler
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: "Gibbler: Git-like hashes for Ruby objects"