acts_as_diffable 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 James Mason & The SUSE Studio Team @ NOVELL/SUSE
+
+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,56 @@
+ActsAsDiffable provides a dead-simple way to compare two instances of a class,
+including any or all associations, or more complex relationships.
+
+The return is a hash*, suitable for digestion by case-based textualizers, 
+JSON processors, etc., in the form { 'attribute' => [from, to] }
+* In the instance of no changes, a nil is returned
+ 
+== Usage
+
+  class Foo < ActiveRecord::Base
+    acts_as_diffable
+  end
+  > Foo.first.diff(Foo.last) => { 'bar' => ['foo', nil] }
+
+=== Associations
+
+For plural associations, a :diff_key option needs to be added to the association,
+defining how to relate disparate instances within each parent's collections.  
+This can be a single field or a collection of fields in an array, and will be 
+expressed as the key side of a hash with the value being the hash of attribute 
+differences.
+
+For singular association, there is no need to specify a way to organize and
+compare, so we only need to express which associations to include in the diff,
+by adding a :diff option to the association that evaluates to true.
+
+  class Foo < ActiveRecord::Base
+    acts_as_diffable
+   
+    has_one :bar, :diff => true
+    has_many :fish, :diff_keypattern => :name
+    has_and_belongs_to_many :users, :diff_keypattern => [:firstname, :lastname]
+  end
+  > Foo.first.diff(Foo.last) 
+  => { 'bar'   => { 'attr1' => ['a', 'b'], 
+                    'attr2' => [14, nil] },
+       'fish   => { 'nemo'   => {'fish_attr1' => [nil, 'zip']   },
+                    'goldie' => {'fish_attr1' => ['zap', 'zop'] } },
+       'users' => { ['Jane', 'Doe'] => { 'firstname' => 'Jane',
+                                         'lastname'  => 'Doe' },
+                    ['John', 'Doe'] => { '_deleted' => true   } } }
+
+=== More complex relationships
+
+In addition to the marked associations, any method on the class that returns an
+ActiveRecord-ish object can be included in the diff by adding a 
+manual_diff_definiton.  For comparing collections of ActiveRecord objects, 
+use the form:
+
+  manual_diff_definition :name, :eval => 'instance_eval_code',
+                                :diff_key => [:key, :pattern]
+                                
+For simpler singular comparisons, omit the diff_key option.
+
+
+Have a lot of fun!

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "acts_as_diffable"
+    gem.summary = "Compare two instances of an ActiveRecord::Base class."
+    gem.description = "ActsAsDiffable provides a dead-simple way to compare two instances of a class, including any or all associations, or more complex relationships."
+    gem.email = "jmason@suse.com"
+    gem.homepage = "https://github.com/bear454/ActsAsDiffable"
+    gem.authors = ["James Mason 'bear454'"]
+    gem.add_dependency "activerecord", ">=2.3.14"
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/acts_as_diffable.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "acts_as_diffable"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["James Mason 'bear454'"]
+  s.date = "2012-04-19"
+  s.description = "ActsAsDiffable provides a dead-simple way to compare two instances of a class, including any or all associations, or more complex relationships."
+  s.email = "jmason@suse.com"
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+    "README",
+    "Rakefile",
+    "VERSION",
+    "acts_as_diffable.gemspec",
+    "init.rb",
+    "lib/acts_as_diffable.rb",
+    "test/app_root/app/controllers/application_controller.rb",
+    "test/app_root/app/models/group.rb",
+    "test/app_root/app/models/tag.rb",
+    "test/app_root/app/models/user.rb",
+    "test/app_root/config/boot.rb",
+    "test/app_root/config/database.yml",
+    "test/app_root/config/environment.rb",
+    "test/app_root/config/environments/in_memory.rb",
+    "test/app_root/config/environments/mysql.rb",
+    "test/app_root/config/environments/postgresql.rb",
+    "test/app_root/config/environments/sqlite.rb",
+    "test/app_root/config/environments/sqlite3.rb",
+    "test/app_root/config/routes.rb",
+    "test/app_root/db/migrate/20101117081517_create_users.rb",
+    "test/app_root/db/migrate/20101117081553_create_groups.rb",
+    "test/app_root/db/migrate/20101117081632_create_tags.rb",
+    "test/app_root/lib/console_with_fixtures.rb",
+    "test/app_root/log/.gitignore",
+    "test/app_root/script/console",
+    "test/diff_test.rb",
+    "test/fixtures/groups.yml",
+    "test/fixtures/tags.yml",
+    "test/fixtures/users.yml",
+    "test/test_helper.rb"
+  ]
+  s.homepage = "https://github.com/bear454/ActsAsDiffable"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.22"
+  s.summary = "Compare two instances of an ActiveRecord::Base class."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.3.14"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.3.14"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.3.14"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require 'acts_as_diffable'

