dirty_hashy 0.1.0 → 0.1.1

data/CHANGELOG.rdoc

@@ -1,5 +1,10 @@
 = DirtyHashy CHANGELOG
 
+== Version 0.1.1 (December 24, 2011)
+
+* Added convenience methods (with MethodMap) like +name+, +name=+, +name_changed?+, +name_was+ and +name_change+
+* Added DirtyAttributes with which you can implement dirty tracking within objects (models)
+
 == Version 0.1.0 (December 22, 2011)
 
 * Initial release

data/README.textile

@@ -1,6 +1,6 @@
 h1. DirtyHashy
 
-Dirty tracking within hashes with indifferent access
+Dirty tracking within hashes with indifferent access or objects as it is expected to be!
 
 h2. Introduction
 
@@ -38,6 +38,7 @@ Using @DirtyHashy@ is pretty straightforward and can be used as follows:
   h.dirty? #=> false
   h[:name] = "Paul"
   h.dirty? #=> true
+  h.changed? :name #=> true
   h.was :name #=> nil
   h.change :name #=> [nil, "Paul"]
   h.clean_up!
@@ -63,13 +64,136 @@ Using @DirtyHashy@ is pretty straightforward and can be used as follows:
   h.change :company #=> ["Internetbureau Holder B.V.", nil]
 </pre>
 
+h3. Method mapping DirtyHashy
+
+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:
+
+<pre>
+  require "rubygems"
+  require "dirty_hashy"
+
+  h = DirtyHashy.new({}, true)
+  h.dirty? #=> false
+  h.name #=> NoMethodError: undefined method `name' for {}:DirtyHashy
+  h.name = "Paul"
+  h.dirty? #=> true
+  h.name_changed? #=> true
+  h.name_was #=> nil
+  h.name_change #=> [nil, "Paul"]
+  h.clean_up!
+  h.dirty? #=> false
+  h.name #=> "Paul"
+  h.name = "Paul"
+  h.dirty? #=> false
+  h.name = "Engel"
+  h.name_was #=> "Paul"
+  h.name_change #=> ["Paul", "Engel"]
+  h.foo = "Bar"
+  h.changes #=> {"name"=>["Paul", "Engel"], "foo"=>[nil, "Bar"]}
+</pre>
+
+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:
+
+# 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
+
+The following illustrates the differences between @DirtyAttributes@ and @ActiveModel::Dirty@ when implementing a simple @Person@ model:
+
+h4. When using ActiveModel::Dirty
+
+<pre>
+  class Person
+    include ActiveModel::Dirty
+    define_attribute_methods = [:name]
+
+    def name
+      @name
+    end
+
+    def name=(val)
+      name_will_change! unless val == @name
+      @name = val
+    end
+
+    def save
+      @previously_changed = changes
+      @changed_attributes.clear
+    end
+  end
+</pre>
+
+h4. When using DirtyAttributes
+
+<pre>
+  class Person
+    include DirtyAttributes
+    attrs :name
+
+    def save
+      clean_up!
+    end
+  end
+</pre>
+
+You can use @Person@ objects as you would expect:
+
+<pre>
+  require "rubygems"
+  require "dirty_hashy"
+
+  class Person
+    include DirtyAttributes
+    attrs :name
+  end
+
+  p = Person.new
+  p.dirty? #=> false
+  p.name #=> nil
+  p.name = "Paul"
+  p.dirty? #=> true
+  p.name_changed? #=> true
+  p.name_was #=> nil
+  p.name_change #=> [nil, "Paul"]
+  p.clean_up!
+  p.dirty? #=> false
+  p.name #=> "Paul"
+</pre>
+
+And last but not least: don't care about specifying the attributes available? Well don't! ;)
+
+<pre>
+  require "rubygems"
+  require "dirty_hashy"
+
+  class Person
+    include DirtyAttributes
+  end
+
+  p = Person.new
+  p.dirty? #=> false
+  p.name #=> NoMethodError: undefined method `name' for #<Person:0x00000100d5cd88>
+  p.name = "Paul"
+  p.dirty? #=> true
+  p.name #=> "Paul"
+  p.name_changed? #=> true
+  p.name_was #=> nil
+  p.name_change #=> [nil, "Paul"]
+  p.clean_up!
+  p.dirty? #=> false
+  p.name #=> "Paul"
+  p.foo = "bar"
+  p.foo #=> "bar"
+</pre>
+
 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 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 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.
 
-Note: *DirtyHashy is successfully tested using Ruby 1.8.7 and Ruby 1.9.2*
+Note: *DirtyHashy is successfully tested using Ruby 1.8.7, Ruby 1.9.2 and Ruby 1.9.3*
 
 h2. Contact me
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/dirty_hashy.gemspec

@@ -3,8 +3,8 @@
 Gem::Specification.new do |gem|
   gem.authors       = ["Paul Engel"]
   gem.email         = ["paul.engel@holder.nl"]
