activeadmin-rails 1.7.0

data/lib/active_admin/resource_controller/data_access.rb

@@ -0,0 +1,341 @@
+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
+
+      def permitted_params
+        permitted_params =
+          active_admin_namespace.permitted_params +
+            Array.wrap(active_admin_config.belongs_to_param)
+
+        permitted_params << :create_another if active_admin_config.create_another
+
+        param_key = active_admin_config.param_key
+
+        params.permit(*permitted_params, param_key.to_sym => permitted_attr_names)
+      end
+
+      # @return [Array] names
+      #
+      def permitted_attr_names
+        attr_names = active_admin_config.permitted_attr_names
+        attr_names.is_a?(Proc) ? instance_exec(&attr_names) : attr_names
+      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/lib/active_admin/resource_controller/decorators.rb

@@ -0,0 +1,102 @@
+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/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -0,0 +1,24 @@
+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
+
+          def resource_class
+            self.class.resource_class
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/scoping.rb

@@ -0,0 +1,31 @@
+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/lib/active_admin/resource_controller/sidebars.rb

@@ -0,0 +1,18 @@
+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/lib/active_admin/resource_controller/streaming.rb

@@ -0,0 +1,47 @@
+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[String.new]
+        else
+          self.response_body = Enumerator.new &block
+        end
+      end
+
+      def csv_builder
+        active_admin_config.csv_builder
+      end
+
+      def csv_filename
+        "#{resource_collection_name.to_s.gsub('_', '-')}-#{Time.zone.now.to_date.to_s}.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 &csv_builder.method(:build).to_proc.curry[self]
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller.rb

@@ -0,0 +1,116 @@
+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
+    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
+
+    def page_presenter
+      case params[:action].to_sym
+      when :index
+        active_admin_config.get_page_presenter(params[:action], params[:as])
+      when :new, :edit
+        active_admin_config.get_page_presenter(:form)
+      end || super
+    end
+
+    def default_page_presenter
+      case params[:action].to_sym
+      when :index
+        PagePresenter.new(as: :table)
+      when :new, :edit
+        PagePresenter.new
+      end || super
+    end
+
+    def page_title
+      if page_presenter[:title]
+        case params[:action].to_sym
+        when :index
+          case page_presenter[:title]
+          when Symbol, Proc
+            instance_exec(&page_presenter[:title])
+          else
+            page_presenter[:title]
+          end
+        else
+          helpers.render_or_call_method_or_proc_on(resource, page_presenter[:title])
+        end
+      else
+        default_page_title
+      end
+    end
+
+    def default_page_title
+      case params[:action].to_sym
+      when :index
+        active_admin_config.plural_resource_label
+      when :show
+        helpers.display_name(resource).present? ?
+          helpers.display_name(resource) :
+          "#{active_admin_config.resource_label} ##{resource.id}"
+      when :new, :edit
+        normalized_action = params[:action]
+        normalized_action = 'new' if normalized_action == 'create'
+        normalized_action = 'edit' if normalized_action == 'update'
+
+        ActiveAdmin::Localizers.resource(active_admin_config).t("#{normalized_action}_model")
+      else
+        I18n.t("active_admin.#{params[:action]}", default: params[:action].to_s.titleize)
+      end
+    end
+
+    # Returns the renderer class to use for the given action.
+    def renderer_for(action)
+      Deprecation.warn "This method does not do anything and will be removed."
+    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