activeadmin 1.0.0.pre4 → 2.4.0

data/lib/active_admin/resource_controller/data_access.rb

@@ -14,6 +14,8 @@ module ActiveAdmin
           include ScopeChain
 
           define_active_admin_callbacks :build, :create, :update, :save, :destroy
+
+          helper_method :current_scope
         end
       end
 
@@ -45,7 +47,6 @@ module ActiveAdmin
         end
       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
@@ -60,7 +61,6 @@ module ActiveAdmin
         collection
       end
 
-
       # Override this method in your controllers to modify the start point
       # of our searches and index.
       #
@@ -98,16 +98,11 @@ module ActiveAdmin
       # Does the actual work of finding a resource in the database. This
       # method uses the finder method as defined in InheritedResources.
       #
-      # 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]
       end
 
-
       # 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.
@@ -131,12 +126,12 @@ module ActiveAdmin
       # Builds a new resource. This method uses the method_for_build provided
       # by Inherited Resources.
       #
-      # 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
+        scoped_collection.send(
+          method_for_build,
+          *resource_params.map { |params| params.slice(active_admin_config.resource_class.inheritance_column) }
+        )
       end
 
       # Calls all the appropriate callbacks and then creates the new resource.
@@ -188,12 +183,10 @@ module ActiveAdmin
         end
       end
 
-
       #
       # Collection Helper Methods
       #
 
-
       # Gives the authorization library a change to pre-scope the collection.
       #
       # In the case of the CanCan adapter, it calls `#accessible_by` on
@@ -209,11 +202,10 @@ module ActiveAdmin
 
       def apply_sorting(chain)
         params[:order] ||= active_admin_config.sort_order
-
-        order_clause = OrderClause.new params[:order]
+        order_clause = active_admin_config.order_clause.new(active_admin_config, params[:order])
 
         if order_clause.valid?
-          chain.reorder(order_clause.to_sql(active_admin_config))
+          order_clause.apply(chain)
         else
           chain # just return the chain
         end
@@ -222,16 +214,10 @@ module ActiveAdmin
       # Applies any Ransack search methods to the currently scoped collection.
       # Both `search` and `ransack` are provided, but we use `ransack` to prevent conflicts.
       def apply_filtering(chain)
-        @search = chain.ransack clean_search_params
+        @search = chain.ransack(params[:q] || {})
         @search.result
       end
 
-      def clean_search_params
-        q = params[:q] || {}
-        q = q.to_unsafe_h if q.respond_to? :to_unsafe_h
-        q.delete_if{ |key, value| value.blank? }
-      end
-
       def apply_scoping(chain)
         @collection_before_scope = chain
 
@@ -256,13 +242,15 @@ module ActiveAdmin
 
       def current_scope
         @current_scope ||= if params[:scope]
-          active_admin_config.get_scope_by_id(params[:scope])
-        else
-          active_admin_config.default_scope(self)
-        end
+                             active_admin_config.get_scope_by_id(params[:scope])
+                           else
+                             active_admin_config.default_scope(self)
+                           end
       end
 
       def apply_pagination(chain)
+        # skip pagination if already was paginated by scope
+        return chain if chain.respond_to?(:total_pages)
         page_method_name = Kaminari.config.page_method_name
         page = params[Kaminari.config.param_name]
 
@@ -312,6 +300,23 @@ module ActiveAdmin
       def apply_decorations(resource)
         apply_decorator(resource)
       end
+
+      # @return [String]
+      def smart_resource_url
+        if create_another?
+          new_resource_url(create_another: params[:create_another])
+        else
+          super
+        end
+      end
+
+      private
+
+      # @return [Boolean] true if user requested to create one more
+      #   resource after creating this one.
+      def create_another?
+        params[:create_another].present?
+      end
     end
   end
 end

data/lib/active_admin/resource_controller/decorators.rb

@@ -2,7 +2,7 @@ module ActiveAdmin
   class ResourceController < BaseController
     module Decorators
 
