dirty_hashy 0.1.1 → 0.1.2

data/CHANGELOG.rdoc

@@ -1,5 +1,11 @@
 = DirtyHashy CHANGELOG
 
+== Version 0.1.2 (December 24, 2011)
+
+* Moved restricted keys logic from MethodMap to DirtyHash and thus being able to restrict keys of a DirtyHashy without dirty mapping ^^
+* Corrected DirtyHashy.replace and DirtyHashy.clear in order to dirty track involved changes
+* Improved :attributes= implementation within DirtyAttributes
+
 == Version 0.1.1 (December 24, 2011)
 
 * Added convenience methods (with MethodMap) like +name+, +name=+, +name_changed?+, +name_was+ and +name_change+

data/Gemfile

@@ -13,4 +13,5 @@ end
 group :gem_test do
   gem "minitest"
   gem "mocha"
+  gem "pry"
 end

data/README.textile

@@ -4,7 +4,7 @@ Dirty tracking within hashes with indifferent access or objects as it is expecte
 
 h2. Introduction
 
-"Dirty tracking / objects":http://ryandaigle.com/articles/2008/3/31/what-s-new-in-edge-rails-dirty-objects is a common programming concept. In short, it is the mechanism to track whether or not the attributes of an object have been changed and if so, which ones.
+"Dirty tracking / objects":http://ryandaigle.com/articles/2008/3/31/what-s-new-in-edge-rails-dirty-objects is a common programming concept. In short, it is the concept of tracking whether or not the attributes of an object have been changed and if so, which ones.
 
 It is mostly implemented within ORM's, a couple of examples in the Ruby world are "ActiveRecord":http://ar.rubyonrails.org/classes/ActiveRecord/Dirty.html, "DataMapper":http://rubydoc.info/gems/dm-core/1.1.0/file/README.rdoc, "Mongoid":http://mongoid.org/docs/documents/dirty.html and "CouchRest Model":http://www.couchrest.info/model/dirty_tracking.html.
 
@@ -88,8 +88,35 @@ You can map methods within a DirtyHashy in order to provide convenience methods
   h.name = "Engel"
   h.name_was #=> "Paul"
   h.name_change #=> ["Paul", "Engel"]
-  h.foo = "Bar"
-  h.changes #=> {"name"=>["Paul", "Engel"], "foo"=>[nil, "Bar"]}
+  h.foo = "bar"
+  h.changes #=> {"name"=>["Paul", "Engel"], "foo"=>[nil, "bar"]}
+</pre>
+
+h3. Method mapping DirtyHashy with key restriction
+
+Along with providing convenience methods, you can also restrict the range of keys you are permitted to read / write / merge / replace of a DirtyHash:
+
+<pre>
+  require "rubygems"
+  require "dirty_hashy"
+
+  h = DirtyHashy.new({}, true, [:name])
+  h.dirty? #=> false
+  h.name #=> nil
+  h.name = "Paul"
+  h.dirty? #=> true
+  h.name_changed? #=> true
+  h.name_was #=> nil
+  h.name_change #=> [nil, "Paul"]
+  h.merge! :name => "Engel"
+  h.name #=> "Engel"
+  h.name_was #=> nil
+  h.name_change #=> [nil, "Engel"]
+  h.foo #=> NoMethodError: undefined method `foo' for {"name"=>"Engel"}:DirtyHashy
+  h.foo = "bar" #=> NoMethodError: undefined method `foo=' for {"name"=>"Engel"}:DirtyHashy
+  h.clean_up!
+  h.replace :name => "Paul"
+  h.changes #=> {"name"=>["Engel", "Paul"]}
 </pre>
 
 h3. Dirty tracking objects (models)
@@ -159,6 +186,7 @@ You can use @Person@ objects as you would expect:
   p.clean_up!
   p.dirty? #=> false
   p.name #=> "Paul"
