activeadmin_addons 1.7.1 → 1.8.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions.rb

@@ -1,16 +0,0 @@
-ActiveAdmin.before_load do |app|
-  require "active_admin/batch_actions/resource_extension"
-  require "active_admin/batch_actions/controller"
-
-  # Add our Extensions
-  ActiveAdmin::Resource.send :include, ActiveAdmin::BatchActions::ResourceExtension
-  ActiveAdmin::ResourceController.send :include, ActiveAdmin::BatchActions::Controller
-
-  # Require all the views
-  require "active_admin/batch_actions/views/batch_action_form"
-  require "active_admin/batch_actions/views/selection_cells"
-  require "active_admin/batch_actions/views/batch_action_selector"
-
-  # Register the views with the view factory
-  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions/controller.rb

@@ -1,40 +0,0 @@
-module ActiveAdmin
-  module BatchActions
-    module Controller
-
-      # Controller action that is called when submitting the batch action form
-      def batch_action
-        if action_present?
-          selection  =            params[:collection_selection] || []
-          inputs     = JSON.parse params[:batch_action_inputs]  || '{}'
-          valid_keys = StringSymbolOrProcSetting.new(current_batch_action.inputs).value(self).try(:keys)
-          inputs     = inputs.with_indifferent_access.slice *valid_keys
-          instance_exec selection, inputs, &current_batch_action.block
-        else
-          raise "Couldn't find batch action \"#{params[:batch_action]}\""
-        end
-      end
-
-      protected
-
-      def action_present?
-        params[:batch_action].present? && current_batch_action
-      end
-
-      def current_batch_action
-        active_admin_config.batch_actions.detect{ |action| action.sym.to_s == params[:batch_action] }
-      end
-
-      COLLECTION_APPLIES = [
-        :authorization_scope,
-        :filtering,
-        :scoping,
-        :includes,
-      ].freeze
-
-      def batch_action_collection(only = COLLECTION_APPLIES)
-        find_collection(only: only)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions/resource_extension.rb

@@ -1,151 +0,0 @@
-module ActiveAdmin
-
-  module BatchActions
-    module ResourceExtension
-      def initialize(*)
-        super
-        @batch_actions = {}
-        add_default_batch_action
-      end
-
-      # @return [Array] The set of batch actions for this resource
-      def batch_actions
-        batch_actions_enabled? ? @batch_actions.values.sort : []
-      end
-
-      # @return [Boolean] If batch actions are enabled for this resource
-      def batch_actions_enabled?
-        # If the resource config has been set, use it. Otherwise
-        # return the namespace setting
-        @batch_actions_enabled.nil? ? namespace.batch_actions : @batch_actions_enabled
-      end
-
-      # Disable or Enable batch actions for this resource
-      # Set to `nil` to inherit the setting from the namespace
-      def batch_actions=(bool)
-        @batch_actions_enabled = bool
-      end
-
-      # Add a new batch item to a resource
-      # @param [String] title
-      # @param [Hash] options
-      # => :if is a proc that will be called to determine if the BatchAction should be displayed
-      # => :sort_order is used to sort the batch actions ascending
-      # => :confirm is a string to prompt the user with (or a boolean to use the default message)
-      # => :form is a Hash of form fields you want the user to fill out
-      #
-      def add_batch_action(sym, title, options = {}, &block)
-        @batch_actions[sym] = ActiveAdmin::BatchAction.new(sym, title, options, &block)
-      end
-
-      # Remove a batch action
-      # @param [Symbol] sym
-      # @return [ActiveAdmin::BatchAction] the batch action, if it was present
-      #
-      def remove_batch_action(sym)
-        @batch_actions.delete(sym.to_sym)
-      end
-
-      # Clears all the existing batch actions for this resource
-      def clear_batch_actions!
-        @batch_actions = {}
-      end
-
-      private
-
-      # @return [ActiveAdmin::BatchAction] The default "delete" action
-      def add_default_batch_action
-        destroy_options = {
-          priority: 100,
-          confirm: proc{ I18n.t('active_admin.batch_actions.delete_confirmation', plural_model: active_admin_config.plural_resource_label.downcase) },
-          if: proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
-        }
-
-        add_batch_action :destroy, proc { I18n.t('active_admin.delete') }, destroy_options do |selected_ids|
-          batch_action_collection.find(selected_ids).each do |record|
-            authorize! ActiveAdmin::Auth::DESTROY, record
-            destroy_resource(record)
-          end
-
-          redirect_to active_admin_config.route_collection_path(params),
-                      notice: I18n.t("active_admin.batch_actions.succesfully_destroyed",
-                                        count: selected_ids.count,
-                                        model: active_admin_config.resource_label.downcase,
-                                        plural_model: active_admin_config.plural_resource_label(count: selected_ids.count).downcase)
-        end
-      end
-
-    end
-  end
-
-  class BatchAction
-
-    include Comparable
-
-    attr_reader :block, :title, :sym
-
-    DEFAULT_CONFIRM_MESSAGE = proc{ I18n.t 'active_admin.batch_actions.default_confirmation' }
-
-    # Create a Batch Action
-    #
-    # Examples:
-    #
-    #   BatchAction.new :flag
-    # => Will create an action that appears in the action list popover
-    #
-    #   BatchAction.new(:flag) { |selection| redirect_to collection_path, notice: "#{selection.length} users flagged" }
-    # => Will create an action that uses a block to process the request (which receives one paramater of the selected objects)
-    #
-    #   BatchAction.new("Perform Long Operation on") { |selection| }
-    # => You can create batch actions with a title instead of a Symbol
-    #
-    #   BatchAction.new(:flag, if: proc{ can? :flag, AdminUser }) { |selection| }
-    # => You can provide an `:if` proc to choose when the batch action should be displayed
-    #
-    #   BatchAction.new :flag, confirm: true
-    # => You can pass `true` to `:confirm` to use the default confirm message.
-    #
-    #   BatchAction.new(:flag, confirm: "Are you sure?") { |selection| }
-    # => You can pass a custom confirmation message through `:confirm`
-    #
-    #   BatchAction.new(:flag, form: {foo: :text, bar: :checkbox}) { |selection, inputs| }
-    # => You can pass a hash of options to `:form` that will be rendered as form input fields for the user to fill out.
-    #
-    def initialize(sym, title, options = {}, &block)
-      @sym, @title, @options, @block, @confirm = sym, title, options, block, options[:confirm]
-      @block ||= proc {}
-    end
-
-    def confirm
-      if @confirm == true
-        DEFAULT_CONFIRM_MESSAGE
-      elsif !@confirm && @options[:form]
-        DEFAULT_CONFIRM_MESSAGE
-      else
-        @confirm
-      end
-    end
-
-    def inputs
-      @options[:form]
-    end
-
-    # Returns the display if block. If the block was not explicitly defined
-    # a default block always returning true will be returned.
-    def display_if_block
-      @options[:if] || proc{ true }
-    end
-
-    # Used for sorting
-    def priority
-      @options[:priority] || 10
-    end
-
-    # sort operator
-    def <=>(other)
-      self.priority <=> other.priority
-    end
-
-  end
-
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions/views/batch_action_form.rb

