effective_logging 1.11.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 937a74b79730479f2f0994cc786d8eabff3903dc
-  data.tar.gz: 63dc477e50b0f04be570827151e9d5d7eaaf39f0
+  metadata.gz: ee73b0a26f21fe2980801d4b8e901ec547ae7721
+  data.tar.gz: 46e1f46fac857042523878446ea3c364e138d887
 SHA512:
-  metadata.gz: e38a2c8bde33e965ada2d85341e23fc13d5062d99bf6bc184cc9710538c3dd29dae792b49dc1b5c4ec19c938cc8e4070add8d160ab3e6da43e1b7cae5904dc8f
-  data.tar.gz: 614b8ae1532afe2f49b1dc292a461a4430806db91ec676ab80cc8a0e3c0f48b78049ba45598a0dede8bca0cdd673cc120e8f10f75b5a37f2d8fdb92a016af9d5
+  metadata.gz: daaddf8064d083684ca67c8629f210d5cde233ff0d4c03cc39b428cdd3f078599417c5b121aa82dcbe7a5e23a37c26e5e954025b3ba4b74cf41a12805b17ec2c
+  data.tar.gz: c7a757f10c577b05c8069f822a3f2427c8a2e0cb9d14e0f4cda880a8cb33f806c0ab6681d844b98eb02e7a5dd8e97b037c3a54ffdfb89d8eb88f056630d910f6

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2017 Code and Effect Inc.
+Copyright 2018 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

@@ -2,8 +2,6 @@
 
 Automatically log all sent emails, user logins, and page views. This also will log custom events from Ruby and JavaScript.
 
-A Rails3 / Rails4 engine to completely handle logging of events.
-
 Logs are stored in a single database table. A Log (one logged event) can have many children Logs, nested to any depth.
 
 Provides a ruby one-liner to log a message, status, user, associated object and any number of additional details.
@@ -294,13 +292,7 @@ Creating child logs via JavaScript is not yet supported.
 
 ## Admin Screen
 
