activeadmin 0.5.1 → 0.6.0

data/lib/active_admin/page.rb

@@ -37,6 +37,7 @@ module ActiveAdmin
     include Resource::ActionItems
     include Resource::Menu
     include Resource::Naming
+    include Resource::Routes
 
     # label is singular
     def plural_resource_label
@@ -63,6 +64,11 @@ module ActiveAdmin
       [namespace.module_name, camelized_resource_name + "Controller"].compact.join('::')
     end
 
+    # Override from `ActiveAdmin::Resource::Controllers`
+    def route_uncountable?
+      false
+    end
+
     def belongs_to?
       false
     end

data/lib/active_admin/page_controller.rb

@@ -3,17 +3,27 @@ module ActiveAdmin
   # All Pages controllers inherit from this controller.
   class PageController < BaseController
 
-    # Pages::Page subclasses Page::Base which implements the layout code
-    layout false
+    # Active admin actions don't require layout.  All custom actions do.
+    ACTIVE_ADMIN_ACTIONS = [:index]
 
     actions :index
 
+    before_filter :authorize_access!
+
     def index(options={}, &block)
       render "active_admin/page/index"
     end
-    
+
     def clear_page_actions!
       active_admin_config.clear_page_actions!
     end
+
+    private
+
+    def authorize_access!
+      permission = action_to_permission(params[:action])
+      authorize! permission, active_admin_config
+    end
+
   end
 end

data/lib/active_admin/resource.rb

@@ -3,6 +3,7 @@ require 'active_admin/resource/controllers'
 require 'active_admin/resource/menu'
 require 'active_admin/resource/page_presenters'
 require 'active_admin/resource/pagination'
+require 'active_admin/resource/routes'
 require 'active_admin/resource/naming'
 require 'active_admin/resource/scopes'
 require 'active_admin/resource/sidebars'
@@ -68,14 +69,17 @@ module ActiveAdmin
     end
 
     include Base
+    include ActionItems
+    include Authorization
     include Controllers
+    include Menu
+    include Naming
     include PagePresenters
     include Pagination
-    include ActionItems
-    include Naming
     include Scopes
     include Sidebars
     include Menu
+    include Routes
 
     # The class this resource wraps. If you register the Post model, Resource#resource_class
     # will point to the Post class
@@ -91,6 +95,10 @@ module ActiveAdmin
       resource_class.quoted_table_name
     end
 
+    def resource_column_names
+      resource_class.column_names
+    end
+
     def resource_quoted_column_name(column)
       resource_class.connection.quote_column_name(column)
     end
@@ -100,20 +108,6 @@ module ActiveAdmin
       [route_prefix, controller.resources_configuration[:self][:route_instance_name], 'path'].compact.join('_').to_sym
     end
 
-    # Returns a symbol for the route to use to get to the
-    # collection of this resource
-    def route_collection_path
-      route = super
-
-      # Handle plural resources.
-      if controller.resources_configuration[:self][:route_collection_name] ==
-            controller.resources_configuration[:self][:route_instance_name]
-        route = route.to_s.gsub('_path', '_index_path').to_sym
-      end
-
-      route
-    end
-
     # Clears all the member actions this resource knows about
     def clear_member_actions!
       @member_actions = []
@@ -135,6 +129,7 @@ module ActiveAdmin
 
     def belongs_to(target, options = {})
       @belongs_to = Resource::BelongsTo.new(self, target, options)
+      self.menu_item_menu_name = target unless @belongs_to.optional?
       controller.belongs_to(target, options.dup)
     end
 
@@ -147,10 +142,6 @@ module ActiveAdmin
       !belongs_to_config.nil?
     end
 
-    def include_in_menu?
-      super && !(belongs_to? && !belongs_to_config.optional?)
-    end
-
     # The csv builder for this resource
     def csv_builder
       @csv_builder || default_csv_builder

data/lib/active_admin/resource/action_items.rb

@@ -53,21 +53,21 @@ module ActiveAdmin
       def add_default_action_items
         # New Link on all actions except :new and :show
         add_action_item :except => [:new, :show] do
-          if controller.action_methods.include?('new')
+          if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
             link_to(I18n.t('active_admin.new_model', :model => active_admin_config.resource_label), new_resource_path)
           end
         end
 
         # Edit link on show
         add_action_item :only => :show do
-          if controller.action_methods.include?('edit')
+          if controller.action_methods.include?('edit') && authorized?(ActiveAdmin::Auth::UPDATE, resource)
             link_to(I18n.t('active_admin.edit_model', :model => active_admin_config.resource_label), edit_resource_path(resource))
           end
         end
 
         # Destroy link on show
         add_action_item :only => :show do
-          if controller.action_methods.include?("destroy")
+          if controller.action_methods.include?("destroy") && authorized?(ActiveAdmin::Auth::DESTROY, resource)
             link_to(I18n.t('active_admin.delete_model', :model => active_admin_config.resource_label),
               resource_path(resource),
               :method => :delete, :data => {:confirm => I18n.t('active_admin.delete_confirmation')})