data/lib/acts_as_diffable.rb

@@ -0,0 +1,213 @@
+require 'active_record'
+
+module ActiveRecord #:nodoc:
+  module Acts #:nodoc:
+    module Diffable #:nodoc:
+
+      SINGULAR_MACROS = [:has_one, :belongs_to]
+      PLURAL_MACROS   = [:has_many, :has_and_belongs_to_many]
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        
+      end
+
+      module ClassMethods
+        def acts_as_diffable
+          class_variable_set :@@manual_diff_definitions, {}
+          extend ActiveRecord::Acts::Diffable::SingletonMethods
+          include ActiveRecord::Acts::Diffable::InstanceMethods
+        end
+        
+      end
+
+      module SingletonMethods
+        def manual_diff_definition(name, options = {})
+          definitions = class_variable_get :@@manual_diff_definitions
+          definitions[name.to_s] = options if options[:eval] # otherwise just ignore it
+          class_variable_set :@@manual_diff_definitions, definitions
+        end
+        
+        def manual_diff_definitions
+          class_variable_get :@@manual_diff_definitions
+        end
+      end
+
+      # Adds instance methods.
+      module InstanceMethods
+        # Return a hash of the different attributes between two hashes, such as
+        # attributes of an ActiveRecord class.
+        def diff(other)
+          # is other an instance or just an id?
+          case other.class
+          when self.class
+            other
+          else
+            other = self.class.find(other)
+          end
+          # diff the top-level attributes
+          differences = attributes_diff(self, other) || {}
+          # has_one and belongs_to associations
+          ActiveRecord::Acts::Diffable::SINGULAR_MACROS.each do |macro|
+            self.class.reflect_on_all_associations(macro).each do |a|
+              differences[a.name.to_s] = singular_association_diff(self, other, a.name) if a.options[:diff]
+              differences.delete(a.options[:foreign_key] || "#{a.name}_id")
+            end
+          end
+          # has_many and habtm associations
+          ActiveRecord::Acts::Diffable::PLURAL_MACROS.each do |macro|
+            self.class.reflect_on_all_associations(macro).each do |a|
+              differences[a.name.to_s] = plural_association_diff(self, other, a.name, a.options[:diff_key]) if a.options[:diff_key]
+            end
+          end
+          # manually defined diffs
+          self.class.manual_diff_definitions.each{|d_name, d_props|
+            if d_props[:diff_key]
+              differences[d_name] = plural_association_diff(self, other, d_props[:eval], d_props[:diff_key])
+            else
+              differences[d_name] = singular_association_diff(self, other, d_props[:eval])
+            end
+          }
+          remove_unchanged_entries differences
+        end
+        
+        def timed_log(start_time, msg)
+          puts "%04.2fs %s" % [(Time.now - start_time), msg]
+        end
+        
+        # Helper for processing a single associated object, 
+        # such as has_one (or belongs_to) associations.
+        def singular_association_diff(left_parent, right_parent, association)
+          association = association.to_s #instance_eval doesn't like symbols.  What'ev.
+          attributes_diff(
+            left_parent.instance_eval(association),
+            right_parent.instance_eval(association),
+            association_ids(left_parent) )
+        end    
+
+        # Helper for processing a collection of associated objects,
+        # such as has_many (or habtm) association.
+        def plural_association_diff(left_parent, right_parent, association, key_pattern)
+          key_pattern = Array(key_pattern)
+          association = association.to_s #instance_eval doesn't like symbols.  What'ev.
+          left_association_set = Array(left_parent.instance_eval(association))
+          right_associaton_set = Array(right_parent.instance_eval(association))
+          # construct a set of values (key_set) from the attributes defined in key_pattern
+          key_sets = (
+            left_association_set.collect{|i| key_pattern.collect{|k| i.send(k) } } +
+            right_associaton_set.collect{|i| key_pattern.collect{|k| i.send(k) } } ).uniq
+          # for each key_set, compare instances in each collection
+          diff_set = {}
+          key_sets.each do |key_set|
+            conditions = {}   
+            key_pattern.each_with_index{|k, i| conditions[k] = key_set[i] } 
+            left_instance = left_association_set.find{|i|
+              conditions.collect{|cf,cv| i.send(cf) == cv}.all?
+            }
+            right_instance = right_associaton_set.find{|i|
+              conditions.collect{|cf,cv| i.send(cf) == cv}.all?
+            }
+            diff_set[keyify(key_set)] = attributes_diff(left_instance, right_instance, association_ids(left_parent) )
+          end
+          
+          # clean up unchanged pairs
+          remove_unchanged_entries diff_set
+        end
+
+        # reduce the key out of an array to a single string if only one element
+        def keyify(keyset)
+          case keyset.size
+          when 1
+            keyset[0]
+          else
+            keyset
+          end    
+        end
+        
+        # Helper for collecting ids to ignore.
+        def association_ids(*instances)
+          ['id'] + instances.collect{|i| i.class.to_s.underscore + '_id'}
+        end
+        
+        # Helper for handing objects with an attributes hash (a la ARec).
+        def attributes_diff(left, right, ignore = [:id])
+          left_attributes = case
+            when left.is_a?(Hash) then 
+              left
+            when left.respond_to?(:attributes) then 
+              left.attributes
+            else 
+              left.instance_values
+            end
+          right_attributes = case
+            when right.is_a?(Hash) then
+              right
+            when right.respond_to?(:attributes) then
+              right.attributes
+            else
+              right.instance_values
+            end
+
+          if left_attributes == right_attributes
+            return nil
+          else
+            generate_diff_hash(left_attributes, right_attributes, *ignore)
+          end
+        end
+        
+        # Helper for thinning the herd
+        def remove_unchanged_entries(diff_hash)
+          return nil if !diff_hash
+          diff_hash.delete_if{|k,v| v.nil? }
+          if diff_hash.empty?
+            return nil 
+          else
+            return diff_hash
+          end
+        end
+
+        # Accepts a left & right hash, and an array of keys to ignore,
+        # returns a hash of the differences.
+        #
+        # This here is the meat & potatoes!
+        def generate_diff_hash(left, right, *ignore)
+          case [left.blank?, right.blank?] 
+          when [false, true] # the represented object was deleted
+            { '_delete' => true } # inspired by nested_attributes
+          when [true, false] # the represented object was added
+            (ignore + %w(created_at updated_at)).each{|k| right.delete(k.to_s) }
+            return right # just return the attributes to add
+          when [false, false] # the represented object changed
+            # generate the attribute diffs from each side and
+            # merge them together as attribute => [left_value, right_value]
+            if left == right
+              return nil
+            else
+              diff_hash = left.diff(right).merge(right.diff(left)){|k, lv, rv| [lv, rv] }
+              # remove any ignored attributes
+              ignore.each {|k| diff_hash.delete(k.to_s) }
+              # compress created_at/updated_at duplication
+              diff_hash.delete('updated_at') if diff_hash['created_at'] == diff_hash['updated_at']
+              remove_unchanged_entries diff_hash
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+# reopen ActiveRecord and include all the above to make
+# them available to all our models if they want it
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Acts::Diffable
+end
+
+# monkeypatch the diff keys onto the association proxies
+ActiveRecord::Associations::Builder::BelongsTo.class_eval("self.valid_options += [:diff]")
+ActiveRecord::Associations::Builder::HasOne.class_eval("self.valid_options += [:diff]")
+ActiveRecord::Associations::Builder::HasMany.class_eval("self.valid_options += [:diff_key]")
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.class_eval("self.valid_options += [:diff_key]")

