recorder 0.1.23 → 1.1.0

data/lib/recorder/rails/controller_concern.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Recorder
   module Rails
     # Extensions to rails controllers. Provides convenient ways to pass certain
@@ -8,7 +10,7 @@ module Recorder
         base.before_action :set_recorder_meta
       end
 
-    protected
+      protected
 
       # Returns the user who is responsible for any changes that occur.
       # By default this calls `current_user` and returns the result.
@@ -17,6 +19,7 @@ module Recorder
       # method, e.g. `current_person`, or anything you like.
       def recorder_user_id
         return unless defined?(current_user)
+
         current_user.try!(:id)
       rescue NoMethodError
         current_user
@@ -24,10 +27,10 @@ module Recorder
 
       def recorder_info
         {
-          :user_id => self.recorder_user_id,
-          :ip => request.remote_ip,
-          :action_date => Date.current,
-          :meta => self.recorder_meta
+          user_id: recorder_user_id,
+          ip: request.remote_ip,
+          action_date: Date.current,
+          meta: recorder_meta
         }
       end
 
@@ -40,11 +43,11 @@ module Recorder
       # Tells Recorder any information from the controller you want to store
       # alongside any changes that occur.
       def set_recorder_info
-        ::Recorder.info = self.recorder_info
+        ::Recorder.info = recorder_info
       end
 
       def set_recorder_meta
-        ::Recorder.meta = self.recorder_meta
+        ::Recorder.meta = recorder_meta
       end
     end
   end

data/lib/recorder/rails/railtie.rb

@@ -1,7 +1,11 @@
-class Recorder::Rails::Railtie < Rails::Railtie
-  initializer "recorder.configure" do |app|
-    if defined?(Sidekiq)
-      require 'recorder/sidekiq/revisions_worker'
+# frozen_string_literal: true
+
+module Recorder
+  module Rails
+    class Railtie < Rails::Railtie
+      initializer 'recorder.configure' do |_app|
+        require 'recorder/sidekiq/revisions_worker' if defined?(Sidekiq)
+      end
     end
   end
 end

data/lib/recorder/revision.rb

@@ -1,72 +1,93 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
-class Recorder::Revision < ActiveRecord::Base
-  self.table_name = 'recorder_revisions'
-
-  if ::Recorder.active_record_protected_attributes?
-    attr_accessible(
-      :event,
-      :user_id,
-      :ip,
-      :user_agent,
-      :action_date,
-      :data,
-      :meta
-    )
-  end
+module Recorder
+  class Revision < ActiveRecord::Base
+    self.table_name = 'recorder_revisions'
 
-  belongs_to :item, :polymorphic => true, :inverse_of => :revisions
-  belongs_to :user
+    if ::Recorder.active_record_protected_attributes?
+      attr_accessible(
+        :event,
+        :user_id,
+        :ip,
+        :user_agent,
+        :action_date,
+        :data,
+        :meta
+      )
+    end
 
-  validates :item, :presence => true
-  validates :event, :presence => true
-  validates :action_date, :presence => true
-  validates :data, :presence => true
+    belongs_to :user
 
-  scope :ordered_by_created_at, -> { order(:created_at => :desc) }
+    validates :item_type, presence: true
+    validates :event, presence: true
+    validates :action_date, presence: true
+    validates :data, presence: true
 
-  # Get changeset for an item
-  # @return [Recorder::Changeset]
-  def item_changeset
-    return @item_changeset if defined?(@item_changeset)
-    return nil if self.data['changes'].nil?
+    scope :ordered_by_created_at, -> { order(created_at: :desc) }
 
-    @item_changeset ||= self.changeset_class(self.item).new(self.item, self.data['changes'])
-  end
+    def item
+      return @item if defined?(@item)
+      return if item_id.nil?
 
-  # Get names of item associations that has been changed
-  # @return [Array]
-  def changed_associations
-    self.data['associations'].try(:keys) || []
-  end
+      @item = item_type.classify.constantize.new(data['attributes'])
 
-  # Get changeset for an association
-  # @param name [String] name of association to return changeset
-  # @return [Recorder::Changeset]
-  def association_changeset(name)
-    association = self.item.send(name)
-    # association = association.source if association.decorated?
+      if data['associations'].present?
+        data['associations'].each do |name, association|
+          @item.send("build_#{name}", association['attributes'])
+        end
+      end
 
-    self.changeset_class(association).new(association, self.data['associations'].fetch(name.to_s).try(:fetch, 'changes'))
-  end
+      @item
+    end
 
-protected
+    # Get changeset for an item
+    # @return [Recorder::Changeset]
+    def item_changeset
+      return @item_changeset if defined?(@item_changeset)
+      return nil if item.nil?
+      return nil if data['changes'].nil?
 
