table_differ 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 753fc1ecd3ac45fb1a11785069a8236127cde352
-  data.tar.gz: 10d8fd04834d8cf542e86717332f8ad831f48cf8
+  metadata.gz: 0cca324c658aebd498e3a150ef613027b416f434
+  data.tar.gz: 78b5e10edf2b2da4ffdc209ca8ce4d8d62418db9
 SHA512:
-  metadata.gz: 383647ef5b7608af4b895548868e33459bc752ec9ba5c82700d1678229c166d2b219b858e35fdb6aead81a72c3c50aec80acf0cc7f4134c76222a6f39707c806
-  data.tar.gz: 809cf0d2b6519daf343f5f1d8e01f7b9f7739bdd71b7c811ff19b7702bc2997ad74f23fae0f09e85653b29921181c7f00e19155d376bbe3d51a1247eefe52505
+  metadata.gz: 6238ba387974306c3e18deeac1cfebb5da47c5565e51f6905423584878068e8ebf0b61a446ccabd93cf9a91b7e53bb18bdf7084b64f5f1d586b09b5cc5dc409c
+  data.tar.gz: c1351cd32f9e19f439bd40f47273d5405c1b24dc0184941c54d004b93294ab48905fa273c690276e38d691b48634a9a741a9b708432b1a11c2cad5e97179a943

data/README.md

