yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/lib/active_admin/resource/page_presenters.rb

@@ -32,7 +32,7 @@ module ActiveAdmin
       #
       # @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]
+      # @return [PagePresenter, nil]
       def get_page_presenter(action, type=nil)
 
         if action.to_s == "index" && type && page_presenters[:index].kind_of?(Hash)

data/lib/active_admin/resource/routes.rb

@@ -1,13 +1,13 @@
 module ActiveAdmin
   class Resource
     module Routes
-      # @params params [Hash] of params: {study_id: 3}
+      # @param params [Hash] of params: { study_id: 3 }
       # @return [String] the path to this resource collection page
       # @example "/admin/posts"
       def route_collection_path(params = {})
         RouteBuilder.new(self).collection_path(params)
       end
-      
+
       # @param resource [ActiveRecord::Base] the instance we want the path of
       # @return [String] the path to this resource collection page
       # @example "/admin/posts/1"
@@ -15,13 +15,17 @@ module ActiveAdmin
         RouteBuilder.new(self).instance_path(resource)
       end
 
+      def route_edit_instance_path(resource)
+        RouteBuilder.new(self).edit_instance_path(resource)
+      end
+
       # Returns the routes prefix for this config
       def route_prefix
         namespace.module_name.try(:underscore)
       end
 
       def route_uncountable?
-        config = controller.resources_configuration[:self]
+        config = resources_configuration[:self]
 
         config[:route_collection_name] == config[:route_instance_name]
       end
@@ -35,29 +39,41 @@ module ActiveAdmin
 
         def collection_path(params)
           route_name = route_name(
-            resource.controller.resources_configuration[:self][:route_collection_name],
-            (resource.route_uncountable? ? 'index_path' : 'path')
+            resource.resources_configuration[:self][:route_collection_name],
+            suffix: (resource.route_uncountable? ? "index_path" : "path")
           )
 
-          routes.send(route_name, *route_collection_params(params))
+          routes.public_send route_name, *route_collection_params(params)
         end
 
         # @return [String] the path to this resource collection page
         # @param instance [ActiveRecord::Base] the instance we want the path of
         # @example "/admin/posts/1"
         def instance_path(instance)
-          route_name = route_name(resource.controller.resources_configuration[:self][:route_instance_name])
+          route_name = route_name(resource.resources_configuration[:self][:route_instance_name])
+
+          routes.public_send route_name, *route_instance_params(instance)
+        end
+
+        # @return [String] the path to the edit page of this resource
+        # @param instance [ActiveRecord::Base] the instance we want the path of
+        # @example "/admin/posts/1/edit"
+        def edit_instance_path(instance)
+          path = resource.resources_configuration[:self][:route_instance_name]
+          route_name = route_name(path, action: :edit)
 
-          routes.send(route_name, *route_instance_params(instance))
+          routes.public_send route_name, *route_instance_params(instance)
         end
 
         private
 
         attr_reader :resource
 
-        def route_name(resource_path_name, suffix = 'path')
+        def route_name(resource_path_name, options = {})
+          suffix = options[:suffix] || "path"
           route = []
 
+          route << options[:action]           # "edit" or "new"
           route << resource.route_prefix      # "admin"
           route << belongs_to_name if nested? # "category"
           route << resource_path_name         # "posts" or "post"
@@ -70,7 +86,7 @@ module ActiveAdmin
         # @return params to pass to instance path
         def route_instance_params(instance)
           if nested?
-            [instance.send(belongs_to_name).to_param, instance.to_param]
+            [instance.public_send(belongs_to_name).to_param, instance.to_param]
           else
             instance.to_param
           end

data/lib/active_admin/resource/scope_to.rb

@@ -20,7 +20,7 @@ module ActiveAdmin
       # 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
+      #   scope_to :current_user, association_method: :blog_posts
       #
       # will result in the following
       #
@@ -28,11 +28,11 @@ module ActiveAdmin
       #
       # To conditionally use this scope, you can use conditional procs
       #