data/test/app_root/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/app_root/app/models/group.rb

@@ -0,0 +1,4 @@
+# for testing single associations
+class Group < ActiveRecord::Base
+  has_many :users
+end

data/test/app_root/app/models/tag.rb

@@ -0,0 +1,4 @@
+# for testing plural associations
+class Tag < ActiveRecord::Base
+  belongs_to :user
+end

data/test/app_root/app/models/user.rb

@@ -0,0 +1,11 @@
+# top-level class
+class User < ActiveRecord::Base
+  acts_as_diffable
+
+  belongs_to :group, :diff => true
+  has_many :tags, :diff_key => :name
+  
+  manual_diff_definition :group_name, :eval => 'group.name'
+  manual_diff_definition :m_tags, :eval => 'tags', :diff_key => 'name'
+
+end

data/test/app_root/config/boot.rb

@@ -0,0 +1,115 @@
+# Allow customization of the rails framework path
+RAILS_FRAMEWORK_ROOT = (ENV['RAILS_FRAMEWORK_ROOT'] || "#{File.dirname(__FILE__)}/../../../../../../vendor/rails") unless defined?(RAILS_FRAMEWORK_ROOT) 
+
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+Rails.root.to_s = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?(RAILS_FRAMEWORK_ROOT)
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{Rails.root.to_s}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_FRAMEWORK_ROOT}/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+      Rails::GemDependency.add_frozen_gem_path
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.3.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+ 
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          environment_rb = "#{Rails.root.to_s}/config/environment.rb"
+          environment_rb = "#{HELPER_Rails.root.to_s}/config/environment.rb" unless File.exists?(environment_rb)
+          File.read(environment_rb)
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/test/app_root/config/database.yml