data/lib/active_admin/resource/controllers.rb

@@ -13,23 +13,6 @@ module ActiveAdmin
         @controller ||= controller_name.constantize
       end
 
-      # Returns the routes prefix for this config
-      def route_prefix
-        namespace.module_name.try(:underscore)
-      end
-
-      # Returns a symbol for the route to use to get to the
-      # collection of this resource
-      def route_collection_path
-        route = [
-          route_prefix, 
-          controller.resources_configuration[:self][:route_collection_name], 
-          'path'
-        ]
-
-        route.compact.join('_').to_sym
-      end
-
     end
   end
 end

data/lib/active_admin/resource/menu.rb

@@ -1,49 +1,77 @@
 module ActiveAdmin
   class Resource
+
     module Menu
 
       # Set the menu options. To not add this resource to the menu, just
       # call #menu(false)
-      def menu(options = {})
+      def menu_item_options=(options)
         if options == false
-          @display_menu = false
+          @navigation_menu = false
+          @menu_item_options = {}
         else
-          options = default_menu_options.merge(options)
-          @parent_menu_item = value_or_proc(options.delete(:parent))
-          @menu_item = MenuItem.new(default_menu_options.merge(options))
+          self.menu_item_menu_name = options[:menu_name]
+          @menu_item_options = default_menu_options.merge(options)
         end
       end
 
-      def menu_item
-        @menu_item ||= MenuItem.new(default_menu_options)
-      end
-
-      def parent_menu_item_name
-        return nil unless @parent_menu_item
-        ActiveAdmin::Resource::Name.new(nil, @parent_menu_item)
+      def menu_item_options
+        @menu_item_options ||= default_menu_options
       end
 
-      # The default menu options to pass through to MenuItem.new
       def default_menu_options
+        # These local variables are accessible to the procs.
+        menu_resource_class = respond_to?(:resource_class) ? resource_class : self
+        resource = self
         {
-          :id => resource_name.plural,
-          :label => proc{ plural_resource_label },
-          :url => route_collection_path
+          :id    => resource_name.plural,
+          :label => proc{ resource.plural_resource_label },
+          :url   => proc{ resource.route_collection_path(params) },
+          :if    => proc{ authorized?(:read, menu_resource_class) }
         }
       end
 
-      # Should this resource be added to the menu system?
-      def include_in_menu?
-        @display_menu != false
+      def navigation_menu_name=(menu_name)
+        @navigation_menu_name = menu_name
+      end
+
+      def navigation_menu_name
+        @navigation_menu_name ||= DEFAULT_MENU
+        case @navigation_menu_name
+        when Proc
+          controller.instance_eval(&@navigation_menu_name).to_sym
+        else
+          @navigation_menu_name
+        end
+      end
+
+      def navigation_menu
+        namespace.fetch_menu(navigation_menu_name)
       end
 
-      private
+      def menu_item_menu_name=(menu_name)
+        @menu_item_menu_name = menu_name
+      end
+
+      def menu_item_menu_name
+        @menu_item_menu_name ||= DEFAULT_MENU
+      end
+
+      def add_to_menu(menu_collection)
+        if include_in_menu?
+          @menu_item = menu_collection.add(menu_item_menu_name, menu_item_options)
+        end
+      end
 
-      # Evaluates value if this is proc or return value if else
-      def value_or_proc(value)
-        return value.call if value.is_a? Proc
-        value
+      def menu_item
+        @menu_item
+      end
+
+      # Should this resource be added to the menu system?
+      def include_in_menu?
+        @navigation_menu != false
       end
+
     end
   end
 end

data/lib/active_admin/resource/naming.rb

@@ -17,20 +17,12 @@ module ActiveAdmin
 
       # Returns the name to call this resource such as "Bank Account"
       def resource_label
-        if @options[:as]
-          @options[:as]
-        else
-           resource_name.human(:default => resource_name.gsub('::', ' ').titleize)
-         end
+        resource_name.translate :count => 1,  :default => resource_name.gsub('::', ' ').titleize
       end
 
       # Returns the plural version of this resource such as "Bank Accounts"
       def plural_resource_label
-        if @options[:as]
-          @options[:as].pluralize
-        else
-          resource_name.human(:count => 1.1, :default => resource_label.pluralize.titleize)
-        end
+        resource_name.translate :count => 1.1, :default => resource_label.pluralize.titleize
       end
     end
 
@@ -46,6 +38,10 @@ module ActiveAdmin
         end
       end
 
+      def translate(options = {})
+        I18n.t i18n_key, {:scope => [:activerecord, :models]}.merge(options)
+      end
+
       def proxy_for_initializer(klass, name)
         return klass unless name
         return StringClassProxy.new(klass, name) if klass

data/lib/active_admin/resource/page_presenters.rb

@@ -2,6 +2,11 @@ module ActiveAdmin
   class Resource
     module PagePresenters
 
+      # for setting default css class in admin ui
+      def default_index_class
+        @default_index
+      end
+
       # A hash of page configurations for the controller indexed by action name
       def page_presenters
         @page_presenters ||= {}
