activeadmin_addons 1.1.2 → 1.2.0

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/base_controller.rb

@@ -1,77 +0,0 @@
-require 'active_admin/base_controller/authorization'
-require 'active_admin/base_controller/menu'
-
-module ActiveAdmin
-  # BaseController for ActiveAdmin.
-  # It implements ActiveAdmin controllers core features.
-  class BaseController < ::InheritedResources::Base
-    helper ::ActiveAdmin::ViewHelpers
-    helper_method :env
-
-    layout :determine_active_admin_layout
-
-    before_filter :only_render_implemented_actions
-    before_filter :authenticate_active_admin_user
-
-    class << self
-      # Ensure that this method is available for the DSL
-      public :actions
-
-      # Reference to the Resource object which initialized
-      # this controller
-      attr_accessor :active_admin_config
-    end
-
-    # By default Rails will render un-implemented actions when the view exists. Because Active
-    # Admin allows you to not render any of the actions by using the #actions method, we need
-    # to check if they are implemented.
-    def only_render_implemented_actions
-      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
-    end
-
-    include Menu
-    include Authorization
-
-    private
-
-    # Calls the authentication method as defined in ActiveAdmin.authentication_method
-    def authenticate_active_admin_user
-      send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
-    end
-
-    def current_active_admin_user
-      send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
-    end
-    helper_method :current_active_admin_user
-
-    def current_active_admin_user?
-      !!current_active_admin_user
-    end
-    helper_method :current_active_admin_user?
-
-    def active_admin_config
-      self.class.active_admin_config
-    end
-    helper_method :active_admin_config
-
-    def active_admin_namespace
-      active_admin_config.namespace
-    end
-    helper_method :active_admin_namespace
-
-
-    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
-
-    # Determine which layout to use.
-    #
-    #   1.  If we're rendering a standard Active Admin action, we want layout(false)
-    #       because these actions are subclasses of the Base page (which implements
-    #       all the required layout code)
-    #   2.  If we're rendering a custom action, we'll use the active_admin layout so
-    #       that users can render any template inside Active Admin.
-    def determine_active_admin_layout
-      ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : 'active_admin'
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/base_controller/authorization.rb