+  p.foo = "bar" #=> NoMethodError: undefined method `foo=' for #<Person:0x00000100d89860>
 </pre>
 
 And last but not least: don't care about specifying the attributes available? Well don't! ;)

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/dirty_hashy.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "dirty_hashy"
   gem.require_paths = ["lib"]
-  gem.version       = "0.1.1"
+  gem.version       = "0.1.2"
 
   gem.add_dependency "activesupport", ">= 3.0.0"
 end

data/lib/dirty_attributes.rb

@@ -12,7 +12,7 @@ module DirtyAttributes
     end
 
     def attributes
-      @attrs || []
+      @attrs
     end
   end
 
@@ -20,15 +20,17 @@ module DirtyAttributes
     attr_reader :attributes
 
     def initialize
-      attrs = self.class.attributes.inject({}){|h, a| h.merge({a => nil})}
-      @attributes = DirtyHashy.new(attrs).tap do |hashy|
-        dirty_map! hashy, attrs.keys
+      @attributes = DirtyHashy.new({}, true, self.class.attributes).tap do |hashy|
+        dirty_map! hashy
         clean_up!
       end
     end
 
     def attributes=(other)
-      attributes.clear.merge! other
+      attributes.replace other
+    rescue IndexError => e
+      e.message.match /"(.*)"/
+      raise NoMethodError, "undefined method `#{$1}=' for #{self.inspect}"
     end
   end
 

data/lib/dirty_hashy.rb

@@ -5,18 +5,36 @@ require "method_map"
 
 class DirtyHashy < HashWithIndifferentAccess
 
-  def self.new(constructor = {}, map_methods = false)
-    super(constructor).tap do |instance|
-      if map_methods
-        instance.extend MethodMap
-        instance.dirty_map!
-      end
+  def initialize(constructor = {}, map_methods = false, restricted_keys = nil)
+    super constructor
+    if map_methods
+      extend MethodMap
+      dirty_map!
     end
+    if restricted_keys
+      restricted_keys.each{|key| self[key] ||= nil}
+      @restricted_keys = keys
+    end
+  end
+
+  def replace(other)
+    clear
+    merge! other
+  end
+
+  def clear
+    keys.each{|key| delete key}
+  end
+
+  def [](key, mapped = false)
+    validate_read!(key) if mapped || restricted_keys?
+    super(key)
   end
 
   alias :_regular_writer :regular_writer
   def regular_writer(key, value)
-    original_value = changes.key?(key) ? was(key) : self[key]
+    validate_write!(key)
+    original_value = changes.key?(key) ? was(key) : fetch(key, nil)
     if original_value == value
       changes.delete key
     else
@@ -34,17 +52,18 @@ class DirtyHashy < HashWithIndifferentAccess
     @changes ||= HashWithIndifferentAccess.new
   end
 
-  def changed?(key = nil)
+  def changed?(key = nil, mapped = false)
+    validate_read!(key) if !key.nil? && (mapped || restricted_keys?)
     key.nil? ? !changes.empty? : changes.key?(key)
   end
   alias :dirty? :changed?
 
-  def change(key)
-    changes[key] if changed?(key)
+  def change(key, mapped = false)
+    changes[key] if changed?(key, mapped)
   end
 
-  def was(key)
-    change(key).first if changed?(key)
+  def was(key, mapped = false)
+    change(key).first if changed?(key, mapped)
   end
 
   def clean_up!
@@ -52,4 +71,18 @@ class DirtyHashy < HashWithIndifferentAccess
     nil
   end
 
+private
+
+  def restricted_keys?
+    !(@restricted_keys || []).empty?
+  end
+
+  def validate_read!(key)
+    raise IndexError, "Invalid key: \"#{key}\"" unless (keys + changes.keys).include?(key.to_s)
+  end
+
+  def validate_write!(key)
+    raise IndexError, "Invalid key: \"#{key}\"" unless @restricted_keys.nil? || @restricted_keys.empty? || @restricted_keys.include?(key.to_s)
+  end
+
 end

data/lib/dirty_hashy/version.rb