-To use the Admin screen, please also install the [effective_datatables](https://github.com/code-and-effect/effective_datatables/) gem:
-
-```ruby
-gem 'effective_datatables'
-```
-
-Then you should be able to visit:
+Visit:
 
 ```ruby
 link_to 'Logs', effective_logging.admin_logs_path   # /admin/logs
@@ -341,22 +333,10 @@ EffectiveLogsDatatable.new(for: @user.id)
 EffectiveLogsDatatable.new(for: [1, 2, 3])  # Users with ID 1, 2 and 3
 ```
 
-
 ## License
 
 MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 
-## Testing
-
-The test suite for this gem is unfortunately not yet complete.
-
-Run tests by:
-
-```ruby
-rake spec
-```
-
-
 ## Contributing
 
 1. Fork it

data/app/controllers/admin/logs_controller.rb

@@ -1,42 +1,32 @@
 module Admin
   class LogsController < ApplicationController
-    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+    before_action :authenticate_user!
+    skip_log_page_views
 
     layout (EffectiveLogging.layout.kind_of?(Hash) ? EffectiveLogging.layout[:admin_logs] : EffectiveLogging.layout)
 
-    skip_log_page_views quiet: true
-    helper EffectiveLoggingHelper
-
     def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::Logs.new()
-      else
-        @datatable = EffectiveLogsDatatable.new(self)
-      end
+      @datatable = EffectiveLogsDatatable.new(self)
 
       @page_title = 'Logs'
 
-      EffectiveLogging.authorized?(self, :index, Effective::Log)
-      EffectiveLogging.authorized?(self, :admin, :effective_logging)
+      EffectiveLogging.authorize!(self, :index, Effective::Log)
+      EffectiveLogging.authorize!(self, :admin, :effective_logging)
     end
 
     def show
       @log = Effective::Log.includes(:logs).find(params[:id])
-      @log.next_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id > ?', @log.id).first
-      @log.prev_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id < ?', @log.id).last
+      @log.next_log = Effective::Log.order(:id).where(parent_id: @log.parent_id).where('id > ?', @log.id).first
+      @log.prev_log = Effective::Log.order(:id).where(parent_id: @log.parent_id).where('id < ?', @log.id).last
 
       @page_title = "Log ##{@log.to_param}"
 
       if @log.logs.present?
-        if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-          @log.datatable = Effective::Datatables::Logs.new(log_id: @log.id)
-        else
-          @log.datatable = EffectiveLogsDatatable.new(self, log_id: @log.id)
-        end
+        @log.datatable = EffectiveLogsDatatable.new(self, log_id: @log.id)
       end
 
-      EffectiveLogging.authorized?(self, :show, @log)
-      EffectiveLogging.authorized?(self, :admin, :effective_logging)
+      EffectiveLogging.authorize!(self, :show, @log)
+      EffectiveLogging.authorize!(self, :admin, :effective_logging)
     end
   end
 end

data/app/controllers/effective/logs_controller.rb

@@ -1,21 +1,16 @@
 module Effective
   class LogsController < ApplicationController
-    skip_log_page_views quiet: true
-
-    if respond_to?(:before_action) # Devise
-      before_action :authenticate_user!, only: [:index, :show]
-    else
-      before_filter :authenticate_user!, only: [:index, :show]
-    end
+    skip_log_page_views
+    before_action :authenticate_user!, only: [:index, :show]
 
     # This is a post from our Javascript
     def create
-      EffectiveLogging.authorized?(self, :create, Effective::Log.new())
+      EffectiveLogging.authorize!(self, :create, Effective::Log.new)
 
-      @log = Effective::Log.new().tap do |log|
+      @log = Effective::Log.new.tap do |log|
         log.message = log_params[:message]
-        log.status = (EffectiveLogging.statuses.include?(log_params[:status]) ? log_params[:status] : 'info')
-        log.user = (current_user rescue nil)
+        log.status = EffectiveLogging.statuses.find { |status| status == log_params[:status] } || 'info'
+        log.user = EffectiveLogging.current_user || current_user
 
         count = -1
         Array((JSON.parse(log_params[:details]) rescue [])).flatten(1).each do |obj|
@@ -39,38 +34,31 @@ module Effective
 
     # This is the User index event
     def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::Logs.new(user_id: current_user.id)
-      else
-        @datatable = EffectiveLogsDatatable.new(self, user_id: current_user.id)
-      end
+      EffectiveLogging.authorize!(self, :index, Effective::Log.new(user_id: current_user.id))
 
-      EffectiveLogging.authorized?(self, :index, Effective::Log.new(user_id: current_user.id))
+      @datatable = EffectiveLogsDatatable.new(self, user_id: current_user.id)
     end
 
     # This is the User show event
     def show
       @log = Effective::Log.includes(:logs).find(params[:id])
+
+      EffectiveLogging.authorize!(self, :show, @log)
+
       @log.next_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id > ?', @log.id).first
       @log.prev_log = Effective::Log.unscoped.order(:id).where(parent_id: @log.parent_id).where('id < ?', @log.id).last
 
       @page_title = "Log ##{@log.to_param}"
 
       if @log.logs.present?
-        if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-          @log.datatable = Effective::Datatables::Logs.new(log_id: @log.id)
-        else
-          @log.datatable = EffectiveLogsDatatable.new(self, log_id: @log.id)
-        end
+        @log.datatable = EffectiveLogsDatatable.new(self, log_id: @log.id)
       end
-
-      EffectiveLogging.authorized?(self, :show, @log)
     end
 
     def html_part
       @log = Effective::Log.find(params[:id])
 
-      EffectiveLogging.authorized?(self, :show, @log)
+      EffectiveLogging.authorize!(self, :show, @log)
 
       value = @log.details[(params[:key] || '').to_sym].to_s
 
@@ -88,11 +76,7 @@ module Effective
 
     # StrongParameters
     def log_params
-      begin
-        params.require(:effective_log).permit(:message, :status, :details)
-      rescue => e
-        params[:effective_log] || {}
-      end
+      params.require(:effective_log).permit(:message, :status, :details)
     end
 
   end

data/app/datatables/effective_logs_datatable.rb

@@ -1,72 +1,70 @@
-unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  class EffectiveLogsDatatable < Effective::Datatable
-    datatable do
-      order :updated_at
+class EffectiveLogsDatatable < Effective::Datatable
+  datatable do
+    order :updated_at
 
-      col :updated_at, label: 'Date'
-      col :id, visible: false
+    col :updated_at, label: 'Date'
+    col :id, visible: false
 
-      if attributes[:user] == false
-        # Do not include
-      elsif attributes[:for]
-        col :user, search: :string
-      else
-        col :user
-      end
+    if attributes[:user] == false
+      # Do not include
+    elsif attributes[:for]
+      col :user, search: :string
+    else
+      col :user
+    end
 
-      unless attributes[:status] == false
-        col :status, search: { collection: EffectiveLogging.statuses }
-      end
+    unless attributes[:status] == false
+      col :status, search: { collection: EffectiveLogging.statuses }
+    end
 
-      unless attributes[:log_changes]
-        col :associated_type, search: { as: :string }, visible: false
-        col :associated_id, search: { as: :integer }, visible: false, label: 'Associated Id'
-        col :associated_to_s, search: { as: :string }, label: 'Associated'
-      end
+    unless attributes[:log_changes]
+      col :associated_type, search: { as: :string }, visible: false
+      col :associated_id, search: { as: :integer }, visible: false, label: 'Associated Id'
+      col :associated_to_s, search: { as: :string }, label: 'Associated'
+    end
 
-      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
+    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
+    end
 
-      col :logs_count, visible: false
+    col :logs_count, visible: false
 
-      col :details, visible: false, sort: false do |log|
-        tableize_hash(log.details.except(:email))
-      end
-
-      unless attributes[:actions] == false
-        actions_col partial: 'admin/logs/actions', partial_as: :log
-      end
+    col :details, visible: false, sort: false do |log|
+      tableize_hash(log.details.except(:email))
     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
-      scope = Effective::Log.unscoped.where(parent_id: attributes[:log_id]).includes(:user, :associated)
+    unless attributes[:actions] == false
+      actions_col partial: 'admin/logs/actions', partial_as: :log
+    end
+  end
 
-      if attributes[:log_changes]
-        scope = scope.where(status: EffectiveLogging.log_changes_status)
-      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
+    scope = Effective::Log.deep.where(parent_id: attributes[:log_id])
 
-      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')
-      end
+    if attributes[:log_changes]
+      scope = scope.where(status: EffectiveLogging.log_changes_status)
+    end
 
-      if attributes[:associated_id] && attributes[:associated_type]
-        scope = scope.where(associated_id: attributes[:associated_id], associated_type: attributes[:associated_type])
-      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')
+    end
 
-      if attributes[:associated]
-        scope = scope.where(associated: attributes[:associated])
-      end
+    if attributes[:associated_id] && attributes[:associated_type]
+      scope = scope.where(associated_id: attributes[:associated_id], associated_type: attributes[:associated_type])
+    end
 
-      scope
+    if attributes[:associated]
+      scope = scope.where(associated: attributes[:associated])
     end
 
+    scope
   end
+
 end

data/app/helpers/effective_logging_helper.rb

@@ -12,7 +12,7 @@ module EffectiveLoggingHelper
   end
 
   def render_log(log)
-    render(partial: 'effective/logs/log', locals: {log: log})
+    render(partial: 'effective/logs/log', locals: { log: log })
   end
 
   def parents_of_log(log)
@@ -24,13 +24,11 @@ module EffectiveLoggingHelper
   # This is called on the Logs#show Admin page, and is intended for override by the application
   def effective_logging_object_link_to(obj, action = :show)
     if obj.kind_of?(User)
-      return (
-        if action == :show && defined?(admin_user_path)
-          link_to('View', admin_user_path(obj))
-        elsif action == :edit && defined?(edit_admin_user_path)
-          link_to('Edit', edit_admin_user_path(obj))
-        end
-      )
+      if action == :show && defined?(admin_user_path)
+        link_to('View', admin_user_path(obj))
+      elsif action == :edit && defined?(edit_admin_user_path)
+        link_to('Edit', edit_admin_user_path(obj))
+      end
     end
   end
 

data/app/models/concerns/acts_as_loggable.rb

@@ -14,7 +14,7 @@ module ActsAsLoggable
   end
 
   included do
-    has_many :logged_changes, -> { 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: :associated, class_name: 'Effective::Log'
 
     around_save do |_, block|
       @acts_as_loggable_new_record = new_record?
@@ -72,11 +72,7 @@ module ActsAsLoggable
     return nil unless persisted?
 
     @log_changes_datatable ||= (
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        Effective::Datatables::Logs.new(associated_id: id, associated_type: self.class.name, log_changes: true, status: false)
-      else
-        EffectiveLogsDatatable.new(associated_id: id, associated_type: self.class.name, log_changes: true, status: false)
-      end
+      EffectiveLogsDatatable.new(associated_id: id, associated_type: self.class.name, log_changes: true, status: false)
     )
   end
 

data/app/models/effective/log.rb

@@ -11,15 +11,8 @@ module Effective
     belongs_to :parent, class_name: 'Effective::Log', counter_cache: true
     has_many :logs, class_name: 'Effective::Log', foreign_key: :parent_id
 
-    # The user this log item is referring to
-    # An associated object, if we wanna add anything extra
-    if Gem::Version.new(Rails.version) < Gem::Version.new('5.0')
-      belongs_to :user
-      belongs_to :associated, polymorphic: true
-    else
-      belongs_to :user, optional: true
-      belongs_to :associated, polymorphic: true, optional: true
-    end
+    belongs_to :user
+    belongs_to :associated, polymorphic: true
 
     serialize :details, Hash
 
@@ -37,8 +30,8 @@ module Effective
     validates :message, presence: true
     validates :status, presence: true, inclusion: { in: EffectiveLogging.statuses }
 
-    default_scope -> { order(updated_at: :desc) }
-
+    scope :deep, -> { includes(:user, :associated) }
+    scope :sorted, -> { order(:id) }
     scope :logged_changes, -> { where(status: EffectiveLogging.log_changes_status)}
     scope :changes, -> { where(status: EffectiveLogging.log_changes_status)}
 
@@ -58,14 +51,6 @@ module Effective
       self[:details] || {}
     end
 
-    # def next_log
-    #   @next_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id > ?', self.id).first
-    # end
-
-    # def prev_log
-    #   @prev_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id < ?', self.id).last
-    # end
-
     # Dynamically add logging methods based on the defined statuses
     # EffectiveLogging.info 'my message'
     (EffectiveLogging.statuses || []).each do |status|

data/app/views/admin/logs/_actions.html.haml

@@ -1,15 +1,7 @@
-:ruby
-  show_path =
-    if datatable.try(:admin_namespace?)
-      effective_logging.admin_log_path(log)
-    else
-      effective_logging.log_path(log)
-    end
+- show_path = (datatable.admin_namespace? ? effective_logging.admin_log_path(log) : effective_logging.log_path(log))
 
-- if log.logs_count.to_i > 0
-  = link_to show_path, title: 'View' do
-    %span.glyphicon.glyphicon-eye-open
-    = "(#{log.logs_count})"
+- if defined?(EffectiveBootstrap)
+  = show_icon_to(show_path)
 - else
   = link_to show_path, title: 'View' do
     %span.glyphicon.glyphicon-eye-open

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

@@ -1,33 +1,37 @@
-.panel{:class => "panel-#{bootstrap_class_for_status(log.status)}"}
-  .panel-heading
+.panel.card
+  .panel-heading.card-header
     .row
-      .col-sm-10
+      .col-md-10
         - parents_of_log(log).each do |parent|
-          = link_to(log.message, (request.fullpath.gsub(log.to_param, parent.to_param) rescue '#'))
+          = link_to(log.message, request.fullpath.sub('/' + log.to_param, '/' + parent.to_param))
           = ' > '
         %p= log.message.html_safe
-      .col-sm-2.text-right
-        = link_to 'Prev', request.fullpath.gsub(log.to_param, log.prev_log.try(:to_param).to_s), class: 'btn btn-default', disabled: log.prev_log.blank?
-        = link_to 'Next', request.fullpath.gsub(log.to_param, log.next_log.try(:to_param).to_s), class: 'btn btn-default', disabled: log.next_log.blank?
+      .col-md-2.text-right
+        - if log.prev_log
+          = link_to 'Prev', request.fullpath.sub('/' + log.to_param, '/' + log.prev_log.to_param), class: 'btn btn-primary'
 
-  .panel-body
+        - if log.next_log
+          = link_to 'Next', request.fullpath.sub('/' + log.to_param, '/' + log.prev_log.to_param), class: 'btn btn-primary'
+
+  .panel-body.card-body
     .row
-      .col-lg-6
-        %span.label{:class => "label-#{bootstrap_class_for_status(log.status)}"}= log.status
+      .col-md-6
+        - status_class = bootstrap_class_for_status(log.status)
+        %span.label.badge{:class => "label-#{status_class} badge-#{status_class}"}= log.status
          
-        = log.created_at.strftime("%Y-%m-%d %H:%M:%S")
+        = log.created_at.strftime("%F %H:%M:%S")
         = '(' + time_ago_in_words(log.created_at) + ' ago)'
         %br
         %br
 
-      .col-lg-6
+      .col-md-6
         - if log.user.present?
           %strong User:
            
           = (log.user.to_s.starts_with?('#<User:0x') ? (log.user.email rescue log.user) : log.user)
         - if (log.associated.present? rescue false)
           %br
-          %strong Regarding:
+          %strong Associated:
           &nbsp;
           - if log.associated.to_s.starts_with?('#<')
             = "#{log.associated.class.name} ##{log.associated.to_param}"
@@ -37,20 +41,21 @@
     - log.details.each do |key, value|
       - next unless value.present?
       .row
-        .col-lg-12
+        .col-md-12
           %p
             %strong= "#{key.to_s.titleize}:"
           = format_log_details_value(log, key)
 
     - if log.logs.present?
       .row
-        .col-lg-12
+        .col-md-12
           %br
           %p
             %strong Additional Entries:
             = "this log contains #{log.logs_count} additional sub entries"
-      - if log.datatable.nil? == false
+
+      - unless log.datatable.nil?
         %hr
         .row
-          .col-lg-12= render_datatable(log.datatable)
+          .col-md-12= render_datatable(log.datatable)
 

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

@@ -1,6 +1,3 @@
 %h1.effective-heading= @page_title
 
-- if @datatable.present?
-  = render_datatable(@datatable)
-- else
-  %p You have no previous recorded activity
+= render_datatable(@datatable)

data/config/effective_logging.rb

@@ -23,9 +23,6 @@ EffectiveLogging.setup do |config|
   # config.authorization_method = false
   config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) } # CanCanCan
 
-  # Register Effective::Logs with ActiveAdmin if ActiveAdmin is present
-  config.use_active_admin = true
-
   # Admin Screens Layout Settings
   config.layout = 'application'   # All EffectiveLogging controllers will use this layout
 
@@ -34,8 +31,9 @@ EffectiveLogging.setup do |config|
   #   admin_logs: 'admin',
   # }
 
-  # All statuses defined here, as well as 'info', 'success', and 'error' (hardcoded) will be created as
   # EffectiveLogger.info('my message') macros
+  # The following statuses are already present: info, success, error, view, change, email, sign_in, sign_out
+  # Add more here
   config.additional_statuses = []
 
   #########################################

data/config/routes.rb

@@ -7,10 +7,8 @@ EffectiveLogging::Engine.routes.draw do
     end
   end
 
-  if defined?(EffectiveDatatables)
-    namespace :admin do
-      resources :logs, only: [:index, :show]
-    end
+  namespace :admin do
+    resources :logs, only: [:index, :show]
   end
 
 end

data/lib/effective_logging/engine.rb

@@ -11,14 +11,6 @@ module EffectiveLogging
       eval File.read("#{config.root}/config/effective_logging.rb")
     end
 
-    # ActiveAdmin (optional)
-    # This prepends the load path so someone can override the assets.rb if they want.
-    initializer 'effective_logging.active_admin' do
-      if defined?(ActiveAdmin) && EffectiveLogging.use_active_admin == true
-        ActiveAdmin.application.load_paths.unshift Dir["#{config.root}/active_admin"]
-      end
-    end
-
     # Automatically Log Emails
     initializer 'effective_logging.emails' do |app|
       if EffectiveLogging.email_enabled == true
@@ -55,11 +47,7 @@ module EffectiveLogging
     config.after_initialize do
       if EffectiveLogging.sign_in_enabled || EffectiveLogging.sign_out_enabled
         ActiveSupport.on_load :active_record do
-          if defined?(Devise)
-            EffectiveLogging::UserLogger.create_warden_hooks()
-          else
-            raise ArgumentError.new("EffectiveLogging.sign_in_enabled only works with Devise")
-          end
+          EffectiveLogging::UserLogger.create_warden_hooks()
         end
       end
     end

data/lib/effective_logging/log_page_views.rb

@@ -18,25 +18,18 @@ module EffectiveLogging
         self.log_page_views_opts = logging_options
 
         # Set up the after_filter to do page logging
-        if respond_to?(:after_action)
-          after_action :effective_logging_log_page_view, filter_options
-        else
-          after_filter :effective_logging_log_page_view, filter_options
-        end
+        after_action :effective_logging_log_page_view, filter_options
       end
 
       def skip_log_page_views(options = {})
-        Rails.logger.info("WARNING EffectiveLogging: skip_log_page_views called without first having called log_page_views. Please add 'log_page_views' to your ApplicationController or this controller before using skip_log_page_views") unless options[:quiet]
+        # Nothing
       end
+
     end
 
     module ClassMethods
       def skip_log_page_views(options = {})
-        if respond_to?(:before_action)
-          before_action :skip_log_page_view, options
-        else
-          before_filter :skip_log_page_view, options
-        end
+        before_action :skip_log_page_view, options
       end
     end
 
@@ -45,7 +38,7 @@ module EffectiveLogging
         return if @_effective_logging_skip_log_page_view == true
         return if (self.class.log_page_views_opts[:skip_namespace] || []).include?(self.class.parent)
 
-        user = (current_user rescue nil)
+        user = EffectiveLogging.current_user || current_user
 
         if self.class.log_page_views_opts[:details] == false
           ::EffectiveLogger.view("#{request.request_method} #{request.path}", user: user)

data/lib/effective_logging/set_current_user.rb

@@ -6,15 +6,7 @@ module EffectiveLogging
       # before_action :set_effective_logging_current_user
 
       def set_effective_logging_current_user
-        if respond_to?(:current_user)
-          EffectiveLogging.current_user = current_user
-        else
-          raise "(effective_logging) set_effective_logging_current_user expects a current_user() method to be available"
-        end
-      end
-
-      def set_log_changes_user
-        # No longer need to call this
+        EffectiveLogging.current_user = current_user
       end
 
     end

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '1.11.5'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/effective_logging.rb

@@ -6,7 +6,6 @@ module EffectiveLogging
 
   # The following are all valid config keys
   mattr_accessor :logs_table_name
-  mattr_accessor :use_active_admin
 
   mattr_accessor :authorization_method
   mattr_accessor :layout
@@ -21,10 +20,20 @@ module EffectiveLogging
   end
 
   def self.authorized?(controller, action, resource)
-    if authorization_method.respond_to?(:call) || authorization_method.kind_of?(Symbol)
-      raise Effective::AccessDenied.new() unless (controller || self).instance_exec(controller, action, resource, &authorization_method)
+    @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
+
+    return !!authorization_method unless authorization_method.respond_to?(:call)
+    controller = controller.controller if controller.respond_to?(:controller)
+
+    begin
+      !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
+    rescue *@_exceptions
+      false
     end
-    true
+  end
+
+  def self.authorize!(controller, action, resource)
+    raise Effective::AccessDenied unless authorized?(controller, action, resource)
   end
 
   def self.supressed(&block)
@@ -37,9 +46,8 @@ module EffectiveLogging
 
   def self.statuses
     @statuses ||= (
-      Array(@@additional_statuses).map do |status|
-        status.to_s.downcase
-      end | ['info', 'success', 'error', log_changes_status, ('email' if email_enabled), ('sign_in' if sign_in_enabled), ('sign_out' if sign_out_enabled), 'view'].compact
+      Array(@@additional_statuses).map { |status| status.to_s.downcase } |  # union
+      ['info', 'success', 'error', 'view', log_changes_status, ('email' if email_enabled), ('sign_in' if sign_in_enabled), ('sign_out' if sign_out_enabled)].compact
     )
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 1.11.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-21 00:00:00.000000000 Z
+date: 2018-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: effective_datatables
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: effective_resources
   requirement: !ruby/object:Gem::Requirement
@@ -98,11 +98,8 @@ files:
 - app/helpers/effective_logging_helper.rb
 - app/models/concerns/acts_as_loggable.rb
 - app/models/effective/access_denied.rb
-- app/models/effective/datatables/logs.rb
 - app/models/effective/log.rb
 - app/models/effective_logger.rb
-- app/views/active_admin/effective_logging/logs/index.html.haml
-- app/views/active_admin/effective_logging/logs/show.html.haml
 - app/views/admin/logs/_actions.html.haml
 - app/views/admin/logs/index.html.haml
 - app/views/admin/logs/show.html.haml

data/app/models/effective/datatables/logs.rb

@@ -1,80 +0,0 @@
-if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  module Effective
-    module Datatables
-      class Logs < Effective::Datatable
-        include EffectiveLoggingHelper
-
-        datatable do
-          default_order :updated_at, :desc
-
-          table_column :updated_at, label: 'Date'
-          table_column :id, visible: false
-
-          if attributes[:user] == false
-            # Do not include
-          elsif attributes[:user_id].present?
-            table_column :user, filter: { collection: User.where(id: Array(attributes[:user_id])) }
-          elsif attributes[:user].present?
-            table_column :user, filter: { collection: User.where(id: Array(attributes[:user]).map { |user| user.to_param }) }
-          else
-            table_column :user
-          end
-
-          unless attributes[:status] == false
-            table_column :status, filter: { type: :select, values: EffectiveLogging.statuses }
-          end
-
-          unless attributes[:log_changes]
-            table_column :associated_type, visible: false
-            table_column :associated_id, visible: false, label: 'Associated Id'
-            table_column :associated_to_s, label: 'Associated'
-          end
-
-          if attributes[:log_changes]
-            table_column :message do |log|
-              log.message.starts_with?("\t") ? log.message.gsub("\t", "&nbsp;&nbsp;") : log.message
-            end
-          else
-            table_column :message
-          end
-
-          table_column :logs_count, visible: false
-
-          table_column :details, visible: false, sortable: false do |log|
-            tableize_hash(log.details.except(:email), th: true, sub_th: false)
-          end
-
-          unless attributes[:actions] == false
-            actions_column partial: 'admin/logs/actions', partial_local: :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
-        def collection
-          collection = Effective::Log.unscoped.where(parent_id: attributes[:log_id]).includes(:user, :associated)
-
-          if attributes[:log_changes]
-            collection = collection.where(status: EffectiveLogging.log_changes_status)
-          end
-
-          if (attributes[:user] || attributes[:user_id]).present?
-            user_ids = Array(attributes[:user].presence || attributes[:user_id]).map { |user| user.kind_of?(User) ? user.id : user.to_i }
-            collection = collection.where('user_id IN (?) OR (associated_id IN (?) AND associated_type = ?)', user_ids, user_ids, 'User')
-          end
-
-          if attributes[:associated_id] && attributes[:associated_type]
-            collection = collection.where(associated_id: attributes[:associated_id], associated_type: attributes[:associated_type])
-          end
-
-          if attributes[:associated]
-            collection = collection.where(associated: attributes[:associated])
-          end
-
-          collection
-        end
-
-      end
-    end
-  end
-end

data/app/views/active_admin/effective_logging/logs/index.html.haml

@@ -1,7 +0,0 @@
-.fluid-container
-  .row
-    .col-sm-12
-      - if @datatable.present?
-        = render_datatable(@datatable)
-      - else
-        %p There are no logs

data/app/views/active_admin/effective_logging/logs/show.html.haml

@@ -1,4 +0,0 @@
-.fluid-container
-  .row
-    .col-sm-12
-      = render_log(@log)