tree_diff 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e1a59222b215b096b927b8278b6be165ff26d96f6e7c9a6714996b459b8f5b4
-  data.tar.gz: cb2363e020e496f6f8a8380fed116f0dbeb544140145e8584f3840bdd17109c8
+  metadata.gz: e3699e4d25cd4ef5e40056955c4cb5a72f34d022d91d0cdcf1987cc285f338be
+  data.tar.gz: 0f9da5732ba16921b1dfbd46e16051618787b6369a287536f8ced41c8a137282
 SHA512:
-  metadata.gz: '08d71f0379f871769f2a039d5f1856252f48bbbab5574fa2b4ad7d7939a919e56a608ee8527a3ff4496a24615f517620b4b0a6077ec9ab88ef1e370328d0ca3e'
-  data.tar.gz: c30c915a69acb00c0399909ae57143d732de9d82535373ff6b88270aea8f7ca539c77cfb0d784be2ec09803d725897466aae4e24b11cc44fd5807b176e636378
+  metadata.gz: 8183fd052ac83c3142b200caf071facbeb3be93585e184456f6d78a1967fda9986869997284e605221bc0111272bc018b77fbc5bc1f4d20a5417634f438c4e3c
+  data.tar.gz: dfb3b3ae7a125ecdba7224f1c5036499e81b2fbbc8bf9ceec9773a09796896c9e5c116816df78c198d5366a337dd86c118208d540645a72f51f55cda3640a2ae

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Michael Nelson
+
+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/lib/tree_diff.rb

@@ -32,11 +32,22 @@ class TreeDiff
     observe_chain [], defs
   end
 
+  def self.condition(path, &condition)
+    class_variable_set(:@@conditions, []) unless conditions
+    conditions << [path, condition]
+  end
+
+  def self.condition_for(path)
+    return unless (condition = conditions.detect { |c| c.first == path })
+
+    condition.last # A stored block (proc)
+  end
+
   def self.observe_chain(chain, attributes)
     attributes.each do |method_name|
       if method_name.respond_to?(:keys)
         method_name.each do |child_method, child_attributes|
-          observe_chain chain + [child_method], child_attributes
+          observe_chain chain + [child_method], keep_as_array(child_attributes)
         end
       else
         observations << chain + [method_name]
@@ -45,16 +56,10 @@ class TreeDiff
   end
   private_class_method :observe_chain
 
-  def self.condition(path, &condition)
-    class_variable_set(:@@conditions, []) unless conditions
-    conditions << [path, condition]
-  end
-
-  def self.condition_for(path)
-    return unless (condition = conditions.detect { |c| c.first == path })
-
-    condition.last # A stored block (proc)
+  def self.keep_as_array(input)
+    input.is_a?(Array) ? input : [input]
   end
+  private_class_method :keep_as_array
 
   def initialize(original_object)
     check_observations
@@ -91,40 +96,42 @@ class TreeDiff
       raise 'TreeDiff is an abstract class - write a child class with observations'
     end
 
-    if self.class.original_observations.empty?
+    if !self.class.original_observations || self.class.original_observations.empty?
       raise 'you need to define some observations first'
     end
   end
 
   def create_mold(mold, source_object, attributes)
-    attributes.each do |a|
-      if a.respond_to?(:keys)
-        a.each do |key, child_attributes|
-          source_value = source_object.public_send(key)
-
-          mold_or_molds = if source_value.respond_to?(:each) # 1:many
-                            source_value.map do |val|
-                              create_mold(Mold.new, val, child_attributes)
-                            end
-                          else # 1:1
-                            create_mold(Mold.new, source_value, child_attributes)
-                          end
-
-          mold.define_singleton_method(key) { mold_or_molds }
+    attributes.each do |attribute|
+      if attribute.respond_to?(:keys)
+        attribute.each do |attribute_name, child_attributes|
+          mold_or_molds = mold_relationship(source_object, attribute_name, child_attributes)
+          mold.define_singleton_method(attribute_name) { mold_or_molds }
         end
       else
