dirty_hashy 0.1.3 → 0.2.0

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 = DirtyHashy CHANGELOG
 
+== Version 0.2.0 (January 4, 2011)
+
+* Extracted DirtyHashy implementation to Dirty::Hash
+* Renamed DirtyAttributes to Dirty::Attributes
+* Inheriting DirtyHashy from Hash instead of HashWithIndifferentAccess on request of @technoweenie
+* Introducing DirtyIndifferentHashy which is the previously known DirtyHashy
+
 == Version 0.1.3 (December 24, 2011)
 
 * Fixed incorrect regular expressions within dirty_map!

data/README.textile

@@ -26,15 +26,23 @@ Run the following in your console to install with Bundler:
   bundle install
 </pre>
 
+h2. DirtyHashy versus DirtyIndifferentHashy
+
+"On request":https://github.com/archan937/dirty_hashy/issues/1 of "@technoweenie":https://twitter.com/technoweenie, I have released DirtyHashy v0.2.0. Previous to this release, the @DirtyHashy@ class inherited from ActiveSupport's @HashWithIndifferentAccess@ *but that has changed*.
+
+As of the @0.2.0@ release, the @DirtyHashy@ class is inherited from the @Hash@ class. So I have introduced @DirtyIndifferentHashy@ which resembles the @DirtyHashy@ class of the @0.1.x@ releases. You can check out the different types of behaviour by looking at the "DirtyHashy test":https://github.com/archan937/dirty_hashy/blob/279da72873a91216dbecadb3a6d53ebae2fd8198/test/unit/test_dirty_hashy.rb and "DirtyIndifferentHashy test":https://github.com/archan937/dirty_hashy/blob/279da72873a91216dbecadb3a6d53ebae2fd8198/test/unit/test_dirty_indifferent_hashy.rb.
+
+*Note*: This README will continue focusing on the usage of the @DirtyIndifferentHashy@ class and @Dirty::Attributes@ module.
+
 h2. Usage
 
-Using @DirtyHashy@ is pretty straightforward and can be used as follows:
+Using @DirtyIndifferentHashy@ is pretty straightforward and can be used as follows:
 
 <pre>
   require "rubygems"
   require "dirty_hashy"
 
-  h = DirtyHashy.new
+  h = DirtyIndifferentHashy.new
   h.dirty? #=> false
   h[:name] = "Paul"
   h.dirty? #=> true
@@ -64,17 +72,17 @@ Using @DirtyHashy@ is pretty straightforward and can be used as follows:
   h.change :company #=> ["Internetbureau Holder B.V.", nil]
 </pre>
 
-h3. Method mapping DirtyHashy
+h3. Method mapping DirtyIndifferentHashy
 
-You can map methods within a DirtyHashy in order to provide convenience methods like @name@, @name=@, @name_changed?@, @name_was@ and @name_change@. Just pass @true@ for the @map_methods@ argument when initializing a DirtyHashy:
+You can map methods within a DirtyIndifferentHashy in order to provide convenience methods like @name@, @name=@, @name_changed?@, @name_was@ and @name_change@. Just pass @true@ for the @map_methods@ argument when initializing a DirtyIndifferentHashy:
 
 <pre>
   require "rubygems"
   require "dirty_hashy"
 
-  h = DirtyHashy.new({}, true)
+  h = DirtyIndifferentHashy.new({}, true)
   h.dirty? #=> false
-  h.name #=> NoMethodError: undefined method `name' for {}:DirtyHashy
+  h.name #=> NoMethodError: undefined method `name' for {}:DirtyIndifferentHashy
   h.name = "Paul"
   h.dirty? #=> true
   h.name_changed? #=> true
@@ -92,15 +100,15 @@ You can map methods within a DirtyHashy in order to provide convenience methods
   h.changes #=> {"name"=>["Paul", "Engel"], "foo"=>[nil, "bar"]}
 </pre>
 
-h3. Method mapping DirtyHashy with key restriction
+h3. Method mapping DirtyIndifferentHashy 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:
+Along with providing convenience methods, you can also restrict the range of keys you are permitted to read / write / merge / replace of a DirtyIndifferentHashy:
 
 <pre>
   require "rubygems"
   require "dirty_hashy"
 
-  h = DirtyHashy.new({}, true, [:name])
+  h = DirtyIndifferentHashy.new({}, true, [:name])
   h.dirty? #=> false
   h.name #=> nil
   h.name = "Paul"
