activeadmin 0.6.0 → 0.6.1

data/lib/active_admin/resource_controller.rb

@@ -24,24 +24,20 @@ module ActiveAdmin
     include Sidebars
     extend  ResourceClassMethods
 
-    class << self
-      def active_admin_config=(config)
-        @active_admin_config = config
-
-        unless config.nil?
-          defaults :resource_class => config.resource_class, :route_prefix => config.route_prefix, :instance_name => config.resource_name.singular
-        end
-      end
-
-      # Inherited Resources uses the inherited(base) hook method to
-      # add in the Base.resource_class class method. To override it, we
-      # need to install our resource_class method each time we're inherited from.
-      def inherited(base)
-        super(base)
-        base.override_resource_class_methods!
+    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
 
-      public :belongs_to
+    # 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

data/lib/active_admin/resource_controller/data_access.rb

@@ -21,8 +21,8 @@ module ActiveAdmin
       # 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 
+      # 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
@@ -38,15 +38,16 @@ module ActiveAdmin
       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 
+      # 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_authorization_scope(collection)
         collection = apply_sorting(collection)
         collection = apply_filtering(collection)
         collection = apply_scoping(collection)
@@ -67,10 +68,10 @@ module ActiveAdmin
       # scope_to method from the Scoping module instead of overriding this
       # method.
       def scoped_collection
-        scope_for_authorization end_of_association_chain
+        end_of_association_chain
       end
 
-      # Retrieve, memoize and authorize a resource based on params[:id]. The 
+      # 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:
@@ -105,7 +106,7 @@ module ActiveAdmin
       end
 
 
-      # Does the actual work of finding a resource in the database. This 
+      # 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.
@@ -114,8 +115,8 @@ module ActiveAdmin
       end
 
 
-      # Builds, memoize and authorize a new instance of the resource. The 
-      # actual work of building the new instance is delegated to the 
+      # 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
@@ -202,14 +203,15 @@ module ActiveAdmin
 
       # Gives the authorization library a change to pre-scope the collection.
       #
-      # In the case of the CanCan adapter, it calls `#accessible_by` on 
+      # 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)
+      def apply_authorization_scope(collection)
+        action_name = action_to_permission(params[:action])
+        active_admin_authorization.scope_collection(collection, action_name)
       end
 
 
@@ -260,28 +262,23 @@ module ActiveAdmin
         @current_scope ||= if params[:scope]
           active_admin_config.get_scope_by_id(params[:scope]) if params[:scope]
         else
-          active_admin_config.default_scope
+          active_admin_config.default_scope(self)
         end
       end
 
       def apply_pagination(chain)
-        page_method_name = Kaminari.config.page_method_name
-        page = params[Kaminari.config.param_name]
+        page_method = Kaminari.config.page_method_name
+        page_param  = params[Kaminari.config.param_name]
 
-        chain.send(page_method_name, page).per(per_page)
+        chain.send(page_method, page_param).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

data/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -2,11 +2,11 @@ module ActiveAdmin
   class ResourceController < BaseController
     module ResourceClassMethods
 
-      # Override the default resource_class class and instance
+      # 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!
-        self.class_eval do
+        class_exec do
           def self.resource_class=(klass); end
 
           def self.resource_class

data/lib/active_admin/resource_controller/scoping.rb

@@ -11,16 +11,11 @@ module ActiveAdmin
       # 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
-        case active_admin_config.scope_to
-        when Proc
-          instance_eval &active_admin_config.scope_to
-        when Symbol
-          send active_admin_config.scope_to
-        else
-          raise ArgumentError, "#scope_to accepts a symbol or a block"
-        end
+        return nil unless active_admin_config.scope_to?(self)
+        render_in_context(self, active_admin_config.scope_to_method)
       end
 
       # Overriding from InheritedResources::BaseHelpers

data/lib/active_admin/resource_dsl.rb

@@ -7,36 +7,9 @@ module ActiveAdmin
       config.belongs_to(target, options)
     end
 