-        mold.define_singleton_method(a, &copied_value(source_object, a))
+        mold.define_singleton_method(attribute, &call_and_copy_value(source_object, attribute))
       end
     end
 
     mold
   end
 
-  def copied_value(object, attribute_name)
-    source_value = object.public_send(attribute_name)
+  def mold_relationship(source_object, relationship_name, relationship_attributes)
+    source_value = source_object.public_send(relationship_name)
+    relationship_attributes = [relationship_attributes] unless relationship_attributes.is_a?(Array)
+
+    if source_value.respond_to?(:each) # 1:many
+      source_value.map do |v|
+        create_mold(Mold.new, v, relationship_attributes)
+      end
+    else # 1:1
+      create_mold(Mold.new, source_value, relationship_attributes)
+    end
+  end
 
-    # TODO This properly clones hashes but is a dependency on Rails. Figure out a better way.
-    source_value = source_value.deep_dup
+  def call_and_copy_value(receiver, method_name)
+    source_value = receiver.public_send(method_name)
+    source_value = Marshal.load(Marshal.dump(source_value)) # Properly clones hashes
 
     -> { source_value }
   end
@@ -145,7 +152,8 @@ class TreeDiff
     callable = method_caller_with_condition(path)
 
     if object_and_method.is_a?(Array)
-      object_and_method.each.with_object([]) do |r, c|
+      # TODO: Flatten is kind of a hack? Revisit this..
+      object_and_method.flatten.each.with_object([]) do |r, c|
         result = callable.(r)
         c << result if result
       end
@@ -159,8 +167,8 @@ class TreeDiff
     ->(object_and_method) do
       condition = self.class.condition_for(path)
 
-      if !condition || condition.call(object_and_method.fetch(:object))
-        object_and_method.fetch(:object).public_send(object_and_method.fetch(:method_name))
+      if !condition || condition.call(object_and_method.fetch(:receiver))
+        object_and_method.fetch(:receiver).public_send(object_and_method.fetch(:method_name))
       end
     end
   end
@@ -174,8 +182,8 @@ class TreeDiff
   # the call chain on not only the changed/current object, but that original object too. The mold is created
   # with correct 1:many relationships and does not have the aforementioned problem, so by verifying the path
   # against the mold first, we avoid that issue.
-  def try_path(object, path, mold_as_reference = nil)
-    result, reference_result = follow_call_chain(object, path, mold_as_reference)
+  def try_path(receiver, path, mold_as_reference = nil)
+    result, reference_result = follow_call_chain(receiver, path, mold_as_reference)
 
     if result.respond_to?(:each)
       result.map.with_index do |o, idx|
@@ -183,7 +191,7 @@ class TreeDiff
         try_path(o, path[1..-1], ref)
       end
     else
-      {object: result, method_name: path.last}
+      {receiver: result, method_name: path.last}
     end
   end
 

data/test/helper.rb

@@ -15,14 +15,90 @@ ActiveRecord::Schema.define do
     t.integer :price_usd_cents
     t.belongs_to :order, index: true
   end
+
+  create_table :item_categories, force: true do |t|
+    t.string :short_name
+    t.string :description
+    t.integer :ordering
+    t.belongs_to :line_item, index: true
+  end
+
+  create_table :deliveries, force: true do |t|
+    t.time :at
+    t.integer :quantity
+  end
+
+  create_table :orders_vehicles, force: true do |t|
+    t.datetime :created_at
+    t.belongs_to :order, index: true
+    t.belongs_to :vehicle, polymorphic: true
+  end
+
+  create_table :trucks, force: true do |t|
+    t.integer :number
+    t.integer :capacity
+  end
+
+  create_table :delivery_bikes, force: true do |t|
+    t.integer :max_speed
+    t.string :maintenance_status
+  end
 end
 
 # Define the models
 class Order < ActiveRecord::Base
   has_many :line_items, inverse_of: :order