@@ -1,133 +0,0 @@
-module ActiveAdmin
-  class BaseController < ::InheritedResources::Base
-    module Authorization
-      include MethodOrProcHelper
-      extend ActiveSupport::Concern
-
-      ACTIONS_DICTIONARY = {
-        index:   ActiveAdmin::Authorization::READ,
-        show:    ActiveAdmin::Authorization::READ,
-        new:     ActiveAdmin::Authorization::CREATE,
-        create:  ActiveAdmin::Authorization::CREATE,
-        edit:    ActiveAdmin::Authorization::UPDATE,
-        update:  ActiveAdmin::Authorization::UPDATE,
-        destroy: ActiveAdmin::Authorization::DESTROY
-      }
-
-      included do
-        rescue_from ActiveAdmin::AccessDenied, with: :dispatch_active_admin_access_denied
-
-        helper_method :authorized?
-        helper_method :authorize!
-      end
-
-      protected
-
-      # Authorize the action and subject. Available in the controller
-      # as well as all the views.
-      #
-      # @param [Symbol] action The action to check if the user has permission
-      #                 to perform on the subject.
-      #
-      # @param [any] subject The subject that the user is trying to perform
-      #                 the action on.
-      #
-      # @return [Boolean]
-      #
-      def authorized?(action, subject = nil)
-        active_admin_authorization.authorized?(action, subject)
-      end
-
-
-      # Authorize the action and subject. Available in the controller
-      # as well as all the views. If the action is not allowd, it raises
-      # an ActiveAdmin::AccessDenied exception.
-      #
-      # @param [Symbol] action The action to check if the user has permission
-      #                 to perform on the subject.
-      #
-      # @param [any] subject The subject that the user is trying to perform
-      #                 the action on.
-      #
-      # @return [Boolean] True if authorized, otherwise raises
-      #                 an ActiveAdmin::AccessDenied.
-      def authorize!(action, subject = nil)
-        unless authorized? action, subject
-          raise ActiveAdmin::AccessDenied.new(current_active_admin_user,
-                                              action,
-                                              subject)
-        end
-      end
-
-      # Performs authorization on the resource using the current controller
-      # action as the permission action.
-      #
-      def authorize_resource!(resource)
-        permission = action_to_permission(params[:action])
-        authorize! permission, resource
-      end
-
-      # Retrieve or instantiate the authorization instance for this resource
-      #
-      # @return [ActiveAdmin::AuthorizationAdapter]
-      def active_admin_authorization
-        @active_admin_authorization ||=
-         active_admin_authorization_adapter.new active_admin_config, current_active_admin_user
-      end
-
-      # Returns the class to be used as the authorization adapter
-      #
-      # @return [Class]
-      def active_admin_authorization_adapter
-        adapter = active_admin_namespace.authorization_adapter
-        if adapter.is_a? String
-          ActiveSupport::Dependencies.constantize adapter
-        else
-          adapter
-        end
-      end
-
-      # Converts a controller action into one of the correct Active Admin
-      # authorization names. Uses the ACTIONS_DICTIONARY to convert the
-      # action name to permission.
-      #
-      # @param [String, Symbol] action The controller action name.
-      #
-      # @return [Symbol] The permission name to use.
-      def action_to_permission(action)
-        if action && action = action.to_sym
-          Authorization::ACTIONS_DICTIONARY[action] || action
-        end
-      end
-
-      def dispatch_active_admin_access_denied(exception)
-        call_method_or_exec_proc active_admin_namespace.on_unauthorized_access, exception
-      end
-
-      def rescue_active_admin_access_denied(exception)
-        error = exception.message
-
-        respond_to do |format|
-          format.html do
-            flash[:error] = error
-            redirect_backwards_or_to_root
-          end
-
-          format.csv  { render text:          error,           status: :unauthorized }
-          format.json { render json: { error: error },         status: :unauthorized }
-          format.xml  { render xml: "<error>#{error}</error>", status: :unauthorized }
-        end
-      end
-
-      def redirect_backwards_or_to_root
-        if request.headers.key? "HTTP_REFERER"
-          redirect_to :back
-        else
-          controller, action = active_admin_namespace.root_to.split '#'
-          redirect_to controller: controller, action: action
-        end
-      end
-
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/activeadmin-a5a53c3f2b8f/lib/active_admin/base_controller/menu.rb

@@ -1,34 +0,0 @@
-module ActiveAdmin
-  class BaseController < ::InheritedResources::Base
-    module Menu
-      extend ActiveSupport::Concern
-
-      included do
-        before_filter :set_current_tab
-        helper_method :current_menu
-      end
-
-      protected
-
-      def current_menu
-        active_admin_config.navigation_menu
-      end
-
-      # Set's @current_tab to be name of the tab to mark as current
-      # Get's called through a before filter
-      def set_current_tab
-        @current_tab = if current_menu && active_admin_config.belongs_to? && parent?
-          parent_item = active_admin_config.belongs_to_config.target.menu_item
-          if current_menu.include? parent_item
-            parent_item
-          else
-            active_admin_config.menu_item
-          end
-        else
-          active_admin_config.menu_item
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,41 +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 = render_in_context(self, current_batch_action.inputs).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,
-        :collection_decorator
-      ].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-a5a53c3f2b8f/lib/active_admin/batch_actions/resource_extension.rb

@@ -1,158 +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
-
-      # Path to the batch action itself
-      def batch_action_path(params = {})
-        path = [route_collection_path(params), "batch_action"].join("/")
-        query = params.slice(:q, :scope).to_param
-        [path, query].reject(&:blank?).join("?")
-      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-a5a53c3f2b8f/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.batch_action_path(params), 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