activeadmin 0.3.4 → 0.4.0

data/lib/active_admin/resource/action_items.rb

@@ -42,6 +42,11 @@ module ActiveAdmin
         @action_items = []
       end
 
+      # Used by active_admin Base view
+      def action_items?
+        !!@action_items && @action_items.any?
+      end
+
       private
 
       # Adds the default action items to each resource

data/lib/active_admin/resource/belongs_to.rb

@@ -1,3 +1,5 @@
+require 'active_admin/resource'
+
 module ActiveAdmin
   class Resource
     class BelongsTo
@@ -14,8 +16,8 @@ module ActiveAdmin
 
       # Returns the target resource class or raises an exception if it doesn't exist
       def target
-        namespace.resources[@target_name.to_s.camelize] or 
-          raise TargetNotFound, "Could not find registered resource #{@target_name} in #{namespace.name} with #{namespace.resources.keys.inspect}"
+        namespace.resources.find_by_key(@target_name.to_s.camelize) or 
+          raise TargetNotFound, "Could not find registered resource #{@target_name} in #{namespace.name} with #{namespace.resources.inspect}"
       end
 
       def namespace

data/lib/active_admin/resource/controllers.rb

@@ -0,0 +1,35 @@
+module ActiveAdmin
+  class Resource
+    module Controllers
+
+      # Returns a properly formatted controller name for this
+      # config within its namespace
+      def controller_name
+        [namespace.module_name, plural_camelized_resource_name + "Controller"].compact.join('::')
+      end
+
+      # Returns the controller for this config
+      def controller
+        @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

@@ -36,8 +36,7 @@ module ActiveAdmin
 
       # Should this resource be added to the menu system?
       def include_in_menu?
-        return false if menu_options[:display] == false
-        !(belongs_to? && !belongs_to_config.optional?)
+        menu_options[:display] != false
       end
 
     end

data/lib/active_admin/resource/naming.rb

@@ -1,49 +1,71 @@
 module ActiveAdmin
   class Resource
     module Naming
+      # Returns the user facing name. Example: "Bank Account"
+      def resource_name
+        @resource_name ||= @options[:as]
+        @resource_name ||= singular_human_name
+        @resource_name ||= safe_resource_name
+      end
 
-      # An underscored safe representation internally for this resource
-      def underscored_resource_name
-        @underscored_resource_name ||= if @options[:as]
-          @options[:as].gsub(' ', '').underscore.singularize
-        else
-          resource.name.gsub('::','').underscore
-        end
+      # Returns the plural version of the user facing name. Example: "Bank Accounts"
+      def plural_resource_name
+        @plural_resource_name ||= @options[:as].pluralize if @options[:as]
+        @plural_resource_name ||= plural_human_name
+        @plural_resource_name ||= resource_name.pluralize
+      end
+
+      # A name used internally to uniquely identify this resource
+      def resource_key
+        camelized_resource_name
+      end
+
+      def safe_resource_name
+        @safe_resource_name ||= @options[:as]
+        @safe_resource_name ||= resource_class.name.gsub('::',' ')
+      end
+
+      def plural_safe_resource_name
+        safe_resource_name.pluralize
       end
 
       # A camelized safe representation for this resource
       def camelized_resource_name
-        underscored_resource_name.camelize
+        safe_resource_name.titleize.gsub(' ', '')
       end
 
-      # Returns the name to call this resource.
-      # By default will use resource.model_name.human
-      def resource_name
-        @resource_name ||= if @options[:as] || !resource.respond_to?(:model_name)
-          underscored_resource_name.titleize
-        else
-          resource.model_name.human.titleize
-        end
+      def plural_camelized_resource_name
+        plural_safe_resource_name.titleize.gsub(' ', '')
       end
 
-      # Returns the plural version of this resource
-      def plural_resource_name
-        @plural_resource_name ||= if @options[:as] || !resource.respond_to?(:model_name)
-          resource_name.pluralize
-        else
-          # Check if we have a translation available otherwise pluralize
-          begin
-            I18n.translate!("activerecord.models.#{resource.model_name.underscore}")
-            resource.model_name.human(:count => 3)
-          rescue I18n::MissingTranslationData
-            resource_name.pluralize
-          end
-        end
+      # An underscored safe representation internally for this resource
+      def underscored_resource_name
+        camelized_resource_name.underscore
       end
-      
+
       # Returns the plural and underscored version of this resource. Useful for element id's.
       def plural_underscored_resource_name