-  gem.description   = %q{Dirty tracking within hashes with indifferent access}
-  gem.summary       = %q{Dirty tracking within hashes with indifferent access}
+  gem.description   = %q{Dirty tracking within hashes with indifferent access or objects as it is expected to be!}
+  gem.summary       = %q{Dirty tracking within hashes with indifferent access or objects as it is expected to be!}
   gem.homepage      = "https://github.com/archan937/dirty_hashy"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -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.0"
+  gem.version       = "0.1.1"
 
   gem.add_dependency "activesupport", ">= 3.0.0"
 end

data/lib/dirty_attributes.rb

@@ -0,0 +1,35 @@
+module DirtyAttributes
+
+  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
+      attrs = self.class.attributes.inject({}){|h, a| h.merge({a => nil})}
+      @attributes = DirtyHashy.new(attrs).tap do |hashy|
+        dirty_map! hashy, attrs.keys
+        clean_up!
+      end
+    end
+
+    def attributes=(other)
+      attributes.clear.merge! other
+    end
+  end
+
+end

data/lib/dirty_hashy.rb

@@ -1,8 +1,19 @@
 require "active_support/hash_with_indifferent_access"
 require "dirty_hashy/version"
+require "dirty_attributes"
+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
+    end
+  end
+
   alias :_regular_writer :regular_writer
   def regular_writer(key, value)
     original_value = changes.key?(key) ? was(key) : self[key]

data/lib/dirty_hashy/version.rb

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

data/lib/method_map.rb

@@ -0,0 +1,54 @@
+module MethodMap
+
+  def dirty_map!(mapped = nil, restricted_keys = 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 })
+  end
+
+  def map_method(pattern, method_or_proc = nil)
+    regex = pattern.is_a?(Regexp) ? pattern : Regexp.new("^#{Regexp.escape(pattern.to_s)}$")
+    method_map[regex] = method_or_proc || pattern
+  end
+
+  def method_missing(method, *args)
+    if m = match_method(method)
+      @mapped.send *(m + args)
+    else
+      super
+    end
+  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|
+      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
+      end
+    end
+    nil
+  end
+
+end

data/test/unit/test_dirty_attributes.rb

@@ -0,0 +1,126 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestDirtyAttributes < MiniTest::Unit::TestCase
+
+    describe DirtyAttributes do
+      it "should behave as expected without key restriction" do
+        class Person
+          include DirtyAttributes
+        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)
+      end
+
+      it "should behave as expected with key restriction" do
+        class User
+          include DirtyAttributes
+          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)
+      end
+    end
+
+  end
+end

data/test/unit/test_dirty_hashy.rb

@@ -4,13 +4,17 @@ module Unit
   class TestDirtyHashy < MiniTest::Unit::TestCase
 
     describe DirtyHashy do
-      it "should behave as expected" do
+      it "should behave as expected without method mapping" do
         hashy = DirtyHashy.new
 
         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?
@@ -134,6 +138,98 @@ module Unit
         assert_equal ["Holder", nil], hashy.change(:company)
         assert_equal ["Holder", nil], hashy.change("company")
       end
+
+      it "should behave as expected with method mapping" do
+        hashy = DirtyHashy.new({}, true)
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+        assert_equal({}, hashy.changes)
+
+        assert_raises(NoMethodError) do
+          hashy.name
+        end
+
+        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)
+
+        hashy.name = "Tim"
+        hashy.city = "Amsterdam"
+
+        assert_equal true, hashy.city_changed?
+        assert_equal true, hashy.changed?(:city)
+        assert_equal nil, hashy.city_was
+        assert_equal [nil, "Amsterdam"], hashy.city_change
+        assert_equal({"name" => ["Stephan", "Tim"], "city" => [nil, "Amsterdam"]}, hashy.changes)
+
+        hashy.delete :city
+        assert_equal({"name" => ["Stephan", "Tim"]}, hashy.changes)
+
+        hashy.clean_up!
+
+        assert_equal false, hashy.dirty?
+        assert_equal false, hashy.changed?
+      end
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dirty_hashy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-22 00:00:00.000000000 Z
+date: 2011-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2156836380 !ruby/object:Gem::Requirement
+  requirement: &2152647000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +21,9 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2156836380
-description: Dirty tracking within hashes with indifferent access
+  version_requirements: *2152647000
+description: Dirty tracking within hashes with indifferent access or objects as it
+  is expected to be!
 email:
 - paul.engel@holder.nl
 executables: []
@@ -37,10 +38,13 @@ files:
 - Rakefile
 - VERSION
 - dirty_hashy.gemspec
+- lib/dirty_attributes.rb
 - lib/dirty_hashy.rb
 - lib/dirty_hashy/version.rb
+- lib/method_map.rb
 - script/console
 - test/test_helper.rb
+- test/unit/test_dirty_attributes.rb
 - test/unit/test_dirty_hashy.rb
 homepage: https://github.com/archan937/dirty_hashy
 licenses: []
@@ -65,7 +69,9 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Dirty tracking within hashes with indifferent access
+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