@@ -1,7 +1,7 @@
 class DirtyHashy < HashWithIndifferentAccess
   MAJOR = 0
   MINOR = 1
-  TINY  = 1
+  TINY  = 2
 
   VERSION = [MAJOR, MINOR, TINY].join(".")
 end

data/lib/method_map.rb

@@ -1,51 +1,44 @@
 module MethodMap
 
-  def dirty_map!(mapped = nil, restricted_keys = nil)
+  def dirty_map!(mapped = nil)
     @mapped = mapped || self
-    @restricted_keys = (restricted_keys || []).collect(&:to_s)
     map_method(:changes)
     map_method(:dirty?)
     map_method(:changed?)
     map_method(:clean_up!)
-    map_method(/^([\w_]+)_changed\?$/, Proc.new{ |match| :changed? if map_key? match })
-    map_method(/^([\w_]+)_change$/   , Proc.new{ |match| :change   if map_key? match })
-    map_method(/^([\w_]+)_was$/      , Proc.new{ |match| :was      if map_key? match })
-    map_method(/(^[\w_]+)=$/         , Proc.new{ |match| :[]=      if accept_key? match })
-    map_method(/(^[\w_]+)$/          , Proc.new{ |match| :[]       if map_key? match })
+    map_method(/^([\w_]+)_changed\?$/, :changed?, true)
+    map_method(/^([\w_]+)_change$/, :change, true)
+    map_method(/^([\w_]+)_was$/, :was, true)
+    map_method(/(^[\w_]+)=$/, :[]=)
+    map_method(/(^[\w_]+)$/, :[], true)
   end
 
-  def map_method(pattern, method_or_proc = nil)
+  def map_method(pattern, method_or_proc = nil, args = nil)
     regex = pattern.is_a?(Regexp) ? pattern : Regexp.new("^#{Regexp.escape(pattern.to_s)}$")
-    method_map[regex] = method_or_proc || pattern
+    method_map[regex] = {:method_or_proc => (method_or_proc || pattern), :args => args}
   end
 
   def method_missing(method, *args)
     if m = match_method(method)
-      @mapped.send *(m + args)
-    else
-      super
+      begin
+        return @mapped.send *(m + args)
+      rescue IndexError; end
     end
+    super
   end
 
 private
 
-  def map_key?(key)
-    (@mapped.keys + @mapped.changes.keys).include?(key.to_s)
-  end
-
-  def accept_key?(key)
-    @restricted_keys.empty? || @restricted_keys.include?(key.to_s)
-  end
-
   def method_map
     @method_map ||= {}
   end
 
   def match_method(method)
-    method_map.each do |pattern, method_or_proc|
+    method_map.each do |pattern, spec|
+      method_or_proc = spec[:method_or_proc]
       if method.to_s.match pattern
         m = method_or_proc.is_a?(Proc) ? method_or_proc.call($1 || method) : method_or_proc
-        return [m, $1].compact if m
+        return [m, $1, spec[:args]].compact if m
       end
     end
     nil

data/test/unit/test_dirty_attributes.rb

@@ -63,6 +63,38 @@ module Unit
         assert_equal nil, person.name_change
         assert_equal [nil, "Bar"], person.foo_change
         assert_equal({"foo" => [nil, "Bar"]}, person.changes)
