effective_logging 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c1119cce5caf2fb9dca0d4eb7411b47c37bbf1a
-  data.tar.gz: ae41f8263546dee230f0f52527d81ae590c083da
+  metadata.gz: 20e9e57d5a67995068422a609568b3124e6bab4b
+  data.tar.gz: be6fdf6286b4b661881e13e529b8f7ce220cdccf
 SHA512:
-  metadata.gz: 12de1d7714145177529bfe2ce9d4d258c7ecdb790bc116246b4daf01452d4f1ff70a4c5bf79d6c67cbacbd90891368aa23874e7809cedc0efd06c7b6e6f49441
-  data.tar.gz: eca3118328ae97ffdd3c835236477ffe2d4c465de367fe83f664cadada66be41bcc412fe588a62d8aeac790837e3a3ec18e5ebe0f78bf6fc17967667a7ae8201
+  metadata.gz: eb7025f50e12b1fca55f87a66ae177b923a0d06800d9b3fa1fc0979e08b97a48976e31c341a2f522d521c49d487ccdf652be893a7c98c0644eefe5af421f9269
+  data.tar.gz: 744819fb3d4dd1d27c02064c5cd09ce504c650a3cb91d96c1aed298d5810b3bcabc79ce24abac6e3b7d517672cd3da89d9e850c8d63f9dad5649b03114e78ccf

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2018 Code and Effect Inc.
+Copyright 2019 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -233,9 +233,7 @@ class Post < ActiveRecord::Base
 end
 ```
 
-There is some initial support for passing `only`, `except`, and `additionally` to the mixin to customize what attributes are saved.
-
-Define your model with `log_changes additionally: [:method1, :method2]` to also _always_ log the value of that method. Even if it's unchanged.
+There is some initial support for passing `only`, and `except`, to the mixin to customize what attributes are saved.
 
 Apply your own formatting to the logged title of each attribute by creating an instance method on the resource:
 

data/app/datatables/effective_log_changes_datatable.rb

@@ -0,0 +1,43 @@
+class EffectiveLogChangesDatatable < Effective::Datatable
+  datatable do
+    order :updated_at
+
+    col :updated_at, label: 'Date'
+    col :id, visible: false
+
+    col :user, sort: false
+
+    col :associated_type, visible: false
+    col :associated_id, visible: false
+    col :associated_to_s, visible: false
+
+    col :message, sort: false do |log|
+      message = log.message.gsub("\n", '<br>')
+
+      if log.associated_id == attributes[:changes_to_id] && log.associated_type == attributes[:changes_to_type]
+        message
+      else
+        "#{log.associated_type} #{log.associated_to_s} - #{message}"
+      end
+
+    end.search do |collection, term, column, sql_column|
+      collection.where("associated_type #{resource.ilike} ? OR associated_to_s #{resource.ilike} ? OR message #{resource.ilike} ?", "%#{term}%", "%#{term}%", "%#{term}%")
+    end
+
+    col :details, visible: false, sort: false do |log|
+      tableize_hash(log.details)
+    end
+
+    unless attributes[:actions] == false
+      actions_col partial: 'admin/logs/actions', partial_as: :log
+    end
+  end
+
+  # A nil attributes[:log_id] means give me all the top level log entries
+  # If we set a log_id then it's for sub logs
+  collection do
+    Effective::Log.logged_changes.deep
+      .where(changes_to_type: attributes[:changes_to_type], changes_to_id: attributes[:changes_to_id])
+  end
+
+end

data/app/datatables/effective_logs_datatable.rb

@@ -17,18 +17,12 @@ class EffectiveLogsDatatable < Effective::Datatable
       col :status, search: { collection: EffectiveLogging.statuses }
     end
 
-    unless attributes[:log_changes]
-      col :associated_type, search: { as: :string }
-      col :associated_id, search: { as: :integer }, visible: false, label: 'Associated Id'
-      col :associated_to_s, search: { as: :string }, label: 'Associated'
-    end
+    col :associated_type, search: { as: :string }
+    col :associated_id, search: { as: :integer }, visible: false, label: 'Associated Id'
+    col :associated_to_s, search: { as: :string }, label: 'Associated'
 
-    if attributes[:log_changes]
-      col :message do |log|
-        log.message.starts_with?("\t") ? log.message.gsub("\t", "&nbsp;&nbsp;") : log.message
-      end
-    else
-      col :message
+    col :message do |log|
+      log.message.gsub("\n", '<br>')
     end
 
     col :logs_count, visible: false
@@ -47,10 +41,6 @@ class EffectiveLogsDatatable < Effective::Datatable
   collection do
     scope = Effective::Log.deep.where(parent_id: attributes[:log_id])
 
-    if attributes[:log_changes]
-      scope = scope.where(status: EffectiveLogging.log_changes_status)
-    end
-
     if attributes[:for]
       user_ids = Array(attributes[:for])
       scope = scope.where('user_id IN (?) OR (associated_id IN (?) AND associated_type = ?)', user_ids, user_ids, 'User')

data/app/models/concerns/acts_as_loggable.rb

@@ -9,7 +9,7 @@ module ActsAsLoggable
         raise ArgumentError.new('invalid arguments passed to (effective_logging) log_changes. Example usage: log_changes except: [:created_at]')
       end
 
-      if (unknown = (@acts_as_loggable_options.keys - [:only, :except, :additionally, :include_associated, :include_nested])).present?
+      if (unknown = (@acts_as_loggable_options.keys - [:to, :prefix, :only, :except])).present?
         raise ArgumentError.new("unknown keyword: #{unknown.join(', ')}")
       end
 
@@ -18,64 +18,52 @@ module ActsAsLoggable
   end
 
   included do
-    has_many :logged_changes, -> { order(:id).where(status: EffectiveLogging.log_changes_status) }, as: :associated, class_name: 'Effective::Log'
+    has_many :logged_changes, -> { order(:id).where(status: EffectiveLogging.log_changes_status) }, as: :changes_to, class_name: 'Effective::Log'
 
     log_changes_options = {
-      only: Array(@acts_as_loggable_options[:only]).map { |attribute| attribute.to_s },
-      except: Array(@acts_as_loggable_options[:except]).map { |attribute| attribute.to_s },
-      additionally: Array(@acts_as_loggable_options[:additionally]).map { |attribute| attribute.to_s },
-      include_associated: @acts_as_loggable_options.fetch(:include_associated, true),
-      include_nested: @acts_as_loggable_options.fetch(:include_nested, true)
+      to: @acts_as_loggable_options[:to],
+      prefix: @acts_as_loggable_options[:prefix],
+      only: Array(@acts_as_loggable_options[:only]),
+      except: Array(@acts_as_loggable_options[:except])
     }
 
     if name == 'User'
-      log_changes_options[:except] += %w(sign_in_count current_sign_in_at current_sign_in_ip last_sign_in_at last_sign_in_ip encrypted_password remember_created_at reset_password_token invitation_sent_at invitation_created_at invitation_token)
+      log_changes_options[:except] += %i(sign_in_count current_sign_in_at current_sign_in_ip last_sign_in_at last_sign_in_ip encrypted_password remember_created_at reset_password_token invitation_sent_at invitation_created_at invitation_token)
     end
 
     self.send(:define_method, :log_changes_options) { log_changes_options }
 
     after_create(unless: -> { EffectiveLogging.supressed? }) do
-      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).execute!
+      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).created!
     end
 
     after_destroy(unless: -> { EffectiveLogging.supressed? }) do
-      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).execute!
+      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).destroyed!
     end
 
     after_update(unless: -> { EffectiveLogging.supressed? }) do
-      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).execute!
+      ::EffectiveLogging::ActiveRecordLogger.new(self, log_changes_options).updated!
     end
   end
 
   module ClassMethods
+    def acts_as_loggable?; true; end
   end
 
   # Regular instance methods
 
   # Format the title of this attribute. Return nil to use the default attribute.titleize
   def log_changes_formatted_attribute(attribute)
-    if attribute == 'roles_mask' && defined?(EffectiveRoles) && respond_to?(:roles)
-      'Roles'
-    end
+    'Roles' if attribute == 'roles_mask' && defined?(EffectiveRoles) && respond_to?(:roles)
   end
 
   # Format the value of this attribute. Return nil to use the default to_s
   def log_changes_formatted_value(attribute, value)
-    if attribute == 'roles_mask' && defined?(EffectiveRoles) && respond_to?(:roles)
-      EffectiveRoles.roles_for(value)
-    end
+    EffectiveRoles.roles_for(value) if attribute == 'roles_mask' && defined?(EffectiveRoles) && respond_to?(:roles)
   end
 
   def log_changes_datatable
-    return nil unless persisted?
-
-    @log_changes_datatable ||= (
-      EffectiveLogsDatatable.new(associated_id: id, associated_type: self.class.name, log_changes: true, status: false)
-    )
-  end
-
-  def refresh_datatables
-    @refresh_datatables ||= [:effective_logs]
+    EffectiveLogChangesDatatable.new(changes_to_id: id, changes_to_type: self.class.name) if persisted?
   end
 
 end

data/app/models/effective/log.rb

@@ -12,6 +12,8 @@ module Effective
     has_many :logs, class_name: 'Effective::Log', foreign_key: :parent_id
 
     belongs_to :user
+
+    belongs_to :changes_to, polymorphic: true # This is the log_changes to: option
     belongs_to :associated, polymorphic: true
 
     serialize :details, Hash
@@ -19,10 +21,13 @@ module Effective
     # Attributes
     # logs_count          :integer  # Rails Counter Cache
 
+    # changes_to_type     :string
+    # changes_to_id       :string
+
     # associated_type     :string
     # associated_id       :integer
     # associated_to_s     :string
-    # message             :string
+    # message             :text
     # details             :text
     # status              :string
     # timestamps
@@ -39,10 +44,6 @@ module Effective
       "Log #{id}"
     end
 
-    def message=(msg)
-      write_attribute(:message, msg.kind_of?(String) ? msg.to_s[0...255] : msg)
-    end
-
     def log(message, status = EffectiveLogging.statuses.first, options = {})
       EffectiveLogger.log(message, status, (options || {}).merge(parent: self))
     end

data/app/views/effective/logs/_log.html.haml

@@ -5,7 +5,7 @@
         - parents_of_log(log).each do |parent|
           = link_to(log.message, request.fullpath.sub('/' + log.to_param, '/' + parent.to_param))
           = ' > '
-        %p= log.message.html_safe
+        %p= log.message.to_s.gsub("\n", '<br>').html_safe
 
       .col-md-4.text-right
         - if log.prev_log

data/db/migrate/01_create_effective_logging.rb.erb

@@ -5,13 +5,16 @@ class CreateEffectiveLogging < ActiveRecord::Migration[4.2]
 
       t.integer       :user_id
 
+      t.string        :changes_to_type
+      t.integer       :changes_to_id
+
       t.string        :associated_type
       t.integer       :associated_id
       t.string        :associated_to_s
 
       t.integer       :logs_count
 
-      t.string        :message
+      t.text          :message
       t.text          :details
 
       t.string        :status

data/lib/effective_logging/active_record_logger.rb

@@ -1,179 +1,89 @@
 module EffectiveLogging
   class ActiveRecordLogger
-    attr_accessor :object, :resource, :logger, :depth, :include_associated, :include_nested, :log_parents, :options
+    attr_accessor :object, :resource, :options
 
     BLANK = "''"
+    BLACKLIST = [:updated_at, :created_at, :encrypted_password, :status_steps] # Don't log changes or attributes
 
-    def initialize(object, options = {})
-      raise ArgumentError.new('options must be a Hash') unless options.kind_of?(Hash)
-
+    def initialize(object, to: nil, prefix: nil, only: nil, except: nil)
       @object = object
       @resource = Effective::Resource.new(object)
 
-      @logger = options.fetch(:logger, object)
-      @depth = options.fetch(:depth, 0)
-      @include_associated = options.fetch(:include_associated, true)
-      @include_nested = options.fetch(:include_nested, true)
-      @log_parents = options.fetch(:log_parents, true)
-      @options = options
-
-      raise ArgumentError.new('logger must respond to logged_changes') unless @logger.respond_to?(:logged_changes)
-    end
-
-    def execute!
-      @logged = false
-
-      if new_record?(object)
-        created!
-      elsif destroyed_record?(object)
-        destroyed!
-      else
-        updated!
+      # Validate changes_to value
+      if to.present? && !@resource.belong_tos.map(&:name).include?(to)
+        raise ArgumentError.new("unable to find existing belongs_to relationship matching #{to}. Expected a symbol matching a belongs_to.")
       end
 
-      logged?
+      @options = { to: to, prefix: prefix, only: only, except: Array(except) + BLACKLIST }.compact
     end
 
+    # Effective::Log.where(message: 'Deleted').where('details ILIKE ?', '%lab_test_id: 263%')
     def destroyed!
-      log('Deleted', applicable(instance_attributes))
+      log('Deleted', resource_attributes)
     end
 
     def created!
-      log('Created', applicable(instance_attributes))
+      log('Created', resource_attributes)
     end
 
     def updated!
-      log_resource_changes!
-      log_nested_resources!
-
-      (logged? && depth == 0) ? log('Updated', applicable(instance_attributes)) : true
-    end
-
-    def log_resource_changes!
-      applicable(resource.instance_changes).each do |attribute, (before, after)|
-        if object.respond_to?(:log_changes_formatted_value)
-          before = object.log_changes_formatted_value(attribute, before) || before
-          after = object.log_changes_formatted_value(attribute, after) || after
-        end
-
-        before = before.to_s if before.kind_of?(ActiveRecord::Base) || before.kind_of?(FalseClass)
-        after = after.to_s if after.kind_of?(ActiveRecord::Base) || after.kind_of?(FalseClass)
+      changes = resource_changes
 
-        attribute = if object.respond_to?(:log_changes_formatted_attribute)
-          object.log_changes_formatted_attribute(attribute)
-        end || attribute.titleize
-
-        log("#{attribute}: #{before.presence || BLANK} → #{after.presence || BLANK}", { attribute: attribute, before: before, after: after })
-      end
-    end
+      return true if changes.blank? # If you just click save and change nothing, don't log it.
 
-    def log_nested_resources!
-      return unless include_nested
+      message = (['Updated'] + changes.map do |attribute, (before, after)|
+        "#{attribute}: #{before.presence || BLANK} → #{after.presence || BLANK}"
+      end).join("\n")
 
-      # Log changes on all accepts_as_nested_parameters has_many associations
-      resource.nested_resources.each do |association|
-        title = association.name.to_s.singularize.titleize
-
-        Array(object.send(association.name)).each_with_index do |child, index|
-          next unless child.present?
-
-          child_options = options.merge(logger: logger, depth: depth+1, prefix: "#{title} #{index} - #{child} - ", include_associated: include_associated, include_nested: include_nested)
-          child_options = child_options.merge(child.log_changes_options) if child.respond_to?(:log_changes_options)
-
-          @logged = true if ActiveRecordLogger.new(child, child_options).execute!
-        end
-      end
+      log(message, resource_attributes.merge(changes: changes))
     end
 
     def log(message, details)
-      log = logger.logged_changes.build(
+      Effective::Log.create!(
+        changes_to: log_changes_to,
+        associated: object,
+        associated_to_s: (object.to_s rescue nil),
         user: EffectiveLogging.current_user,
         status: EffectiveLogging.log_changes_status,
-        message: "#{"\t" * depth}#{options[:prefix]}#{message}",
-        associated_to_s: (logger.to_s rescue nil),
+        message: [options[:prefix].presence, message].compact.join,
         details: (details.presence || {})
       )
+    end
 
-      log_changes_to_parents(message, details) if depth == 0 && log_parents
+    private
 
-      @logged = log.save!
-      log
-    end
+    def log_changes_to
+      logger = object
 
-    def log_changes_to_parents(message, details)
-      log_changes_parents.each do |parent|
-        title = object.class.name.to_s.singularize.titleize
-        parent_options = { logger: parent, prefix: "#{title} - #{object} - " }
-        ActiveRecordLogger.new(parent, parent_options).log(message, details)
+      while(logger.log_changes_options[:to].present?)
+        belongs_to = logger.public_send(logger.log_changes_options[:to])
+        break unless belongs_to.respond_to?(:log_changes_options)
+        logger = belongs_to
       end
-    end
 
-    private
-
-    def logged?
-      @logged == true
+      logger
     end
 
-    def instance_attributes # effective_resources gem
-      resource.instance_attributes(include_associated: include_associated, include_nested: include_nested)
+    def resource_attributes # effective_resources gem
+      resource.instance_attributes(only: options[:only], except: options[:except])
     end
 
-    # A parent is a belongs_to that accepts_nested_attributes for this resource
-    def log_changes_parents
-      resource.belong_tos.map do |association|
-        parent_klass = (association.options[:polymorphic] ? object.public_send(association.name).class : association.klass)
-
-        # Skip if the parent doesn't log_changes
-        next unless parent_klass.respond_to?(:log_changes)
-
-        # Skip unless the parent accepts_nested_attributes
-        next unless Effective::Resource.new(parent_klass).nested_resources.find { |ass| ass.plural_name == resource.plural_name }
-
-        parent = object.public_send(association.name).presence
-
-        # Sanity check
-        next unless parent.respond_to?(:log_changes_options)
-
-        # Skip if the parent does not log its nested or associated items
-        next unless parent.log_changes_options[:include_nested] || parent.log_changes_options[:include_associated]
-
-        parent
-      end.compact
-    end
+    def resource_changes # effective_resources gem
+      resource.instance_changes(only: options[:only], except: options[:except]).inject({}) do |h, (attribute, (before, after))|
+        if object.respond_to?(:log_changes_formatted_value)
+          before = object.log_changes_formatted_value(attribute, before) || before
+          after = object.log_changes_formatted_value(attribute, after) || after
+        end
 
-    # TODO: Make this work better with nested objects
-    def applicable(attributes)
-      atts = if options[:only].present?
-        attributes.stringify_keys.slice(*options[:only])
-      elsif options[:except].present?
-        attributes.stringify_keys.except(*options[:except])
-      else
-        attributes.except(:updated_at, :created_at, 'updated_at', 'created_at')
-      end
+        before = before.to_s if before.kind_of?(ActiveRecord::Base) || before.kind_of?(FalseClass)
+        after = after.to_s if after.kind_of?(ActiveRecord::Base) || after.kind_of?(FalseClass)
 
-      (options[:additionally] || []).each do |attribute|
-        value = (object.send(attribute) rescue :effective_logging_nope)
-        next if attributes[attribute].present? || value == :effective_logging_nope
+        attribute = if object.respond_to?(:log_changes_formatted_attribute)
+          object.log_changes_formatted_attribute(attribute)
+        end || attribute.to_s.titleize
 
-        atts[attribute] = value
+        h[attribute] = [before, after]; h
       end
-
-      # Blacklist
-      atts.except(:logged_changes, :trash, :updated_at, :status_steps, 'logged_changes', 'trash', 'updated_at', 'status_steps')
-    end
-
-    def new_record?(object)
-      return true if object.respond_to?(:new_record?) && object.new_record?
-      return true if object.respond_to?(:id_was) && object.id_was.nil?
-      return true if object.respond_to?(:previous_changes) && object.previous_changes.key?('id') && object.previous_changes['id'].first.nil?
-      false
-    end
-
-    def destroyed_record?(object)
-      return true if object.respond_to?(:destroyed?) && object.destroyed?
-      return true if object.respond_to?(:marked_for_destruction?) && object.marked_for_destruction?
-      return true if object.respond_to?(:previous_changes) && object.previous_changes.key?('id') && object.previous_changes['id'].last.nil?
-      false
     end
   end
 

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '2.1.2'.freeze
+  VERSION = '3.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-24 00:00:00.000000000 Z
+date: 2019-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,6 +94,7 @@ files:
 - app/assets/javascripts/effective_logging/effective_logger.js.coffee.erb
 - app/controllers/admin/logs_controller.rb
 - app/controllers/effective/logs_controller.rb
+- app/datatables/effective_log_changes_datatable.rb
 - app/datatables/effective_logs_datatable.rb
 - app/helpers/effective_logging_helper.rb
 - app/models/concerns/acts_as_loggable.rb