activehistory 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 643c618d011f3af9b72ba7a7fadf3a713aeb0cf4
-  data.tar.gz: bc2d64e5b59d78deb335733d46eef644defc2656
+  metadata.gz: 94d976170424ce9995a019e74e9475ce1036ee85
+  data.tar.gz: 3ed68d22d9444cab4a7d1536b5a6514d822a677d
 SHA512:
-  metadata.gz: 53870be2424fa9b20e5bea593fb7691f9cd9e92214d558039ec25122f20ef5eb399cdd406c655e71bc978a5fc62289302d8b8be402f3767c210af78245d332bd
-  data.tar.gz: 4d8b2f3dea6b2aac7922bc8d28868a4b7b6d4f52917d920559f3041ab10fee6e7a5c6fe1aaa661d34b215f5c7f7d8ae6d6690dba93b1bc92ea6b50f0338fed33
+  metadata.gz: 448baea6c2bc3e7d3d284491bfcaebf807ef3ac61fe021151065a88a4b6d38b02ef594a6ffe2b115b57fcef420032c4bfc74b3f0a08cbc6a76e7afba4e51b0b6
+  data.tar.gz: 202e03ba0ed75936b7ac9f66406f2b1e559449d2eeaa78299793cb65af0d6c18ff06b11da6b1e16931cfb74897dfbac628e416871b0c89cc172c80590653fffe

data/Gemfile.lock

@@ -4,6 +4,7 @@ PATH
     activehistory (0.1)
       activerecord (= 5.0.0.1)
       arel (~> 7.0)
+      globalid (~> 0.3.7)
 
 GEM
   remote: http://rubygems.org/
@@ -21,7 +22,7 @@ GEM
       tzinfo (~> 1.1)
     addressable (2.4.0)
     ansi (1.5.0)
-    arel (7.1.2)
+    arel (7.1.4)
     builder (3.2.2)
     concurrent-ruby (1.0.2)
     crack (0.4.3)
@@ -31,6 +32,8 @@ GEM
       activesupport (>= 3.0.0)
     faker (1.6.6)
       i18n (~> 0.5)
+    globalid (0.3.7)
+      activesupport (>= 4.1.0)
     hashdiff (0.3.0)
     i18n (0.7.0)
     json (1.8.3)
@@ -87,4 +90,4 @@ DEPENDENCIES
   webmock
 
 BUNDLED WITH
-   1.12.5
+   1.13.2

data/activehistory.gemspec

@@ -37,4 +37,5 @@ Gem::Specification.new do |s|
   # s.add_runtime_dependency 'cookie_store'
   s.add_runtime_dependency 'arel', '~> 7.0'
   s.add_runtime_dependency 'activerecord', '5.0.0.1'
-end
+  s.add_runtime_dependency 'globalid', '~> 0.3.7'
+end

data/lib/activehistory.rb

@@ -2,28 +2,41 @@ module ActiveHistory
   
   mattr_accessor :connection
   
+  UUIDV4 = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+  
   def self.configure(settings)
     @@connection = ActiveHistory::Connection.new(settings)
   end
   
   def self.configured?
-    class_variable_defined?(:@@connection)
+    class_variable_defined?(:@@connection) && !@@connection.nil?
   end
   
   def self.url
     @@connection.url
   end
 
-  def self.encapsulate(id_or_options=nil)
-    Thread.current[:activehistory_event] = id_or_options
+  def self.encapsulate(attributes_or_event={}, &block)
+    if attributes_or_event.is_a?(ActiveHistory::Event)
+      event = attributes_or_event
+    else
+      event = ActiveHistory::Event.new(attributes_or_event)
+    end
+
+    Thread.current[:activehistory_event] = event
+    
     yield
   ensure
-    if Thread.current[:activehistory_event].is_a?(ActiveHistory::Event)
+    if Thread.current[:activehistory_event] && !Thread.current[:activehistory_event].actions.empty?
       Thread.current[:activehistory_event].save!
     end
     Thread.current[:activehistory_event] = nil
   end
   
