activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/resource_controller/data_access.rb

@@ -7,17 +7,28 @@ module ActiveAdmin
     # The module also deals with authorization and resource callbacks.
     #
     module DataAccess
-      extend ActiveSupport::Concern
 
-      include ActiveAdmin::Callbacks
-      include ActiveAdmin::ScopeChain
+      def self.included(base)
+        base.class_exec do
+          include Callbacks
+          include ScopeChain
 
-      included do
-        define_active_admin_callbacks :build, :create, :update, :save, :destroy
+          define_active_admin_callbacks :build, :create, :update, :save, :destroy
+        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.
       #
@@ -25,16 +36,13 @@ module ActiveAdmin
       # either the @collection instance variable or an instance variable named
       # after the resource that the collection is for. eg: Post => @post.
       #
-      # @returns [ActiveRecord::Relation] The collection for the index
+      # @return [ActiveRecord::Relation] The collection for the index
       def collection
-        _collection = get_collection_ivar
-
-        return _collection if _collection
-
-        _collection = find_collection
-        authorize! ActiveAdmin::Authorization::READ, active_admin_config.resource_class
-
-        set_collection_ivar _collection
+        get_collection_ivar || begin
+          collection = find_collection
+          authorize! Authorization::READ, active_admin_config.resource_class
+          set_collection_ivar collection
+        end
       end
 
 
@@ -43,17 +51,12 @@ module ActiveAdmin
       # some additional db # work before your controller returns and
       # authorizes the collection.
       #
-      # @returns [ActiveRecord::Relation] The collectin for the index
-      def find_collection
+      # @return [ActiveRecord::Relation] The collection for the index
+      def find_collection(options = {})
         collection = scoped_collection
-
-        collection = apply_authorization_scope(collection)
-        collection = apply_sorting(collection)
-        collection = apply_filtering(collection)
-        collection = apply_scoping(collection)
-        collection = apply_pagination(collection)
-        collection = apply_decorator(collection)
-
+        collection_applies(options).each do |applyer|
+          collection = send("apply_#{applyer}", collection)
+        end
         collection
       end
 
@@ -81,37 +84,27 @@ module ActiveAdmin
       #   * update
       #   * destroy
       #
-      # @returns [ActiveRecord::Base] An active record object
+      # @return [ActiveRecord::Base] An active record object
       def resource
-        _resource = get_resource_ivar
-
-        return _resource if _resource
-
-        _resource = find_resource
-        authorize_resource! _resource
+        get_resource_ivar || begin
+          resource = find_resource
+          authorize_resource! resource
 
-        if decorator?
-          _resource = decorator_class.new(_resource)
+          resource = apply_decorator resource
+          set_resource_ivar resource
         end
-
-        set_resource_ivar(_resource)
-      end
-
-      def decorator?
-        !!active_admin_config.decorator_class
       end
 
-      def decorator_class
-        active_admin_config.decorator_class
-      end
-
-
       # Does the actual work of finding a resource in the database. This
       # method uses the finder method as defined in InheritedResources.
       #
-      # @returns [ActiveRecord::Base] An active record object.
+      # Note that public_send can't be used here because Rails 3.2's
+      # ActiveRecord::Associations::CollectionProxy (belongs_to associations)
+      # mysteriously returns an Enumerator object.
+      #
+      # @return [ActiveRecord::Base] An active record object.
       def find_resource
-        scoped_collection.send(method_for_find, params[:id])
+        scoped_collection.send method_for_find, params[:id]
       end
 
 
@@ -122,31 +115,34 @@ module ActiveAdmin
       # This method is used to instantiate and authorize new resources in the
       # new and create controller actions.
       #
-      # @returns [ActiveRecord::Base] An un-saved active record base object
+      # @return [ActiveRecord::Base] An un-saved active record base object
       def build_resource
-        return resource if resource = get_resource_ivar
-
-        resource = build_new_resource
-
-        run_build_callbacks resource
-        authorize_resource! resource
+        get_resource_ivar || begin
+          resource = build_new_resource
+          run_build_callbacks resource
+          authorize_resource! resource
 
-        set_resource_ivar(resource)
+          resource = apply_decorator resource
+          set_resource_ivar resource
+        end
       end
 
       # Builds a new resource. This method uses the method_for_build provided
       # by Inherited Resources.
       #
-      # @returns [ActiveRecord::Base] An un-saved active record base object
+      # Note that public_send can't be used here w/ Rails 3.2 & a belongs_to
+      # config, or you'll get undefined method `build' for []:Array.
+      #
+      # @return [ActiveRecord::Base] An un-saved active record base object
       def build_new_resource
-        scoped_collection.send(method_for_build, *resource_params)
+        scoped_collection.send method_for_build, *resource_params
       end
 
       # Calls all the appropriate callbacks and then creates the new resource.
       #
       # @param [ActiveRecord::Base] object The new resource to create
       #