-    protected
+      protected
 
       def apply_decorator(resource)
         decorate? ? decorator_class.new(resource) : resource
@@ -24,7 +24,7 @@ module ActiveAdmin
         end
       end
 
-    private
+      private
 
       def decorate?
         case action_name
@@ -62,13 +62,13 @@ module ActiveAdmin
           end
         end
 
-      private
+        private
 
         def self.wrap!(parent, name)
           ::Class.new parent do
             delegate :reorder, :page, :current_page, :total_pages, :limit_value,
-                     :total_count, :total_pages, :to_key, :group_values, :except,
-                     :find_each, :ransack
+                     :total_count, :total_pages, :offset, :to_key, :group_values,
+                     :except, :find_each, :ransack
 
             define_singleton_method(:name) { name }
           end

data/lib/active_admin/resource_controller/polymorphic_routes.rb

@@ -0,0 +1,36 @@
+require "active_admin/resource"
+require "active_admin/resource/model"
+
+module ActiveAdmin
+  class ResourceController < BaseController
+    module PolymorphicRoutes
+      def polymorphic_url(record_or_hash_or_array, options = {})
+        super(map_named_resources_for(record_or_hash_or_array), options)
+      end
+
+      def polymorphic_path(record_or_hash_or_array, options = {})
+        super(map_named_resources_for(record_or_hash_or_array), options)
+      end
+
+      private
+
+      def map_named_resources_for(record_or_hash_or_array)
+        return record_or_hash_or_array unless record_or_hash_or_array.is_a?(Array)
+
+        record_or_hash_or_array.map { |record| to_named_resource(record) }
+      end
+
+      def to_named_resource(record)
+        if record.is_a?(resource_class)
+          return ActiveAdmin::Model.new(active_admin_config, record)
+        end
+
+        if record.is_a?(parent.class)
+          return ActiveAdmin::Model.new(active_admin_config.belongs_to_config.resource, record)
+        end
+
+        record
+      end
+    end
+  end
+end

data/lib/active_admin/resource_controller/resource_class_methods.rb

@@ -13,6 +13,8 @@ module ActiveAdmin
             @active_admin_config ? @active_admin_config.resource_class : nil
           end
 
+          private
+
           def resource_class
             self.class.resource_class
           end

data/lib/active_admin/resource_controller/scoping.rb

@@ -15,7 +15,7 @@ module ActiveAdmin
       # Collection can be scoped conditionally with an :if or :unless proc.
       def begin_of_association_chain
         return nil unless active_admin_config.scope_to?(self)
-        render_in_context(self, active_admin_config.scope_to_method)
+        MethodOrProcHelper.render_in_context(self, active_admin_config.scope_to_method)
       end
 
       # Overriding from InheritedResources::BaseHelpers

data/lib/active_admin/resource_controller.rb

@@ -1,6 +1,7 @@
 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/polymorphic_routes'
 require 'active_admin/resource_controller/scoping'
 require 'active_admin/resource_controller/streaming'
 require 'active_admin/resource_controller/sidebars'
@@ -18,9 +19,11 @@ module ActiveAdmin
     include ActionBuilder
     include Decorators
     include DataAccess
+    include PolymorphicRoutes
     include Scoping
     include Streaming
     include Sidebars
+    include ViewHelpers::DownloadFormatLinksHelper
     extend  ResourceClassMethods
 
     def self.active_admin_config=(config)
@@ -45,7 +48,19 @@ module ActiveAdmin
     def renderer_for(action)
       active_admin_namespace.view_factory["#{action}_page"]
     end
+
     helper_method :renderer_for
 
+    def restrict_format_access!
+      unless request.format.html?
+        presenter = active_admin_config.get_page_presenter(:index)
+        download_formats = (presenter || {}).fetch(:download_links, active_admin_config.namespace.download_links)
+        unless build_download_formats(download_formats).include?(request.format.symbol)
+          raise ActiveAdmin::AccessDenied.new(current_active_admin_user, :index)
+        end
+      end
+    end
+
+    before_action :restrict_format_access!, only: [:index, :show]
   end
 end