@@ -3,6 +3,7 @@
 Take snapshots of database tables and compute the differences between two snapshots.
 
 [![Build Status](https://api.travis-ci.org/bronson/table_differ.png?branch=master)](http://travis-ci.org/bronson/table_differ)
+[![Gem Version](https://badge.fury.io/rb/table_differ.svg)](http://badge.fury.io/rb/table_differ)
 
 ## Installation
 
@@ -17,12 +18,11 @@ gem 'table_differ'
 ```ruby
 Attachment.create_snapshot
   => "attachments_20140626_233336"
-Attachment.first.touch               # set updated_at to right now
-  => true
-added,removed,changed = Attachment.diff_snapshot
+Attachment.first.update_attributes!(name: 'newname')
+added,removed,changed = Attachment.diff_snapshot   # diffs against most recent snapshot
   => [[], [], [<Attachment 1>]]
-changed.first.original_attributes    # returns the fields that have changed
-  => {"updated_at"=>Fri, 27 Jun 2014 05:45:56 UTC +00:00}
+changed.first.original_attributes    # returns original value for each field
+  => {"name" => 'oldname'}
 Attachment.delete_snapshot "attachments_20140626_233336"
 ```
 
@@ -85,7 +85,7 @@ made.  For example, if you changed the name column from 'Nexus' to 'Nexii':
 record.attributes
 => { 'id' => 1, 'name' => 'Nexus' }
 record.original_attributes
-=> { 'name' => 'Nexii' }   # id didn't change so it's not included
+=> { 'id' => 1, 'name' => 'Nexii' }
 ```
 
 Single-Table Inheritance (STI) appears to work correctly (TODO: add this to tests!)
@@ -108,6 +108,20 @@ so you can ignore the empty third array.
 added,removed = Attachment.diff_snapshot(ignore: 'id')
 ```
 
+If there are other fields that you can use to uniquely identify the records,
+you can specify them in the unique_by option.  This will ensure that changes
+are returned (not just adds/removes), and the ActiveRecord objects returned are
+complete with IDs.  This requires one database lookup per returned object,
+however so, if your results sets are huge, this might not be a good idea.
+
+```ruby
+# Normally ingoring the ID prevents diff from being able to compute the changed records.
+# If we can tell it that one or more fields can be used to uniquely identify the object,
+# then it can compute the changed records and return full ActiveRecord objects.
+added,removed,changed = Contact.diff_snapshot(ignore: 'id', unique_by: [:property_id, :contact_id])
+
+```
+
 Also, if you ignore the ID, you won't be able to update or save any models directly.
 You must copy the attributes to another model, one that was loaded from the database
 normally and still knows its ID.
@@ -124,10 +138,12 @@ a,r,c = Property.diff_snapshot('cc', 'cd')           # difference between the tw
 ### Delete Snapshots
 
 delete_snapshot gets rid of unwanted snapshots.
-Either pass a name or a proc to specify which snapshots should be deleted.
+Pass an array of names or a proc to specify which snapshots should be deleted,
+or `:all`.
 
 ```ruby
-Property.delete_snapshot 'import_0012'
+Property.delete_snapshot  'import_0012'
+Property.delete_snapshots :all
 
 week_old_name = Property.snapshot_name(1.week.ago)
 old_snapshots = Property.snapshots.select { |name| name < week_old_name }

data/lib/table_differ/version.rb

@@ -1,3 +1,3 @@
 module TableDiffer
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/table_differ.rb

@@ -44,8 +44,24 @@ module TableDiffer
     end
 
     # deletes every snapshot named in the array
-    def delete_snapshots snapshots
-      snapshots.each { |name| delete_snapshot(name) }
+    # Model.delete_snapshots(:all) deletes all snapshots
+    def delete_snapshots snaps
+      snaps = self.snapshots if snaps == :all
+      snaps.each { |name| delete_snapshot(name) }
+    end
+
+    def table_differ_remap_objects params, records
+      params = Array(params)
+      records.map do |record|
+        args = params.inject({}) { |hash,key| hash[key] = record[key]; hash }
+        real_record = where(args).first
+        if real_record
+          real_record.original_attributes = record.attributes
+          real_record
+        else
+          record
+        end
+      end
     end
 
     # ignore: %w[ created_at updated_at id ]
@@ -71,19 +87,23 @@ module TableDiffer
       # actually, it's probably more reliable just to use the presence of an id to determine if the record can be saved
       # [*added, *removed].select { |o| !o.id }.each { |o| o.instance_variable_set("@new_record", true) }
 
+      if options[:unique_by]
+        added = table_differ_remap_objects(options[:unique_by], added)
+        removed = table_differ_remap_objects(options[:unique_by], removed)
+      end
+
       changed = added & removed
       changed.each do |obj|
         orig = removed.find { |r| r == obj }
         raise "this is impossible" if orig.nil?
-
-        nattrs = obj.attributes
-        # remove all unchanged elements -- original_attributes only contains changed values
-        oattrs = orig.attributes.reject { |k,v| nattrs.include?(k) && nattrs[k] == v }
-
-        obj.original_attributes = HashWithIndifferentAccess.new(oattrs)
+        obj.original_attributes = orig.original_attributes || orig.attributes
       end
 
-      [added - changed, removed - changed, changed]
+      added -= changed
+      removed -= changed
+      [*added, *removed].each { |o| o.original_attributes = nil }
+
+      [added, removed, changed]
     end
   end
 end

data/spec/diff_spec.rb

@@ -63,8 +63,7 @@ describe "diffing a model" do
       expect(changed.first.name).to eq 'uno'
 
       # ensure we can access the previous value, with indifferent access
-      expect(changed.first.original_attributes[:name]).to eq 'one'
-      expect(changed.first.original_attributes).to eq({'name' => 'one'})
+      expect(changed.first.original_attributes).to eq({'id' => one.id, 'name' => 'one'})
 
       # changed records are normal AR objects, try using it
       changed.first.update_attributes!(name: 'nuevo')
@@ -123,7 +122,7 @@ describe "diffing a model" do
     end
 
     # without an ID, we can't tell if anything changed
-    it "detects a changed field" do
+    it "detects a changed field by add/remove" do
       one = Model.where(name: 'one').first
       one.update_attributes!(name: 'uno')
       added,removed,changed = Model.diff_snapshot(ignore: :id)

data/spec/remap_spec.rb

@@ -0,0 +1,41 @@
+describe "diffing a model" do
+  include_context "surrogate_model"
+
+  it "detects a changed field using a single surrogate" do
+    first = SurrogateModel.create!(name: 'one', original_name: 'one')
+    second = SurrogateModel.create!(name: 'two', original_name: 'two')
+
+    SurrogateModel.create_snapshot('original')
+
+    first.update_attributes!(name: 'uno')
+    third = SurrogateModel.create!(name: 'three', original_name: 'three')
+    second.destroy!
+
+    added,removed,changed = SurrogateModel.diff_snapshot(ignore: :id, unique_by: :original_name)
+
+    # we can find added and changed records by surrogate IDs but, of course, can't find removed ones
+    expect(added).to eq [third]
+    expect(added.first.original_attributes).to eq nil
+    expect(removed.map(&:attributes)).to eq [{"id" => nil, "name" => "two", "original_name" => "two", "alternate_value" => nil}]
+    expect(removed.first.original_attributes).to eq nil
+    expect(changed).to eq [first]
+    expect(changed.first.name).to eq 'uno'
+    expect(changed.first.original_attributes).to eq({"id" => nil, "name" => 'one', "original_name" => 'one', "alternate_value" => nil})
+  end
+
+  it "detects a changed field using a composite surrogate" do
+    first = SurrogateModel.create!(name: 'one', original_name: 'one', alternate_value: 1)
+    second = SurrogateModel.create!(name: 'one', original_name: 'one', alternate_value: 2)
+    third = SurrogateModel.create!(name: 'one', original_name: 'one', alternate_value: 3)
+
+    SurrogateModel.create_snapshot('original')
+
+    second.update_attributes!(name: 'uno')
+
+    added,removed,changed = SurrogateModel.diff_snapshot(ignore: :id, unique_by: [:original_name, 'alternate_value'])
+
+    expect(added).to eq []
+    expect(removed).to eq []
+    expect(changed).to eq [second]   # the alternate value should ensure we pick up the correct record
+  end
+end

data/spec/snapshot_spec.rb

@@ -47,4 +47,11 @@ describe TableDiffer do
     Model.delete_snapshots(to_delete)
     expect(Model.snapshots.sort).to eq ['models_21']
   end
+
+  it "deletes all snapshots" do
+    Model.create_snapshot('snapname')
+    expect(Model.snapshots.size).to eq 1
+    Model.delete_snapshots(:all)
+    expect(Model.snapshots.size).to eq 0
+  end
 end

data/spec/spec_helper.rb

@@ -23,6 +23,12 @@ RSpec.configure do |config|
       create_table :models do |table|
         table.column :name, :string
       end
+
+      create_table :surrogate_models do |table|
+        table.column :name, :string
+        table.column :original_name, :string
+        table.column :alternate_value, :string
+      end
     end
 
     # need to explicitly specify active_record since we don't have a database.yml?
@@ -44,6 +50,12 @@ RSpec.shared_context "model" do
   end
 end
 
+RSpec.shared_context "surrogate_model" do
+  class SurrogateModel < ActiveRecord::Base
+    include TableDiffer
+  end
+end
+
 =begin
   maybe later...
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_differ
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Scott Bronson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-27 00:00:00.000000000 Z
+date: 2014-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -100,6 +100,7 @@ files:
 - lib/table_differ.rb
 - lib/table_differ/version.rb
 - spec/diff_spec.rb
+- spec/remap_spec.rb
 - spec/snapshot_spec.rb
 - spec/spec_helper.rb
 - tablediffer.gemspec
@@ -130,5 +131,6 @@ summary: Take snapshots of database tables and compute the differences between t
   snapshots.
 test_files:
 - spec/diff_spec.rb
+- spec/remap_spec.rb
 - spec/snapshot_spec.rb
 - spec/spec_helper.rb