-  # Returns changeset class for passed object.
-  # Changeset class name can be overriden with `#recorder_changeset_class` method.
-  # If `#recorder_changeset_class` method is not defined, then class name is generated as "#{class}Changeset"
-  # @api private
-  def changeset_class(object)
-    klass = (defined?(Draper) && object.decorated?) ? object.source.class : object.class
-    klass = klass.base_class
+      @item_changeset ||= changeset_class(item).new(item, data['changes'])
+    end
 
-    if klass.respond_to?(:recorder_changeset_class)
-      return klass.send(:recorder_changeset_class)
+    # Get names of item associations that has been changed
+    # @return [Array]
+    def changed_associations
+      data['associations'].try(:keys) || []
     end
 
-    klass = "#{klass}Changeset"
+    # Get changeset for an association
+    # @param name [String] name of association to return changeset
+    # @return [Recorder::Changeset]
+    def association_changeset(name)
+      association = item.send(name)
+      # association = association.source if association.decorated?
 
-    klass = klass.constantize rescue nil
-    klass.present? ? klass : Recorder::Changeset
+      changeset_class(association).new(association, data['associations'].fetch(name.to_s).try(:fetch, 'changes'))
+    end
+
+    protected
+
+    # Returns changeset class for passed object.
+    # Changeset class name can be overriden with `#recorder_changeset_class` method.
+    # If `#recorder_changeset_class` method is not defined, then class name is generated as "#{class}Changeset"
+    # @api private
+    def changeset_class(object)
+      klass = defined?(Draper) && object.decorated? ? object.source.class : object.class
+      klass = klass.base_class
+
+      return klass.send(:recorder_changeset_class) if klass.respond_to?(:recorder_changeset_class)
+
+      klass = "#{klass}Changeset"
+
+      klass = begin
+        klass.constantize
+      rescue
+        nil
+      end
+      klass.present? ? klass : Recorder::Changeset
+    end
   end
 end

data/lib/recorder/sidekiq/revisions_worker.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Recorder
   module Sidekiq
     class RevisionsWorker
@@ -5,9 +7,8 @@ module Recorder
 
       sidekiq_options Recorder.config.sidekiq_options
 
-      def perform(klass, id, params)
-        object = klass.constantize.find_by(:id => id)
-        object.revisions.create(params) if object.present?
+      def perform(params)
+        Recorder::Revision.create(params)
       end
     end
   end

data/lib/recorder/store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'request_store'
+
+module Recorder
+  class Store
+    def params
+      store[:params]
+    end
+
+    def recorder_enabled!
+      store[:enabled] = true
+    end
+
+    def recorder_disabled!
+      store[:enabled] = false
+    end
+
+    def recorder_enabled?
+      store[:enabled]
+    end
+
+    def recorder_disabled?
+      !store[:enabled]
+    end
+
+    private
+
+    def store
+      RequestStore.store[:recorder] ||= {
+        enabled: true,
+        params: {}
+      }
+    end
+  end
+end

data/lib/recorder/tape/data.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Recorder
+  class Tape
+    class Data
+      attr_reader :item
+
+      def initialize(item)
+        @item = item
+      end
+
+      def data_for(event, options = {})
+        {
+          **attributes_for(event, options),
+          **changes_for(event, options),
+          **associations_for(event, options)
+        }
+      end
+
+      def attributes_for(_event, options)
+        {attributes: sanitize_attributes(item.attributes, options)}
+      end
+
+      def changes_for(event, options)
+        changes =
+          case event.to_sym
+          when :update
+            sanitize_attributes(item.saved_changes, options)
+          end
+
+        changes.present? ? {changes: changes} : {}
+      end
+
+      def associations_for(event, options)
+        associations = parse_associations_attributes(event, options)
+
+        associations.present? ? {associations: associations} : {}
+      end
+
+      private
+
+      def sanitize_attributes(attributes, options)
+        if options[:only].present?
+          only = wrap_options(options[:only])
+          attributes.symbolize_keys.slice(*only)
+        elsif options[:ignore].present?
+          ignore = wrap_options(options[:ignore])
+          attributes.symbolize_keys.except(*ignore)
+        else
+          attributes.symbolize_keys.except(*Recorder.config.ignore)
+        end
+      end
+
+      def wrap_options(values)
+        Array.wrap(values).map(&:to_sym)
+      end
+
+      def parse_associations_attributes(event, options)
+        return unless options[:associations]
+
+        options[:associations].each_with_object({}) do |(association, options), hash|
+          name, data = parse_association(event, association, options)
+
+          hash[name] = data if data.any?
+        end
+      end
+
+      def parse_association(event, association, options)
+        reflection = item.class.reflect_on_association(association)
+
+        if reflection.present?
+          if reflection.collection?
+
+          elsif (object = item.send(association))
+            data = Recorder::Tape::Data.new(object).data_for(event, options || {})
+
+            [reflection.name, data]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/recorder/tape/record.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Recorder
+  class Tape
+    module Record
+      def record(params, options = {})
+        return if Recorder.store.recorder_disabled?
+
+        params = params_for(params)
+
+        if async?(options)
+          record_async(params, options)
+        else
+          Recorder::Revision.create(params)
+        end
+      end
+
+      private
+
+      def params_for(params)
+        Recorder.store.params.merge({
+          action_date: Date.today,
+          **params
+        })
+      end
+
+      def async?(options)
+        options[:async].nil? ? Recorder.config.async : options[:async]
+      end
+
+      def record_async(params, options)
+        Recorder::Sidekiq::RevisionsWorker.perform_in(
+          options[:delay] || 2.seconds,
+          params
+        )
+      end
+    end
+  end
+end

