attribute-kit 0.1.1

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem 'yard'
+  gem 'rdiscount'
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.9)
+    rdiscount (1.6.8)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    yard (0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  rdiscount
+  rspec (~> 2.3.0)
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jonathan Mischo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,36 @@
+# attribute-kit
+
+Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own
+
+## Contributing to attribute-kit
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright and License
+
+Copyright (c) 2011 Jonathan Mischo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "attribute-kit"
+  gem.homepage = "http://github.com/supertaz/attribute-kit"
+  gem.license = "MIT"
+  gem.summary = %Q{Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own}
+  gem.description = %Q{Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own}
+  gem.email = "jon.mischo@gmail.com"
+  gem.authors = ["Jonathan Mischo"]
+  gem.version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  gem.files = FileList['lib/**/*.rb', '[A-Z]*', 'spec/**/*'].to_a
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/attribute-kit.rb

@@ -0,0 +1 @@
+require 'attribute-kit/attribute-kit.rb'

data/lib/attribute-kit/attribute-kit.rb

@@ -0,0 +1 @@
+require 'attribute-kit/attribute_hash'

data/lib/attribute-kit/attribute_hash.rb

@@ -0,0 +1,247 @@
+# A group of classes and other tools that are designed to make handling of attributes and dealing with changes to
+# groups of attributes easy and convenient.  This is particularly useful if you intend to build, extend, or even
+# simply wish to avoid using someone else's ORM or DRM.
+#
+# The original intent of this library was to make it easier to store and track changes to attributes on a model that
+# was not managed by an ORM, yet needed to be selectively synchronized between a client, server, and data store.  From
+# those humble beginnings, this optimized library was created.
+#
+# @author Jonathan Mischo
+# @note Copyright (c) 2011 Jonathan Mischo
+# @note Distributed under the MIT license (see LICENSE.txt, distributed with the original source code)
+
+module AttributeKit
+
+  # AttributeHash inherits from and extends Hash, to provide tracking of attribute status (changed/deleted keys).
+  class AttributeHash < Hash
+
+    # @visibility private
+    def self.cond_deletion_method(method_name)
+      define_method(method_name) { |&block|
+        unless block.nil?
+          keys = self.keys
+          r = super(&block)
+          @deleted_keys += keys - self.keys
+          r
+        else
+          super()
+        end
+      }
+    end
+
+    private_class_method :cond_deletion_method
+
+    # Creates a new instance, using identical syntax to Hash
+    # @see Hash#new
+    def initialize(*args)
+      super(*args)
+      @dirty_keys = []
+      @deleted_keys = []
+    end
+
+    # Assigns a value to a key
+    # @param [Object] k key of key-value pair to insert or change in instance
+    # @param [Object] v value of key-value pair to insert or change in instance
+    # @return [Object] value of key-value pair inserted
+    # @see Hash#[]=
+    def []=(k,v)
+      if self[k].eql? v
+        v
+      else
+        @dirty_keys << k
+        super
+      end
+    end
+
+    alias_method :store, :[]=
+
+    # Delete a key-value pair
+    # @param [Object] key key of key-value pair to delete from instance
+    # @return [Object] value of key-value pair deleted
+    # @see Hash#delete
+    def delete(k)
+      @deleted_keys << k
+      @dirty_keys.delete(k)
+      super
+    end
+
+    # @method reject!
+    # Delete keys matching an expression in the provided block
+    # @return [AttributeHash] if changes are made
+    # @return [Nil] if no changes are made
+    # @yield [key, value] block is executed for every key-value pair stored in the instance
+    # @yieldparam [Object] key the key from the key-value pair being evaluated
+    # @yieldparam [Object] value the value from the key-value pair being evaluated
+    # @yieldreturn [Boolean] whether or not to delete a particular stored key-value pair from the instance
+    # @see Hash#reject!
+    cond_deletion_method(:reject!)
+
+    # @method select!
+    # Delete keys not matching an expression in the provided block
+    # @return [AttributeHash] if changes are made
+    # @return [Nil] if no changes are made
+    # @yield [key, value] block is executed for every key-value pair stored in the instance
+    # @yieldparam [Object] key the key from the key-value pair being evaluated
+    # @yieldparam [Object] value the value from the key-value pair being evaluated
+    # @yieldreturn [Boolean] whether or not to keep a particular stored key-value pair in the instance
+    # @see Hash#select!
+    cond_deletion_method(:select!)
+
+    # @method keep_if
+    # Delete keys not matching an expression in the provided block
+    # @return [AttributeHash] self with changes applied
+    # @yield [key, value] block is executed for every key-value pair stored in the instance
+    # @yieldparam [Object] key the key from the key-value pair being evaluated
+    # @yieldparam [Object] value the value from the key-value pair being evaluated
+    # @yieldreturn [Boolean] whether or not to keep a particular stored key-value pair in the instance
+    # @see Hash#keep_if
+    cond_deletion_method(:keep_if)
+
+    # @method delete_if
+    # Delete keys matching an expression in the provided block
+    # @return [AttributeHash] self with changes applied
+    # @yield [key, value] block is executed for every key-value pair stored in the instance
+    # @yieldparam [Object] key the key from the key-value pair being evaluated
+    # @yieldparam [Object] value the value from the key-value pair being evaluated
+    # @yieldreturn [Boolean] whether or not to delete a particular stored key-value pair from the instance
+    # @see Hash#delete_if
+    cond_deletion_method(:delete_if)
+
+    # Replace the contents of this object with the contents of the supplied hash
+    # @param [Hash] other_hash hash of values to replace instance contents with
+    # @return [AttributeHash] self with changes applied
+    # @see Hash#replace
+    def replace(other_hash)
+      old_keys = self.keys
+      r = super
+      new_keys = self.keys
+      @dirty_keys = new_keys
+      @deleted_keys += (old_keys - new_keys)
+      r
+    end
+
+    # Combine the contents of this object with the contents of the supplied hash, calling an optional supplied block to
+    # determine what value is used when there are duplicate keys.  Without the block, values from the supplied hash will
+    # be used in the case of duplicate keys
+    # @param [Hash] other_hash hash of values to merge in to the instance
+    # @yield [key, oldval, newval] block is executed for every duplicate key between the instance and other_hash
+    # @yieldparam [Object] key the key being evaluated
+    # @yieldparam [Object] oldval the value from the value from the instance
+    # @yieldparam [Object] newval the value from the value from other_hash
+    # @yieldreturn [Object] the value to store for the key in question
+    # @return [AttributeHash] self with changes applied
+    # @see Hash#merge!
+    def merge!(other_hash, &block)
+      old_keys = self.keys
+      overlapping_keys = old_keys.dup.keep_if {|v| other_hash.keys.include?(v)}
+      r = super
+      if block.nil?
+        @dirty_keys += (self.keys - old_keys) + overlapping_keys
+      else
+        new_values = other_hash.keep_if {|k,v| overlapping_keys.include?(k)}
+        @dirty_keys += (self.keys - old_keys) + (new_values.keep_if {|k,v| !self[k].eql?(v) }).keys
+      end
+      r
+    end
+
+    alias_method :update, :merge!
+
+    # Returns a key-value pair from the instance and deletes it.
+    # @return [Array] key-value pair
+    # @see Hash#shift
+    def shift
+      (k,v) = super
+      @deleted_keys << k
+      [k,v]
+    end
+
+    # Clear all contents of the object.
+    # @see Hash#clear
+    def clear
+      @deleted_keys += self.keys
+      @dirty_keys.clear
+      super
+    end
+
+    # Check whether the contents of the object have changed since the last time clean_attributes was run.
+    # @return [Boolean] value indicating whether or not key-value pairs have been added, changed, or deleted
+    def dirty?
+      !(@dirty_keys.empty? && @deleted_keys.empty?)
+    end
+
+    # Returns the set of keys that have been modified since the AttributeHash was last marked clean.
+    # @return [Array] all of the changed keys
+    def dirty_keys
+      @dirty_keys.uniq!
+      @dirty_keys + self.deleted_keys
+    end
+
+    # Returns the set of keys that have been deleted since the AttributeHash was last marked clean.
+    # @return [Array] all of the deleted keys
+    def deleted_keys
+      @deleted_keys.uniq!
+      @deleted_keys
+    end
+
+    # Calls a block with a hash of all keys, actions (:changed or :deleted), and current values (if :changed) of keys
+    # that have changed since the object was last marked clean.  Marks the object as clean when it compiles
+    # the list of keys that have been modified.
+    # @param [Block] block to execute with hash of modified keys, actions, and values
+    def clean_attributes(&block)
+      if !@dirty_keys.empty?
+        dirty_attrs = {}
+        @dirty_keys.uniq!
+        dirty = @dirty_keys.dup
+        @dirty_keys.clear
+        deleted = @deleted_keys.dup
+        @deleted_keys.clear
+
+        while dirty.length > 0 do
+          key = dirty.shift
+          dirty_attrs[key] = [:changed, self[key]]
+        end
+
+        while deleted.length > 0 do
+          key = deleted.shift
+          dirty_attrs[key] = [:deleted, nil]
+        end
+
+        block.call(dirty_attrs)
+      end
+    end
+
+    # @overload KEY_dirty?()
+    #   Check whether a particular key is dirty - KEY is a string representation of the key name for the key-value pair being queried
+    #   @note There can be conflicts if you have multiple keys that are similar, i.e. :blue and 'blue', so only use this
+    #     when you can guarantee homogenous keys and are using either strings or symbols for the key (the only cases where
+    #     it will work)
+    #   @return [Boolean] value indicating key-value pair state
+    #   @note Uses method_missing to implement the check
+    # @overload KEY_deleted?()
+    #   Check whether a particular key has been deleted - KEY is a string representation of the key name for the key-value pair being queried
+    #   @note There can be conflicts if you have multiple keys that are similar, i.e. :blue and 'blue', so only use this
+    #     when you can guarantee homogenous keys and are using either strings or symbols for the key (the only cases where
+    #     it will work)
+    #   @return [Boolean] value indicating key-value pair state
+    #   @note Uses method_missing to implement the check
+
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+      case method_name
+        when /(.*)_dirty?/
+          return @dirty_keys.include?($1) if self.has_key?($1)
+          return @dirty_keys.include?($1.to_sym) if self.has_key?($1.to_sym)
+          @deleted_keys.include?($1) || @deleted_keys.include?($1.to_sym)
+        when /(.*)_deleted?/
+          @deleted_keys.include?($1) || @deleted_keys.include?($1.to_sym)
+        else
+          if self.class.superclass.instance_methods.include?('method_missing')
+            super(method, *args, &block)
+          else
+            raise NoMethodError.new("undefined method '#{method_name}' for #{self}")
+          end
+      end
+    end
+
+  end
+end

data/spec/attribute-kit_spec.rb

@@ -0,0 +1,646 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "AttributeKit" do
+  it "loads" do
+    defined?(AttributeKit).should == 'constant'
+  end
+
+  describe "::AttributeHash" do
+    describe '#new' do
+      it "should return an empty AttributeHash when initialized without arguments" do
+        test_hash = AttributeKit::AttributeHash.new
+        test_hash.empty?.should be_true
+      end
+
+      it 'should return a 0 length AttributeHash when initialized' do
+        test_hash = AttributeKit::AttributeHash.new
+        test_hash.length.should == 0
+      end
+
+      it "should return a default value for invalid keys when initialized with a default value" do
+        test_hash = AttributeKit::AttributeHash.new('blue')
+        test_hash.empty?.should be_true
+        test_hash[:blue].should == 'blue'
+        test_hash[:red].should == 'blue'
+      end
+
+      it "should execute and return the result of a block for invalid keys when initialized with a block" do
+        test_hash = AttributeKit::AttributeHash.new { |hash, key| [hash, key] }
+        test_hash.empty?.should be_true
+        test_hash[:blue].eql?([test_hash, :blue]).should be_true
+        test_hash[:red].eql?([test_hash, :red]).should be_true
+      end
+    end
+
+    describe '#[]=' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+      end
+
+      it "should store a value" do
+        @test_hash.empty?.should be_false
+        @test_hash[:blue].should == 'blue'
+      end
+
+      it "should mark the attribute as dirty" do
+        @test_hash.blue_dirty?.should be_true
+      end
+
+      it "should not mark the attribute as deleted" do
+        @test_hash.blue_deleted?.should be_false
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return the value set" do
+        ret = @test_hash[:red] = 'red'
+        ret.should == 'red'
+      end
+    end
+
+    describe '#store' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash.store(:blue, 'blue')
+      end
+
+      it "should store a value" do
+        @test_hash.empty?.should be_false
+        @test_hash[:blue].should == 'blue'
+      end
+
+      it "should be dirty" do
+        @test_hash.blue_dirty?.should be_true
+      end
+
+      it "should not be deleted" do
+        @test_hash.blue_deleted?.should be_false
+      end
+
+      it "should return the value set" do
+        ret = @test_hash.store(:red, 'red')
+        ret.should == 'red'
+      end
+    end
+
+    describe '#[]' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new('red')
+        @test_hash[:blue] = 'blue'
+        @test_hash.clean_attributes {}
+      end
+
+      it "should get a correct value (sanity check)" do
+        @test_hash.empty?.should be_false
+        @test_hash[:blue].should == 'blue'
+      end
+
+      it "should be clean" do
+        @test_hash.dirty?.should be_false
+      end
+    end
+
+    describe '#delete' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash.clean_attributes {}
+        @test_hash.delete(:blue)
+      end
+
+      it "should delete a value" do
+        @test_hash[:blue].should be_nil
+        @test_hash.empty?.should be_true
+      end
+
+      it "should mark the attribute as deleted" do
+        @test_hash.blue_deleted?.should be_true
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should include the attribute in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_true
+      end
+
+      it "should include the attribute in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+      end
+    end
+
+    describe '#delete_if' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @test_hash.delete_if {|k,v| v == 'blue'}
+      end
+
+      it "should delete only the matching items" do
+        @test_hash[:blue].should be_nil
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should mark deleted attributes as deleted" do
+        @test_hash.blue_deleted?.should be_true
+      end
+
+      it "should not mark untouched attributes as deleted" do
+        @test_hash.red_deleted?.should be_false
+      end
+
+      it "should include deleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_true
+      end
+
+      it "should include deleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+      end
+
+      it "should not include undeleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should not include undeleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+    end
+
+    describe '#keep_if' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @test_hash.keep_if {|k,v| v == 'red'}
+      end
+
+      it "should delete only the matching items" do
+        @test_hash[:blue].should be_nil
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should mark deleted attributes as deleted" do
+        @test_hash.blue_deleted?.should be_true
+      end
+
+      it "should not mark untouched attributes as deleted" do
+        @test_hash.red_deleted?.should be_false
+      end
+
+      it "should include deleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_true
+      end
+
+      it "should include deleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+      end
+
+      it "should not include undeleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should not include undeleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+    end
+
+    describe '#reject!' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @test_hash.reject! {|k,v| v == 'blue'}
+      end
+
+      it "should delete only the matching items" do
+        @test_hash[:blue].should be_nil
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should mark deleted attributes as deleted" do
+        @test_hash.blue_deleted?.should be_true
+      end
+
+      it "should not mark untouched attributes as deleted" do
+        @test_hash.red_deleted?.should be_false
+      end
+
+      it "should include deleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_true
+      end
+
+      it "should include deleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+      end
+
+      it "should not include undeleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should not include undeleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return nil if no changes are made" do
+        test_hash = AttributeKit::AttributeHash.new
+        test_hash[:blue] = 'blue'
+        test_hash.clean_attributes {}
+        ret = test_hash.reject! {|k,v| v == 'red'}
+        ret.should be_nil
+      end
+    end
+
+    describe '#select!' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @test_hash.select! {|k,v| v == 'red'}
+      end
+
+      it "should delete only the matching items" do
+        @test_hash[:blue].should be_nil
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should mark deleted attributes as deleted" do
+        @test_hash.blue_deleted?.should be_true
+      end
+
+      it "should not mark untouched attributes as deleted" do
+        @test_hash.red_deleted?.should be_false
+      end
+
+      it "should include deleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_true
+      end
+
+      it "should include deleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+      end
+
+      it "should not include undeleted attributes in dirty_keys" do
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should not include undeleted attributes in deleted_keys" do
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return nil if no changes are made" do
+        test_hash = AttributeKit::AttributeHash.new
+        test_hash[:blue] = 'blue'
+        test_hash.clean_attributes {}
+        ret = test_hash.select! {|k,v| v == 'blue'}
+        ret.should be_nil
+      end
+    end
+
+    describe "#replace" do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @ret_val = @test_hash.replace({:yellow => 'yellow', :green => 'green'})
+      end
+
+      it "should remove old contents" do
+        @test_hash[:blue].should be_nil
+        @test_hash[:red].should be_nil
+      end
+
+      it "should replace contents with supplied hash's contents" do
+        @test_hash[:yellow].should == 'yellow'
+        @test_hash[:green].should == 'green'
+      end
+
+      it "should mark old attributes as deleted" do
+        @test_hash.blue_deleted?.should be_true
+        @test_hash.red_deleted?.should be_true
+      end
+
+      it "should mark new attributes as dirty" do
+        @test_hash.yellow_dirty?.should be_true
+        @test_hash.green_dirty?.should be_true
+      end
+
+      it "should include old keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_true
+        @test_hash.deleted_keys.include?(:red).should be_true
+      end
+
+      it "should not include new keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:yellow).should be_false
+        @test_hash.deleted_keys.include?(:green).should be_false
+      end
+
+      it "should mark instance as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return an AttributeHash containing the new contents" do
+        @ret_val.class.should == AttributeKit::AttributeHash
+        @ret_val.eql?({:yellow => 'yellow', :green => 'green'}).should be_true
+      end
+    end
+
+    describe "#merge!" do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash[:green] = 'grn'
+        @test_hash.clean_attributes {}
+        @ret_val = @test_hash.merge!({:yellow => 'yellow', :green => 'green'})
+      end
+
+      it "should retain unupdated contents" do
+        @test_hash.blue_deleted?.should be_false
+        @test_hash.red_deleted?.should be_false
+        @test_hash[:blue].should == 'blue'
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should add supplied hash's contents to object's contents" do
+        @test_hash[:yellow].should == 'yellow'
+        @test_hash[:green].should == 'green'
+      end
+
+      it "should mark new attributes as dirty" do
+        @test_hash.yellow_dirty?.should be_true
+      end
+
+      it "should mark changed attributes as dirty" do
+        @test_hash.green_dirty?.should be_true
+      end
+
+      it "should not include unupdated keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_false
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should include new keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:yellow).should be_true
+      end
+
+      it "should include changed keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:green).should be_true
+      end
+
+      it "should not include unupdated keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_false
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should not include new keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:yellow).should be_false
+        @test_hash.deleted_keys.include?(:green).should be_false
+      end
+
+      it "should mark instance as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return an AttributeHash containing the new contents" do
+        @ret_val.class.should == AttributeKit::AttributeHash
+        @ret_val.eql?({:blue => 'blue', :red => 'red', :yellow => 'yellow', :green => 'green'}).should be_true
+      end
+    end
+
+    describe "#update" do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash[:green] = 'grn'
+        @test_hash.clean_attributes {}
+        @ret_val = @test_hash.update({:yellow => 'yellow', :green => 'green'})
+      end
+
+      it "should retain unupdated contents" do
+        @test_hash.blue_deleted?.should be_false
+        @test_hash.red_deleted?.should be_false
+        @test_hash[:blue].should == 'blue'
+        @test_hash[:red].should == 'red'
+      end
+
+      it "should add supplied hash's contents to object's contents" do
+        @test_hash[:yellow].should == 'yellow'
+        @test_hash[:green].should == 'green'
+      end
+
+      it "should mark new attributes as dirty" do
+        @test_hash.yellow_dirty?.should be_true
+      end
+
+      it "should mark changed attributes as dirty" do
+        @test_hash.green_dirty?.should be_true
+      end
+
+      it "should not include unupdated keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:blue).should be_false
+        @test_hash.dirty_keys.include?(:red).should be_false
+      end
+
+      it "should include new keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:yellow).should be_true
+      end
+
+      it "should include changed keys in dirty_keys" do
+        @test_hash.dirty_keys.include?(:green).should be_true
+      end
+
+      it "should not include unupdated keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:blue).should be_false
+        @test_hash.deleted_keys.include?(:red).should be_false
+      end
+
+      it "should not include new keys in deleted_keys" do
+        @test_hash.deleted_keys.include?(:yellow).should be_false
+        @test_hash.deleted_keys.include?(:green).should be_false
+      end
+
+      it "should mark instance as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should return an AttributeHash containing the new contents" do
+        @ret_val.class.should == AttributeKit::AttributeHash
+        @ret_val.eql?({:blue => 'blue', :red => 'red', :yellow => 'yellow', :green => 'green'}).should be_true
+      end
+    end
+
+    describe "#shift" do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash.clean_attributes {}
+        @ret = @test_hash.shift
+      end
+
+      it "should delete a key-value pair" do
+        if @ret[0] == :blue
+          @test_hash[:blue].should be_nil
+        else
+          @test_hash[:red].should be_nil
+        end
+      end
+
+      it "should return a key-value pair" do
+        @ret.class.should == Array
+        if @ret[0] == :blue
+          @ret[1].should == 'blue'
+        else
+          @ret[1].should == 'red'
+        end
+      end
+
+      it "should mark the attribute as deleted" do
+        if @ret[0] == :blue
+          @test_hash.blue_deleted?.should be_true
+        else
+          @test_hash.red_deleted?.should be_true
+        end
+      end
+
+      it "should mark the AttributeHash as dirty" do
+        @test_hash.dirty?.should be_true
+      end
+
+      it "should include the attribute in dirty_keys" do
+        if @ret[0] == :blue
+          @test_hash.dirty_keys.include?(:blue).should be_true
+        else
+          @test_hash.dirty_keys.include?(:red).should be_true
+        end
+      end
+
+      it "should include the attribute in deleted_keys" do
+        if @ret[0] == :blue
+          @test_hash.deleted_keys.include?(:blue).should be_true
+        else
+          @test_hash.deleted_keys.include?(:red).should be_true
+        end
+      end
+    end
+
+    describe "#clear" do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash[:green] = 'grn'
+        @test_hash.clean_attributes {}
+        @test_hash[:green] = 'green'
+        @old_keys = @test_hash.keys
+        @test_hash.clear
+      end
+
+      it "should empty the hash" do
+        @test_hash.empty?.should be_true
+      end
+
+      it 'should list all former keys as deleted' do
+        @test_hash.deleted_keys.should == @old_keys
+      end
+
+      it 'should list all former keys (and only former keys) as dirty, with no duplicates' do
+        @test_hash.dirty_keys.should == @old_keys
+      end
+
+      it 'should respond with true when sent #<key>_deleted?' do
+        @test_hash.green_deleted?.should be_true
+      end
+
+      it 'should mark the object as dirty' do
+        @test_hash.dirty?.should be_true
+      end
+    end
+
+    describe '#clean_attributes' do
+      before(:each) do
+        @test_hash = AttributeKit::AttributeHash.new
+        @test_hash[:blue] = 'blue'
+        @test_hash[:red] = 'red'
+        @test_hash[:green] = 'grn'
+        @test_hash.clean_attributes {}
+        @test_hash[:green] = 'green'
+        @test_hash[:yellow] = 'yellow'
+        @test_hash.delete(:red)
+        @test_hash.clean_attributes { |change_hash| @change_hash = change_hash }
+      end
+
+      it "should unmark the hash as dirty" do
+        @test_hash.dirty?.should be_false
+      end
+
+      it "should unmark an attribute as dirty" do
+        @test_hash.blue_dirty.should be_false
+      end
+
+      it "should unmark an attribute as deleted" do
+        @test_hash.red_deleted?.should be_false
+      end
+
+      it 'should pass the block a hash of changed keys' do
+        @change_hash.class.should == Hash
+      end
+
+      it 'should contain deleted keys in the passed hash' do
+        @change_hash.has_key?(:red).should be_true
+      end
+
+      it 'should contain changed keys in the passed hash' do
+        @change_hash.has_key?(:green).should be_true
+      end
+
+      it 'should contain added keys in the passed hash' do
+        @change_hash.has_key?(:yellow).should be_true
+      end
+
+      it 'should not contain unchanged keys in the passed hash' do
+        @change_hash.has_key?(:bluw).should be_false
+      end
+
+      it 'should contain deleted keys in the passed hash with an Array containing :deleted and nil as the value' do
+        @change_hash[:red].eql?([:deleted, nil]).should be_true
+      end
+
+      it 'should contain changed keys in the passed hash with an Array containing :changed and the new value as the value' do
+        @change_hash[:green].eql?([:changed, 'green']).should be_true
+      end
+
+      it 'should contain added keys in the passed hash with an Array containing :changed and the new value as the value' do
+        @change_hash[:yellow].eql?([:changed, 'yellow']).should be_true
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'attribute-kit'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: attribute-kit
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jonathan Mischo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-11 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rdiscount
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+description: Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own
+email: jon.mischo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.markdown
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- VERSION
+- lib/attribute-kit.rb
+- lib/attribute-kit/attribute-kit.rb
+- lib/attribute-kit/attribute_hash.rb
+- spec/attribute-kit_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/supertaz/attribute-kit
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3580658089229278680
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Tools for attribute tracking like Hashes with dirty tracking and events, for building hybrid models and generally going beyond what's provided by your local ORM/DRM, while allowing you to expand what you can do with them, live without them, or roll your own
+test_files: []
+