activeadmin_addons 1.7.0 → 1.9.0

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

@@ -1,31 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    module ActionBuilder
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-        def clear_member_actions!
-          remove_action_methods(:member)
-          active_admin_config.clear_member_actions!
-        end
-
-        def clear_collection_actions!
-          remove_action_methods(:collection)
-          active_admin_config.clear_collection_actions!
-        end
-
-        private
-
-        def remove_action_methods(actions_type)
-          active_admin_config.public_send("#{actions_type}_actions").each do |action|
-            remove_method action.name
-          end
-        end
-      end
-
-    end
-
-  end
-end

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

@@ -1,322 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # This module overrides most of the data access methods in Inherited
-    # Resources to provide Active Admin with it's data.
-    #
-    # The module also deals with authorization and resource callbacks.
-    #
-    module DataAccess
-
-      def self.included(base)
-        base.class_exec do
-          include Callbacks
-          include ScopeChain
-
-          define_active_admin_callbacks :build, :create, :update, :save, :destroy
-
-          helper_method :current_scope
-        end
-      end
-
-      protected
-
-      COLLECTION_APPLIES = [
-        :authorization_scope,
-        :sorting,
-        :filtering,
-        :scoping,
-        :includes,
-        :pagination,
-        :collection_decorator
-      ].freeze
-
-      # Retrieve, memoize and authorize the current collection from the db. This
-      # method delegates the finding of the collection to #find_collection.
-      #
-      # Once #collection has been called, the collection is available using
-      # either the @collection instance variable or an instance variable named
-      # after the resource that the collection is for. eg: Post => @post.
-      #
-      # @return [ActiveRecord::Relation] The collection for the index
-      def collection
-        get_collection_ivar || begin
-          collection = find_collection
-          authorize! Authorization::READ, active_admin_config.resource_class
-          set_collection_ivar collection
-        end
-      end
-
-      # Does the actual work of retrieving the current collection from the db.
-      # This is a great method to override if you would like to perform
-      # some additional db # work before your controller returns and
-      # authorizes the collection.
-      #
-      # @return [ActiveRecord::Relation] The collection for the index
-      def find_collection(options = {})
-        collection = scoped_collection
-        collection_applies(options).each do |applyer|
-          collection = send("apply_#{applyer}", collection)
-        end
-        collection
-      end
-
-      # Override this method in your controllers to modify the start point
-      # of our searches and index.
-      #
-      # This method should return an ActiveRecord::Relation object so that
-      # the searching and filtering can be applied on top
-      #
-      # Note, unless you are doing something special, you should use the
-      # scope_to method from the Scoping module instead of overriding this
-      # method.
-      def scoped_collection
-        end_of_association_chain
-      end
-
-      # Retrieve, memoize and authorize a resource based on params[:id]. The
-      # actual work of finding the resource is done in #find_resource.
-      #
-      # This method is used on all the member actions:
-      #
-      #   * show
-      #   * edit
-      #   * update
-      #   * destroy
-      #
-      # @return [ActiveRecord::Base] An active record object
-      def resource
-        get_resource_ivar || begin
-          resource = find_resource
-          resource = apply_decorations(resource)
-          authorize_resource! resource
-
-          set_resource_ivar resource
-        end
-      end
-
-      # Does the actual work of finding a resource in the database. This
-      # method uses the finder method as defined in InheritedResources.
-      #
-      # @return [ActiveRecord::Base] An active record object.
-      def find_resource
-        scoped_collection.send method_for_find, params[:id]
-      end
-
-      # Builds, memoize and authorize a new instance of the resource. The
-      # actual work of building the new instance is delegated to the
-      # #build_new_resource method.
-      #
-      # This method is used to instantiate and authorize new resources in the
-      # new and create controller actions.
-      #
-      # @return [ActiveRecord::Base] An un-saved active record base object
-      def build_resource
-        get_resource_ivar || begin
-          resource = build_new_resource
-          resource = apply_decorations(resource)
-          resource = assign_attributes(resource, resource_params)
-          run_build_callbacks resource
-          authorize_resource! resource
-
-          set_resource_ivar resource
-        end
-      end
-
-      # Builds a new resource. This method uses the method_for_build provided
-      # by Inherited Resources.
-      #
-      # @return [ActiveRecord::Base] An un-saved active record base object
-      def build_new_resource
-        scoped_collection.send(
-          method_for_build,
-          *resource_params.map { |params| params.slice(active_admin_config.resource_class.inheritance_column) }
-        )
-      end
-
-      # Calls all the appropriate callbacks and then creates the new resource.
-      #
-      # @param [ActiveRecord::Base] object The new resource to create
-      #
-      # @return [void]
-      def create_resource(object)
-        run_create_callbacks object do
-          save_resource(object)
-        end
-      end
-
-      # Calls all the appropriate callbacks and then saves the new resource.
-      #
-      # @param [ActiveRecord::Base] object The new resource to save
-      #
-      # @return [void]
-      def save_resource(object)
-        run_save_callbacks object do
-          object.save
-        end
-      end
-
-      # Update an object with the given attributes. Also calls the appropriate
-      # callbacks for update action.
-      #
-      # @param [ActiveRecord::Base] object The instance to update
-      #
-      # @param [Array] attributes An array with the attributes in the first position
-      #                           and the Active Record "role" in the second. The role
-      #                           may be set to nil.
-      #
-      # @return [void]
-      def update_resource(object, attributes)
-        object = assign_attributes(object, attributes)
-
-        run_update_callbacks object do
-          save_resource(object)
-        end
-      end
-
-      # Destroys an object from the database and calls appropriate callbacks.
-      #
-      # @return [void]
-      def destroy_resource(object)
-        run_destroy_callbacks object do
-          object.destroy
-        end
-      end
-
-      #
-      # Collection Helper Methods
-      #
-
-      # Gives the authorization library a change to pre-scope the collection.
-      #
-      # In the case of the CanCan adapter, it calls `#accessible_by` on
-      # the collection.
-      #
-      # @param [ActiveRecord::Relation] collection The collection to scope
-      #
-      # @return [ActiveRecord::Relation] a scoped collection of query
-      def apply_authorization_scope(collection)
-        action_name = action_to_permission(params[:action])
-        active_admin_authorization.scope_collection(collection, action_name)
-      end
-
-      def apply_sorting(chain)
-        params[:order] ||= active_admin_config.sort_order
-        order_clause = active_admin_config.order_clause.new(active_admin_config, params[:order])
-
-        if order_clause.valid?
-          order_clause.apply(chain)
-        else
-          chain # just return the chain
-        end
-      end
-
-      # Applies any Ransack search methods to the currently scoped collection.
-      # Both `search` and `ransack` are provided, but we use `ransack` to prevent conflicts.
-      def apply_filtering(chain)
-        @search = chain.ransack(params[:q] || {})
-        @search.result
-      end
-
-      def apply_scoping(chain)
-        @collection_before_scope = chain
-
-        if current_scope
-          scope_chain(current_scope, chain)
-        else
-          chain
-        end
-      end
-
-      def apply_includes(chain)
-        if active_admin_config.includes.any?
-          chain.includes *active_admin_config.includes
-        else
-          chain
-        end
-      end
-
-      def collection_before_scope
-        @collection_before_scope
-      end
-
-      def current_scope
-        @current_scope ||= if params[:scope]
-                             active_admin_config.get_scope_by_id(params[:scope])
-                           else
-                             active_admin_config.default_scope(self)
-                           end
-      end
-
-      def apply_pagination(chain)
-        # skip pagination if already was paginated by scope
-        return chain if chain.respond_to?(:total_pages)
-        page_method_name = Kaminari.config.page_method_name
-        page = params[Kaminari.config.param_name]
-
-        chain.public_send(page_method_name, page).per(per_page)
-      end
-
-      def collection_applies(options = {})
-        only   = Array(options.fetch(:only, COLLECTION_APPLIES))
-        except = Array(options.fetch(:except, []))
-
-        COLLECTION_APPLIES & only - except
-      end
-
-      def per_page
-        if active_admin_config.paginate
-          dynamic_per_page || configured_per_page
-        else
-          active_admin_config.max_per_page
-        end
-      end
-
-      def dynamic_per_page
-        params[:per_page] || @per_page
-      end
-
-      def configured_per_page
-        Array(active_admin_config.per_page).first
-      end
-
-      # @param resource [ActiveRecord::Base]
-      # @param attributes [Array<Hash]
-      # @return [ActiveRecord::Base] resource
-      #
-      def assign_attributes(resource, attributes)
-        if resource.respond_to?(:assign_attributes)
-          resource.assign_attributes(*attributes)
-        else
-          resource.attributes = attributes[0]
-        end
-
-        resource
-      end
-
-      # @param resource [ActiveRecord::Base]
-      # @return [ActiveRecord::Base] resource
-      #
-      def apply_decorations(resource)
-        apply_decorator(resource)
-      end
-
-      # @return [String]
-      def smart_resource_url
-        if create_another?
-          new_resource_url(create_another: params[:create_another])
-        else
-          super
-        end
-      end
-
-      private
-
-      # @return [Boolean] true if user requested to create one more
-      #   resource after creating this one.
-      def create_another?
-        params[:create_another].present?
-      end
-    end
-  end
-end

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