+  def self.current_event(timestamp: nil)
+    Thread.current[:activehistory_event]
+  end
+  
 end
 
 require 'activehistory/connection'

data/lib/activehistory/action.rb

@@ -1,17 +1,19 @@
 class ActiveHistory::Action
 
-  attr_accessor :type, :timestamp, :subject, :diff
+  attr_accessor :type, :timestamp, :subject_type, :subject_id, :diff
 
   def initialize(attrs)
     attrs.each do |k,v|
       self.send("#{k}=", v)
     end
+    self.diff ||= {}
   end
   
   def as_json
     {
-      diff: diff.as_json,
-      subject:   @subject,
+      diff:         diff.as_json,
+      subject_type: @subject_type,
+      subject_id:   @subject_id,
       timestamp:    @timestamp.iso8601(3),
       type:         @type
     }

data/lib/activehistory/adapters/active_record.rb

@@ -1,78 +1,135 @@
 module ActiveHistory::Adapter
   module ActiveRecord
     extend ActiveSupport::Concern
-  
+    
     class_methods do
     
       def self.extended(other)
-        other.before_save     :activehistory_start
-        other.before_destroy  :activehistory_start
-        
-        other.after_create  { activehistory_track(:create) }
-        other.after_update  { activehistory_track(:update) }
-        other.before_destroy { activehistory_track(:destroy) }
-        
-        other.after_commit  { activehistory_complete }
+        other.after_create      { activehistory_track(:create) }
+        other.after_update      { activehistory_track(:update) }
+        other.before_destroy    { activehistory_track(:destroy) }
       end
       
       def inherited(subclass)
         super
-        
         subclass.instance_variable_set('@activehistory', @activehistory.clone) if defined?(@activehistory)
       end
       
       def track(exclude: [], habtm_model: nil)
-        @activehistory = {exclude: Array(exclude), habtm_model: habtm_model}
+        options = { exclude: Array(exclude) }
+        options[:habtm_model] = habtm_model if habtm_model
+        @activehistory = options
       end
       
       def has_and_belongs_to_many(name, scope = nil, options = {}, &extension)
         super
+        name = name.to_s
         habtm_model = self.const_get("HABTM_#{name.to_s.camelize}")
         
         habtm_model.track habtm_model: {
           :left_side => { foreign_key: "#{base_class.name.underscore}_id", inverse_of: name.to_s },
-          name.to_s.singularize.to_sym => {inverse_of: self.name.underscore.pluralize.to_s}
+          name.to_s.singularize.to_sym => { inverse_of: self.name.underscore.pluralize.to_s }
         }
         
+
         callback = ->(method, owner, record) {
-          owner.activehistory_association_udpated(
-            record.class.reflect_on_association(owner.class.reflect_on_association(name.to_s).options[:inverse_of].to_s),
-            owner.id,
-            removed: [record.id],
-            timestamp: owner.activehistory_timestamp
-          )
-          record.activehistory_association_udpated(
-            owner.class.reflect_on_association(name.to_s),
-            record.id,
-            removed: [owner.id],
-            timestamp: owner.activehistory_timestamp
-          )
+          owner.activehistory_association_changed(name, removed: [record.id])
         }
         self.send("after_remove_for_#{name}=", Array(self.send("after_remove_for_#{name}")).compact + [callback])
       end