-    # Scope this controller to some object which has a relation
-    # to the resource. Can either accept a block or a symbol 
-    # of a method to call.
-    #
-    # Eg:
-    #
-    #   ActiveAdmin.register Post do
-    #     scope_to :current_user
-    #   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
-    # method to call as the association. If its different, you can 
-    # pass in the association_method as an option.
-    #
-    #   scope_to :current_user, :association_method => :blog_posts
-    #
-    # will result in the following
-    #
-    #   current_user.blog_posts.build
-    #
+    # Scope collection to a relation
     def scope_to(*args, &block)
-      options = args.extract_options!
-      method = args.first
-
-      config.scope_to = block_given? ? block : method
-      config.scope_to_association_method = options[:association_method]
+      config.scope_to(*args, &block)
     end
 
     # Create a scope
@@ -49,7 +22,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)
@@ -68,7 +41,7 @@ module ActiveAdmin
     #     column("Author") { |post| post.author.full_name }
     #   end
     #
-    #   csv :separator => ";", :options => { :force_quotes => true } do
+    #   csv :col_sep => ";", :force_quotes => true do
     #     column :name
     #   end
     #
@@ -144,7 +117,7 @@ module ActiveAdmin
     delegate :before_destroy, :after_destroy, :to => :controller
 
     # Standard rails filters
-    delegate :before_filter, :skip_before_filter, :after_filter, :around_filter, :to => :controller
+    delegate :before_filter, :skip_before_filter, :after_filter, :around_filter, :skip_filter, :to => :controller
 
     # Specify which actions to create in the controller
     #

data/lib/active_admin/router.rb

@@ -13,101 +13,88 @@ module ActiveAdmin
     #   end
     #
     def apply(router)
-      define_basic_routes router
+      define_root_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|
+    def define_root_routes(router)
+      router.instance_exec @application.namespaces.values do |namespaces|
         namespaces.each do |namespace|
           if namespace.root?
-            instance_eval &aa_router.root_and_dashboard_routes(namespace)
+            root :to => namespace.root_to
           else
-            namespace(namespace.name) do
-              instance_eval &aa_router.root_and_dashboard_routes(namespace)
+            namespace namespace.name do
+              root :to => namespace.root_to
             end
           end
         end
       end
     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
-
-    # Define the routes for each resource
+    # Defines the routes for each resource
     def define_resource_routes(router)
-      resource_routes = method(:resource_routes)
-
-      router.instance_exec(@application.namespaces, self) do |namespaces, aa_router|
-        resources = namespaces.values.collect{|n| n.resources.resources }.flatten
+      router.instance_exec @application.namespaces, self do |namespaces, aa_router|
+        resources = namespaces.values.map{ |n| n.resources.values }.flatten
         resources.each do |config|
-          route_definition_block = aa_router.resource_routes(config)
+          routes = aa_router.resource_routes(config)
 
           # Add in the parent if it exists
           if config.belongs_to?
-            routes_for_belongs_to = route_definition_block.dup
-            route_definition_block = Proc.new do
-              # If its optional, make the normal resource routes
-              instance_eval &routes_for_belongs_to if config.belongs_to_config.optional?
+            belongs_to = routes
+            routes     = Proc.new do
+              # If it's optional, make the normal resource routes
+              instance_exec &belongs_to if config.belongs_to_config.optional?
 
               # Make the nested belongs_to routes
               # :only is set to nothing so that we don't clobber any existing routes on the resource
               resources config.belongs_to_config.target.resource_name.plural, :only => [] do
-                instance_eval &routes_for_belongs_to
+                instance_exec &belongs_to
               end
             end
           end
 
           # Add on the namespace if required
           unless config.namespace.root?
-            routes_in_namespace = route_definition_block.dup
-            route_definition_block = Proc.new do
+            nested = routes
+            routes = Proc.new do
               namespace config.namespace.name do
-                instance_eval(&routes_in_namespace)
+                instance_exec &nested
               end
             end
           end
 
-          instance_eval &route_definition_block
+          instance_exec &routes
         end
       end
     end
 
     def resource_routes(config)
       Proc.new do