+
+        person.attributes.merge! :company => "Internetbureau Holder B.V."
+
+        assert_equal true, person.dirty?
+        assert_equal true, person.changed?
+        assert_equal false, person.name_changed?
+        assert_equal true, person.foo_changed?
+        assert_equal true, person.company_changed?
+        assert_equal nil, person.name_change
+        assert_equal [nil, "Bar"], person.foo_change
+        assert_equal [nil, "Internetbureau Holder B.V."], person.company_change
+        assert_equal({"foo" => [nil, "Bar"], "company" => [nil, "Internetbureau Holder B.V."]}, person.changes)
+
+        person.attributes.delete :foo
+        person.clean_up!
+
+        assert_equal false, person.dirty?
+        assert_equal false, person.changed?
+        assert_equal({"name" => "Stephan", "company" => "Internetbureau Holder B.V."}, person.attributes)
+        assert_equal({}, person.changes)
+
+        person.attributes = {"name" => "Paul", "city" => "Amsterdam"}
+
+        assert_equal true, person.dirty?
+        assert_equal true, person.changed?
+        assert_equal true, person.name_changed?
+        assert_equal true, person.company_changed?
+        assert_equal true, person.city_changed?
+        assert_equal ["Stephan", "Paul"], person.name_change
+        assert_equal ["Internetbureau Holder B.V.", nil], person.company_change
+        assert_equal [nil, "Amsterdam"], person.city_change
+        assert_equal({"name" => ["Stephan", "Paul"], "company" => ["Internetbureau Holder B.V.", nil], "city" => [nil, "Amsterdam"]}, person.changes)
       end
 
       it "should behave as expected with key restriction" do
@@ -119,6 +151,22 @@ module Unit
         assert_equal false, user.name_changed?
         assert_equal nil, user.name_change
         assert_equal({}, user.changes)
+
+        user.attributes = {"name" => "Paul"}
+
+        assert_equal true, user.dirty?
+        assert_equal true, user.changed?
+        assert_equal true, user.name_changed?
+        assert_equal ["Stephan", "Paul"], user.name_change
+        assert_equal({"name" => ["Stephan", "Paul"]}, user.changes)
+
+        assert_raises(NoMethodError) do
+          user.attributes = {"company" => "Internetbureau Holder B.V."}
+        end
+
+        assert_raises(IndexError) do
+          user.attributes.merge! "company" => "Internetbureau Holder B.V."
+        end
       end
     end
 

data/test/unit/test_dirty_hashy.rb

@@ -4,9 +4,10 @@ module Unit
   class TestDirtyHashy < MiniTest::Unit::TestCase
 
     describe DirtyHashy do
-      it "should behave as expected without method mapping" do
+      it "should behave as expected without method mapping and without restricted keys" do
         hashy = DirtyHashy.new
 
+        assert_equal({}, hashy)
         assert_equal false, hashy.dirty?
         assert_equal false, hashy.changed?
         assert_equal({}, hashy.changes)
@@ -137,11 +138,159 @@ module Unit
         assert_equal "Holder", hashy.was("company")
         assert_equal ["Holder", nil], hashy.change(:company)
         assert_equal ["Holder", nil], hashy.change("company")