@@ -0,0 +1,31 @@
+in_memory:
+  adapter: sqlite3
+  database: ":memory:"
+  verbosity: quiet
+  pool: 5
+  timeout: 5000
+sqlite:
+  adapter: sqlite
+  dbfile: plugin_test.sqlite.db
+  pool: 5
+  timeout: 5000
+sqlite3:
+  adapter: sqlite3
+  dbfile: plugin_test.sqlite3.db
+  pool: 5
+  timeout: 5000
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: plugin_test
+  pool: 5
+  timeout: 5000
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: plugin_test
+  pool: 5
+  timeout: 5000

data/test/app_root/config/environment.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
+  config.plugin_locators.unshift(
+    Class.new(Rails::Plugin::Locator) do
+      def plugins
+        [Rails::Plugin.new(File.expand_path('.'))]
+      end
+    end
+  ) unless defined?(PluginTestHelper::PluginLocator)
+end

data/test/app_root/config/routes.rb

@@ -0,0 +1,4 @@
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/app_root/db/migrate/20101117081517_create_users.rb

@@ -0,0 +1,19 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.integer :rank
+      t.float :factor
+      t.date :activated_on
+      t.text :biography
+      t.boolean :admin
+      t.integer :group_id
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/test/app_root/db/migrate/20101117081553_create_groups.rb

@@ -0,0 +1,13 @@
+class CreateGroups < ActiveRecord::Migration
+  def self.up
+    create_table :groups do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :groups
+  end
+end