@@ -112,8 +120,8 @@ Along with providing convenience methods, you can also restrict the range of key
   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.foo #=> NoMethodError: undefined method `foo' for {"name"=>"Engel"}:DirtyIndifferentHashy
+  h.foo = "bar" #=> NoMethodError: undefined method `foo=' for {"name"=>"Engel"}:DirtyIndifferentHashy
   h.clean_up!
   h.replace :name => "Paul"
   h.changes #=> {"name"=>["Engel", "Paul"]}
@@ -121,12 +129,12 @@ Along with providing convenience methods, you can also restrict the range of key
 
 h3. Dirty tracking objects (models)
 
-Like "ActiveModel::Dirty":http://api.rubyonrails.org/classes/ActiveModel/Dirty.html, you can use "DirtyAttributes":https://github.com/archan937/dirty_hashy/blob/master/lib/dirty_attributes.rb to dirty track your own objects (models). But there are two differences:
+Like "ActiveModel::Dirty":http://api.rubyonrails.org/classes/ActiveModel/Dirty.html, you can use "Dirty::Attributes":https://github.com/archan937/dirty_hashy/blob/master/lib/dirty_attributes.rb to dirty track your own objects (models). But there are two differences:
 
-# Setting up @DirtyAttributes@ is easier to setup than @ActiveModel::Dirty@
-# The implementation of "DirtyAttributes":https://github.com/archan937/dirty_hashy/tree/master/lib is more minimalistic and thus looks a bit cleaner than "ActiveModel::Dirty":https://github.com/rails/rails/blob/master/activemodel/lib/active_model/dirty.rb with "ActiveModel::AttributeMethods":https://github.com/rails/rails/blob/master/activemodel/lib/active_model/attribute_methods.rb
+# Setting up @Dirty::Attributes@ is easier to setup than @ActiveModel::Dirty@
+# The implementation of "Dirty::Attributes":https://github.com/archan937/dirty_hashy/tree/master/lib is more minimalistic and thus looks a bit cleaner than "ActiveModel::Dirty":https://github.com/rails/rails/blob/master/activemodel/lib/active_model/dirty.rb with "ActiveModel::AttributeMethods":https://github.com/rails/rails/blob/master/activemodel/lib/active_model/attribute_methods.rb
 
-The following illustrates the differences between @DirtyAttributes@ and @ActiveModel::Dirty@ when implementing a simple @Person@ model:
+The following illustrates the differences between @Dirty::Attributes@ and @ActiveModel::Dirty@ when implementing a simple @Person@ model:
 
 h4. When using ActiveModel::Dirty
 
@@ -151,11 +159,11 @@ h4. When using ActiveModel::Dirty
   end
 </pre>
 
-h4. When using DirtyAttributes
+h4. When using Dirty::Attributes
 
 <pre>
   class Person
-    include DirtyAttributes
+    include Dirty::Attributes
     attrs :name
 
     def save
@@ -171,7 +179,7 @@ You can use @Person@ objects as you would expect:
   require "dirty_hashy"
 
   class Person
-    include DirtyAttributes
+    include Dirty::Attributes
     attrs :name
   end
 
@@ -196,7 +204,7 @@ And last but not least: don't care about specifying the attributes available? We
   require "dirty_hashy"
 
   class Person
-    include DirtyAttributes
+    include Dirty::Attributes
   end
 
   p = Person.new
@@ -217,7 +225,8 @@ And last but not least: don't care about specifying the attributes available? We
 
 h2. Last remarks
 
-Please check out "test/unit/test_dirty_hashy.rb":https://github.com/archan937/dirty_hashy/blob/master/test/unit/test_dirty_hashy.rb and "test/unit/test_dirty_attributes.rb":https://github.com/archan937/dirty_hashy/blob/master/test/unit/test_dirty_attributes.rb the tests available. You can run the unit tests with @rake@ within the terminal.
+Please check out "test/unit/test_dirty_hashy.rb":https://github.com/archan937/dirty_hashy/blob/master/test/unit/test_dirty_hashy.rb, "test/unit/test_dirty_indifferent_hashy.rb":https://github.com/archan937/dirty_hashy/blob/master/test/unit/test_dirty_indifferent_hashy.rb and "test/unit/test_dirty_attributes.rb":https://github.com/archan937/dirty_hashy/blob/master/test/unit/test_dirty_attributes.rb the tests available.
+You can run the unit tests with @rake@ within the terminal.
 
 Also, the DirtyHashy repo is provided with @script/console@ which you can use for testing purposes.
 

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

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.3"
+  gem.version       = "0.2.0"
 
   gem.add_dependency "activesupport", ">= 3.0.0"
 end

