acts_as_comparable 1.0

data/LICENSE

@@ -0,0 +1,20 @@
+# Copyright (c) 2007 Mark Van Holstyn, Zach Dennis
+# 
+# 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

@@ -0,0 +1,25 @@
+acts_as_comparable
+-------------------
+
+acts_as_comparable allows you to compare ActiveRecord models.
+To test or build documentation see the rake tasks available.
+  rake -T
+
+
+TESTING 
+-------
+Testing acts_as_comparable relies on:
+ * ActiveRecord (any version, tested up to 1.15.3)
+ * Mocha 0.4.0 or higher (tested with 0.4.0)
+ * Ruby 1.8.4, 1.8.5 or 1.8.6
+ 
+SVN
+----
+Public anonymous read svn:
+   http://rails.lotswholetime.com/svn/acts_as_comparable/trunk
+
+AUTHORS
+-------
+* Mark Van Holstyn - http://www.lotswholetime.com
+* Zach Dennis - http://www.continuousthinking.com 
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc "Default Task"
+task :default => :test 
+
+desc "Test acts_as_comparable"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Generate documentation for acts_as_comparable"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "acts_as_comparable"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require File.join( File.dirname( __FILE__ ), 'lib', 'acts_as_comparable' )

data/lib/acts_as_comparable.rb

@@ -0,0 +1,170 @@
+# == acts_as_comparable
+# acts_as_comparable provides comparison to ActiveRecord models. 
+# It allows you to capture what fields are different, as well as
+# easy access to those diferrent values.
+#
+#  class MyModel < ActiveRecord::Base
+#  acts_as_comparable
+#  end
+#
+#
+# == EXAMPLES
+#
+#  # default options which treats all fields as comparable
+#  class Person < ActiveRecord::Base
+#  acts_as_comparable
+#  end
+#
+#  # specifying which fields that should act as comparable
+#  class Person < ActiveRecord::Base
+#    acts_as_comparable :only => [ :first_name, :last_name, :age ]
+#  end
+#
+#
+#  # specifying which fields shouldn't act as comparable
+#  class Person < ActiveRecord::Base
+#    acts_as_comparable :except => [ :eyecolor ]
+#  end
+#
+#
+#  # specifying fields which compare to another field on the same model
+#  class Account < ActiveRecord::Base
+#    acts_as_comparable :attrs_map => { :accountno => :parent_accountno }
+#  end
+#
+# See unit tests for more usage examples.
+#
+# == AUTHORS
+# * Mark Van Holstyn http://www.lotswholetime.com
+# * Zach Dennis http://www.continuousthinking.com
+#
+module ActiveRecord::Acts::Comparable
+  def self.included( base )
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    
+    # Sets up the current model to be comparable against other models or instances.
+    #
+    # == Options
+    # * :only - an array of fields as symbols which should be held onto for comparison
+    # * :except - an array of fields as symbols which should not be held onto for comparison
+    # * :attrs_map - a hash of field to field mappings as symbols which define how fields should be compared  
+    def acts_as_comparable( options = {} )
+      #pullin in necessary methods
+      cattr_accessor :comparable_attributes, :comparable_options
+      include ActiveRecord::Acts::Comparable::InstanceMethods
+      
+      #setup options
+      self.comparable_options = options
+      self.comparable_attributes = comparable_options_to_attributes_hash options
+    end
+  
+    private
+    
+    def comparable_options_to_attributes_hash( options )
+      #setup attributes
+      attrs = {}
+      
+      if options[:only]
+        options[:only].to_a.each { |attr| attrs[attr.to_sym] = attr.to_sym } 
+      else
+        self.column_names.each { |attr| attrs[attr.to_sym] = attr.to_sym } 
+      end
+
+      if options[:attrs_map]
+        options[:attrs_map].each_pair do |attr,action| 
+          attrs[attr.to_sym] = action
+        end
+      end
+            
+      if options[:except]
+        options[:except].to_a.each { |attr| attrs.delete attr.to_sym } 
+      end
+      
+      attrs
+    end
+  end
+
+  module InstanceMethods
+    
+    # Returns true if the passed in +other+ model is different then this
+    # model given the fields that are marked as comparable. Otherwise
+    # returns false.
+    #
+    # == Arguments
+    # * other - another ActiveRecord model to compare this model against
+    # * options - a hash of options. All options for ActiveRecord::Acts::Comparable::ClassMethods.acts_as_comparable apply.
+    #
+    def different?( other = nil, options = nil )
+      other ||= self.new_record? ? self.class.new : self.class.find( self.id )
+      comparable_attributes_for( options ).each_pair do |attr, action|
+        if action.is_a? Proc
+          return true unless action.call( self ) == action.call( other )
+        else
+          return true unless self.send( attr ) == other.send( attr )
+        end
+      end
+      false
+    end
+    
+    # Returns true if the passed in +other+ model is comparable to this
+    # model given the fields that are marked as comparable. Otherwise
+    # returns false.
+    #
+    # == Arguments
+    # * other - another ActiveRecord model to compare this model against
+    # * options - a hash of options. All options for ActiveRecord::Acts::Comparable::ClassMethods.acts_as_comparable apply.
+    #
+    def same?( other = nil, options = nil )
+      not different?( other, options )
+    end
+    
+    # Returns a hash of field to value mappings which signify the differences between
+    # this model object and the passed in +other+ model object given an optional
+    # set of options. Returns an empty hash if there are no comparable differences.
+    #
+    # The value of the field to value mappings is an array of the values that differ.
+    #
+    # == Arguments
+    # * other - another ActiveRecord model to compare this model against
+    # * options - a hash of options. All options for ActiveRecord::Acts::Comparable::ClassMethods.acts_as_comparable apply.
+    #
+    # == Example
+    #
+    #  class Pet < ActiveRecord::Base ; end
+    # 
+    #  pet1 = Pet.new :id=>1, :name=>"dog", :value=>"Tiny"
+    #  pet2 = Pet.new :id=>5, :name=>"cat", :value=>"Norm"
+    #
+    #  differences = pet1.differences(pet2)
+    #  #  => {:value=>["Tiny", "Norm"], :name=>["dog", "cat"], :id=>[1, 5]}
+    #
+    def differences( other = nil, options = nil )
+      other ||= self.new_record? ? self.class.new : self.class.find( self.id )
+      diffs = {}
+      comparable_attributes_for( options ).each_pair do |attr, action|
+        unless self.send( attr ) == other.send( attr )
+          if action.is_a? Proc
+            diffs[attr] = [ action.call( self ), action.call( other ) ]
+          else
+            diffs[attr] = [ self.send( attr ), other.send( attr ) ]
+          end
+        end
+      end
+      diffs.symbolize_keys
+    end
+    
+    # Returns an hash of comparable attribute mappings given the passed in options.
+    #
+    # == Arguments
+    # * options - a hash of options. All options for ActiveRecord::Acts::Comparable::ClassMethods.acts_as_comparable apply.
+    def comparable_attributes_for( options )
+      attrs = options ? self.class.send( :comparable_options_to_attributes_hash, options ) : self.class.comparable_attributes
+    end
+  end
+  
+end
+
+ActiveRecord::Base.send( :include, ActiveRecord::Acts::Comparable )