+        # Builds one route for each HTTP verb passed in
+        build_route  = proc{ |verbs, *args|
+          [*verbs].each{ |verb| send verb, *args }
+        }
+        # Deals with +ControllerAction+ instances
+        build_action = proc{ |action|
+          build_route.call(action.http_verb, action.name)
+        }
         case config
-        when Resource
+        when ::ActiveAdmin::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
+              config.member_actions.each &build_action
             end
 
-            # Define any collection actions
             collection do
-              config.collection_actions.each do |action|
-                send(action.http_verb, action.name)
-              end
-
+              config.collection_actions.each &build_action
               post :batch_action
             end
           end
-        when Page
-          match "/#{config.underscored_resource_name}" => "#{config.underscored_resource_name}#index"
+        when ::ActiveAdmin::Page
+          page = config.underscored_resource_name
+          get "/#{page}" => "#{page}#index"
           config.page_actions.each do |action|
-            match "/#{config.underscored_resource_name}/#{action.name}" => "#{config.underscored_resource_name}##{action.name}", :via => action.http_verb
+            build_route.call action.http_verb, "/#{page}/#{action.name}" => "#{page}##{action.name}"
           end
         else
           raise "Unsupported config class: #{config.class}"

data/lib/active_admin/scope.rb

@@ -1,7 +1,7 @@
 module ActiveAdmin
   class Scope
 
-    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block
 
     # Create a Scope
     #
@@ -13,7 +13,7 @@ module ActiveAdmin
     #   Scope.new('Published', :public)
     #   # => Scope with name 'Published' and scope method :public
     #
-    #   Scope.new 'Published', :public, :if => proc { current_admin_user.can? :manage, resource_class } do |articles| 
+    #   Scope.new 'Published', :public, :if => proc { current_admin_user.can? :manage, resource_class } do |articles|
     #     articles.where :published => true
     #   end
     #   # => Scope with name 'Published' and scope method :public, optionally displaying the scope per the :if block
@@ -39,7 +39,9 @@ module ActiveAdmin
       @scope_method, @scope_block = nil, block if block_given?
 
       @show_count       = options[:show_count].nil? ? true : options[:show_count]
-      @display_if_block = options[:if] || proc{ true }
+      @display_if_block = options[:if]      || proc{ true }
+      @default_block    = options[:default] || proc{ false }
+
     end
 
     def name

data/lib/active_admin/sidebar_section.rb

@@ -16,7 +16,7 @@ module ActiveAdmin
     end
 
     def icon?
-      options[:icon]
+      !!options[:icon]
     end
 
     def icon

data/lib/active_admin/version.rb

@@ -1,3 +1,3 @@
 module ActiveAdmin
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

data/lib/active_admin/view_factory.rb

@@ -5,12 +5,12 @@ module ActiveAdmin
 
     # Register Helper Renderers
     register  :global_navigation    => ActiveAdmin::Views::TabbedNavigation,
+              :utility_navigation   => ActiveAdmin::Views::TabbedNavigation,
               :site_title           => ActiveAdmin::Views::SiteTitle,
               :action_items         => ActiveAdmin::Views::ActionItems,
               :title_bar            => ActiveAdmin::Views::TitleBar,
               :header               => ActiveAdmin::Views::Header,
               :footer               => ActiveAdmin::Views::Footer,
-              :dashboard_section    => ActiveAdmin::Views::DashboardSection,
               :index_scopes         => ActiveAdmin::Views::Scopes,
               :blank_slate          => ActiveAdmin::Views::BlankSlate,
               :action_list_popover  => ActiveAdmin::Views::ActionListPopover

data/lib/active_admin/view_helpers/auto_link_helper.rb

@@ -15,7 +15,7 @@ module ActiveAdmin
         content = link_content || display_name(resource)
         if (registration = active_admin_resource_for(resource.class))
           begin
-            content = link_to(content, send(registration.route_instance_path, resource))
+            content = link_to(content, registration.route_instance_path(resource))
           rescue
             # ignored
           end