+  has_many :orders_vehicles
+
+  has_many :trucks, through: :orders_vehicles, source: :vehicle, source_type: "Vehicle", class_name: "Truck"
+
   accepts_nested_attributes_for :line_items, allow_destroy: true
 end
 
 class LineItem < ActiveRecord::Base
   belongs_to :order, inverse_of: :line_items
+  has_many :item_categories
+
+  accepts_nested_attributes_for :item_categories, allow_destroy: true
+end
+
+class ItemCategory < ActiveRecord::Base
+  belongs_to :line_item, inverse_of: :item_categories
+end
+
+class Delivery < ActiveRecord::Base
+end
+
+class OrdersVehicle < ActiveRecord::Base
+  belongs_to :order, inverse_of: :orders_vehicles
+  belongs_to :vehicle, polymorphic: true
+end
+
+class Truck < ActiveRecord::Base
+end
+
+class DeliveryBike < ActiveRecord::Base
+end
+
+module HashInitialization
+  def initialize(hash)
+    hash.each do |k, v|
+      public_send("#{k}=", v)
+    end
+  end
+end
+
+class Table
+  include HashInitialization
+  attr_accessor :wood_finish
+end
+
+class WoodFinish
+  include HashInitialization
+  attr_accessor :color, :cost, :applied_at, :blemishes, :cost_mapping
+end
+
+class Blemish
+  include HashInitialization
+  attr_accessor :severity
 end

data/test/tree_diff_test.rb

@@ -3,12 +3,48 @@ require 'helper'
 require 'minitest/autorun'
 
 class TreeDiffTest < Minitest::Test
+  class DeliveryDiff < TreeDiff
+    observe :at, :quantity
+  end
+
   class OrderDiff < TreeDiff
-    observe :number, line_items: [:description, :price_usd_cents]
+    observe :number, line_items: [:description, :price_usd_cents, item_categories: [:description]]
+  end
+
+  class OrderVehicleDiff < TreeDiff
+    observe trucks: [:number], orders_vehicles: [{vehicle: [:id]}]
+  end
+
+  class OmittingArraysDiff < TreeDiff
+    observe :number, orders_vehicles: {vehicle: :id}
   end
 
-  def test_todo
-    thing = LineItem.new(description: 'thing', price_usd_cents: 1234)
+  class TableDiff < TreeDiff
+    observe wood_finish: [:color, :cost, :applied_at, :cost_mapping,
+                          blemishes: [:severity]]
+  end
+
+  class EmptyDiff < TreeDiff
+  end
+
+  def test_simple_one_table
+    delivery = Delivery.create!(at: '12:30', quantity: 50)
+
+    diff = DeliveryDiff.new(delivery)
+
+    assert_empty diff.changes
+
+    delivery.update!(at: '1:30')
+
+    assert_equal [[:at]], diff.changed_paths
+    assert_equal [{path: [:at], old: Time.gm(2000, 1, 1, 12, 30), new: Time.gm(2000, 1, 1, 1, 30)}], diff.changes
+  end
+
+  def test_big_tree
+    foo_category = ItemCategory.new(description: 'foo')
+    bar_category = ItemCategory.new(description: 'bar')
+
+    thing = LineItem.new(description: 'thing', price_usd_cents: 1234, item_categories: [foo_category, bar_category])
     other_thing = LineItem.new(description: 'other thing', price_usd_cents: 5678)
     order = Order.create!(number: 'XYZ123', line_items: [thing, other_thing])
 
