tree_diff 1.0.0

checksums.yaml

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

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'minitest'
+  gem 'm'
+  gem 'sqlite3'
+  gem 'activerecord'
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    concurrent-ruby (1.1.5)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    m (1.5.1)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (0.9.2)
+    minitest (5.11.3)
+    rake (12.3.2)
+    sqlite3 (1.4.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  m
+  minitest
+  sqlite3
+
+BUNDLED WITH
+   1.17.3

data/lib/tree_diff.rb

@@ -0,0 +1,201 @@
+class TreeDiff
+  Mold = Class.new
+
+  class Change
+    attr_reader :path, :old, :new
+
+    def initialize(path, old, new)
+      @path = path
+      @old = old
+      @new = new
+    end
+  end
+
+  def self.original_observations
+    class_variable_set(:@@original_observations, nil) unless class_variable_defined?(:@@original_observations)
+    class_variable_get(:@@original_observations)
+  end
+
+  def self.observations
+    class_variable_set(:@@observations, nil) unless class_variable_defined?(:@@observations)
+    class_variable_get(:@@observations)
+  end
+
+  def self.conditions
+    class_variable_set(:@@conditions, nil) unless class_variable_defined?(:@@conditions)
+    class_variable_get(:@@conditions)
+  end
+
+  def self.observe(*defs)
+    class_variable_set(:@@original_observations, defs)
+    class_variable_set(:@@observations, [])
+    observe_chain [], defs
+  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
+        end
+      else
+        observations << chain + [method_name]
+      end
+    end
+  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)
+  end
+
+  def initialize(original_object)
+    check_observations
+
+    self.class.class_variable_set(:@@conditions, [])
+    @old_object_as_mold = create_mold Mold.new, original_object, self.class.original_observations
+    @current_object = original_object
+  end
+
+  def saw_any_change?
+    changes.present?
+  end
+
+  def changes
+    iterate_observations(@old_object_as_mold, @current_object)
+  end
+
+  def changes_as_objects
+    changes.map { |c| Change.new(c.fetch(:path), c.fetch(:old), c.fetch(:new)) }
+  end
+
+  def changed_paths
+    changes_as_objects.map(&:path)
+  end
+
+  def changes_at(path)
+    changes_as_objects.detect { |c| c.path == path }
+  end
+
+  private
+
+  def check_observations
+    if self.class == TreeDiff
+      raise 'TreeDiff is an abstract class - write a child class with observations'
+    end
+
+    if 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 }
+        end
+      else
+        mold.define_singleton_method(a, &copied_value(source_object, a))
+      end
+    end
+
+    mold
+  end
+
+  def copied_value(object, attribute_name)
+    source_value = object.public_send(attribute_name)
+
+    # TODO This properly clones hashes but is a dependency on Rails. Figure out a better way.
+    source_value = source_value.deep_dup
+
+    -> { source_value }
+  end
+
+  def iterate_observations(mold, current_object)
+    self.class.observations.each.with_object([]) do |path, changes|
+      old_obj_and_method = try_path mold, path
+      new_obj_and_method = try_path current_object, path, mold
+
+      old_value = call_method_on_object(old_obj_and_method, path)
+      new_value = call_method_on_object(new_obj_and_method, path)
+
+      changes << {path: path, old: old_value, new: new_value} if old_value != new_value
+    end
+  end
+
+  def call_method_on_object(object_and_method, path)
+    callable = method_caller_with_condition(path)
+
+    if object_and_method.is_a?(Array)
+      object_and_method.each.with_object([]) do |r, c|
+        result = callable.(r)
+        c << result if result
+      end
+    else
+      result = callable.(object_and_method)
+      result
+    end
+  end
+
+  def method_caller_with_condition(path)
+    ->(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))
+      end
+    end
+  end
+
+  # By design this tries to be as loosely typed and flexible as possible. Sometimes, calling an attribute
+  # name on a collection of them yields an enumerable object. For example, active record's enum column returns
+  # a hash indicating the enumeration definition. That would lead to incorrectly comparing this value, a hash,
+  # rather than the actual data point in each item of the collection.
+  #
+  # I overcome this by passing the mold, or the original object, as a reference, and following each result of
+  # 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)
+
+    if result.respond_to?(:each)
+      result.map.with_index do |o, idx|
+        ref = reference_result[idx] if reference_result
+        try_path(o, path[1..-1], ref)
+      end
+    else
+      {object: result, method_name: path.last}
+    end
+  end
+
+  # Execute the call chain given by path. i.e. [:method, :foo, :bar] until just before the last method
+  def follow_call_chain(receiver, chain, reference)
+    chain[0...-1].each do |method_name|
+      if receiver.respond_to?(method_name) && (!reference || reference.respond_to?(method_name))
+        receiver = receiver.public_send(method_name)
+        reference = reference.public_send(method_name) if reference
+      end
+    end
+
+    [receiver, reference]
+  end
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+ActiveRecord::Schema.define do
+  create_table :orders, force: true do |t|
+    t.string :number
+  end
+
+  create_table :line_items, force: true do |t|
+    t.string :description
+    t.integer :price_usd_cents
+    t.belongs_to :order, index: true
+  end
+end
+
+# Define the models
+class Order < ActiveRecord::Base
+  has_many :line_items, inverse_of: :order
+  accepts_nested_attributes_for :line_items, allow_destroy: true
+end
+
+class LineItem < ActiveRecord::Base
+  belongs_to :order, inverse_of: :line_items
+end

data/test/tree_diff_test.rb

@@ -0,0 +1,29 @@
+require_relative '../lib/tree_diff'
+require 'helper'
+require 'minitest/autorun'
+
+class TreeDiffTest < Minitest::Test
+  class OrderDiff < TreeDiff
+    observe :number, line_items: [:description, :price_usd_cents]
+  end
+
+  def test_todo
+    thing = LineItem.new(description: 'thing', price_usd_cents: 1234)
+    other_thing = LineItem.new(description: 'other thing', price_usd_cents: 5678)
+    order = Order.create!(number: 'XYZ123', line_items: [thing, other_thing])
+
+    diff = OrderDiff.new(order)
+
+    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},
+                                          {description: 'new thing', price_usd_cents: 1357}])
+
+    assert_equal [[:line_items, :description],
+                  [:line_items, :price_usd_cents]], 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
+  end
+end

data/tree_diff.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = 'tree_diff'
+  s.version     = '1.0.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 " \
+                  "call chain. Call just before and after you make a change. Completely ORM and framework agnostic."
+  s.authors     = ["Michael Nelson"]
+  s.email       = 'michael@nelsonware.com'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- test/*`.split("\n")
+  s.homepage    = 'https://gitlab.com/mcnelson/tree_diff'
+  s.license     = 'MIT'
+
+  # s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 2.5.1' # TODO
+
+  s.add_development_dependency "minitest", "~> 5.11"
+  s.add_development_dependency "m", "~> 1.5"
+  s.add_development_dependency "sqlite3", "~> 1.4"
+  s.add_development_dependency "activerecord", "~> 5.2"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: tree_diff
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: Given a tree of relationships in a similar format to strong params, analyzes
+  attribute changes by call chain. Call just before and after you make a change. Completely
+  ORM and framework agnostic.
+email: michael@nelsonware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- lib/tree_diff.rb
+- test/helper.rb
+- test/tree_diff_test.rb
+- tree_diff.gemspec
+homepage: https://gitlab.com/mcnelson/tree_diff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Observe attribute changes in big complex object trees, like a generic & standalone
+  ActiveModel::Dirty
+test_files:
+- test/helper.rb
+- test/tree_diff_test.rb