-      #   scope_to :current_user, :if => proc{ admin_user_signed_in? }
+      #   scope_to :current_user, if: proc{ admin_user_signed_in? }
       #
       # or
       #
-      #   scope_to :current_user, :unless => proc{ current_user.admin? }
+      #   scope_to :current_user, unless: proc{ current_user.admin? }
       #
       def scope_to(*args, &block)
         options = args.extract_options!
@@ -55,10 +55,10 @@ module ActiveAdmin
 
       def scope_to_config
         @scope_to_config ||= {
-          :method               => nil,
-          :association_method   => nil,
-          :if                   => nil,
-          :unless               => nil
+          method:             nil,
+          association_method: nil,
+          if:                 nil,
+          unless:             nil
         }
       end
 

data/lib/active_admin/resource/sidebars.rb

@@ -15,6 +15,7 @@ module ActiveAdmin
 
       def sidebar_sections_for(action, render_context = nil)
         sidebar_sections.select{|section| section.display_on?(action, render_context) }
+          .sort_by(&:priority)
       end
 
       def sidebar_sections?

data/lib/active_admin/resource_collection.rb

@@ -4,14 +4,19 @@ module ActiveAdmin
   class ResourceCollection
     include Enumerable
     extend Forwardable
-    def_delegators :@resources, :empty?, :has_key?, :keys, :values, :[]=
+    def_delegators :@collection, :empty?, :has_key?, :keys, :values, :size
 
     def initialize
-      @resources = {}
+      @collection = {}
     end
 
     def add(resource)
-      @resources[resource.resource_name] ||= resource
+      if match = @collection[resource.resource_name]
+        raise_if_mismatched! match, resource
+        match
+      else
+        @collection[resource.resource_name] = resource
+      end
     end
 
     # Changes `each` to pass in the value, instead of both the key and value.
@@ -19,23 +24,46 @@ module ActiveAdmin
       values.each &block
     end
 
-    # Finds a resource based on the resource name, the resource class, or the base class.
-    def [](klass)
-      if match = @resources[klass]
-        match
-      elsif match = real_resources.detect{ |r| [r.resource_name.to_s, r.resource_class.to_s].include? klass.to_s }
-        match
-      elsif klass.respond_to? :base_class
-        real_resources.detect{ |r| r.resource_class.to_s == klass.base_class.to_s }
-      end
+    def [](obj)
+      @collection[obj] || find_resource(obj)
     end
 
     private
 
-    # REFACTOR: ResourceCollection currently stores Resource and Page objects. That doesn't
-    # make sense, because by definition a ResourceCollection is a collection of resources.
-    def real_resources
-      select{ |r| r.respond_to? :resource_class }
+    # Finds a resource based on the resource name, resource class, or base class.
+    def find_resource(obj)
+      resources.detect do |r|
+        r.resource_name.to_s == obj.to_s || r.resource_class.to_s == obj.to_s
+      end ||
+      if obj.respond_to? :base_class
+        resources.detect{ |r| r.resource_class.to_s == obj.base_class.to_s }
+      end
+    end
+
+    def resources
+      select{ |r| r.class <= Resource } # can otherwise be a Page
+    end
+
+    def raise_if_mismatched!(existing, given)
+      if existing.class != given.class
+        raise IncorrectClass.new existing, given
+      elsif given.class <= Resource && existing.resource_class != given.resource_class
+        raise ConfigMismatch.new existing, given
+      end
+    end
+
+    class IncorrectClass < StandardError
+      def initialize(existing, given)
+        super "You're trying to register #{given.resource_name} which is a #{given.class}, " +
+              "but #{existing.resource_name}, a #{existing.class} has already claimed that name."
+      end
+    end
+
+    class ConfigMismatch < StandardError
+      def initialize(existing, given)
+        super "You're trying to register #{given.resource_class} as #{given.resource_name}, " +
+              "but the existing #{existing.class} config was built for #{existing.resource_class}!"
+      end
     end
 
   end

data/lib/active_admin/resource_controller.rb