@@ -17,13 +53,93 @@ class TreeDiffTest < Minitest::Test
     assert_empty diff.changes
 
     order.update!(line_items_attributes: [{id: thing.id, description: 'thing', price_usd_cents: 1234, _destroy: true},
-                                          {id: other_thing.id, description: 'other thing', price_usd_cents: 5678},
+                                          {id: other_thing.id, description: 'other thing', price_usd_cents: 5678,
+                                           item_categories_attributes: [{description: 'foo'}]},
                                           {description: 'new thing', price_usd_cents: 1357}])
 
     assert_equal [[:line_items, :description],
-                  [:line_items, :price_usd_cents]], diff.changed_paths
+                  [:line_items, :price_usd_cents],
+                  [:line_items, :item_categories, :description]], diff.changed_paths
 
     assert_equal [{path: [:line_items, :description], old: ["thing", "other thing"], new: ["other thing", "new thing"]},
-                  {path: [:line_items, :price_usd_cents], old: [1234, 5678], new: [5678, 1357]}], diff.changes
+                  {path: [:line_items, :price_usd_cents], old: [1234, 5678], new: [5678, 1357]},
+                  {path: [:line_items, :item_categories, :description], old: ['foo', 'bar'], new: ['foo']}], diff.changes
+  end
+
+  def test_polymorphic_path
+    truck = Truck.new(number: 123, capacity: 55)
+    other_truck = Truck.new(number: 456, capacity: 25)
+    order = Order.create!(number: 'XYZ123', trucks: [truck])
+
+    diff = OrderVehicleDiff.new(order)
+
+    assert_empty diff.changes
+
+    order.update!(trucks: [])
+
+    assert_equal [[:trucks, :number],
+                  [:orders_vehicles, :vehicle, :id]], diff.changed_paths
+
+    changes = diff.changes_as_objects
+    assert_equal [123], changes.first.old
+    assert_equal [], changes.first.new
+
+    assert_kind_of Integer, changes.last.old.first
+    assert_equal [], changes.last.new
+  end
+
+  def test_omitting_arrays_of_child_attributes
+    truck = Truck.new(number: 123, capacity: 55)
+    order = Order.create!(number: 'XYZ123', trucks: [truck])
+
+    diff = OmittingArraysDiff.new(order)
+
+    assert_empty diff.changes
+
+    order.update!(number: 'ZYX987')
+
+    assert_equal [{:path => [:number], :old => "XYZ123", :new => "ZYX987"}], diff.changes
+  end
+
+  def test_poro_tree
+    blemish = Blemish.new(severity: 'super_bad')
+    wood_finish = WoodFinish.new(color: 'mahogany',
+                                 cost: 500.0,
+                                 applied_at: Time.now.utc,
+                                 blemishes: [blemish],
+                                 cost_mapping: {mahogany: 500.0,
+                                                pine: 250.0,
+                                                plywood: 60.0})
+
+    table = Table.new(wood_finish: wood_finish)
+
+    diff = TableDiff.new(table)
+
+    wood_finish = table.wood_finish
+    wood_finish.blemishes.first.severity = 'not_that_bad'
+    wood_finish.cost_mapping[:pine] = 200.0
+
+    assert_equal [{:path => [:wood_finish, :cost_mapping],
+                   :old => {mahogany: 500.0, pine: 250.0, plywood: 60.0},
+                   :new => {mahogany: 500.0, pine: 200.0, plywood: 60.0}},
+                  {:path => [:wood_finish, :blemishes, :severity],
+                   :old => ["super_bad"],
+                   :new => ["not_that_bad"]}], diff.changes
+  end
+
+  def test_abstract_class
+    e = assert_raises RuntimeError do
+      TreeDiff.new(Object.new)
+    end
+
+    assert_includes e.message, 'is an abstract'
+  end
+
+  def test_requires_observations
+    e = assert_raises RuntimeError do
+      EmptyDiff.new(Object.new)
+    end
+
+    assert_includes e.message, 'some observations first'
   end
 end

data/tree_diff.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'tree_diff'
-  s.version     = '1.0.0'
+  s.version     = '1.1.0'
   s.date        = '2019-07-13'
   s.summary     = "Observe attribute changes in big complex object trees, like a generic & standalone ActiveModel::Dirty"
   s.description = "Given a tree of relationships in a similar format to strong params, analyzes attribute changes by " \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tree_diff
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Michael Nelson
@@ -77,6 +77,7 @@ files:
 - ".ruby-version"
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - lib/tree_diff.rb
 - test/helper.rb
 - test/tree_diff_test.rb