data/lib/dirty.rb

@@ -0,0 +1,2 @@
+require "dirty/hash"
+require "dirty/attributes"

data/lib/dirty/attributes.rb

@@ -0,0 +1,39 @@
+module Dirty
+  module Attributes
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+      base.send :include, MethodMap
+    end
+
+    module ClassMethods
+      def attrs(*names)
+        @attrs = names.collect(&:to_s)
+      end
+
+      def attributes
+        @attrs
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :attributes
+
+      def initialize
+        @attributes = DirtyIndifferentHashy.new({}, true, self.class.attributes).tap do |hashy|
+          dirty_map! hashy
+          clean_up!
+        end
+      end
+
+      def attributes=(other)
+        attributes.replace other
+      rescue IndexError => e
+        e.message.match /"(.*)"/
+        raise NoMethodError, "undefined method `#{$1}=' for #{self.inspect}"
+      end
+    end
+
+  end
+end

data/lib/dirty/hash.rb

@@ -0,0 +1,108 @@
+module Dirty
+  module Hash
+
+    def self.included(base)
+      base.method_defined?(:regular_writer).tap do |defined|
+        base.send :include, InstanceMethods
+        unless defined
+          base.send :alias_method, :_store, :store
+          base.send :alias_method, :store, :regular_writer
+          base.send :alias_method, :[]=, :store
+          base.send :define_method, :update do |other|
+            other.each{|key, value| store key, value}
+          end
+          base.send :alias_method, :merge!, :update
+        end
+      end
+    end
+
+    module InstanceMethods
+      def initialize(constructor = {}, map_methods = false, restricted_keys = nil)
+        constructor.each do |key, value|
+          self[key] = value
+        end
+        if map_methods
+          extend MethodMap
+          dirty_map!
+        end
+        if restricted_keys
+          restricted_keys.each{|key| self[correct_key(key, map_methods)] ||= 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
+
+      def regular_writer(key, value)
+        validate_write!(key)
+        original_value = changes.key?(key) ? was(key) : fetch(key, nil)
+        if original_value == value
+          changes.delete key
+        else
+          changes[key] = [original_value, value]
+        end
+        defined?(_store) ? _store(key, value) : super(key, value)
+      end
+
+      def delete(key)
+        self[key] = nil
+        super
+      end
+
+      def changes
+        @changes ||= self.class.superclass.new
+      end
+
+      def changed?(key = nil, mapped = false)
+        validate_read!(correct_key(key, mapped)) if !key.nil? && (mapped || restricted_keys?)
+        key.nil? ? !changes.empty? : changes.key?(key)
+      end
+      alias :dirty? :changed?
+
+      def change(key, mapped = false)
+        changes[key] if changed?(key, mapped)
+      end
+
+      def was(key, mapped = false)
+        change(key).first if changed?(key, mapped)
+      end
+
+      def clean_up!
+        changes.clear
+        nil
+      end
+
+    private
+
+      def correct_key(key, mapped = false)
+        mapped || is_a?(HashWithIndifferentAccess) ? key.to_s : key
+      end
+
+      def restricted_keys?
+        !(@restricted_keys || []).empty?
+      end
+
+      def validate_read!(key)
+        raise IndexError, "Invalid key: \"#{key}\"" unless (keys + changes.keys).include?(key)
+      end
+
+      def validate_write!(key)
+        raise IndexError, "Invalid key: \"#{key}\"" unless @restricted_keys.nil? || @restricted_keys.empty? || @restricted_keys.include?(key)
+      end
+
+    end
+
+  end
+end

data/lib/dirty_hashy.rb

@@ -1,88 +1,8 @@
-require "active_support/hash_with_indifferent_access"
+require "dirty"
+require "dirty_indifferent_hashy"
 require "dirty_hashy/version"
-require "dirty_attributes"
 require "method_map"
 
-class DirtyHashy < HashWithIndifferentAccess
-
-  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)
-    validate_write!(key)
-    original_value = changes.key?(key) ? was(key) : fetch(key, nil)
-    if original_value == value
-      changes.delete key
-    else
-      changes[key] = [original_value, value]
-    end
-    _regular_writer key, value
-  end
-
-  def delete(key)
-    self[key] = nil
-    super
-  end
-
-  def changes
-    @changes ||= HashWithIndifferentAccess.new
-  end
-
-  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, mapped = false)
-    changes[key] if changed?(key, mapped)
-  end
-
-  def was(key, mapped = false)
-    change(key).first if changed?(key, mapped)
-  end
-
-  def clean_up!
-    changes.clear
-    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
-
+class DirtyHashy < Hash
+  include Dirty::Hash
 end

