activeadmin 0.5.1 → 0.6.0

data/lib/active_admin/resource_controller/data_access.rb

@@ -0,0 +1,299 @@
+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
+      extend ActiveSupport::Concern
+
+      include ActiveAdmin::Callbacks
+      include ActiveAdmin::ScopeChain
+
+      included do
+        define_active_admin_callbacks :build, :create, :update, :save, :destroy
+      end
+
+      protected
+
+      # 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.
+      #
+      # @returns [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
+      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.
+      #
+      # @returns [ActiveRecord::Relation] The collectin for the index
+      def find_collection
+        collection = scoped_collection
+
+        collection = apply_sorting(collection)
+        collection = apply_filtering(collection)
+        collection = apply_scoping(collection)
+        collection = apply_pagination(collection)
+        collection = apply_decorator(collection)
+
+        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
+        scope_for_authorization 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
+      #
+      # @returns [ActiveRecord::Base] An active record object
+      def resource
+        _resource = get_resource_ivar
+
+        return _resource if _resource
+
+        _resource = find_resource
+        authorize_resource! _resource
+
+        if decorator?
+          _resource = decorator_class.new(_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.
+      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.
+      #
+      # @returns [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
+
+        set_resource_ivar(resource)
+      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
+      def build_new_resource
+        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]
+      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
+      #
+      # @returns [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.
+      #
+      # @returns [void]
+      def update_resource(object, attributes)
+        if object.respond_to?(:assign_attributes)
+          object.assign_attributes(*attributes)
+        else
+          object.attributes = attributes[0]
+        end
+
+        run_update_callbacks object do
+          save_resource(object)
+        end
+      end
+
+      # Destroys an object from the database and calls appropriate callbacks.
+      #
+      # @returns [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
+      #
+      # @retruns [ActiveRecord::Relation] a scoped collection of query
+      def scope_for_authorization(collection)
+        active_admin_authorization.scope_collection(collection)
+      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}")
+        else
+          chain # just return the chain
+        end
+      end
+
+      def apply_filtering(chain)
+        @search = chain.metasearch(clean_search_params(params[:q]))
+        @search.relation
+      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 == ""
+        end
+        search_params
+      end
+
+      def apply_scoping(chain)
+        @collection_before_scope = chain
+
+        if current_scope
+          scope_chain(current_scope, chain)
+        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]
+        else
+          active_admin_config.default_scope
+        end
+      end
+
+      def apply_pagination(chain)
+        page_method_name = Kaminari.config.page_method_name
+        page = params[Kaminari.config.param_name]
+
+        chain.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
+      end
+
+      def max_csv_records
+        10_000
+      end
+
+      def max_per_page
+        10_000
+      end
+
+      def apply_decorator(chain)
+        if decorator?
+          decorator_class.decorate_collection(chain)
+        else
+          chain
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/decorators.rb

@@ -12,8 +12,9 @@ module ActiveAdmin
       def active_admin_collection
         decorator = active_admin_config.decorator_class
         collection = super
-        decorator ? decorator.decorate(collection) : collection
+        decorator ? decorator.decorate_collection(collection) : collection
       end
+
     end
   end
 end

data/lib/active_admin/resource_dsl.rb

@@ -18,7 +18,7 @@ module ActiveAdmin
     #   end
     #
     # Then every time we instantiate and object, it would call
-    #   
+    #
     #   current_user.posts.build
     #
     # By default Active Admin will use the resource name to build a
@@ -28,7 +28,7 @@ module ActiveAdmin
     #   scope_to :current_user, :association_method => :blog_posts
     #
     # will result in the following
-    # 
+    #
     #   current_user.blog_posts.build
     #
     def scope_to(*args, &block)
@@ -49,7 +49,7 @@ module ActiveAdmin
       options[:as] ||= :table
       config.set_page_presenter :index, ActiveAdmin::PagePresenter.new(options, &block)
     end
-
+    
     # Configure the show page for the resource
     def show(options = {}, &block)
       config.set_page_presenter :show, ActiveAdmin::PagePresenter.new(options, &block)
@@ -94,9 +94,9 @@ module ActiveAdmin
     #
     # You can treat everything within the block as a standard Rails controller
     # action.
-    # 
-    def member_action(name, options = {}, &block)
-      config.member_actions << ControllerAction.new(name, options)
+    #
+    def action(set, name, options = {}, &block)
+      set << ControllerAction.new(name, options)
       title = options.delete(:title)
 
       controller do
@@ -105,14 +105,12 @@ module ActiveAdmin
       end
     end
 
-    def collection_action(name, options = {}, &block)
-      config.collection_actions << ControllerAction.new(name, options)
-      title = options.delete(:title)
+    def member_action(name, options = {}, &block)
+      action config.member_actions, name, options, &block
+    end
 
-      controller do
-        before_filter(:only => [name]){ @page_title = title } if title
-        define_method(name, &block || Proc.new{})
-      end
+    def collection_action(name, options = {}, &block)
+      action config.collection_actions, name, options, &block
     end
 
     # Defined Callbacks