+
+        hashy.merge! :name => "Paul", :company => "Internetbureau Holder B.V."
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal true, hashy.changed?(:company)
+        assert_equal true, hashy.changed?("company")
+        assert_equal ["Tim", "Paul"], hashy.change(:name)
+        assert_equal ["Tim", "Paul"], hashy.change("name")
+        assert_equal ["Holder", "Internetbureau Holder B.V."], hashy.change(:company)
+        assert_equal ["Holder", "Internetbureau Holder B.V."], hashy.change("company")
+        assert_equal({"name" => ["Tim", "Paul"], "company" => ["Holder", "Internetbureau Holder B.V."]}, hashy.changes)
+      end
+
+      it "should behave as expected without method mapping, but with restricted keys" do
+        hashy = DirtyHashy.new({}, false, [:name])
+
+        assert_equal({"name" => nil}, hashy)
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal({}, hashy.changes)
+
+        assert_raises(NoMethodError) do
+          hashy.name = "Paul"
+        end
+
+        hashy["name"] = "Paul"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal [nil, "Paul"], hashy.change(:name)
+        assert_equal [nil, "Paul"], hashy.change("name")
+        assert_equal({"name" => [nil, "Paul"]}, hashy.changes)
+
+        hashy[:name] = nil
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal false, hashy.changed?("name")
+        assert_equal nil, hashy.change(:name)
+        assert_equal nil, hashy.change("name")
+        assert_equal({}, hashy.changes)
+
+        hashy[:name] = "Stephan"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal [nil, "Stephan"], hashy.change(:name)
+        assert_equal [nil, "Stephan"], hashy.change("name")
+        assert_equal({"name" => [nil, "Stephan"]}, hashy.changes)
+
+        hashy.clean_up!
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal false, hashy.changed?("name")
+        assert_equal nil, hashy.change(:name)
+        assert_equal nil, hashy.change("name")
+        assert_equal({}, hashy.changes)
+
+        hashy["name"] = "Chris"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal "Stephan", hashy.was("name")
+        assert_equal ["Stephan", "Chris"], hashy.change(:name)
+        assert_equal ["Stephan", "Chris"], hashy.change("name")
+        assert_equal({"name" => ["Stephan", "Chris"]}, hashy.changes)
+
+        hashy["name"] = "Stephan"
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal false, hashy.changed?("name")
+        assert_equal nil, hashy.change(:name)
+        assert_equal nil, hashy.change("name")
+        assert_equal({}, hashy.changes)
+
+        hashy["name"] = "Paul"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal ["Stephan", "Paul"], hashy.change(:name)
+        assert_equal ["Stephan", "Paul"], hashy.change("name")
+        assert_equal({"name" => ["Stephan", "Paul"]}, hashy.changes)
+
+        hashy["name"] = "Tim"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal ["Stephan", "Tim"], hashy.change(:name)
+        assert_equal ["Stephan", "Tim"], hashy.change("name")
+        assert_equal({"name" => ["Stephan", "Tim"]}, hashy.changes)
+
+        hashy.clean_up!
+        hashy.merge! :name => "Paul"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal ["Tim", "Paul"], hashy.change(:name)
+        assert_equal ["Tim", "Paul"], hashy.change("name")
+        assert_equal({"name" => ["Tim", "Paul"]}, hashy.changes)
+
+        assert_raises(IndexError) do
+          hashy[:company]
+        end
+
+        assert_raises(IndexError) do
+          hashy["company"] = "Holder"
+        end
+
+        assert_raises(IndexError) do
+          hashy.delete :company
+        end
+
+        assert_raises(IndexError) do
+          hashy.changed? :company
+        end
+
+        assert_raises(IndexError) do
+          hashy.change :company
+        end
+
+        assert_raises(IndexError) do
+          hashy.was :company
+        end
+
+        assert_raises(IndexError) do
+          hashy.merge! :name => "Paul", :company => "Internetbureau Holder B.V."
+        end
       end
 
-      it "should behave as expected with method mapping" do
+      it "should behave as expected with method mapping and without restricted keys" do
         hashy = DirtyHashy.new({}, true)
 
+        assert_equal({}, hashy)
         assert_equal false, hashy.dirty?
         assert_equal false, hashy.changed?
         assert_equal({}, hashy.changes)
@@ -225,10 +374,125 @@ module Unit
         hashy.delete :city
         assert_equal({"name" => ["Stephan", "Tim"]}, hashy.changes)
 