data/lib/dirty_hashy/version.rb

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

data/lib/dirty_indifferent_hashy.rb

@@ -0,0 +1,5 @@
+require "active_support/hash_with_indifferent_access"
+
+class DirtyIndifferentHashy < HashWithIndifferentAccess
+  include Dirty::Hash
+end

data/test/unit/dirty/test_attributes.rb

@@ -0,0 +1,176 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+module Unit
+  module Dirty
+    class TestAttributes < MiniTest::Unit::TestCase
+
+      describe ::Dirty::Attributes do
+        it "should behave as expected without key restriction" do
+          class Person
+            include ::Dirty::Attributes
+          end
+
+          person = Person.new
+
+          assert_equal({}, person.attributes)
+          assert_equal false, person.dirty?
+          assert_equal false, person.changed?
+          assert_equal({}, person.changes)
+
+          assert_raises(NoMethodError) do
+            person.name
+          end
+
+          person.name = "Paul"
+
+          assert_equal "Paul", person.name
+          assert_equal true, person.dirty?
+          assert_equal true, person.changed?
+          assert_equal true, person.name_changed?
+          assert_equal [nil, "Paul"], person.name_change
+          assert_equal({"name" => [nil, "Paul"]}, person.changes)
+
+          person.name = nil
+
+          assert_equal false, person.dirty?
+          assert_equal false, person.changed?
+          assert_equal false, person.name_changed?
+          assert_equal nil, person.name_change
+          assert_equal({}, person.changes)
+
+          person.name = "Stephan"
+
+          assert_equal true, person.dirty?
+          assert_equal true, person.changed?
+          assert_equal true, person.name_changed?
+          assert_equal [nil, "Stephan"], person.name_change
+          assert_equal({"name" => [nil, "Stephan"]}, person.changes)
+
+          person.clean_up!
+
+          assert_equal false, person.dirty?
+          assert_equal false, person.changed?
+          assert_equal false, person.name_changed?
+          assert_equal nil, person.name_change
+          assert_equal({}, person.changes)
+
+          person.foo = "Bar"
+
+          assert_equal "Bar", person.foo
+          assert_equal true, person.dirty?
+          assert_equal true, person.changed?
+          assert_equal false, person.name_changed?
+          assert_equal true, person.foo_changed?
+          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
+          class User
+            include ::Dirty::Attributes
+            attrs :name
+          end
+
+          user = User.new
+
+          assert_equal({"name" => nil}, user.attributes)
+          assert_equal nil, user.name
+          assert_equal false, user.dirty?
+          assert_equal false, user.changed?
+          assert_equal({}, user.changes)
+
+          assert_raises(NoMethodError) do
+            user.foo
+          end
+
+          assert_raises(NoMethodError) do
+            user.foo = "Bar"
+          end
+
+          user.name = "Paul"
+
+          assert_equal "Paul", user.name
+          assert_equal true, user.dirty?
+          assert_equal true, user.changed?
+          assert_equal true, user.name_changed?
+          assert_equal [nil, "Paul"], user.name_change
+          assert_equal({"name" => [nil, "Paul"]}, user.changes)
+
+          user.name = nil
+
+          assert_equal false, user.dirty?
+          assert_equal false, user.changed?
+          assert_equal false, user.name_changed?
+          assert_equal nil, user.name_change
+          assert_equal({}, user.changes)
+
+          user.name = "Stephan"
+
+          assert_equal true, user.dirty?
+          assert_equal true, user.changed?
+          assert_equal true, user.name_changed?
+          assert_equal [nil, "Stephan"], user.name_change
+          assert_equal({"name" => [nil, "Stephan"]}, user.changes)
+
+          user.clean_up!
+
+          assert_equal false, user.dirty?
+          assert_equal false, user.changed?
+          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
+
+    end
+  end
+end