@@ -1,38 +0,0 @@
-require 'active_admin/component'
-
-module ActiveAdmin
-  module BatchActions
-
-    # Build a BatchActionForm
-    class BatchActionForm < ActiveAdmin::Component
-      builder_method :batch_action_form
-
-      attr_reader :prefix_html
-
-      def build(options = {}, &block)
-        options[:id] ||= "collection_selection"
-
-        # Open a form with two hidden input fields:
-        # batch_action        => name of the specific action called
-        # batch_action_inputs => a JSON string of any requested confirmation values
-        text_node form_tag active_admin_config.route_batch_action_path(params, url_options), id: options[:id]
-        input name: :batch_action,        id: :batch_action,        type: :hidden
-        input name: :batch_action_inputs, id: :batch_action_inputs, type: :hidden
-
-        super(options)
-      end
-
-      # Override the default to_s to include a closing form tag
-      def to_s
-        content + closing_form_tag
-      end
-
-      private
-
-      def closing_form_tag
-        '</form>'.html_safe
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions/views/batch_action_selector.rb

@@ -1,58 +0,0 @@
-require 'active_admin/component'
-
-module ActiveAdmin
-  module BatchActions
-
-    class BatchActionSelector < ActiveAdmin::Component
-      builder_method :batch_action_selector
-
-      # Build a new batch actions selector
-      #
-      # @param [Array] batch_actions An array of batch actions
-      def build(batch_actions)
-        @batch_actions = Array(batch_actions)
-        @drop_down = build_drop_down
-      end
-
-      # We don't want to wrap the action list (or any other children) in
-      # an unnecessary div, so instead we just return the children
-      def to_s
-        children.to_s
-      end
-
-      private
-
-      def build_drop_down
-        return if batch_actions_to_display.empty?
-        dropdown_menu I18n.t("active_admin.batch_actions.button_label"),
-                      class: "batch_actions_selector dropdown_menu",
-                      button: { class: "disabled" } do
-          batch_actions_to_display.each do |batch_action|
-            confirmation_text = render_or_call_method_or_proc_on(self, batch_action.confirm)
-
-            options = {
-              :class         => "batch_action",
-              "data-action"  => batch_action.sym,
-              "data-confirm" => confirmation_text,
-              "data-inputs"  => render_in_context(self, batch_action.inputs).to_json
-            }
-
-            default_title = render_or_call_method_or_proc_on(self, batch_action.title)
-            title = I18n.t("active_admin.batch_actions.labels.#{batch_action.sym}", default: default_title)
-            label = I18n.t("active_admin.batch_actions.action_label", title: title)
-
-            item label, "#", options
-          end
-        end
-      end
-
-      # Return the set of batch actions that should be displayed
-      def batch_actions_to_display
-        @batch_actions.select do |batch_action|
-          call_method_or_proc_on(self, batch_action.display_if_block)
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/batch_actions/views/selection_cells.rb