data/lib/recorder/tape.rb

@@ -1,105 +1,58 @@
+# frozen_string_literal: true
+
+require 'recorder/tape/data'
+require 'recorder/tape/record'
+
 module Recorder
   class Tape
-    attr_reader :item
+    extend Record
 
-    def initialize(item)
-      @item = item;
+    attr_reader :item, :data
 
-      self.item.instance_variable_set(:@recorder_dirty, true)
-    end
-
-    def changes_for(event)
-      changes = case event.to_sym
-      when :create
-        self.sanitize_attributes(self.item.attributes)
-      when :update
-        self.sanitize_attributes(self.item.changes)
-      when :destroy
-        self.sanitize_attributes(self.item.changes)
-      else
-        raise ArgumentError
-      end
+    def initialize(item)
+      @item = item
+      @data = Data.new(item)
 
-      changes.any? ? { :changes => changes } : {}
+      item.instance_variable_set(:@recorder_dirty, true)
     end
 
     def record_create
-      data = self.changes_for(:create)
-
-      associations_attributes = self.parse_associations_attributes(:create)
-      data.merge!(:associations => associations_attributes) if associations_attributes.present?
+      data = data_for(:create, recorder_options)
 
-      if data.any?
-        self.record(
-          Recorder.store.merge({
-            :event => :create,
-            :data => data
-          })
-        )
-      end
+      record(event: :create, data: data) if data.any?
     end
 
     def record_update
-      data = self.changes_for(:update)
+      data = data_for(:update, recorder_options)
 
-      associations_attributes = self.parse_associations_attributes(:update)
-      data.merge!(:associations => associations_attributes) if associations_attributes.present?
-
-      if data.any?
-        self.record(
-          Recorder.store.merge({
-            :event => :update,
-            :data => data
-          })
-        )
-      end
+      record(event: :update, data: data) if data.any?
     end
 
     def record_destroy
-    end
+      data = data_for(:destroy, recorder_options)
 
-  protected
+      record(event: :destroy, data: data) if data.any?
+    end
 
-    def record(params)
-      params.merge!({
-        :action_date => Date.today
-      })
+    protected
 
-      if self.item.recorder_options[:async]
-        self.item.revisions.create_async(params)
-      else
-        self.item.revisions.create(params)
-      end
+    def recorder_options
+      item.respond_to?(:recorder_options) ? item.recorder_options : {}
     end
 
-    def sanitize_attributes(attributes = {})
-      if self.item.respond_to?(:recorder_options) && self.item.recorder_options[:ignore].present?
-        ignore = Array.wrap(self.item.recorder_options[:ignore]).map(&:to_sym)
-        attributes.symbolize_keys.except(*ignore)
-      else
-        attributes.symbolize_keys.except(*Recorder.config.ignore)
-      end
+    def data_for(event, options)
+      data.data_for(event, options)
     end
 
-    def parse_associations_attributes(event)
-      if self.item.respond_to?(:recorder_options) && self.item.recorder_options[:associations].present?
-        self.item.recorder_options[:associations].inject({}) do |hash, association|
-          reflection = self.item.class.reflect_on_association(association)
-          if reflection.present?
-            if reflection.collection?
-
-            else
-              if object = self.item.send(association)
-                changes = Recorder::Tape.new(object).changes_for(event)
-                hash[reflection.name] =  changes if changes.any?
-                object.instance_variable_set(:@recorder_dirty, false)
-              end
-            end
-          end
-
-          hash
-        end
-      end
+    def record(params)
+      Recorder::Tape.record(
+        {
+          item_type: item.class.to_s,
+          item_id: item.id,
+          **params
+        },
+        item.recorder_options
+      )
     end
   end
 end