@@ -1,8 +1,8 @@
-require 'inherited_resources'
 require 'active_admin/resource_controller/action_builder'
 require 'active_admin/resource_controller/data_access'
 require 'active_admin/resource_controller/decorators'
 require 'active_admin/resource_controller/scoping'
+require 'active_admin/resource_controller/streaming'
 require 'active_admin/resource_controller/sidebars'
 require 'active_admin/resource_controller/resource_class_methods'
 
@@ -13,20 +13,21 @@ module ActiveAdmin
     layout :determine_active_admin_layout
 
     respond_to :html, :xml, :json
-    respond_to :csv, :only => :index
+    respond_to :csv, only: :index
 
     include ActionBuilder
     include Decorators
     include DataAccess
     include Scoping
+    include Streaming
     include Sidebars
     extend  ResourceClassMethods
 
     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
+        defaults resource_class: config.resource_class,
+                 route_prefix:   config.route_prefix,
+                 instance_name:  config.resource_name.singular
       end
     end
 

data/lib/active_admin/resource_controller/data_access.rb

@@ -7,13 +7,14 @@ module ActiveAdmin
     # The module also deals with authorization and resource callbacks.
     #
     module DataAccess
-      extend ActiveSupport::Concern
 
-      include ActiveAdmin::Callbacks
-      include ActiveAdmin::ScopeChain
+      def self.included(base)
+        base.class_exec do
+          include Callbacks
+          include ScopeChain
 
-      included do
-        define_active_admin_callbacks :build, :create, :update, :save, :destroy
+          define_active_admin_callbacks :build, :create, :update, :save, :destroy
+        end
       end
 
       protected
@@ -25,16 +26,13 @@ module ActiveAdmin
       # 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
+      # @return [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
+        get_collection_ivar || begin
+          collection = find_collection
+          authorize! Authorization::READ, active_admin_config.resource_class
+          set_collection_ivar collection
+        end
       end
 
 
@@ -43,7 +41,7 @@ module ActiveAdmin
       # some additional db # work before your controller returns and
       # authorizes the collection.
       #
-      # @returns [ActiveRecord::Relation] The collectin for the index
+      # @return [ActiveRecord::Relation] The collectin for the index
       def find_collection
         collection = scoped_collection
 
@@ -51,8 +49,13 @@ module ActiveAdmin
         collection = apply_sorting(collection)
         collection = apply_filtering(collection)
         collection = apply_scoping(collection)
-        collection = apply_pagination(collection)
-        collection = apply_decorator(collection)
+        collection = apply_includes(collection)
+
+        unless request.format == 'text/csv'
+          collection = apply_pagination(collection)
+        end
+
+        collection = apply_collection_decorator(collection)
 
         collection
       end
@@ -81,37 +84,27 @@ module ActiveAdmin
       #   * update
       #   * destroy
       #
-      # @returns [ActiveRecord::Base] An active record object
+      # @return [ActiveRecord::Base] An active record object
       def resource
-        _resource = get_resource_ivar
-
-        return _resource if _resource
-
-        _resource = find_resource
-        authorize_resource! _resource
+        get_resource_ivar || begin
+          resource = find_resource
+          authorize_resource! resource
 
-        if decorator?
-          _resource = decorator_class.new(_resource)
+          resource = apply_decorator resource
+          set_resource_ivar 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.
+      # Note that public_send can't be used here because Rails 3.2's
+      # ActiveRecord::Associations::CollectionProxy (belongs_to associations)
+      # mysteriously returns an Enumerator object.
+      #
+      # @return [ActiveRecord::Base] An active record object.
       def find_resource
-        scoped_collection.send(method_for_find, params[:id])
+        scoped_collection.send method_for_find, params[:id]
       end
 
 
@@ -122,31 +115,34 @@ module ActiveAdmin
       # 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
+      # @return [ActiveRecord::Base] An un-saved active record base object
       def build_resource
-        return resource if resource = get_resource_ivar
-
-        resource = build_new_resource
+        get_resource_ivar || begin
+          resource = build_new_resource
+          run_build_callbacks resource
+          authorize_resource! resource
 