-        plural_resource_name.underscore.gsub(/\s/, '_')
+        plural_camelized_resource_name.underscore
+      end
+
+
+      private
+
+      # @return [String] Titleized human name via ActiveRecord I18n or nil
+      def singular_human_name
+        return nil unless resource_class.respond_to?(:model_name)
+        resource_class.model_name.human.titleize
+      end
+
+      # @return [String] Titleized plural human name via ActiveRecord I18n or nil
+      def plural_human_name
+        return nil unless resource_class.respond_to?(:model_name)
+
+        begin
+          I18n.translate!("activerecord.models.#{resource_class.model_name.underscore}.other").titleize
+        rescue I18n::MissingTranslationData
+          nil
+        end
       end
     end
   end

data/lib/active_admin/resource/page_presenters.rb

@@ -0,0 +1,28 @@
+module ActiveAdmin
+  class Resource
+    module PagePresenters
+
+      # A hash of page configurations for the controller indexed by action name
+      def page_presenters
+        @page_presenters ||= {}
+      end
+
+      # Sets a page config for a given action
+      #
+      # @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
+      end
+
+      # Returns a stored page config
+      #
+      # @param [Symbol, String] action The action to get the config for
+      # @returns [PagePresenter, nil]
+      def get_page_presenter(action)
+        page_presenters[action.to_sym]
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource/scopes.rb

@@ -22,10 +22,23 @@ module ActiveAdmin
       # to your i18n files a key like "active_admin.scopes.scope_method".
       def scope(*args, &block)
         options = args.extract_options!
-        self.scopes << ActiveAdmin::Scope.new(*args, &block)
-        if options[:default]
-          @default_scope = scopes.last
+        title = args[0] rescue nil
+        method = args[1] rescue nil
+
+        scope = ActiveAdmin::Scope.new(title, method, options, &block)
+
+        # Finds and replaces a scope by the same name if it already exists
+        existing_scope_index = scopes.index{|existing_scope| existing_scope.id == scope.id }
+        if existing_scope_index
+          scopes.delete_at(existing_scope_index)
+          scopes.insert(existing_scope_index, scope)
+        else
+          self.scopes << scope
         end
+
+        @default_scope = scope if options[:default]
+
+        scope
       end
 
     end

data/lib/active_admin/resource/sidebars.rb

@@ -22,6 +22,10 @@ module ActiveAdmin
         sidebar_sections.select{|section| section.display_on?(action) }
       end
 
+      def sidebar_sections?
+        !!@sidebar_sections && @sidebar_sections.any?
+      end
+
       private
 
       def add_default_sidebar_sections

data/lib/active_admin/resource_collection.rb

@@ -0,0 +1,88 @@
+module ActiveAdmin
+
+  class ResourceMismatchError < StandardError; end
+
+  # Holds on to a collection of Resources. Is an Enumerable object
+  # so it has some Array like qualities.
+  #
+  # Adding a resource assumes that the object responds to #resource_key
+  class ResourceCollection
+    include Enumerable
+
+    def initialize
+      @resource_hash = {}
+    end
+
+    # Add a new resource to the collection. If the resource_key already
+    # exists, the exiting resource is returned.
+    #
+    # @param [Resource, Page] resource The resource to add to the collection
+    #
+    # @returns [Resource, Page] Either the existing resource or the new one
+    def add(resource)
+      if has_key?(resource.resource_key)
+        existing_resource = find_by_key(resource.resource_key)
+        ensure_resource_classes_match!(existing_resource, resource)
+        existing_resource
+      else
+        @resource_hash[resource.resource_key] = resource
+      end
+    end
+
+    # @returns [Array] An array of all the resources
+    def resources
+      @resource_hash.values
+    end
+
+    # For enumerable
+    def each(&block)
+      @resource_hash.values.each(&block)
+    end
+
+    # @returns [Array] An array of all the keys registered in the collection
+    def keys
+      @resource_hash.keys
+    end
+
+    # @returns [Boolean] If the key has been registered in the collection
+    def has_key?(resource_key)
+      @resource_hash.has_key?(resource_key)
+    end
+
+    # Finds a resource by a given key
+    def find_by_key(resource_key)
+      @resource_hash[resource_key]
+    end
+
+    # Finds a resource based on it's class. Looks up the class Heirarchy if its
+    # a subclass of an Active Record class (ie: implementes base_class)
+    def find_by_resource_class(resource_class)
+      resource_class_name = resource_class.to_s
+      match = resources_with_a_resource_class.find{|r| r.resource_class.to_s == resource_class_name }
+      return match if match
+
+      if resource_class.respond_to?(:base_class)
+        base_class_name = resource_class.base_class.to_s
+        resources_with_a_resource_class.find{|r| r.resource_class.to_s == base_class_name }
+      else
+        nil
+      end
+    end
+
+    private
+
+    def resources_with_a_resource_class
+      select{|resource| resource.respond_to?(:resource_class) }
+    end
+
+    def ensure_resource_classes_match!(existing_resource, resource)
+      return unless existing_resource.respond_to?(:resource_class) && resource.respond_to?(:resource_class)
+
+      if existing_resource.resource_class != resource.resource_class
+        raise ActiveAdmin::ResourceMismatchError, 
+          "Tried to register #{resource.resource_class} as #{resource.resource_key} but already registered to #{existing_resource.resource_class}"
+      end
+    end
+
+  end
+end