data/test/app_root/db/migrate/20101117081632_create_tags.rb

@@ -0,0 +1,14 @@
+class CreateTags < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name
+      t.integer :user_id
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :tags
+  end
+end

data/test/app_root/lib/console_with_fixtures.rb

@@ -0,0 +1,4 @@
+# Loads fixtures into the database when running the test app via the console
+(ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(Rails.root, '../fixtures/*.{yml,csv}'))).each do |fixture_file|
+  Fixtures.create_fixtures(File.join(Rails.root, '../fixtures'), File.basename(fixture_file, '.*'))
+end

data/test/app_root/script/console

@@ -0,0 +1,7 @@
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs =  " -r irb/completion"
+libs << " -r test/test_helper"
+libs << " -r console_app"
+libs << " -r console_with_helpers"
+libs << " -r console_with_fixtures"
+exec "#{irb} #{libs} --simple-prompt"

data/test/diff_test.rb

@@ -0,0 +1,40 @@
+require 'test/test_helper'
+
+class DiffTest < ActiveSupport::TestCase
+  def test_instance_is_loadable
+    assert users(:john)
+  end
+
+  def test_instances_with_identical_attributes_should_return_a_nill_for_diff
+    assert_equal nil, users(:john).diff(users(:john))
+  end
+  
+  def test_only_different_attributes_should_be_returned
+    diff_expectation = {'name' => ['John Doe', 'Jane Doe'],
+                        'rank' => [1, 2],
+                        'factor' => [2.718281828459045, 3.141592653589793],
+                        'activated_on' => [ Date.new(2010,11,17), Date.new(2005,01,01) ],
+                        'admin' => [false, true] }
+    diff_result = users(:john).diff(users(:jane))
+    
+    assert_equal diff_expectation.inspect, diff_result.inspect
+  end
+  
+  def test_singular_associations
+    diff_expectation = {'group' => { 'name' => ['FirstGroup', 'SecondGroup'] } }
+    diff_result = users(:jane).diff(users(:jane_in_a_different_group))
+    
+    assert_equal diff_expectation.inspect, diff_result.inspect
+  end
+  
+  def test_plural_associations
+    diff_expectation = {'tags'   => { 'foo' => {'name' => 'foo' },
+                                      'bar' => {'_delete' => true } },
+                        'm_tags' => { 'foo' => {'name' => 'foo' },
+                                      'bar' => {'_delete' => true } } }
+    diff_result = users(:john).diff(users(:john_with_different_tags))
+    
+    assert_equal diff_expectation.inspect, diff_result.inspect
+  end
+  
+end

data/test/fixtures/groups.yml

@@ -0,0 +1,7 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+
+one:
+  name: FirstGroup
+
+two:
+  name: SecondGroup

data/test/fixtures/tags.yml

@@ -0,0 +1,33 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+
+foo:
+  name: foo
+  user: john_with_different_tags
+
+de:
+  name: de
+  user: john
+
+de2:
+  name: de
+  user: john_with_different_tags
+  
+de3:
+  name: de
+  user: jane
+
+de4:
+  name: de
+  user: jane_in_a_different_group
+  
+bar:
+  name: bar
+  user: john
+
+bar2:
+  name: bar
+  user: jane
+
+bar3:
+  name: bar
+  user: jane_in_a_different_group

data/test/fixtures/users.yml