-        run_build_callbacks resource
-        authorize_resource! resource
-
-        set_resource_ivar(resource)
+          resource = apply_decorator resource
+          set_resource_ivar resource
+        end
       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
+      # Note that public_send can't be used here w/ Rails 3.2 & a belongs_to
+      # config, or you'll get undefined method `build' for []:Array.
+      #
+      # @return [ActiveRecord::Base] An un-saved active record base object
       def build_new_resource
-        scoped_collection.send(method_for_build, *resource_params)
+        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]
+      # @return [void]
       def create_resource(object)
         run_create_callbacks object do
           save_resource(object)
@@ -157,7 +153,7 @@ module ActiveAdmin
       #
       # @param [ActiveRecord::Base] object The new resource to save
       #
-      # @returns [void]
+      # @return [void]
       def save_resource(object)
         run_save_callbacks object do
           object.save
@@ -173,7 +169,7 @@ module ActiveAdmin
       #                           and the Active Record "role" in the second. The role
       #                           may be set to nil.
       #
-      # @returns [void]
+      # @return [void]
       def update_resource(object, attributes)
         if object.respond_to?(:assign_attributes)
           object.assign_attributes(*attributes)
@@ -188,7 +184,7 @@ module ActiveAdmin
 
       # Destroys an object from the database and calls appropriate callbacks.
       #
-      # @returns [void]
+      # @return [void]
       def destroy_resource(object)
         run_destroy_callbacks object do
           object.destroy
@@ -208,23 +204,19 @@ module ActiveAdmin
       #
       # @param [ActiveRecord::Relation] collection The collection to scope
       #
-      # @retruns [ActiveRecord::Relation] a scoped collection of query
+      # @return [ActiveRecord::Relation] a scoped collection of query
       def apply_authorization_scope(collection)
         action_name = action_to_permission(params[:action])
         active_admin_authorization.scope_collection(collection, action_name)
       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}")
+
+        order_clause = OrderClause.new params[:order]
+
+        if order_clause.valid?
+          chain.reorder(order_clause.to_sql(active_admin_config))
         else
           chain # just return the chain
         end
@@ -237,13 +229,12 @@ module ActiveAdmin
         @search.result
       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 == ""
+      def clean_search_params(params)
+        if params.is_a? Hash
+          params.dup.delete_if{ |key, value| value.blank? }
+        else
+          {}
         end
-        search_params
       end
 
       def apply_scoping(chain)
@@ -256,43 +247,57 @@ module ActiveAdmin
         end
       end
 
+      def apply_includes(chain)
+        if active_admin_config.includes.any?
+          chain.includes *active_admin_config.includes
+        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]
+          active_admin_config.get_scope_by_id(params[:scope])
         else
           active_admin_config.default_scope(self)
         end
       end
 
       def apply_pagination(chain)
-        page_method = Kaminari.config.page_method_name
-        page_param  = params[Kaminari.config.param_name]
+        page_method_name = Kaminari.config.page_method_name
+        page = params[Kaminari.config.param_name]
 
-        chain.send(page_method, page_param).per(per_page)
+        chain.public_send(page_method_name, page).per(per_page)
       end
 
       def per_page
-        return max_per_page if active_admin_config.paginate == false
-
-        @per_page || active_admin_config.per_page
+        if active_admin_config.paginate
+          dynamic_per_page || configured_per_page
+        else
+          max_per_page
+        end
       end
 
-      def max_per_page
-        10_000
+      def dynamic_per_page
+        params[:per_page] || @per_page
       end
 
-      def apply_decorator(chain)
-        if decorator?
-          decorator_class.decorate_collection(chain)
+      def configured_per_page
+        if active_admin_config.per_page.is_a?(Array)
+          active_admin_config.per_page[0]
         else
-          chain
+          active_admin_config.per_page
         end
       end
 
+      def max_per_page
+        10_000
+      end
+
     end
   end
 end