@@ -1,38 +0,0 @@
-require 'active_admin/component'
-
-module ActiveAdmin
-  module BatchActions
-
-    # Creates the toggle checkbox used to toggle the collection selection on/off
-    class ResourceSelectionToggleCell < ActiveAdmin::Component
-      builder_method :resource_selection_toggle_cell
-
-      def build(label_text = '')
-        label do
-          input type: "checkbox", id: "collection_selection_toggle_all", name: "collection_selection_toggle_all", class: "toggle_all"
-          text_node label_text if label_text.present?
-        end
-      end
-    end
-
-    # Creates the checkbox used to select a resource in the collection selection
-    class ResourceSelectionCell < ActiveAdmin::Component
-      builder_method :resource_selection_cell
-
-      def build(resource)
-        input type: "checkbox", id: "batch_action_item_#{resource.id}", value: resource.id, class: "collection_selection", name: "collection_selection[]"
-      end
-    end
-
-    # Creates a wrapper panel for all index pages, except for the table, as the table has the checkbox in the thead
-    class ResourceSelectionTogglePanel < ActiveAdmin::Component
-      builder_method :resource_selection_toggle_panel
-
-      def build
-        super(id: "collection_selection_toggle_panel")
-        resource_selection_toggle_cell(I18n.t('active_admin.batch_actions.selection_toggle_explanation', default: "(Toggle Selection)"))
-      end
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/callbacks.rb

@@ -1,88 +0,0 @@
-module ActiveAdmin
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    private
-
-    # Simple callback system. Implements before and after callbacks for
-    # use within the controllers.
-    #
-    # We didn't use the ActiveSupport callbacks because they do not support
-    # passing in any arbitrary object into the callback method (which we
-    # need to do)
-
-    def run_callback(method, *args)
-      case method
-      when Symbol
-        send(method, *args)
-      when Proc
-        instance_exec(*args, &method)
-      else
-        raise "Please register with callbacks using a symbol or a block/proc."
-      end
-    end
-
-    module ClassMethods
-
-      private
-
-      # Define a new callback.
-      #
-      # Example:
-      #
-      #   class MyClassWithCallbacks
-      #     include ActiveAdmin::Callbacks
-      #
-      #     define_active_admin_callbacks :save
-      #
-      #     before_save do |arg1, arg2|
-      #       # runs before save
-      #     end
-      #
-      #     after_save :call_after_save
-      #
-      #     def save
-      #       # Will run before, yield, then after
-      #       run_save_callbacks :arg1, :arg2 do
-      #         save!
-      #       end
-      #     end
-      #
-      #     protected
-      #
-      #     def call_after_save(arg1, arg2)
-      #       # runs after save
-      #     end
-      #   end
-      #
-      def define_active_admin_callbacks(*names)
-        names.each do |name|
-          [:before, :after].each do |type|
-            callback_name = "#{type}_#{name}_callbacks"
-            callback_ivar = "@#{callback_name}"
-
-            # def self.before_create_callbacks
-            singleton_class.send :define_method, callback_name do
-              instance_variable_get(callback_ivar) || instance_variable_set(callback_ivar, [])
-            end
-            singleton_class.send :private, callback_name
-
-            # def self.before_create
-            singleton_class.send :define_method, "#{type}_#{name}" do |method = nil, &block|
-              send(callback_name).push method || block
-            end
-          end
-
-          # def run_create_callbacks
-          define_method "run_#{name}_callbacks" do |*args, &block|
-            self.class.send("before_#{name}_callbacks").each{ |cbk| run_callback(cbk, *args) }
-            value = block.try :call
-            self.class.send("after_#{name}_callbacks").each { |cbk| run_callback(cbk, *args) }
-            return value
-          end
-          send :private, "run_#{name}_callbacks"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-f71b375325eb/lib/active_admin/cancan_adapter.rb

@@ -1,36 +0,0 @@
-unless ActiveAdmin::Dependency.cancan? || ActiveAdmin::Dependency.cancancan?
-  ActiveAdmin::Dependency.cancan!
-end
-
-require 'cancan'
-
-# Add a setting to the application to configure the ability
-ActiveAdmin::Application.inheritable_setting :cancan_ability_class, "Ability"
-
-module ActiveAdmin
-
-  class CanCanAdapter < AuthorizationAdapter
-
-    def authorized?(action, subject = nil)
-      cancan_ability.can?(action, subject)
-    end
-
-    def cancan_ability
-      @cancan_ability ||= initialize_cancan_ability
-    end
-
-    def scope_collection(collection, action = ActiveAdmin::Auth::READ)
-      collection.accessible_by(cancan_ability, action)
-    end
-
-    private
-
-    def initialize_cancan_ability
-      klass = resource.namespace.cancan_ability_class
-      klass = klass.constantize if klass.is_a? String
-      klass.new user
-    end
-
-  end
-
-end