@@ -151,7 +149,7 @@ module ActiveAdmin
     # Specify which actions to create in the controller
     #
     # Eg:
-    #   
+    #
     #   ActiveAdmin.register Post do
     #     actions :index, :show
     #   end

data/lib/active_admin/router.rb

@@ -1,6 +1,5 @@
 module ActiveAdmin
   class Router
-
     def initialize(application)
       @application = application
     end
@@ -14,63 +13,42 @@ module ActiveAdmin
     #   end
     #
     def apply(router)
-      # Define any necessary dashboard routes and root
-      router.instance_exec(@application.namespaces.values) do |namespaces|
-        namespaces.each do |namespace|
-          root_and_dashboard_routes = Proc.new do
-            root :to => (namespace.root_to || "dashboard#index")
-            if ActiveAdmin::Dashboards.built?
-              match '/dashboard' => 'dashboard#index', :as => 'dashboard'
-            end
-          end
+      define_basic_routes router
+      define_resource_routes router
+    end
 
+    # Define any necessary dashboard routes and root
+    def define_basic_routes(router)
+      router.instance_exec(@application.namespaces.values, self) do |namespaces, aa_router|
+        namespaces.each do |namespace|
           if namespace.root?
-            instance_eval &root_and_dashboard_routes
+            instance_eval &aa_router.root_and_dashboard_routes(namespace)
           else
             namespace(namespace.name) do
-              instance_eval &root_and_dashboard_routes
+              instance_eval &aa_router.root_and_dashboard_routes(namespace)
             end
           end
         end
       end
+    end
 
-      # Now define the routes for each resource
-      router.instance_exec(@application.namespaces) do |namespaces|
-        resources = namespaces.values.collect{|n| n.resources.resources }.flatten
-        resources.each do |config|
-
-          # Define the block the will get eval'd within the namespace
-          route_definition_block = Proc.new do
-            case config
-            when Resource
-              resources config.resource_name.route_key, :only => config.defined_actions do
-                # Define any member actions
-                member do
-                  config.member_actions.each do |action|
-                    # eg: get :comment
-                    send(action.http_verb, action.name)
-                  end
-                end
-
-                # Define any collection actions
-                collection do
-                  config.collection_actions.each do |action|
-                    send(action.http_verb, action.name)
-                  end
+    def root_and_dashboard_routes(namespace)
+      Proc.new do
+        root :to => (namespace.root_to || "dashboard#index")
+        if ActiveAdmin::Dashboards.built?
+          match '/dashboard' => 'dashboard#index', :as => 'dashboard'
+        end
+      end
+    end
 
-                  post :batch_action
-                end
-              end
-            when Page
+    # Define the routes for each resource
+    def define_resource_routes(router)
+      resource_routes = method(:resource_routes)
 
-              match "/#{config.underscored_resource_name}" => "#{config.underscored_resource_name}#index"
-              config.page_actions.each do |action|
-                match "/#{config.underscored_resource_name}/#{action.name}" => "#{config.underscored_resource_name}##{action.name}", :via => action.http_verb
-              end
-            else
-              raise "Unsupported config class: #{config.class}"
-            end
-          end
+      router.instance_exec(@application.namespaces, self) do |namespaces, aa_router|
+        resources = namespaces.values.collect{|n| n.resources.resources }.flatten
+        resources.each do |config|
+          route_definition_block = aa_router.resource_routes(config)
 
           # Add in the parent if it exists
           if config.belongs_to?
@@ -84,15 +62,6 @@ module ActiveAdmin
               resources config.belongs_to_config.target.resource_name.plural, :only => [] do
                 instance_eval &routes_for_belongs_to
               end
-
-              # Batch action path is not nested.
-              if config.is_a?(Resource)
-                resources config.resource_name.route_key, :only => config.defined_actions do
-                  collection do
-                    post :batch_action
-                  end
-                end
-              end
             end
           end
 
@@ -110,5 +79,41 @@ module ActiveAdmin
         end
       end
     end
+
+    def resource_routes(config)
+      Proc.new do
+        case config
+        when Resource
+          resources config.resource_name.route_key, :only => config.defined_actions do
+            # Define any member actions
+            member do
+              config.member_actions.each do |action|
+                [*action.http_verb].each do |http_verb|
+                  # eg: get :comment
+                  send(http_verb, action.name)
+                end
+              end
+            end
+
+            # Define any collection actions
+            collection do
+              config.collection_actions.each do |action|
+                send(action.http_verb, action.name)
+              end
+
+              post :batch_action
+            end
+          end
+        when Page
+          match "/#{config.underscored_resource_name}" => "#{config.underscored_resource_name}#index"
+          config.page_actions.each do |action|
+            match "/#{config.underscored_resource_name}/#{action.name}" => "#{config.underscored_resource_name}##{action.name}", :via => action.http_verb
+          end
+        else
+          raise "Unsupported config class: #{config.class}"
+        end
+      end
+
+    end
   end
 end