@@ -1,102 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-    module Decorators
-
-      protected
-
-      def apply_decorator(resource)
-        decorate? ? decorator_class.new(resource) : resource
-      end
-
-      def apply_collection_decorator(collection)
-        if decorate?
-          collection_decorator.decorate collection, with: decorator_class
-        else
-          collection
-        end
-      end
-
-      def self.undecorate(resource)
-        if resource.respond_to?(:decorated?) && resource.decorated?
-          resource.model
-        else
-          resource
-        end
-      end
-
-      private
-
-      def decorate?
-        case action_name
-        when 'new', 'edit', 'create', 'update'
-          form = active_admin_config.get_page_presenter :form
-          form && form.options[:decorate] && decorator_class.present?
-        else
-          decorator_class.present?
-        end
-      end
-
-      def decorator_class
-        active_admin_config.decorator_class
-      end
-
-      # When using Draper, we wrap the collection draper in a new class that
-      # correctly delegates methods that Active Admin depends on.
-      def collection_decorator
-        if decorator_class
-          Wrapper.wrap decorator_class
-        end
-      end
-
-      class Wrapper
-        @cache = {}
-
-        def self.wrap(decorator)
-          collection_decorator = find_collection_decorator(decorator)
-
-          if draper_collection_decorator? collection_decorator
-            name = "#{collection_decorator.name} of #{decorator} + ActiveAdmin"
-            @cache[name] ||= wrap! collection_decorator, name
-          else
-            collection_decorator
-          end
-        end
-
-        private
-
-        def self.wrap!(parent, name)
-          ::Class.new parent do
-            delegate :reorder, :page, :current_page, :total_pages, :limit_value,
-                     :total_count, :total_pages, :to_key, :group_values, :except,
-                     :find_each, :ransack
-
-            define_singleton_method(:name) { name }
-          end
-        end
-
-        # Draper::CollectionDecorator was introduced in 1.0.0
-        # Draper::Decorator#collection_decorator_class was introduced in 1.3.0
-        def self.find_collection_decorator(decorator)
-          if Dependency.draper?    '>= 1.3.0'
-            decorator.collection_decorator_class
-          elsif Dependency.draper? '>= 1.0.0'
-            draper_collection_decorator
-          else
-            decorator
-          end
-        end
-
-        def self.draper_collection_decorator?(decorator)
-          decorator && decorator <= draper_collection_decorator
-        rescue NameError
-          false
-        end
-
-        def self.draper_collection_decorator
-          ::Draper::CollectionDecorator
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-    module ResourceClassMethods
-
-      # Override the default `resource_class` class and instance
-      # methods to only return the class defined in the instance
-      # of ActiveAdmin::Resource
-      def override_resource_class_methods!
-        class_exec do
-          def self.resource_class=(klass); end
-
-          def self.resource_class
-            @active_admin_config ? @active_admin_config.resource_class : nil
-          end
-
-          private
-
-          def resource_class
-            self.class.resource_class
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # This module deals with scoping entire controllers to a relation
-    module Scoping
-      extend ActiveSupport::Concern
-
-      protected
-
-      # Override the default InheritedResource #begin_of_association_chain to allow
-      # the scope to be defined in the active admin configuration.
-      #
-      # If scope_to is a proc, we eval it, otherwise we call the method on the controller.
-      #
-      # Collection can be scoped conditionally with an :if or :unless proc.
-      def begin_of_association_chain
-        return nil unless active_admin_config.scope_to?(self)
-        StringSymbolOrProcSetting.new(active_admin_config.scope_to_method).value(self)
-      end
-
-      # Overriding from InheritedResources::BaseHelpers
-      #
-      # Returns the method for the association chain when using
-      # the scope_to option
-      def method_for_association_chain
-        active_admin_config.scope_to_association_method || super
-      end
-
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    module Sidebars
-
-      protected
-
-      def skip_sidebar!
-        @skip_sidebar = true
-      end
-
-      def skip_sidebar?
-        @skip_sidebar == true
-      end
-    end
-
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'csv'
-
-module ActiveAdmin
-  class ResourceController < BaseController
-
-    # This module overrides CSV responses to allow large data downloads.
-    # Could be expanded to JSON and XML in the future.
-    #
-    module Streaming
-
-      def index
-        super do |format|
-          format.csv { stream_csv }
-          yield(format) if block_given?
-        end
-      end
-
-      protected
-
-      def stream_resource(&block)
-        headers['X-Accel-Buffering'] = 'no'
-        headers['Cache-Control'] = 'no-cache'
-
-        if ActiveAdmin.application.disable_streaming_in.include? Rails.env
-          self.response_body = block['']
-        else
-          self.response_body = Enumerator.new &block
-        end
-      end
-
-      def csv_filename
-        "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.zone.now.to_date.to_s(:default)}.csv"
-      end
-
-      def stream_csv
-        headers['Content-Type'] = 'text/csv; charset=utf-8' # In Rails 5 it's set to HTML??
-        headers['Content-Disposition'] = %{attachment; filename="#{csv_filename}"}
-        stream_resource &active_admin_config.csv_builder.method(:build).to_proc.curry[self]
-      end
-
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-require 'active_admin/resource_controller/action_builder'
-require 'active_admin/resource_controller/data_access'
-require 'active_admin/resource_controller/decorators'
-require 'active_admin/resource_controller/scoping'
-require 'active_admin/resource_controller/streaming'
-require 'active_admin/resource_controller/sidebars'
-require 'active_admin/resource_controller/resource_class_methods'
-
-module ActiveAdmin
-  # All Resources Controller inherits from this controller.
-  # It implements actions and helpers for resources.
-  class ResourceController < BaseController
-    layout :determine_active_admin_layout
-
-    respond_to :html, :xml, :json
-    respond_to :csv, only: :index
-
-    include ActionBuilder
-    include Decorators
-    include DataAccess
-    include Scoping
-    include Streaming
-    include Sidebars
-    include ViewHelpers::DownloadFormatLinksHelper
-    extend  ResourceClassMethods
-
-    def self.active_admin_config=(config)
-      if @active_admin_config = config
-        defaults resource_class: config.resource_class,
-                 route_prefix:   config.route_prefix,
-                 instance_name:  config.resource_name.singular
-      end
-    end
-
-    # Inherited Resources uses the `self.inherited(base)` hook to add
-    # in `self.resource_class`. To override it, we need to install
-    # our resource_class method each time we're inherited from.
-    def self.inherited(base)
-      super(base)
-      base.override_resource_class_methods!
-    end
-
-    private
-
-    # Returns the renderer class to use for the given action.
-    def renderer_for(action)
-      active_admin_namespace.view_factory["#{action}_page"]
-    end
-
-    helper_method :renderer_for
-
-    def restrict_format_access!
-      unless request.format.html?
-        presenter = active_admin_config.get_page_presenter(:index)
-        download_formats = (presenter || {}).fetch(:download_links, active_admin_config.namespace.download_links)
-        unless build_download_formats(download_formats).include?(request.format.symbol)
-          raise ActiveAdmin::AccessDenied.new(current_active_admin_user, :index)
-        end
-      end
-    end
-
-    before_action :restrict_format_access!, only: [:index, :show]
-  end
-end