data/lib/active_admin/resource_controller.rb

@@ -4,24 +4,18 @@ require 'active_admin/resource_controller/action_builder'
 require 'active_admin/resource_controller/callbacks'
 require 'active_admin/resource_controller/collection'
 require 'active_admin/resource_controller/filters'
-require 'active_admin/resource_controller/form'
-require 'active_admin/resource_controller/menu'
-require 'active_admin/resource_controller/page_configurations'
 require 'active_admin/resource_controller/scoping'
+require 'active_admin/resource_controller/resource_class_methods'
 
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
-
-    helper ::ActiveAdmin::ViewHelpers
-
+  # All Resources Controller inherits from this controller.
+  # It implements actions and helpers for resources.
+  class ResourceController < BaseController
     layout :determine_active_admin_layout
 
     respond_to :html, :xml, :json
     respond_to :csv, :only => :index
 
-    before_filter :only_render_implemented_actions
-    before_filter :authenticate_active_admin_user
-
     ACTIVE_ADMIN_ACTIONS = [:index, :show, :new, :create, :edit, :update, :destroy]
 
     include Actions
@@ -29,37 +23,30 @@ module ActiveAdmin
     include Callbacks
     include Collection
     include Filters
-    include Form
-    include Menu
-    include PageConfigurations
     include Scoping
+    extend  ResourceClassMethods
 
     class << self
-      # Ensure that this method is available for the DSL
-      public :actions
-
-      # Reference to the Resource object which initialized
-      # this controller
-      attr_accessor :active_admin_config
-
       def active_admin_config=(config)
         @active_admin_config = config
-        defaults  :resource_class => config.resource,
+
+        defaults  :resource_class => config.resource_class,
                   :route_prefix => config.route_prefix,
                   :instance_name => config.underscored_resource_name
       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!
+      end
+
       public :belongs_to
     end
 
-    protected
-
-    # By default Rails will render un-implemented actions when the view exists. Becuase Active
-    # Admin allows you to not render any of the actions by using the #actions method, we need
-    # to check if they are implemented.
-    def only_render_implemented_actions
-      raise AbstractController::ActionNotFound unless action_methods.include?(params[:action])
-    end
+    private
 
     # Determine which layout to use.
     #
@@ -72,34 +59,11 @@ module ActiveAdmin
       ACTIVE_ADMIN_ACTIONS.include?(params[:action].to_sym) ? false : 'active_admin'
     end
 
-    # Calls the authentication method as defined in ActiveAdmin.authentication_method
-    def authenticate_active_admin_user
-      send(active_admin_application.authentication_method) if active_admin_application.authentication_method
-    end
-
-    def current_active_admin_user
-      send(active_admin_application.current_user_method) if active_admin_application.current_user_method
-    end
-    helper_method :current_active_admin_user
-
-    def current_active_admin_user?
-      !current_active_admin_user.nil?
-    end
-    helper_method :current_active_admin_user?
-
-    def active_admin_config
-      self.class.active_admin_config
-    end
-    helper_method :active_admin_config
-
-    def active_admin_application
-      ActiveAdmin.application
-    end
-
     # Returns the renderer class to use for the given action.
     def renderer_for(action)
-      active_admin_application.view_factory["#{action}_page"]
+      active_admin_namespace.view_factory["#{action}_page"]
     end
     helper_method :renderer_for
+
   end
 end