data/lib/active_admin/resource_dsl.rb

@@ -1,13 +1,28 @@
 module ActiveAdmin
   # This is the class where all the register blocks are evaluated.
   class ResourceDSL < DSL
-    def initialize(config, resource_class)
-      @resource = resource_class
-      super(config)
-    end
 
     private
 
+    # Redefine sort behaviour for column
+    #
+    # For example:
+    #
+    #   # nulls last
+    #   order_by(:age) do |order_clause|
+    #     [order_clause.to_sql, 'NULLS LAST'].join(' ')  if order_clause.order == 'desc'
+    #   end
+    #
+    #   # by last_name but in the case that there is no last name, by first_name.
+    #   order_by(:full_name) do |order_clause|
+    #     ['COALESCE(NULLIF(last_name, ''), first_name), first_name', order_clause.order].join(' ')
+    #   end
+    #
+    #
+    def order_by(column, &block)
+      config.ordering[column] = block
+    end
+
     def belongs_to(target, options = {})
       config.belongs_to(target, options)
     end
@@ -28,7 +43,7 @@ module ActiveAdmin
     end
 
     #
-    # Rails 4 Strong Parameters Support
+    # Keys included in the `permitted_params` setting are automatically whitelisted.
     #
     # Either
     #
@@ -45,16 +60,22 @@ module ActiveAdmin
     #     end
     #   end
     #
-    # Keys included in the `permitted_params` setting are automatically whitelisted.
-    #
     def permit_params(*args, &block)
       param_key = config.param_key.to_sym
+      belongs_to_param = config.belongs_to_param
+      create_another_param = :create_another if config.create_another
 
       controller do
         define_method :permitted_params do
-          params.permit *active_admin_namespace.permitted_params,
-            param_key => block ? instance_exec(&block) : args
+          permitted_params =
+            active_admin_namespace.permitted_params +
+              Array.wrap(belongs_to_param) +
+              Array.wrap(create_another_param)
+
+          params.permit(*permitted_params, param_key => block ? instance_exec(&block) : args)
         end
+
+        private :permitted_params
       end
     end
 
@@ -86,8 +107,8 @@ module ActiveAdmin
     #     column :name
     #   end
     #
-    def csv(options={}, &block)
-      options[:resource] = @resource
+    def csv(options = {}, &block)
+      options[:resource] = config
 
       config.csv_builder = CSVBuilder.new(options, &block)
     end
@@ -100,7 +121,7 @@ module ActiveAdmin
     #
     #   ActiveAdmin.register Post do
     #     member_action :comments do
-    #       @post = Post.find(params[:id]
+    #       @post = Post.find(params[:id])
     #       @comments = @post.comments
     #     end
     #   end
@@ -112,13 +133,14 @@ module ActiveAdmin
     # action.
     #
     def action(set, name, options = {}, &block)
+      warn "Warning: method `#{name}` already defined in #{controller.name}" if controller.method_defined?(name)
+
       set << ControllerAction.new(name, options)
       title = options.delete(:title)
 
       controller do
-        callback = ActiveAdmin::Dependency.rails >= 4 ? :before_action : :before_filter
-        send(callback, only: [name]) { @page_title = title } if title
-        define_method(name, &block || Proc.new{})
+        before_action(only: [name]) { @page_title = title } if title
+        define_method(name, &block || Proc.new {})
       end
     end
 
@@ -130,6 +152,13 @@ module ActiveAdmin
       action config.collection_actions, name, options, &block
     end
 
+    def decorate_with(decorator_class)
+      # Force storage as a string. This will help us with reloading issues.
+      # Assuming decorator_class.to_s will return the name of the class allows
+      # us to handle a string or a class.
+      config.decorator_class_name = "::#{ decorator_class }"
+    end
+
     # Defined Callbacks
     #
     # == After Build
@@ -160,19 +189,24 @@ module ActiveAdmin
     delegate :before_save,    :after_save,    to: :controller
     delegate :before_destroy, :after_destroy, to: :controller
 