-    end
-    
-    def activehistory_id
-      "#{self.class.name}/#{id}"
+      
+      def activehistory_association_changed(id, reflection_or_relation_name, added: [], removed: [], timestamp: nil, type: :update, propagate: true)
+        return if removed.empty? && added.empty?
+        reflection = if reflection_or_relation_name.is_a?(String) || reflection_or_relation_name.is_a?(Symbol)
+          reflect_on_association(reflection_or_relation_name)
+        else
+          reflection_or_relation_name
+        end
+        puts "#{self}##{id}.#{reflection.name} +#{added.inspect} -#{removed.inspect}"
+        
+        action = ActiveHistory.current_event(timestamp: timestamp).action_for(self, id, { type: type, timestamp: timestamp })
+      
+        if reflection.collection?
+          diff_key = "#{reflection.name.to_s.singularize}_ids"
+          action.diff[diff_key] ||= [[], []]
+          action.diff[diff_key][0] |= removed
+          action.diff[diff_key][1] |= added
+        else
+          diff_key = "#{reflection.name.to_s.singularize}_id"
+          action.diff[diff_key] ||= [removed.first, added.first]
+        end
+
+      
+        if propagate && inverse_reflection = reflection.inverse_of
+          inverse_klass = inverse_reflection.active_record
+          
+          added.each do |added_id|
+            inverse_klass.activehistory_association_changed(added_id, inverse_reflection, {
+              added: [id],
+              timestamp: timestamp,
+              type: type,
+              propagate: false
+            })
+          end
+        
+          removed.each do |removed_id|
+            inverse_klass.activehistory_association_changed(removed_id, inverse_reflection, {
+              removed: [id],
+              timestamp: timestamp,
+              type: type,
+              propagate: false
+            })
+          end
+        end
+      end
+      
     end
     
     def activehistory_timestamp
       @activehistory_timestamp ||= Time.now.utc
     end
     
-    def activehistory_start
-      if activehistory_tracking && !instance_variable_defined?(:@activehistory_finish)
-        @activehistory_finish = !Thread.current[:activehistory_event]
-      end
+    def with_transaction_returning_status
       @activehistory_timestamp = Time.now.utc
-    end
-    
-    def activehistory_complete
+      if !Thread.current[:activehistory_save_lock]
+        run_save = true
+        Thread.current[:activehistory_save_lock] = true
+        if !Thread.current[:activehistory_event]
+          destroy_current_event = true
+          Thread.current[:activehistory_event] = ActiveHistory::Event.new(timestamp: @activehistory_timestamp)
+        end
+      end
+
+      status = nil
+      self.class.transaction do
+        add_to_transaction
+        begin
+          status = yield
+        rescue ::ActiveRecord::Rollback
+          clear_transaction_record_state
+          status = nil
+        end
+
+        if status
+          if run_save && ActiveHistory.configured? && !activehistory_event.actions.empty?
+            activehistory_event&.save!
+          end
+        else
+          raise ::ActiveRecord::Rollback
+        end
+      end
+      status
+    ensure
       @activehistory_timestamp = nil
-      if instance_variable_defined?(:@activehistory_finish) && @activehistory_finish && activehistory_tracking
-        activehistory_event.save! if activehistory_event
+      if run_save
+        Thread.current[:activehistory_save_lock] = false
+      end
+      if destroy_current_event
         Thread.current[:activehistory_event] = nil
-        @activehistory_timestamp = nil
+      end
+
+      if @transaction_state && @transaction_state.committed?
+        clear_transaction_record_state
       end
     end
     
@@ -83,16 +140,7 @@ module ActiveHistory::Adapter
     end
     
     def activehistory_event
-      case Thread.current[:activehistory_event]
-      when ActiveHistory::Event
-        Thread.current[:activehistory_event]
-      when Hash
-        Thread.current[:activehistory_event][:timestamp] ||= @activehistory_timestamp
-        Thread.current[:activehistory_event] = ActiveHistory::Event.new(Thread.current[:activehistory_event])
-      when Fixnum
-      else
-        Thread.current[:activehistory_event] = ActiveHistory::Event.new(timestamp: @activehistory_timestamp)
-      end
+      ActiveHistory.current_event(timestamp: activehistory_timestamp)
     end
     
     def activehistory_track(type)
