andrewroth_activeadmin 0.3.4 → 0.3.4.1

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

data/lib/active_admin/resource_controller/action_builder.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     module ActionBuilder
       extend ActiveSupport::Concern

data/lib/active_admin/resource_controller/actions.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     # Override the InheritedResources actions to use the
     # Active Admin templates.

data/lib/active_admin/resource_controller/callbacks.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     module Callbacks
       extend ActiveSupport::Concern

data/lib/active_admin/resource_controller/collection.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     # This module deals with the retrieval of collections for resources
     # within the resource controller.
@@ -46,9 +46,13 @@ module ActiveAdmin
 
         def sort_order(chain)
           params[:order] ||= active_admin_config.sort_order
-          table_name = active_admin_config.resource_table_name
           if params[:order] && params[:order] =~ /^([\w\_\.]+)_(desc|asc)$/
-            chain.order("#{table_name}.#{$1} #{$2}")
+            column = $1
+            order  = $2
+            table  = active_admin_config.resource_table_name
+            table_column = (column =~ /\./) ? column : "#{table}.#{column}"
+
+            chain.order("#{table_column} #{order}")
           else
             chain # just return the chain
           end
@@ -120,7 +124,7 @@ module ActiveAdmin
         end
 
         def paginate(chain)
-          chain.page(params[:page]).per(@per_page || active_admin_application.default_per_page)
+          chain.page(params[:page]).per(@per_page || active_admin_namespace.default_per_page)
         end
       end
 

data/lib/active_admin/resource_controller/filters.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     module Filters
       extend ActiveSupport::Concern

data/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  class ResourceController < BaseController
+    module ResourceClassMethods
+
+      # 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
+          def self.resource_class=(klass); end
+
+          def self.resource_class
+            @active_admin_config ? @active_admin_config.resource_class : nil
+          end
+
+          def resource_class
+            self.class.resource_class
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/resource_controller/scoping.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     # This module deals with scoping entire controllers to a relation
     module Scoping

data/lib/active_admin/resource_controller/sidebars.rb

@@ -1,5 +1,5 @@
 module ActiveAdmin
-  class ResourceController < ::InheritedResources::Base
+  class ResourceController < BaseController
 
     module Sidebars
 

data/lib/active_admin/resource_dsl.rb

@@ -0,0 +1,157 @@
+module ActiveAdmin
+  # This is the class where all the register blocks are instance eval'd
+  class ResourceDSL < DSL
+    private
+
+    def belongs_to(target, options = {})
+      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
+    #
+    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]
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      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)
+    end
+
+    def form(options = {}, &block)
+      config.set_page_presenter :form, ActiveAdmin::PagePresenter.new(options, &block)
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    def csv(&block)
+      config.csv_builder = CSVBuilder.new(&block)
+    end
+
+    # Member Actions give you the functionality of defining both the
+    # action and the route directly from your ActiveAdmin registration
+    # block.
+    #
+    # For example:
+    #
+    #   ActiveAdmin.register Post do
+    #     member_action :comments do
+    #       @post = Post.find(params[:id]
+    #       @comments = @post.comments
+    #     end
+    #   end
+    #
+    # Will create a new controller action comments and will hook it up to
+    # the named route (comments_admin_post_path) /admin/posts/:id/comments
+    #
+    # 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)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    def collection_action(name, options = {}, &block)
+      config.collection_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   :to => :controller
+    delegate :before_create,  :after_create,  :to => :controller
+    delegate :before_update,  :after_update,  :to => :controller
+    delegate :before_save,    :after_save,    :to => :controller
+    delegate :before_destroy, :after_destroy, :to => :controller
+
+    # Filters
+    delegate :filter, :to => :controller
+
+
+    # Standard rails filters
+    delegate :before_filter, :skip_before_filter, :after_filter, :around_filter, :to => :controller
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #   
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, :to => :controller
+
+  end
+end