@@ -0,0 +1,54 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+
+john:
+  name: John Doe
+  rank: 1
+  factor: 2.718281828459045
+  activated_on: 2010-11-17
+  biography: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam a
+    justo sed mauris rutrum rutrum nec vitae ante. Mauris tincidunt, mi sed
+    commodo fermentum, velit magna pulvinar enim, nec fringilla elit risus in
+    dolor. Aenean a lacus nec sem iaculis lacinia eget sed leo. Quisque ipsum
+    velit, sodales non dapibus."
+  admin: false
+  group: one
+
+john_with_different_tags:
+  name: John Doe
+  rank: 1
+  factor: 2.718281828459045
+  activated_on: 2010-11-17
+  biography: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam a
+    justo sed mauris rutrum rutrum nec vitae ante. Mauris tincidunt, mi sed
+    commodo fermentum, velit magna pulvinar enim, nec fringilla elit risus in
+    dolor. Aenean a lacus nec sem iaculis lacinia eget sed leo. Quisque ipsum
+    velit, sodales non dapibus."
+  admin: false
+  group: one
+
+jane:
+  name: Jane Doe
+  rank: 2
+  factor: 3.141592653589793
+  activated_on: 2005-01-01
+  biography: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam a
+    justo sed mauris rutrum rutrum nec vitae ante. Mauris tincidunt, mi sed
+    commodo fermentum, velit magna pulvinar enim, nec fringilla elit risus in
+    dolor. Aenean a lacus nec sem iaculis lacinia eget sed leo. Quisque ipsum
+    velit, sodales non dapibus."
+  admin: true
+  group: one
+  
+jane_in_a_different_group:
+  name: Jane Doe
+  rank: 2
+  factor: 3.141592653589793
+  activated_on: 2005-01-01
+  biography: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam a
+    justo sed mauris rutrum rutrum nec vitae ante. Mauris tincidunt, mi sed
+    commodo fermentum, velit magna pulvinar enim, nec fringilla elit risus in
+    dolor. Aenean a lacus nec sem iaculis lacinia eget sed leo. Quisque ipsum
+    velit, sodales non dapibus."
+  admin: true
+  group: two
+

data/test/test_helper.rb

@@ -0,0 +1,21 @@
+# Set the default environment to sqlite3's in_memory database
+ENV['Rails.env.to_s'] ||= 'in_memory'
+
+# Load the Rails environment and testing framework
+require "#{File.dirname(__FILE__)}/app_root/config/environment"
+require 'test_help'
+
+# Undo changes to Rails.env.to_s
+silence_warnings {Rails.env.to_s = ENV['RAILS_ENV']}
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+# Set default fixture loading properties
+ActiveSupport::TestCase.class_eval do
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+  self.fixture_path = "#{File.dirname(__FILE__)}/fixtures"
+  
+  fixtures :all
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_diffable
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- James Mason 'bear454'
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-19 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 3
+        - 14
+        version: 2.3.14
+  type: :runtime
+  version_requirements: *id001
+description: ActsAsDiffable provides a dead-simple way to compare two instances of a class, including any or all associations, or more complex relationships.
+email: jmason@suse.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- acts_as_diffable.gemspec
+- init.rb
+- lib/acts_as_diffable.rb
+- test/app_root/app/controllers/application_controller.rb
+- test/app_root/app/models/group.rb
+- test/app_root/app/models/tag.rb
+- test/app_root/app/models/user.rb
+- test/app_root/config/boot.rb
+- test/app_root/config/database.yml
+- test/app_root/config/environment.rb
+- test/app_root/config/environments/in_memory.rb
+- test/app_root/config/environments/mysql.rb
+- test/app_root/config/environments/postgresql.rb
+- test/app_root/config/environments/sqlite.rb
+- test/app_root/config/environments/sqlite3.rb
+- test/app_root/config/routes.rb
+- test/app_root/db/migrate/20101117081517_create_users.rb
+- test/app_root/db/migrate/20101117081553_create_groups.rb
+- test/app_root/db/migrate/20101117081632_create_tags.rb
+- test/app_root/lib/console_with_fixtures.rb
+- test/app_root/log/.gitignore
+- test/app_root/script/console
+- test/diff_test.rb
+- test/fixtures/groups.yml
+- test/fixtures/tags.yml
+- test/fixtures/users.yml
+- test/test_helper.rb
+homepage: https://github.com/bear454/ActsAsDiffable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Compare two instances of an ActiveRecord::Base class.
+test_files: []
+