@@ -111,92 +159,268 @@ module ActiveHistory::Adapter
         diff = self.attributes.select { |k| !activehistory_tracking[:exclude].include?(k.to_sym) }.map { |k, i| [k, [i, nil]] }.to_h
       end
       
-      return if type == :update && diff.size == 0
+      return if type == :update && (diff.keys - (self.send(:timestamp_attributes_for_update) + self.send(:timestamp_attributes_for_create)).map(&:to_s)).empty?
       
-      if !activehistory_tracking[:habtm_model]
-        activehistory_event.action!({
+      if activehistory_tracking[:habtm_model]
+        if type == :create
+          self.class.reflect_on_association(:left_side).klass.activehistory_association_changed(
+            self.send(activehistory_tracking[:habtm_model][:left_side][:foreign_key]),
+            activehistory_tracking[:habtm_model][:left_side][:inverse_of],
+            added: [self.send((self.class.column_names - [activehistory_tracking[:habtm_model][:left_side][:foreign_key]]).first)],
+            timestamp: activehistory_timestamp
+          )
+        end
+      else
+        activehistory_event.action_for(self.class, id, {
           type: type,
-          subject: self.activehistory_id,
           diff: diff,
-          timestamp: @activehistory_timestamp
+          timestamp: activehistory_timestamp
         })
-      end
-      
-      self._reflections.each do |key, reflection|
-        foreign_key = activehistory_tracking.dig(:habtm_model, reflection.name, :foreign_key) || reflection.foreign_key
-
-        if areflection = self.class.reflect_on_association(reflection.name)
-          if areflection.macro == :has_and_belongs_to_many && type == :create
-            self.send("#{areflection.name.to_s.singularize}_ids").each do |fid|
-              next unless fid
-              activehistory_association_udpated(areflection, fid, added: [diff['id'][1]], timestamp: activehistory_timestamp)
-              activehistory_association_udpated(areflection.klass.reflect_on_association(areflection.options[:inverse_of]), diff['id'][1], added: [fid], timestamp: activehistory_timestamp, type: :create)
+        
+        
+        self.class.reflect_on_all_associations.each do |reflection|
+          next if activehistory_tracking[:habtm_model]
+          
+          if reflection.macro == :has_and_belongs_to_many && type == :destroy
+            activehistory_association_changed(reflection, removed: self.send("#{reflection.name.to_s.singularize}_ids"))
+          elsif reflection.macro == :belongs_to && diff.has_key?(reflection.foreign_key)
+            case type
+            when :create
+              old_id = nil
+              new_id = diff[reflection.foreign_key][1]
+            when :destroy
+              old_id = diff[reflection.foreign_key][0]
+              new_id = nil
+            else
+              old_id = diff[reflection.foreign_key][0]
+              new_id = diff[reflection.foreign_key][1]
             end
-          elsif areflection.macro == :has_and_belongs_to_many && type == :destroy
-            self.send("#{areflection.name.to_s.singularize}_ids").each do |fid|
-              activehistory_association_udpated(areflection, fid, removed: [diff['id'][0]], timestamp: activehistory_timestamp, type: :update)
-              activehistory_association_udpated(areflection.klass.reflect_on_association(areflection.options[:inverse_of]), diff['id'][0], removed: [fid], timestamp: activehistory_timestamp, type: :update)
+            
+            relation_id = self.id || diff.find { |k, v| k != foreign_key }[1][1]
+            
+            if reflection.polymorphic?
+            else
+              activehistory_association_changed(reflection, removed: [old_id]) if old_id
+              activehistory_association_changed(reflection, added:   [new_id]) if new_id
             end
+            
           end
         end
-        
-        next unless reflection.macro == :belongs_to && (type == :destroy || diff.has_key?(foreign_key))
-        
-        case type
-        when :create
-          old_id = nil
-          new_id = diff[foreign_key][1]
-        when :destroy
-          old_id = diff[foreign_key][0]
-          new_id = nil
-        else
-          old_id = diff[foreign_key][0]
-          new_id = diff[foreign_key][1]
-        end
-        
-        relation_id = self.id || diff.find { |k, v| k != foreign_key }[1][1]
-        
-        if reflection.polymorphic?
-        else
-          activehistory_association_udpated(reflection, old_id, removed: [relation_id], timestamp: activehistory_timestamp) if old_id
-          activehistory_association_udpated(reflection, new_id, added:   [relation_id], timestamp: activehistory_timestamp) if new_id
-        end
-        
       end
+
       
     end
 
+    def activehistory_association_changed(relation_name, added: [], removed: [], timestamp: nil, type: :update)
+      timestamp ||= activehistory_timestamp
+      
+      self.class.activehistory_association_changed(id, relation_name, {
+        added: added,
+        removed: removed,
+        timestamp: timestamp,
+        type: type
+      })
+      
+      
+    end
+    
     def activehistory_association_udpated(reflection, id, added: [], removed: [], timestamp: nil, type: :update)
-      if inverse_of = activehistory_tracking.dig(:habtm_model, reflection.name, :inverse_of)
-        inverse_of = reflection.klass.reflect_on_association(inverse_of)
+      return if !activehistory_tracking || (removed.empty? && added.empty?)
+      klass = reflection.active_record
+      inverse_klass = reflection.klass
+      
+      inverse_association = if activehistory_tracking.has_key?(:habtm_model)
+        inverse_klass.reflect_on_association(activehistory_tracking.dig(:habtm_model, reflection.name.to_s.singularize.to_sym, :inverse_of))
       else
-        inverse_of = reflection.inverse_of
+        reflection.inverse_of
       end
-
-      if inverse_of.nil?
+      
+      if inverse_association.nil?
         puts "NO INVERSE for #{self.class}.#{reflection.name}!!!"
         return
       end
       
-      model_name = reflection.klass.base_class.model_name.name
-      
-      action = activehistory_event.action_for("#{model_name}/#{id}") || activehistory_event.action!({
+      action = activehistory_event.action_for(klass, id, {
         type: type,
-        subject: "#{model_name}/#{id}",
-        timestamp: timestamp# || Time.now
+        timestamp: timestamp
       })
       
       action.diff ||= {}
-      if inverse_of.collection? || activehistory_tracking[:habtm_model]
-        diff_key = "#{inverse_of.name.to_s.singularize}_ids"
+      if (reflection.collection? || activehistory_tracking[:habtm_model])
+        diff_key = "#{reflection.name.to_s.singularize}_ids"
         action.diff[diff_key] ||= [[], []]
         action.diff[diff_key][0] |= removed
         action.diff[diff_key][1] |= added
       else
-        diff_key = "#{inverse_of.name.to_s.singularize}_id"
+        diff_key = "#{reflection.name.to_s.singularize}_id"
         action.diff[diff_key] ||= [removed.first, added.first]
       end
+      
+      removed.each do |removed_id|
+        action = activehistory_event.action_for(inverse_klass, removed_id, {
+          type: type,
+          timestamp: timestamp
+        })
+      
+        action.diff ||= {}
+        if inverse_association.collection? || activehistory_tracking[:habtm_model]
+          diff_key = "#{inverse_association.name.to_s.singularize}_ids"
+          action.diff[diff_key] ||= [[], []]
+          action.diff[diff_key][0] |= [id]
+        else
+          diff_key = "#{inverse_association.name.to_s.singularize}_id"
+          action.diff[diff_key] ||= [id, nil]
+        end
+      end
+      
+      added.each do |added_id|
+        action = activehistory_event.action_for(inverse_klass, added_id, {
+          type: type,
+          timestamp: timestamp
+        })
+      
+        action.diff ||= {}
+        if inverse_association.collection? || activehistory_tracking[:habtm_model]
+          diff_key = "#{inverse_association.name.to_s.singularize}_ids"
+          action.diff[diff_key] ||= [[], []]
+          action.diff[diff_key][1] |= [id]
+        else
+          diff_key = "#{inverse_association.name.to_s.singularize}_id"
+          action.diff[diff_key] ||= [nil, id]
+        end
+      end
     end
 
   end
-end
+end
+
+
+module ActiveRecord
+  module Associations
+    class CollectionAssociation
+      
+      def delete_all(dependent = nil)
+        activehistory_encapsulate do
+          if dependent && ![:nullify, :delete_all].include?(dependent)
+            raise ArgumentError, "Valid values are :nullify or :delete_all"
+          end
+
+          dependent = if dependent
+                        dependent
+                      elsif options[:dependent] == :destroy
+                        :delete_all
+                      else
+                        options[:dependent]
+                      end
+
+          if dependent == :delete_all
+
+          else
+            removed_ids = self.scope.pluck(:id)
+          
+            action = owner.activehistory_event.action_for(self.reflection.active_record, owner.id, {
+              type: :update,
+              timestamp: owner.activehistory_timestamp
+            })
+            
+            diff_key = "#{self.reflection.name.to_s.singularize}_ids"
+            action.diff ||= {}
+            action.diff[diff_key] ||= [[], []]
+            action.diff[diff_key][0] |= removed_ids
+          
+            ainverse_of = self.klass.reflect_on_association(self.options[:inverse_of])
+            if ainverse_of
+              removed_ids.each do |removed_id|
+                action = owner.activehistory_event.action_for(ainverse_of.active_record, removed_id, {
+                  type: :update,
+                  timestamp: owner.activehistory_timestamp
+                })
+                action.diff ||= {}
+                if ainverse_of.collection?
+                  diff_key = "#{ainverse_of.name.to_s.singularize}_ids"
+                  action.diff[diff_key] ||= [[], []]
+                  action.diff[diff_key][0] |= [owner.id]
+                else
+                  diff_key = "#{ainverse_of.name}_id"
+                  action.diff[diff_key] ||= [owner.id, nil]
+                end
+              end
+            end
+          end
+
+          delete_or_nullify_all_records(dependent).tap do
+            reset
+            loaded!
+          end
+        end
+      end
+      
+      private
+      
+      def replace_records(new_target, original_target)
+        activehistory_encapsulate do
+          removed_records = target - new_target
+          added_records = new_target - target
+        
+          delete(removed_records)
+
+          unless concat(added_records)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
+        
+          if !owner.new_record?
+            owner.activehistory_association_changed(self.reflection, added: added_records.map(&:id), removed: removed_records.map(&:id))
+          end
+        end
+        
+        target
+      end
+      
+      def delete_or_destroy(records, method)
+        activehistory_encapsulate do
+          records = records.flatten
+          records.each { |record| raise_on_type_mismatch!(record) }
+          existing_records = records.reject(&:new_record?)
+
+          result = if existing_records.empty?
+            remove_records(existing_records, records, method)
+          else
+            transaction { remove_records(existing_records, records, method) }
+          end
+        end
+      end
+      
+      def activehistory_encapsulate
+        @activehistory_timestamp = Time.now.utc
+        if !Thread.current[:activehistory_save_lock]
+          run_save = true
+          Thread.current[:activehistory_save_lock] = true
+          if !Thread.current[:activehistory_event]
+            destroy_current_event = true
+            Thread.current[:activehistory_event] = ActiveHistory::Event.new(timestamp: @activehistory_timestamp)
+          end
+        end
+      
+        result = yield
+
+        if run_save && ActiveHistory.configured?  && !owner.activehistory_event.actions.empty?
+          owner.activehistory_event&.save!
+        end
+
+        result
+      ensure
+        @activehistory_timestamp = nil
+        if run_save
+          Thread.current[:activehistory_save_lock] = false
+        end
+        if destroy_current_event
+          Thread.current[:activehistory_event] = nil
+        end
+        
+      end
+      
+    end
+  end
+end