-    # This code defines both *_filter and *_action for Rails 3.2 to Rails 5.
-    actions = [
+    # This code defines both *_filter and *_action for Rails 5.0 and  *_action for Rails >= 5.1
+    phases = [
       :before, :skip_before,
       :after,  :skip_after,
       :around, :skip
     ]
-    destination = ActiveAdmin::Dependency.rails >= 4 ? :action : :filter
-    [:action, :filter].each do |name|
-      actions.each do |action|
-        define_method "#{action}_#{name}" do |*args, &block|
-          controller.public_send "#{action}_#{destination}", *args, &block
-        end
-      end
+    keywords = if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 1
+                 [:action]
+               else
+                 [:action, :filter]
+               end
+
+    keywords.each do |name|
+      phases.each do |action|
+       define_method "#{action}_#{name}" do |*args, &block|
+         controller.public_send "#{action}_action", *args, &block
+       end
+     end
     end
 
     # Specify which actions to create in the controller

data/lib/active_admin/router.rb

@@ -1,106 +1,114 @@
 module ActiveAdmin
+  # @private
   class Router
-    def initialize(application)
-      @application = application
+    attr_reader :namespaces, :router
+
+    def initialize(router:, namespaces:)
+      @router = router
+      @namespaces = namespaces
     end
 
-    # Creates all the necessary routes for the ActiveAdmin configurations
-    #
-    # Use this within the routes.rb file:
-    #
-    #   Application.routes.draw do |map|
-    #     ActiveAdmin.routes(self)
-    #   end
-    #
-    def apply(router)
-      define_root_routes router
-      define_resource_routes router
+    def apply
+      define_root_routes
+      define_resources_routes
     end
 
-    def define_root_routes(router)
-      router.instance_exec @application.namespaces do |namespaces|
-        namespaces.each do |namespace|
-          if namespace.root?
-            root namespace.root_to_options.merge(to: namespace.root_to)
-          else
-            namespace namespace.name do
-              root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
-            end
+    private
+
+    def define_root_routes
+      namespaces.each do |namespace|
+        if namespace.root?
+          router.root namespace.root_to_options.merge(to: namespace.root_to)
+        else
+          router.namespace namespace.name, namespace.route_options.dup do
+            router.root namespace.root_to_options.merge(to: namespace.root_to, as: :root)
           end
         end
       end
     end
 
     # Defines the routes for each resource
-    def define_resource_routes(router)
-      router.instance_exec @application.namespaces, self do |namespaces, aa_router|
-        resources = namespaces.flat_map{ |n| n.resources.values }
-        resources.each do |config|
-          routes = aa_router.resource_routes(config)
-
-          # Add in the parent if it exists
-          if config.belongs_to?
-            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_exec &belongs_to
-              end
-            end
-          end
+    def define_resources_routes
+      resources = namespaces.flat_map { |n| n.resources.values }
+      resources.each do |config|
+        define_resource_routes(config)
+      end
+    end
 
-          # Add on the namespace if required
-          unless config.namespace.root?
-            nested = routes
-            routes = Proc.new do
-              namespace config.namespace.name do
-                instance_exec &nested
-              end
-            end
-          end
+    def define_resource_routes(config)
+      if config.namespace.root?
+        define_routes(config)
+      else
+        # Add on the namespace if required
+        define_namespace(config)
+      end
+    end
 
-          instance_exec &routes
-        end
+    def define_routes(config)
+      if config.belongs_to?
+        define_belongs_to_routes(config)
+      else
+        page_or_resource_routes(config)
       end
     end
 
+    def page_or_resource_routes(config)
+      config.is_a?(Page) ? page_routes(config) : resource_routes(config)
+    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 ::ActiveAdmin::Resource
-          resources config.resource_name.route_key, only: config.defined_actions do
-            member do
-              config.member_actions.each &build_action
-            end
-
-            collection do
-              config.collection_actions.each &build_action
-              post :batch_action if config.batch_actions_enabled?
-            end
-          end
-        when ::ActiveAdmin::Page
-          page = config.underscored_resource_name
-          get "/#{page}" => "#{page}#index"
-          config.page_actions.each do |action|
-            build_route.call action.http_verb, "/#{page}/#{action.name}" => "#{page}##{action.name}"
-          end
-        else
-          raise "Unsupported config class: #{config.class}"
+      router.resources config.resource_name.route_key, only: config.defined_actions do
+        define_actions(config)
+      end
+    end
+
+    def page_routes(config)
+      page = config.underscored_resource_name
+      router.get "/#{page}" => "#{page}#index"
+      config.page_actions.each do |action|
+        Array.wrap(action.http_verb).each do |verb|
+          build_route(verb, "/#{page}/#{action.name}" => "#{page}##{action.name}")
         end
       end
+    end
+
+    # Defines member and collection actions
+    def define_actions(config)
+      router.member do
+        config.member_actions.each { |action| build_action(action) }
+      end
+
+      router.collection do
+        config.collection_actions.each { |action| build_action(action) }
+        router.post :batch_action if config.batch_actions_enabled?
+      end
+    end
+
+    # Deals with +ControllerAction+ instances
+    # Builds one route for each HTTP verb passed in
+    def build_action(action)
+      build_route(action.http_verb, action.name)
+    end
+
+    def build_route(verbs, *args)
+      Array.wrap(verbs).each { |verb| router.send(verb, *args) }
+    end
+
+    def define_belongs_to_routes(config)
+      # If it's optional, make the normal resource routes
+      page_or_resource_routes(config) 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
+      router.resources config.belongs_to_config.target.resource_name.plural, only: [] do
+        page_or_resource_routes(config)
+      end
+    end
 
+    def define_namespace(config)
+      router.namespace config.namespace.name, config.namespace.route_options.dup do
+        define_routes(config)
+      end
     end
   end
 end

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, :default_block
+    attr_reader :scope_method, :id, :scope_block, :display_if_block, :show_count, :default_block, :group
 
     # Create a Scope
     #
@@ -24,31 +24,39 @@ module ActiveAdmin
     #   Scope.new ->{Date.today.strftime '%A'}, :published_today
     #   # => Scope with dynamic title using the :published_today scope method
     #
+    #   Scope.new :published, nil, group: :status
+    #   # => Scope with the group :status
+    #
     def initialize(name, method = nil, options = {}, &block)
-      @name, @scope_method = name, method.try(:to_sym)
+      @name = name
+      @scope_method = method.try(:to_sym)
 
       if name.is_a? Proc
         raise "A string/symbol is required as the second argument if your label is a proc." unless method
-        @id = ActiveAdmin::Dependency.rails.parameterize method.to_s
+        @id = method.to_s.parameterize(separator: "_")
       else
         @scope_method ||= name.to_sym
-        @id = ActiveAdmin::Dependency.rails.parameterize name.to_s
+        @id = name.to_s.parameterize(separator: "_")
       end
 
-      @scope_method               = nil        if @scope_method == :all
-      @scope_method, @scope_block = nil, block if block_given?
+      @scope_method = nil if @scope_method == :all
+      if block_given?
+        @scope_method = nil
+        @scope_block = block
+      end
 
+      @localizer        = options[:localizer]
       @show_count       = options.fetch(:show_count, true)
-      @display_if_block = options[:if]      || proc{ true }
-      @default_block    = options[:default] || proc{ false }
+      @display_if_block = options[:if]      || proc { true }
+      @default_block    = options[:default] || proc { false }
+      @group            = options[:group].try(:to_sym)
     end
 
     def name
       case @name
-        when Proc   then @name.call.to_s
-        when String then @name
-        when Symbol then @name.to_s.titleize
-        else             @name.to_s
+      when String then @name
+      when Symbol then @localizer ? @localizer.t(@name, scope: 'scopes') : @name.to_s.titleize
+      else @name
       end
     end