-      # @returns [void]
+      # @return [void]
       def create_resource(object)
         run_create_callbacks object do
           save_resource(object)
@@ -157,7 +153,7 @@ module ActiveAdmin
       #
       # @param [ActiveRecord::Base] object The new resource to save
       #
-      # @returns [void]
+      # @return [void]
       def save_resource(object)
         run_save_callbacks object do
           object.save
@@ -173,7 +169,7 @@ module ActiveAdmin
       #                           and the Active Record "role" in the second. The role
       #                           may be set to nil.
       #
-      # @returns [void]
+      # @return [void]
       def update_resource(object, attributes)
         if object.respond_to?(:assign_attributes)
           object.assign_attributes(*attributes)
@@ -188,7 +184,7 @@ module ActiveAdmin
 
       # Destroys an object from the database and calls appropriate callbacks.
       #
-      # @returns [void]
+      # @return [void]
       def destroy_resource(object)
         run_destroy_callbacks object do
           object.destroy
@@ -208,40 +204,37 @@ module ActiveAdmin
       #
       # @param [ActiveRecord::Relation] collection The collection to scope
       #
-      # @retruns [ActiveRecord::Relation] a scoped collection of query
+      # @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
-        if params[:order] && params[:order] =~ /^([\w\_\.]+)_(desc|asc)$/
-          column = $1
-          order  = $2
-          table  = active_admin_config.resource_column_names.include?(column) ? active_admin_config.resource_table_name : nil
-          table_column = (column =~ /\./) ? column :
-            [table, active_admin_config.resource_quoted_column_name(column)].compact.join(".")
-
-          chain.reorder("#{table_column} #{order}")
+
+        order_clause = OrderClause.new params[:order]
+
+        if order_clause.valid?
+          chain.reorder(order_clause.to_sql(active_admin_config))
         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.metasearch(clean_search_params(params[:q]))
-        @search.relation
+        @search = chain.ransack clean_search_params params[:q]
+        @search.result
       end
 
-      def clean_search_params(search_params)
-        return {} unless search_params.is_a?(Hash)
-        search_params = search_params.dup
-        search_params.delete_if do |key, value|
-          value == ""
+      def clean_search_params(params)
+        if params.is_a? Hash
+          params.dup.delete_if{ |key, value| value.blank? }
+        else
+          {}
         end
-        search_params
       end
 
       def apply_scoping(chain)
@@ -254,13 +247,21 @@ module ActiveAdmin
         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]) if params[:scope]
+          active_admin_config.get_scope_by_id(params[:scope])
         else
           active_admin_config.default_scope(self)
         end
@@ -270,32 +271,39 @@ module ActiveAdmin
         page_method_name = Kaminari.config.page_method_name
         page = params[Kaminari.config.param_name]
 
-        chain.send(page_method_name, page).per(per_page)
+        chain.public_send(page_method_name, page).per(per_page)
       end
 
-      def per_page
-        return max_csv_records if request.format == 'text/csv'
-        return max_per_page if active_admin_config.paginate == false
-
-        @per_page || active_admin_config.per_page
+      def collection_applies(options = {})
+        only = Array(options.fetch(:only, COLLECTION_APPLIES))
+        except = Array(options.fetch(:except, []))
+        COLLECTION_APPLIES && only - except
       end
 
-      def max_csv_records
-        10_000
+      def per_page
+        if active_admin_config.paginate
+          dynamic_per_page || configured_per_page
+        else
+          max_per_page
+        end
       end
 
-      def max_per_page
-        10_000
+      def dynamic_per_page
+        params[:per_page] || @per_page
       end
 
-      def apply_decorator(chain)
-        if decorator?
-          decorator_class.decorate_collection(chain)
+      def configured_per_page
+        if active_admin_config.per_page.is_a?(Array)
+          active_admin_config.per_page[0]
         else
-          chain
+          active_admin_config.per_page
         end
       end
 
+      def max_per_page
+        10_000
+      end
+
     end
   end
 end

data/lib/active_admin/resource_controller/decorators.rb

@@ -1,20 +1,102 @@
 module ActiveAdmin
   class ResourceController < BaseController
     module Decorators
-      protected
 
-      def resource
-        decorator = active_admin_config.decorator_class
-        resource = super
-        decorator ? decorator.new(resource) : resource
+    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'
+          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
 
-      def active_admin_collection
-        decorator = active_admin_config.decorator_class
-        collection = super
-        decorator ? decorator.decorate_collection(collection) : collection
+      # 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, :num_pages, :to_key, :group_values, :except,
+                     :find_each
+
+            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/streaming.rb

@@ -0,0 +1,37 @@
+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'
+        self.response_body = Enumerator.new &block
+      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-Disposition'] = %{attachment; filename="#{csv_filename}"}
+        stream_resource &active_admin_config.csv_builder.method(:build).to_proc.curry[self]
+      end
+
+    end
+  end
+end