@@ -12,15 +17,64 @@ module ActiveAdmin
       # @param [String, Symbol] action The action to store this configuration for
       # @param [PagePresenter] page_presenter The instance of PagePresenter to store
       def set_page_presenter(action, page_presenter)
-        page_presenters[action.to_sym] = page_presenter
+
+        if action.to_s == "index" && page_presenter[:as]
+          index_class = find_index_class(page_presenter[:as])
+          page_presenter_key = index_class.index_name.to_sym
+          set_index_presenter page_presenter_key, page_presenter
+        else
+          page_presenters[action.to_sym] = page_presenter
+        end
+
       end
 
       # Returns a stored page config
       #
       # @param [Symbol, String] action The action to get the config for
+      # @param [String] type The string specified in the presenters index_name method
       # @returns [PagePresenter, nil]
-      def get_page_presenter(action)
-        page_presenters[action.to_sym]
+      def get_page_presenter(action, type=nil)
+        
+        if action.to_s == "index" && type && page_presenters[:index].kind_of?(Hash)
+          page_presenters[:index][type.to_sym] 
+        elsif action.to_s == "index" && page_presenters[:index].kind_of?(Hash)
+          page_presenters[:index].default
+        else
+          page_presenters[action.to_sym]
+        end
+
+      end
+
+      protected
+
+      # Stores a config for all index actions supplied
+      #
+      # @param [Symbol] index_as The index type to store in the configuration
+      # @param [PagePresenter] page_presenter The intance of PagePresenter to store
+      def set_index_presenter(index_as, page_presenter)
+        page_presenters[:index] ||= {}
+
+        #set first index as default value or the index with default param set to to true
+        if page_presenters[:index].empty? || page_presenter[:default] == true
+          page_presenters[:index].default = page_presenter
+          @default_index = find_index_class(page_presenter[:as])
+        end
+
+        page_presenters[:index][index_as] = page_presenter
+      end
+
+      # Returns the actual class for renderering the main content on the index
+      # page. To set this, use the :as option in the page_presenter block.
+      #
+      # @param [Symbol, Class] symbol_or_class The component symbol or class
+      # @return [Class]
+      def find_index_class(symbol_or_class)
+        case symbol_or_class
+        when Symbol
+          ::ActiveAdmin::Views.const_get("IndexAs" + symbol_or_class.to_s.camelcase)
+        when Class
+          symbol_or_class
+        end
       end
 
     end

data/lib/active_admin/resource/routes.rb

@@ -0,0 +1,46 @@
+module ActiveAdmin
+  class Resource
+    module Routes
+
+      # Returns the routes prefix for this config
+      def route_prefix
+        namespace.module_name.try(:underscore)
+      end
+
+      def route_uncountable?
+        controller.resources_configuration[:self][:route_collection_name] ==
+              controller.resources_configuration[:self][:route_instance_name]
+      end
+
+      # Returns a symbol for the route to use to get to the
+      # collection of this resource
+      def route_collection_path(params = {})
+        route, required_params = [], []
+
+        route << route_prefix
+
+        if belongs_to? && !belongs_to_config.optional?
+          name = belongs_to_config.target.resource_name.singular
+          route << name
+          required_params << :"#{name}_id"
+        end
+
+        route << controller.resources_configuration[:self][:route_collection_name]
+
+        route << (route_uncountable? ? 'index_path' : 'path')
+
+        route_name = route.compact.join("_").to_sym
+
+        route_params = params.values_at(*required_params)
+        routes.send(route_name, *route_params)
+      end
+
+      private
+
+      def routes
+        Rails.application.routes.url_helpers
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller.rb

@@ -1,8 +1,7 @@
 require 'inherited_resources'
 require 'active_admin/resource_controller/actions'
 require 'active_admin/resource_controller/action_builder'
-require 'active_admin/resource_controller/callbacks'
-require 'active_admin/resource_controller/collection'
+require 'active_admin/resource_controller/data_access'
 require 'active_admin/resource_controller/decorators'
 require 'active_admin/resource_controller/scoping'
 require 'active_admin/resource_controller/sidebars'
@@ -17,13 +16,10 @@ module ActiveAdmin
     respond_to :html, :xml, :json
     respond_to :csv, :only => :index
 
-    ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
-
     include Actions
     include ActionBuilder
-    include Callbacks
-    include Collection
     include Decorators
+    include DataAccess
     include Scoping
     include Sidebars
     extend  ResourceClassMethods
@@ -50,17 +46,6 @@ module ActiveAdmin
 
     private
 
-    # Determine which layout to use.
-    #
-    #   1.  If we're rendering a standard Active Admin action, we want layout(false)
-    #       because these actions are subclasses of the Base page (which implementes
-    #       all the required layout code)
-    #   2.  If we're rendering a custom action, we'll use the active_admin layout so
-    #       that users can render any template inside Active Admin.
-    def determine_active_admin_layout
-      ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : 'active_admin'
-    end
-
     # Returns the renderer class to use for the given action.
     def renderer_for(action)
       active_admin_namespace.view_factory["#{action}_page"]