+        hashy.merge! :company => "Internetbureau Holder B.V."
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal true, hashy.changed?("name")
+        assert_equal true, hashy.changed?(:company)
+        assert_equal true, hashy.changed?("company")
+        assert_equal ["Stephan", "Tim"], hashy.change(:name)
+        assert_equal ["Stephan", "Tim"], hashy.change("name")
+        assert_equal [nil, "Internetbureau Holder B.V."], hashy.change(:company)
+        assert_equal [nil, "Internetbureau Holder B.V."], hashy.change("company")
+        assert_equal({"name" => ["Stephan", "Tim"], "company" => [nil, "Internetbureau Holder B.V."]}, hashy.changes)
+
+        hashy.clean_up!
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+      end
+
+      it "should behave as expected with method mapping and with restricted keys" do
+        hashy = DirtyHashy.new({}, true, [:name])
+
+        assert_equal({"name" => nil}, hashy)
+        assert_equal nil, hashy.name
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal({}, hashy.changes)
+
+        hashy.name = "Paul"
+
+        assert_equal "Paul", hashy.name
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.name_changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal [nil, "Paul"], hashy.name_change
+        assert_equal [nil, "Paul"], hashy.change(:name)
+        assert_equal({"name" => [nil, "Paul"]}, hashy.changes)
+
+        hashy.name = nil
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal false, hashy.name_changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal nil, hashy.name_change
+        assert_equal nil, hashy.change(:name)
+        assert_equal({}, hashy.changes)
+
+        hashy.name = "Stephan"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.name_changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal [nil, "Stephan"], hashy.name_change
+        assert_equal [nil, "Stephan"], hashy.change(:name)
+        assert_equal({"name" => [nil, "Stephan"]}, hashy.changes)
+
         hashy.clean_up!
 
         assert_equal false, hashy.dirty?
         assert_equal false, hashy.changed?
+        assert_equal false, hashy.name_changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal nil, hashy.name_change
+        assert_equal nil, hashy.change(:name)
+        assert_equal({}, hashy.changes)
+
+        hashy.name = "Chris"
+
+        assert_equal true, hashy.dirty?
+        assert_equal true, hashy.changed?
+        assert_equal true, hashy.name_changed?
+        assert_equal true, hashy.changed?(:name)
+        assert_equal "Stephan", hashy.name_was
+        assert_equal "Stephan", hashy.was(:name)
+        assert_equal ["Stephan", "Chris"], hashy.name_change
+        assert_equal ["Stephan", "Chris"], hashy.change(:name)
+        assert_equal({"name" => ["Stephan", "Chris"]}, hashy.changes)
+
+        hashy.name = "Stephan"
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal false, hashy.name_changed?
+        assert_equal false, hashy.changed?(:name)
+        assert_equal nil, hashy.name_change
+        assert_equal nil, hashy.change(:name)
+        assert_equal({}, hashy.changes)
+
+        assert_raises(NoMethodError) do
+          hashy.company
+        end
+
+        assert_raises(NoMethodError) do
+          hashy.company = "Holder"
+        end
+
+        assert_raises(IndexError) do
+          hashy.delete :company
+        end
+
+        assert_raises(NoMethodError) do
+          hashy.company_changed?
+        end
+
+        assert_raises(NoMethodError) do
+          hashy.company_change
+        end
+
+        assert_raises(NoMethodError) do
+          hashy.company_was
+        end
+
+        assert_raises(IndexError) do
+          hashy.merge! :name => "Paul", :company => "Internetbureau Holder B.V."
+        end
       end
     end
 

metadata

@@ -1,35 +1,39 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: dirty_hashy
-version: !ruby/object:Gem::Version
-  version: 0.1.1
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.1.2
 platform: ruby
-authors:
+authors: 
 - Paul Engel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-24 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-12-24 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &2152647000 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
         version: 3.0.0
   type: :runtime
-  prerelease: false
-  version_requirements: *2152647000
-description: Dirty tracking within hashes with indifferent access or objects as it
-  is expected to be!
-email:
+  version_requirements: *id001
+description: Dirty tracking within hashes with indifferent access or objects as it is expected to be!
+email: 
 - paul.engel@holder.nl
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - CHANGELOG.rdoc
 - Gemfile
@@ -46,32 +50,35 @@ files:
 - test/test_helper.rb
 - test/unit/test_dirty_attributes.rb
 - test/unit/test_dirty_hashy.rb
+has_rdoc: true
 homepage: https://github.com/archan937/dirty_hashy
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Dirty tracking within hashes with indifferent access or objects as it is
-  expected to be!
-test_files:
+summary: Dirty tracking within hashes with indifferent access or objects as it is expected to be!
+test_files: 
 - test/test_helper.rb
 - test/unit/test_dirty_attributes.rb
 - test/unit/test_dirty_hashy.rb