data/test/acts_as_comparable_test.rb

@@ -0,0 +1,136 @@
+require File.join( File.dirname( __FILE__ ), "test_helper")
+
+class ActsAsComparableTest < Test::Unit::TestCase
+  
+  def test_models_are_different_when_both_records_are_new
+    model1 = MockModel.new :name=>"dog"
+    model2 = MockModel.new :name=>"cat"
+    
+    assert model1.different?(model2), "models should have been different!"
+    assert !model1.same?(model2), "models shouldn't have been the same!"
+  end
+  
+  def test_models_are_different_when_one_records_is_new
+    model1 = MockModel.new :name=>"dog"
+    model1.instance_variable_set "@new_record", false
+    
+    model2 = MockModel.new :name=>"cat"
+    
+    assert model1.different?(model2), "models should have been different!"
+    assert !model1.same?(model2), "models shouldn't have been the same!"
+  end
+  
+  def test_models_are_different_when_neither_record_is_new
+    model1 = MockModel.new :name=>"dog"
+    model1.instance_variable_set "@new_record", false
+    
+    model2 = MockModel.new :name=>"cat"
+    model2.instance_variable_set "@new_record", false
+
+    assert model1.different?(model2), "models should have been different!"
+    assert !model1.same?(model2), "models shouldn't have been the same!"
+  end
+  
+  def test_models_are_not_different_when_both_records_are_new 
+    model1 = MockModel.new :name=>"cat"
+    model2 = MockModel.new :name=>"cat"
+    
+    assert model1.same?(model2), "models should have been the same!"
+    assert !model1.different?(model2), "models shouldn't have been different!"
+  end
+  
+  def test_models_are_not_different_when_one_record_is_new 
+    model1 = MockModel.new :name=>"cat"
+    model1.instance_variable_set "@new_record", false    
+    
+    model2 = MockModel.new :name=>"cat"
+    
+    assert model1.same?(model2), "models should have been the same!"
+    assert !model1.different?(model2), "models shouldn't have been different!"
+  end
+  
+  def test_models_are_not_different_when_neither_record_is_new 
+    model1 = MockModel.new :name=>"cat"
+    model1.instance_variable_set "@new_record", false
+    
+    model2 = MockModel.new :name=>"cat"
+    model2.instance_variable_set "@new_record", false
+
+    assert model1.same?(model2), "models should have been the same!"
+    assert !model1.different?(model2), "models shouldn't have been different!"
+  end
+    
+  def test_differences_with_new_records
+    model1 = MockModel.new :id=>nil, :name=>"dog", :value=>"Tiny"
+    model2 = MockModel.new :id=>nil, :name=>"cat", :value=>"Norm"
+    model1.instance_variable_set "@new_record", false
+    
+    differences = model1.differences(model2)
+
+    assert differences[:name] == [ "dog", "cat" ], "Name was expected to be different!"
+    assert differences[:value] == [ "Tiny", "Norm" ], "Value was expected to be different!"
+    assert 2 == differences.size, "Wrong number of differences!"
+  end
+  
+  def test_differences_with_one_new_record
+    model1 = MockModel.new :id=>nil, :name=>"dog", :value=>"Tiny"
+    model2 = MockModel.new :id=>5, :name=>"cat", :value=>"Norm"
+    model2.instance_variable_set "@new_record", false
+    
+    differences = model1.differences(model2)
+
+    assert differences[:id] == [ nil, 5 ], "ID was expected to be different!"
+    assert differences[:name] == [ "dog", "cat" ], "Name was expected to be different!"
+    assert differences[:value] == [ "Tiny", "Norm" ], "Value was expected to be different!"
+    assert 3 == differences.size, "Wrong number of differences!"
+  end
+  
+  def test_differences_with_existing_records
+    model1 = MockModel.new :id=>1, :name=>"dog", :value=>"Tiny"
+    model1.instance_variable_set "@new_record", false
+
+    model2 = MockModel.new :id=>5, :name=>"cat", :value=>"Norm"
+    model1.instance_variable_set "@new_record", false
+
+    differences = model1.differences(model2)
+
+    assert differences[:id] == [ 1, 5 ], "ID was expected to be different!"
+    assert differences[:name] == [ "dog", "cat" ], "Name was expected to be different!"
+    assert differences[:value] == [ "Tiny", "Norm" ], "Value was expected to be different!"
+    assert 3 == differences.size, "Wrong number of differences!"
+  end
+  
+  def test_comparable_attributes_for_without_options
+    comparable_attributes = MockModel.new.comparable_attributes_for( {} )
+    expected_comparable_attributes = { :id=>:id, :name=>:name, :value=>:value }
+
+    assert expected_comparable_attributes == comparable_attributes, "Expected attributes were not comparable!"
+  end
+  
+  def test_comparable_attributes_for_with_only_option
+    comparable_attributes = MockModel.new.comparable_attributes_for( 
+      :only=>[:value] 
+    )
+    expected_comparable_attributes = { :value=>:value }
+
+    assert expected_comparable_attributes == comparable_attributes, "Expected attributes were not comparable!"
+  end
+  
+  def test_comparable_attributes_for_with_except_option
+    comparable_attributes = MockModel.new.comparable_attributes_for( 
+      :except=>[:value] 
+    )
+    expected_comparable_attributes = { :id=>:id, :name=>:name }
+
+    assert expected_comparable_attributes == comparable_attributes, "Expected attributes were not comparable!"
+  end
+  
+  def test_comparable_attributes_for_with_attrs_map_option
+    comparable_attributes = MockModel.new.comparable_attributes_for( 
+      :attrs_map=> {:name=>:value, :value=>:id} 
+    )
+    expected_comparable_attributes = { :id=>:id, :name=>:value, :value=>:id }
+    assert expected_comparable_attributes == comparable_attributes, "Expected attributes were not comparable!"
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+unless Object.const_defined?( :ActiveRecord )
+  begin 
+    require 'active_record'
+  rescue LoadError => ex
+    require 'rubygems'
+    require 'active_record'
+  end
+end
+
+require File.join( File.dirname( __FILE__ ), '..', 'init' )
+require 'test/unit'
+require 'mocha'
+
+###### SETUP a partially mocked out Model for testing #######
+
+class MockModel < ActiveRecord::Base
+  class << self 
+    def column_names
+      %w[ id name value ]
+    end
+  end  
+  
+  acts_as_comparable
+  
+  def initialize( attributes_hsh={} )
+    @attributes = { :id=>nil, :name=>"", :value=>"" }.merge( attributes_hsh )
+    @new_record = true
+    
+    @attributes.keys.each do |column_name|
+      self.class.send( :define_method, column_name ) { @attributes[column_name] }
+    end
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: acts_as_comparable
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+date: 2007-04-20 00:00:00 -04:00
+summary: Adds ActiveRecord model comparison functionality.
+require_paths: 
+- lib
+email: mvette13@gmail.com zach.dennis@gmail.com
+homepage: http://www.continuousthinking.com/tags/acts_as_comparable
+rubyforge_project: arext
+description: Adds ActiveRecord model comparison functionality.
+autorequire: acts_as_comparable.rb
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Mark Van Holstyn
+- Zach Dennis
+files: 
+- init.rb
+- Rakefile
+- LICENSE
+- README
+- lib/acts_as_comparable.rb
+- test/acts_as_comparable_test.rb
+- test/test_helper.rb
+test_files: []
+
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.14.1
+    version: