effective_trash 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 473e805a96b7c73933733dff9e8342b0f6e8eb3c
+  data.tar.gz: 4b4c0294ef97d0ed8545925cecb4810437c362f2
+SHA512:
+  metadata.gz: dcfad56fc484fee2bf983b521011a3e54dbc28855fd0e500b7639b539022038642b65cf04320991f905ec40ec2765e79caf34cf6edd6b4367399d046dc172e52
+  data.tar.gz: 66704561125458f4a8c17ff18db6d8c06d5634dd7179160f345bcde95f6a1cb625aa83793272e7550bbf6eb319204483fb17b810cd5d4e0e9fda36fcb123f130

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+# Effective Trash
+
+Trash and Restore any Active Record object.
+
+## Getting Started
+
+Add to your Gemfile:
+
+```ruby
+gem 'effective_trash'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_trash:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table name (to use something other than the default 'trash'), manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+## Usage
+
+Add to your model:
+
+```ruby
+class Post < ActiveRecord::Base
+  acts_as_trashable
+end
+```
+
+and to your contoller:
+
+```ruby
+class ApplicationController < ActionController::Base
+  before_action :set_effective_trash_current_user
+end
+```
+
+## How it works
+
+The `acts_as_trashable` mixin sets up `before_destroy` and serializes the resource's attributes to an `Effective::Trash` object.
+
+It also serializes the attributes of any `belongs_to`, `has_one`, and `has_many` with `accepts_nested_attributes` related resources.
+
+Restoring only works with the single base object right now.
+
+## Routes
+
+Visit `/trash`, or `/admin/trash` for an interface to view and restore Trash.
+
+```ruby
+link_to 'Trash', effective_trash.trash_index_path   # /trash
+link_to 'Admin Trash', effective_trash.admin_trash_index_path   # /admin/trash
+```
+
+## Permissions
+
+Add the following permissions (using CanCan):
+
+```ruby
+can :manage, Effective::Trash, user_id: user.id
+
+# Admin
+can :manage, Effective::Trash
+can :admin, :effective_trash
+```
+
+The user must be permitted to to `:update` an `Effective::Trash` in order to restore the trashed item.
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request
+

data/app/controllers/admin/trash_controller.rb

@@ -0,0 +1,27 @@
+# This copies the permissions of The Logs controller
+
+module Admin
+  class TrashController < ApplicationController
+    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+
+    layout (EffectiveTrash.layout.kind_of?(Hash) ? EffectiveTrash.layout[:admin_trash] : EffectiveTrash.layout)
+
+    helper EffectiveTrashHelper
+
+    def index
+      @datatable = Effective::Datatables::Trash.new()
+      @page_title = 'Trash'
+
+      EffectiveTrash.authorized?(self, :index, Effective::Trash)
+      EffectiveTrash.authorized?(self, :admin, :effective_trash)
+    end
+
+    def show
+      @trash = Effective::Trash.all.find(params[:id])
+      @page_title = "Trash item - #{@trash.to_s}"
+
+      EffectiveTrash.authorized?(self, :show, @trash)
+      EffectiveTrash.authorized?(self, :admin, :effective_trash)
+    end
+  end
+end

data/app/controllers/effective/trash_controller.rb

@@ -0,0 +1,44 @@
+module Effective
+  class TrashController < ApplicationController
+    if respond_to?(:before_action) # Devise
+      before_action :authenticate_user!
+    else
+      before_filter :authenticate_user!
+    end
+
+    # This is the User index event
+    def index
+      @datatable = Effective::Datatables::Trash.new(user_id: current_user.id)
+      @page_title = 'Trash'
+
+      EffectiveTrash.authorized?(self, :index, Effective::Trash.new(user_id: current_user.id))
+    end
+
+    # This is the User show event
+    def show
+      @trash = Effective::Trash.where(user_id: current_user.id).find(params[:id])
+      @page_title = "Trash item - #{@trash.to_s}"
+
+      EffectiveTrash.authorized?(self, :show, @trash)
+    end
+
+    def restore
+      @trash = Effective::Trash.all.find(params[:id])
+      EffectiveTrash.authorized?(self, :update, @trash)
+
+      Effective::Trash.transaction do
+        begin
+          @trash.restore_trash!
+          @trash.destroy!
+          flash[:success] = "Successfully restored #{@trash}"
+        rescue => e
+          flash[:danger] = "Unable to restore: #{e.message}"
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      redirect_back(fallback_location: effective_trash.trash_path)
+    end
+
+  end
+end

data/app/helpers/effective_trash_helper.rb

@@ -0,0 +1,69 @@
+module EffectiveTrashHelper
+  ALLOWED_TAGS = ActionView::Base.sanitized_allowed_tags.to_a + ['table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']
+  ALLOWED_ATTRIBUTES = ActionView::Base.sanitized_allowed_attributes.to_a + ['colspan', 'rowspan']
+
+  def render_trash(trash)
+    render(partial: 'effective/trash/trash', locals: {trash: trash})
+  end
+
+  # Call me with :th => true, :sub_th => false
+  # Any other options are sent to the table tag
+  def tableize_hash(hash, options = {})
+    if hash.present? && hash.kind_of?(Hash)
+      content_tag(:table, options) do
+        hash.map do |k, v|
+          content_tag(:tr) do
+            content_tag((options[:th] ? :th : :td), k) +
+            content_tag(:td) do
+              if v.kind_of?(Hash)
+                tableize_hash(v, options.merge({:class => 'table table-bordered', :th => (options.key?(:sub_th) ? options[:sub_th] : options[:th])}))
+              elsif v.kind_of?(Array)
+                '[' + v.join(', ') + ']'
+              else
+                v.to_s
+              end
+            end
+          end
+        end.join('').html_safe
+      end.html_safe
+    else
+      hash.to_s.html_safe
+    end
+  end
+
+  def format_trash_details_value(trash, key)
+    value = trash.details[key]
+
+    if value.kind_of?(Hash)
+      tableize_hash(value, :class => 'table', :th => true)
+    elsif value.kind_of?(Array)
+      value.map { |value| effective_trash_simple_format(value) }.join.html_safe
+    else
+      value = value.to_s
+
+      open = value.index('<!DOCTYPE html') || value.index('<html')
+      close = value.rindex('</html>') if open.present?
+      return effective_trash_simple_format(value) unless (open.present? && close.present?)
+
+      before = value[0...open]
+      after = value[(close+7)..-1]
+      divide = before.sub!('<hr>', '').present?
+
+      [
+        h(before).gsub("\n", '<br>'),
+        (content_tag(:hr) if divide),
+        content_tag(:iframe, '',
+          src: '#',
+          style: 'frameborder: 0; border: 0; width: 100%; height: 100%;',
+          onload: "this.style.height=(this.contentDocument.body.scrollHeight + 30) + 'px';",
+          scrolling: 'no'),
+        h(after).gsub("\n", '<br>')
+      ].compact.join.html_safe
+    end
+  end
+
+  def effective_trash_simple_format(value)
+    simple_format(sanitize(value.to_s, :tags => ALLOWED_TAGS, :attributes => ALLOWED_ATTRIBUTES), {}, :sanitize => false)
+  end
+
+end

data/app/models/concerns/acts_as_trashable.rb

@@ -0,0 +1,46 @@
+module ActsAsTrashable
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def acts_as_trashable(*options)
+      @acts_as_trashable_options = options.try(:first) || {}
+
+      unless @acts_as_trashable_options.kind_of?(Hash)
+        raise ArgumentError.new("invalid arguments passed to (effective_trash) acts_as_trashable. Expecting no options.")
+      end
+
+      include ::ActsAsTrashable
+    end
+  end
+
+  included do
+    has_one :trash, as: :trashed, class_name: Effective::Trash
+
+    before_destroy do
+      trash = Effective::Trash.new(
+        trashed: self,
+        user: EffectiveTrash.current_user,
+        trashed_to_s: to_s,
+        trashed_extra: (trashed_extra if respond_to?(:trashed_extra)),
+
+        details: EffectiveTrash::ActiveRecordLogger.new(self, acts_as_trashable_options).attributes
+      ).save!
+    end
+
+    # Parse Options
+    acts_as_trashable_options = {
+      only: Array(@acts_as_trashable_options[:only]).map { |attribute| attribute.to_s },
+      except: Array(@acts_as_trashable_options[:except]).map { |attribute| attribute.to_s },
+      additionally: Array(@acts_as_trashable_options[:additionally]).map { |attribute| attribute.to_s }
+    }
+
+    self.send(:define_method, :acts_as_trashable_options) { acts_as_trashable_options }
+  end
+
+  module ClassMethods
+  end
+
+  # Regular instance methods
+
+end
+

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Trash < Effective::Datatable
+        include EffectiveTrashHelper
+
+        datatable do
+          default_order :created_at, :desc
+
+          table_column :created_at, label: 'Destroyed at'
+          table_column :id, visible: false
+
+          unless attributes[:user_id] || attributes[:user] || (attributes[:user] == false)
+            table_column :user, label: 'Destroyed by', visible: false
+          end
+
+          table_column :trashed_type, label: 'Type'
+          table_column :trashed_id, label: 'Original Id', visible: false
+          table_column :trashed_to_s, label: 'Item'
+
+          table_column :details, visible: true, sortable: false do |trash|
+            tableize_hash(trash.details, th: true, sub_th: false, width: '100%')
+          end
+
+          unless attributes[:actions] == false
+            actions_column partial: 'admin/trash/actions', partial_local: :trash
+          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 trash
+        def collection
+          collection = Effective::Trash.all.includes(:user)
+
+          if attributes[:user_id].present?
+            collection = collection.where(user_id: attributes[:user_id])
+          end
+
+          if attributes[:user].present?
+            collection = collection.where(user: attributes[:user])
+          end
+
+          if attributes[:trashed_id] && attributes[:trashed_type]
+            collection = collection.where(trashed_id: attributes[:trashed_id], trashed_type: attributes[:trashed_type])
+          end
+
+          collection
+        end
+
+      end
+    end
+  end
+end

data/app/models/effective/trash.rb

@@ -0,0 +1,39 @@
+module Effective
+  class Trash < ActiveRecord::Base
+    self.table_name = EffectiveTrash.trash_table_name.to_s
+
+    belongs_to :trashed, polymorphic: true  # The original item type and id. Note that this object will never exist as it's deleted.
+    belongs_to :user, optional: true  # The user that destroyed the original resource
+
+    # Attributes
+    # trashed_type       :string
+    # trashed_id         :integer
+    # trashed_to_s       :string
+    # trashed_extra      :string
+
+    # details            :text
+    # timestamps
+
+    serialize :details, Hash
+
+    default_scope -> { order(updated_at: :desc) }
+
+    def to_s
+      [trashed_type, trashed_id].join(' ').presence || 'New Trash item'
+    end
+
+    def details
+      self[:details] || {}
+    end
+
+    # So this is a Trash item
+    # When we delete ourselves, we restore this trash item first
+    def restore_trash!
+      raise 'no attributes to restore from' unless details.kind_of?(Hash) && details[:attributes].present?
+      trashed_type.constantize.new(details[:attributes]).save!
+    end
+
+  end
+end
+
+

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

@@ -0,0 +1,15 @@
+:ruby
+  show_path =
+    if datatables_active_admin_path?
+      admin_effective_trash_path(trash)
+    elsif datatables_admin_path?
+      effective_trash.admin_trash_path(trash)
+    else
+      effective_trash.trash_path(trash)
+    end
+
+= link_to show_path, title: 'view' do
+  %span.glyphicon.glyphicon-eye-open
+
+= link_to effective_trash.restore_trash_path(trash), title: 'Restore', data: {confirm: 'Restore this item?'} do
+  %span.glyphicon.glyphicon-retweet

data/app/views/admin/trash/index.html.haml

@@ -0,0 +1,3 @@
+%h1.effective-admin-heading= @page_title
+
+= render_datatable(@datatable)

data/app/views/admin/trash/show.html.haml

@@ -0,0 +1,4 @@
+%h1.effective-admin-heading= @page_title
+
+= render_trash(@trash)
+

data/app/views/effective/trash/_trash.html.haml

@@ -0,0 +1,30 @@
+.panel.panel-default
+  .panel-body
+    %p
+      %span.label.label-default= trash
+      = trash.trashed_to_s
+
+    - if trash.trashed_extra.present?
+      %p= trash.trashed_extra
+
+    .row
+      .col-sm-6
+        %strong Destroyed at:
+        = trash.created_at.strftime("%Y-%m-%d %H:%M:%S")
+        = '(' + time_ago_in_words(trash.created_at) + ' ago)'
+
+      .col-sm-6
+        - if trash.user.present?
+          %strong Destroyed by:
+          = trash.user.to_s
+
+    %br
+
+    - trash.details.each do |key, value|
+      - next unless value.present?
+      .row
+        .col-lg-12
+          %p
+            %strong= "#{key.to_s.titleize}:"
+          = format_trash_details_value(trash, key)
+

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

@@ -0,0 +1,6 @@
+%h1.effective-heading= @page_title
+
+- if @datatable.present?
+  = render_datatable(@datatable)
+- else
+  %p You have no previously trashed items

data/app/views/effective/trash/show.html.haml

@@ -0,0 +1,3 @@
+%h1.effective-heading= @page_title
+
+= render_trash(@trash)

data/config/effective_trash.rb

@@ -0,0 +1,36 @@
+EffectiveTrash.setup do |config|
+  # Configure Database Table
+  config.trash_table_name = :trash
+
+  # Authorization Method
+  #
+  # This method is called by all controller actions with the appropriate action and resource
+  # If the method returns false, an Effective::AccessDenied Error will be raised (see README.md for complete info)
+  #
+  # Use via Proc (and with CanCan):
+  # config.authorization_method = Proc.new { |controller, action, resource| can?(action, resource) }
+  #
+  # Use via custom method:
+  # config.authorization_method = :my_authorization_method
+  #
+  # And then in your application_controller.rb:
+  #
+  # def my_authorization_method(action, resource)
+  #   current_user.is?(:admin)
+  # end
+  #
+  # Or disable the check completely:
+  # config.authorization_method = false
+  config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) } # CanCanCan
+
+  # Admin Screens Layout Settings
+  config.layout = 'application'   # All EffectiveTrash controllers will use this layout
+
+  # config.layout = {
+  #   trash: 'application',
+  #   admin_trash: 'admin',
+  # }
+
+  # Enable the /trash, /admin/trash and /trash/:id/restore routes. Doesn't affect acts_as_trashable itself.
+  config.routes_enabled = true
+end

data/config/routes.rb

@@ -0,0 +1,21 @@
+EffectiveTrash::Engine.routes.draw do
+  scope :module => 'effective' do
+
+    if EffectiveTrash.routes_enabled
+      resources :trash, only: [:index, :show] do
+        member { get :restore }
+      end
+    end
+  end
+
+  if EffectiveTrash.routes_enabled
+    namespace :admin do
+      resources :trash, only: [:index, :show]
+    end
+  end
+
+end
+
+Rails.application.routes.draw do
+  mount EffectiveTrash::Engine => '/', :as => 'effective_trash'
+end

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

@@ -0,0 +1,26 @@
+class CreateEffectiveTrash < ActiveRecord::Migration
+  def self.up
+    create_table <%= @trash_table_name %> do |t|
+      t.integer       :user_id
+
+      t.string        :trashed_type
+      t.integer       :trashed_id
+
+      t.string        :trashed_to_s
+      t.string        :trashed_extra
+
+      t.text          :details
+
+      t.timestamps
+    end
+
+    add_index <%= @trash_table_name %>, :user_id
+    add_index <%= @trash_table_name %>, [:trashed_type, :trashed_id]
+    add_index <%= @trash_table_name %>, :trashed_id
+    add_index <%= @trash_table_name %>, :trashed_extra
+  end
+
+  def self.down
+    drop_table <%= @trash_table_name %>
+  end
+end

data/lib/effective_trash/active_record_logger.rb

@@ -0,0 +1,160 @@
+module EffectiveTrash
+  class ActiveRecordLogger
+    attr_accessor :resource, :logger, :depth, :options
+
+    BLANK = "''"
+
+    def initialize(resource, options = {})
+      raise ArgumentError.new('options must be a Hash') unless options.kind_of?(Hash)
+
+      @resource = resource
+      @logger = options.delete(:logger) || resource
+      @depth = options.delete(:depth) || 0
+      @options = options
+
+      unless @logger.respond_to?(:logged_changes) || @logger.respond_to?(:trash)
+        raise ArgumentError.new('logger must respond to logged_changes or trash')
+      end
+    end
+
+    # execute! is called when we recurse, otherwise the following methods are best called individually
+    def execute!
+      if resource.new_record?
+        created!
+      elsif resource.marked_for_destruction?
+        destroyed!
+      else
+        changed!
+      end
+    end
+
+    # before_destroy
+    def trashed!
+      log_trash((resource.to_s rescue ''), details: applicable(attributes))
+    end
+
+    # before_destroy
+    def destroyed!
+      log('Deleted', details: applicable(attributes))
+    end
+
+    # after_commit
+    def created!
+      log('Created', details: applicable(attributes))
+    end
+
+    # after_commit
+    def updated!
+      log('Updated', details: applicable(attributes))
+    end
+
+    # before_save
+    def changed!
+      applicable(changes).each do |attribute, (before, after)|
+        if resource.respond_to?(:log_changes_formatted_value)
+          before = resource.log_changes_formatted_value(attribute, before) || before
+          after = resource.log_changes_formatted_value(attribute, after) || after
+        end
+
+        attribute = if resource.respond_to?(:log_changes_formatted_attribute)
+          resource.log_changes_formatted_attribute(attribute)
+        end || attribute.titleize
+
+        if after.present?
+          log("#{attribute} changed from #{before.presence || BLANK} to #{after.presence || BLANK}", details: { attribute: attribute, before: before, after: after })
+        else
+          log("#{attribute} set to #{before || BLANK}", details: { attribute: attribute, value: before })
+        end
+      end
+
+      # Log changes on all accepts_as_nested_parameters has_many associations
+      (resource.class.try(:reflect_on_all_autosave_associations) || []).each do |association|
+        child_name = association.name.to_s.singularize.titleize
+
+        Array(resource.send(association.name)).each_with_index do |child, index|
+          ActiveRecordLogger.new(child, options.merge(logger: logger, depth: (depth + 1), prefix: "#{child_name} ##{index+1}: ")).execute!
+        end
+      end
+    end
+
+    def attributes
+      attributes = { attributes: resource.attributes }
+
+      # Collect to_s representations of all belongs_to associations
+      (resource.class.try(:reflect_on_all_associations, :belongs_to) || []).each do |association|
+        attributes[association.name] = resource.send(association.name).to_s.presence || 'nil'
+      end
+
+      # Collect to_s representations for all has_one associations
+      (resource.class.try(:reflect_on_all_associations, :has_one) || []).each do |association|
+        next if association.name == :trash && resource.respond_to?(:acts_as_trashable_options) # We skip our own association
+        attributes[association.name] = resource.send(association.name).to_s.presence || 'nil'
+      end
+
+      # Collects attributes for all accepts_as_nested_parameters has_many associations
+      (resource.class.try(:reflect_on_all_autosave_associations) || []).each do |association|
+        attributes[association.name] = {}
+
+        Array(resource.send(association.name)).each_with_index do |child, index|
+          attributes[association.name][index+1] = ActiveRecordLogger.new(child, options.merge(logger: logger)).attributes
+        end
+      end
+
+      attributes
+    end
+
+    def changes
+      changes = resource.changes
+
+      # Log to_s changes on all belongs_to associations
+      (resource.class.try(:reflect_on_all_associations, :belongs_to) || []).each do |association|
+        if (change = changes.delete(association.foreign_key)).present?
+          changes[association.name] = [association.klass.find_by_id(change.first), resource.send(association.name)]
+        end
+      end
+
+      changes
+    end
+
+    private
+
+    def log(message, details: {})
+      logger.logged_changes.build(
+        user: EffectiveTrash.current_user,
+        status: EffectiveTrash.log_changes_status,
+        message: "#{"\t" * depth}#{options[:prefix]}#{message}",
+        details: details
+      ).tap { |log| log.save }
+    end
+
+    def log_trash(message, details: {})
+      logger.build_trash(
+        user: EffectiveTrash.current_user,
+        status: EffectiveTrash.trashable_status,
+        message: "#{"\t" * depth}#{options[:prefix]}#{message}",
+        details: details
+      ).tap { |log| log.save }
+    end
+
+    # TODO: Make this work better with nested objects
+    def applicable(attributes)
+      atts = if options[:only].present?
+        attributes.slice(*options[:only])
+      elsif options[:except].present?
+        attributes.except(*options[:except])
+      else
+        attributes.except(:updated_at, :created_at)
+      end
+
+      (options[:additionally] || []).each do |attribute|
+        value = (resource.send(attribute) rescue :effective_trash_nope)
+        next if attributes[attribute].present? || value == :effective_trash_nope
+
+        atts[attribute] = value
+      end
+
+      atts
+    end
+
+  end
+end

data/lib/effective_trash/engine.rb

@@ -0,0 +1,29 @@
+module EffectiveTrash
+  class Engine < ::Rails::Engine
+    engine_name 'effective_trash'
+
+    config.autoload_paths += Dir["#{config.root}/lib/"]
+
+    # Set up our default configuration options.
+    initializer "effective_trash.defaults", before: :load_config_initializers do |app|
+      eval File.read("#{config.root}/config/effective_trash.rb")
+    end
+
+    # Include acts_as_trashable concern and allow any ActiveRecord object to call it with acts_as_trashable()
+    initializer 'effective_trash.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.extend(ActsAsTrashable::ActiveRecord)
+      end
+    end
+
+    # Register the log_page_views concern so that it can be called in ActionController or elsewhere
+    initializer 'effective_trash.action_controller' do |app|
+      Rails.application.config.to_prepare do
+        ActiveSupport.on_load :action_controller do
+          ActionController::Base.include(EffectiveTrash::SetCurrentUser::ActionController)
+        end
+      end
+    end
+
+  end
+end

data/lib/effective_trash/set_current_user.rb

@@ -0,0 +1,16 @@
+module EffectiveTrash
+  module SetCurrentUser
+    module ActionController
+
+      def set_effective_trash_current_user
+        if respond_to?(:current_user)
+          EffectiveTrash.current_user = current_user
+        else
+          raise "(effective_trash) set_effective_trash_current_user expects a current_user() method to be available"
+        end
+      end
+
+    end
+  end
+end
+

data/lib/effective_trash/version.rb

@@ -0,0 +1,3 @@
+module EffectiveTrash
+  VERSION = '0.2.0'.freeze
+end

data/lib/effective_trash.rb

@@ -0,0 +1,34 @@
+require 'haml-rails'
+require 'effective_trash/engine'
+require 'effective_trash/version'
+
+module EffectiveTrash
+
+  # The following are all valid config keys
+  mattr_accessor :trash_table_name
+
+  mattr_accessor :authorization_method
+  mattr_accessor :layout
+  mattr_accessor :routes_enabled
+
+  def self.setup
+    yield self
+  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)
+    end
+    true
+  end
+
+  # This is set by the "set_effective_trash_current_user" before_filter.
+  def self.current_user=(user)
+    @effective_trash_current_user = user
+  end
+
+  def self.current_user
+    @effective_trash_current_user
+  end
+
+end

data/lib/generators/effective_trash/install_generator.rb

@@ -0,0 +1,29 @@
+module EffectiveTrash
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc 'Creates an EffectiveTrash initializer in your application.'
+
+      source_root File.expand_path('../../templates', __FILE__)
+
+      def self.next_migration_number(dirname)
+        if not ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def copy_initializer
+        template ('../' * 3) + 'config/effective_trash.rb', 'config/initializers/effective_trash.rb'
+      end
+
+      def create_migration_file
+        @trash_table_name = ':' + EffectiveTrash.trash_table_name.to_s
+
+        migration_template ('../' * 3) + 'db/migrate/01_create_effective_trash.rb.erb', 'db/migrate/create_effective_trash.rb'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: effective_trash
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Code and Effect
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: effective_datatables
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: devise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: haml-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Trash and Restore any Active Record object.
+email:
+- info@codeandeffect.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- app/controllers/admin/trash_controller.rb
+- app/controllers/effective/trash_controller.rb
+- app/helpers/effective_trash_helper.rb
+- app/models/concerns/acts_as_trashable.rb
+- app/models/effective/access_denied.rb
+- app/models/effective/datatables/trash.rb
+- app/models/effective/trash.rb
+- app/views/admin/trash/_actions.html.haml
+- app/views/admin/trash/index.html.haml
+- app/views/admin/trash/show.html.haml
+- app/views/effective/trash/_trash.html.haml
+- app/views/effective/trash/index.html.haml
+- app/views/effective/trash/show.html.haml
+- config/effective_trash.rb
+- config/routes.rb
+- db/migrate/01_create_effective_trash.rb.erb
+- lib/effective_trash.rb
+- lib/effective_trash/active_record_logger.rb
+- lib/effective_trash/engine.rb
+- lib/effective_trash/set_current_user.rb
+- lib/effective_trash/version.rb
+- lib/generators/effective_trash/install_generator.rb
+homepage: https://github.com/code-and-effect/effective_trash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Trash and Restore any Active Record object.
+test_files: []