activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/application.rb

@@ -17,7 +17,7 @@ module ActiveAdmin
 
     attr_reader :namespaces
     def initialize
-      @namespaces = {}
+      @namespaces = Namespace::Store.new
     end
 
     # Load paths for admin configurations. Add folders to this load path
@@ -36,7 +36,7 @@ module ActiveAdmin
 
     # Set the site title image displayed in the main layout (has precendence over :site_title)
     inheritable_setting :site_title_image, ""
-    
+
     # Set a favicon
     inheritable_setting :favicon, false
 
@@ -67,8 +67,14 @@ module ActiveAdmin
     # The namespace root.
     inheritable_setting :root_to, 'dashboard#index'
 
+    # Options that a passed to root_to.
+    inheritable_setting :root_to_options, {}
+
+    # Display breadcrumbs
+    inheritable_setting :breadcrumb, true
+
     # Default CSV options
-    inheritable_setting :csv_options, {:col_sep => ','}
+    inheritable_setting :csv_options, { col_sep: ',', byte_order_mark: "\xEF\xBB\xBF" }
 
     # Default Download Links options
     inheritable_setting :download_links, true
@@ -79,6 +85,17 @@ module ActiveAdmin
     # A proc to be used when a user is not authorized to view the current resource
     inheritable_setting :on_unauthorized_access, :rescue_active_admin_access_denied
 
+    # A regex to detect unsupported browser, set to false to disable
+    inheritable_setting :unsupported_browser_matcher, /MSIE [1-8]\.0/
+
+    # Request parameters that are permitted by default
+    inheritable_setting :permitted_params, [
+      :utf8, :_method, :authenticity_token, :commit, :id
+    ]
+
+    # Set flash message keys that shouldn't show in ActiveAdmin
+    inheritable_setting :flash_keys_to_except, ['timedout']
+
     # Active Admin makes educated guesses when displaying objects, this is
     # the list of methods it tries calling in order
     setting :display_name_methods, [ :display_name,
@@ -92,43 +109,45 @@ module ActiveAdmin
 
     # == Deprecated Settings
 
-    # (none currently)
+    def allow_comments=(*)
+      raise "`config.allow_comments` is no longer provided in ActiveAdmin 1.x. Use `config.comments` instead."
+    end
 
     include AssetRegistration
 
     # Event that gets triggered on load of Active Admin
     BeforeLoadEvent = 'active_admin.application.before_load'.freeze
-    AfterLoadEvent = 'active_admin.application.after_load'.freeze
+    AfterLoadEvent  = 'active_admin.application.after_load'.freeze
 
+    # Runs before the app's AA initializer
     def setup!
       register_default_assets
     end
 
+    # Runs after the app's AA initializer
     def prepare!
       remove_active_admin_load_paths_from_rails_autoload_and_eager_load
       attach_reloader
-      generate_stylesheets
     end
 
     # Registers a brand new configuration for the given resource.
     def register(resource, options = {}, &block)
-      ns_name = namespace_name(options)
-      namespace(ns_name).register resource, options, &block
+      ns = options.fetch(:namespace){ default_namespace }
+      namespace(ns).register resource, options, &block
     end
 
     # Creates a namespace for the given name
     #
     # Yields the namespace if a block is given
     #
-    # @returns [Namespace] the new or existing namespace
+    # @return [Namespace] the new or existing namespace
     def namespace(name)
       name ||= :root
 
-      if namespaces[name]
-        namespace = namespaces[name]
-      else
-        namespace = namespaces[name] = Namespace.new(self, name)
+      namespace = namespaces[name] ||= begin
+        namespace = Namespace.new(self, name)
         ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
+        namespace
       end
 
       yield(namespace) if block_given?
@@ -139,12 +158,12 @@ module ActiveAdmin
     # Register a page
     #
     # @param name [String] The page name
-    # @options [Hash] Accepts option :namespace.
+    # @option [Hash] Accepts option :namespace.
     # @&block The registration block.
     #
     def register_page(name, options = {}, &block)
-      ns_name = namespace_name(options)
-      namespace(ns_name).register_page name, options, &block
+      ns = options.fetch(:namespace){ default_namespace }
+      namespace(ns).register_page name, options, &block
     end
 
     # Whether all configuration files have been loaded
@@ -155,7 +174,7 @@ module ActiveAdmin
     # Removes all defined controllers from memory. Useful in
     # development, where they are reloaded on each request.
     def unload!
-      namespaces.values.each{ |namespace| namespace.unload! }
+      namespaces.each &:unload!
       @@loaded = false
     end
 
@@ -171,9 +190,13 @@ module ActiveAdmin
       end
     end
 
+    def load(file)
+      DatabaseHitDuringLoad.capture{ super }
+    end
+
     # Returns ALL the files to be loaded
     def files
-      load_paths.flatten.compact.uniq.map{ |path| Dir["#{path}/**/*.rb"] }.flatten
+      load_paths.flatten.compact.uniq.flat_map{ |path| Dir["#{path}/**/*.rb"] }
     end
 
     def router
@@ -192,62 +215,52 @@ module ActiveAdmin
     #
     %w(before_filter skip_before_filter after_filter skip_after_filter around_filter skip_filter).each do |name|
       define_method name do |*args, &block|
-        ActiveAdmin::BaseController.send              name, *args, &block
-        ActiveAdmin::Devise::PasswordsController.send name, *args, &block
-        ActiveAdmin::Devise::SessionsController.send  name, *args, &block
-        ActiveAdmin::Devise::UnlocksController.send   name, *args, &block
+        controllers_for_filters.each do |controller|
+          controller.public_send name, *args, &block
+        end
       end
     end
 
-    # Helper method to add a dashboard section
-    def dashboard_section(name, options = {}, &block)
-      ActiveAdmin::Dashboards.add_section(name, options, &block)
+    def controllers_for_filters
+      controllers = [BaseController]
+      controllers.push *Devise.controllers_for_filters if Dependency.devise?
+      controllers
     end
 
-    private
-
-    # Return either the passed in namespace or the default
-    def namespace_name(options)
-      options.fetch(:namespace){ default_namespace }
-    end
+  private
 
     def register_default_assets
-      register_stylesheet 'active_admin.css', :media => 'screen'
-      register_stylesheet 'active_admin/print.css', :media => 'print'
-
-      unless ActiveAdmin.use_asset_pipeline?
-        register_javascript 'jquery.min.js'
-        register_javascript 'jquery-ui.min.js'
-        register_javascript 'jquery_ujs.js'
-      end
+      register_stylesheet 'active_admin.css',       media: 'screen'
+      register_stylesheet 'active_admin/print.css', media: 'print'
 
       register_javascript 'active_admin.js'
     end
 
-    # Since we're dealing with all our own file loading, we need
-    # to remove our paths from the ActiveSupport autoload paths.
-    # If not, file naming becomes very important and can cause clashes.
+    # Since app/admin is alphabetically before app/models, we have to remove it
+    # from the host app's +autoload_paths+ to prevent missing constant errors.
+    #
+    # As well, we have to remove it from +eager_load_paths+ to prevent the
+    # files from being loaded twice in production.
     def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
-      ActiveSupport::Dependencies.autoload_paths.reject!{|path| load_paths.include?(path) }
-      # Don't eagerload our configs, we'll deal with them ourselves
-      Rails.application.config.eager_load_paths = Rails.application.config.eager_load_paths.reject do |path|
-        load_paths.include?(path)
-      end
+      ActiveSupport::Dependencies.autoload_paths -= load_paths
+      Rails.application.config.eager_load_paths  -= load_paths
     end
 
+    # Hooks the app/admin directory into our Rails Engine's +watchable_dirs+, so the
+    # files are automatically reloaded in your development environment.
+    #
+    # If files have changed on disk, we forcibly unload all AA configurations, and
+    # tell the host application to redraw routes (triggering AA itself to reload).
     def attach_reloader
-      ActiveAdmin::Reloader.build(Rails.application, self, Rails.version).attach!
-    end
-
-    def generate_stylesheets
-      # Create our own asset pipeline in Rails 3.0
-      if ActiveAdmin.use_asset_pipeline?
-        # Add our mixins to the load path for SASS
-        ::Sass::Engine::DEFAULT_OPTIONS[:load_paths] <<  File.expand_path("../../../app/assets/stylesheets", __FILE__)
-      else
-        require 'active_admin/sass/css_loader'
-        ::Sass::Plugin.add_template_location(File.expand_path("../../../app/assets/stylesheets", __FILE__))
-        ::Sass::Plugin.add_template_location(File.expand_path("../sass", __FILE__))
+      load_paths.each do |path|
+        ActiveAdmin::Engine.config.watchable_dirs[path] = [:rb]
+      end
+
+      Rails.application.config.after_initialize do
+        ActionDispatch::Reloader.to_prepare do
+          ActiveAdmin.application.unload!
+          Rails.application.reload_routes!
+        end
       end
     end
   end

data/lib/active_admin/asset_registration.rb

@@ -10,7 +10,7 @@ module ActiveAdmin
     end
 
     def clear_stylesheets!
-      @stylesheets = {}
+      stylesheets.clear
     end
 
     def register_javascript(name)
@@ -22,7 +22,7 @@ module ActiveAdmin
     end
 
     def clear_javascripts!
-      @javascripts = Set.new
+      javascripts.clear
     end
 
   end

data/lib/active_admin/authorization_adapter.rb

@@ -49,7 +49,7 @@ module ActiveAdmin
     #        global navigation. To deal with this nicely in a case statement, take
     #        a look at `#normalized(klasss)`
     #
-    # @returns [Boolean]
+    # @return [Boolean]
     def authorized?(action, subject = nil)
       true
     end
@@ -66,7 +66,7 @@ module ActiveAdmin
     #        one of the `ActiveAdmin::Auth::*` symbols. Defaults to `Auth::READ` if
     #        no action passed in.
     #
-    # @returns [ActiveRecord::Relation] A new collection, scoped to the
+    # @return [ActiveRecord::Relation] A new collection, scoped to the
     #          objects that the current user has access to.
     def scope_collection(collection, action = Auth::READ)
       collection

data/lib/active_admin/base_controller.rb

@@ -1,5 +1,3 @@
-require 'inherited_resources'
-
 require 'active_admin/base_controller/authorization'
 require 'active_admin/base_controller/menu'
 
@@ -8,6 +6,7 @@ module ActiveAdmin
   # It implements ActiveAdmin controllers core features.
   class BaseController < ::InheritedResources::Base
     helper ::ActiveAdmin::ViewHelpers
+    helper_method :env
 
     layout :determine_active_admin_layout
 
@@ -23,7 +22,7 @@ module ActiveAdmin
       attr_accessor :active_admin_config
     end
 
-    # By default Rails will render un-implemented actions when the view exists. Becuase Active
+    # By default Rails will render un-implemented actions when the view exists. Because 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

data/lib/active_admin/base_controller/authorization.rb

@@ -1,39 +1,21 @@
 module ActiveAdmin
-
-  # Exception class to raise when there is an authorized access
-  # exception thrown. The exception has a few goodies that may
-  # be useful for capturing / recognizing security issues.
-  class AccessDenied < StandardError
-    attr_reader :user, :action, :subject
-
-    def initialize(user, action, subject)
-      @user, @action, @subject = user, action, subject
-
-      super()
-    end
-
-    def message
-      I18n.t("active_admin.access_denied.message")
-    end
-  end
-
   class BaseController < ::InheritedResources::Base
     module Authorization
       include MethodOrProcHelper
       extend ActiveSupport::Concern
 
       ACTIONS_DICTIONARY = {
-        :index   => ActiveAdmin::Authorization::READ,
-        :show    => ActiveAdmin::Authorization::READ,
-        :new     => ActiveAdmin::Authorization::CREATE,
-        :create  => ActiveAdmin::Authorization::CREATE,
-        :edit    => ActiveAdmin::Authorization::UPDATE,
-        :update  => ActiveAdmin::Authorization::UPDATE,
-        :destroy => ActiveAdmin::Authorization::DESTROY
+        index:   ActiveAdmin::Authorization::READ,
+        show:    ActiveAdmin::Authorization::READ,
+        new:     ActiveAdmin::Authorization::CREATE,
+        create:  ActiveAdmin::Authorization::CREATE,
+        edit:    ActiveAdmin::Authorization::UPDATE,
+        update:  ActiveAdmin::Authorization::UPDATE,
+        destroy: ActiveAdmin::Authorization::DESTROY
       }
 
       included do
-        rescue_from ActiveAdmin::AccessDenied, :with => :dispatch_active_admin_access_denied
+        rescue_from ActiveAdmin::AccessDenied, with: :dispatch_active_admin_access_denied
 
         helper_method :authorized?
         helper_method :authorize!
@@ -50,7 +32,7 @@ module ActiveAdmin
       # @param [any] subject The subject that the user is trying to perform
       #                 the action on.
       #
-      # @returns [Boolean]
+      # @return [Boolean]
       #
       def authorized?(action, subject = nil)
         active_admin_authorization.authorized?(action, subject)
@@ -67,7 +49,7 @@ module ActiveAdmin
       # @param [any] subject The subject that the user is trying to perform
       #                 the action on.
       #
-      # @returns [Boolean] True if authorized, otherwise raises
+      # @return [Boolean] True if authorized, otherwise raises
       #                 an ActiveAdmin::AccessDenied.
       def authorize!(action, subject = nil)
         unless authorized? action, subject
@@ -87,7 +69,7 @@ module ActiveAdmin
 
       # Retrieve or instantiate the authorization instance for this resource
       #
-      # @returns [ActiveAdmin::AuthorizationAdapter]
+      # @return [ActiveAdmin::AuthorizationAdapter]
       def active_admin_authorization
         @active_admin_authorization ||=
          active_admin_authorization_adapter.new active_admin_config, current_active_admin_user
@@ -95,7 +77,7 @@ module ActiveAdmin
 
       # Returns the class to be used as the authorization adapter
       #
-      # @returns [Class]
+      # @return [Class]
       def active_admin_authorization_adapter
         adapter = active_admin_namespace.authorization_adapter
         if adapter.is_a? String
@@ -111,7 +93,7 @@ module ActiveAdmin
       #
       # @param [String, Symbol] action The controller action name.
       #
-      # @returns [Symbol] The permission name to use.
+      # @return [Symbol] The permission name to use.
       def action_to_permission(action)
         if action && action = action.to_sym
           Authorization::ACTIONS_DICTIONARY[action] || action

data/lib/active_admin/batch_actions.rb

@@ -13,5 +13,5 @@ ActiveAdmin.before_load do |app|
   require "active_admin/batch_actions/views/batch_action_selector"
 
   # Register the views with the view factory
-  app.view_factory.register :batch_action_selector => ActiveAdmin::BatchActions::BatchActionSelector
+  app.view_factory.register batch_action_selector: ActiveAdmin::BatchActions::BatchActionSelector
 end

data/lib/active_admin/batch_actions/controller.rb

@@ -2,12 +2,14 @@ module ActiveAdmin
   module BatchActions
     module Controller
 
-      # Controller Action that get's called when submitting the batch action form
+      # Controller action that is called when submitting the batch action form
       def batch_action
-        if selected_batch_action
-          selected_ids = params[:collection_selection]
-          selected_ids ||= []
-          instance_exec selected_ids, &selected_batch_action.block
+        if action_present?
+          selection  =            params[:collection_selection] ||  []
+          inputs     = JSON.parse params[:batch_action_inputs]  || '{}'
+          valid_keys = render_in_context(self, current_batch_action.inputs).try(:keys)
+          inputs     = inputs.with_indifferent_access.slice *valid_keys
+          instance_exec selection, inputs, &current_batch_action.block
         else
           raise "Couldn't find batch action \"#{params[:batch_action]}\""
         end
@@ -15,11 +17,25 @@ module ActiveAdmin
 
       protected
 
-      def selected_batch_action
-        return unless params[:batch_action].present?
-        active_admin_config.batch_actions.select { |action| action.sym == params[:batch_action].to_sym }.first
+      def action_present?
+        params[:batch_action].present? && current_batch_action
       end
 
+      def current_batch_action
+        active_admin_config.batch_actions.detect{ |action| action.sym.to_s == params[:batch_action] }
+      end
+
+      COLLECTION_APPLIES = [
+        :authorization_scope,
+        :collection_decorator,
+        :filtering,
+        :scoping,
+        :includes
+      ].freeze
+
+      def batch_action_collection(only = COLLECTION_APPLIES)
+        find_collection(only: only)
+      end
     end
   end
 end

data/lib/active_admin/batch_actions/resource_extension.rb

@@ -5,7 +5,7 @@ module ActiveAdmin
       def initialize(*)
         super
         @batch_actions = {}
-        add_default_batch_actions
+        add_default_batch_action
       end
 
       # @return [Array] The set of batch actions for this resource
@@ -31,7 +31,8 @@ module ActiveAdmin
       # @param [Hash] options
       # => :if is a proc that will be called to determine if the BatchAction should be displayed
       # => :sort_order is used to sort the batch actions ascending
-      # => :confirm is a string which the user will have to accept in order to process the action
+      # => :confirm is a string to prompt the user with (or a boolean to use the default message)
+      # => :form is a Hash of form fields you want the user to fill out
       #
       def add_batch_action(sym, title, options = {}, &block)
         @batch_actions[sym] = ActiveAdmin::BatchAction.new(sym, title, options, &block)
@@ -39,7 +40,7 @@ module ActiveAdmin
 
       # Remove a batch action
       # @param [Symbol] sym
-      # @returns [ActiveAdmin::BatchAction] the batch action, if it was present
+      # @return [ActiveAdmin::BatchAction] the batch action, if it was present
       #
       def remove_batch_action(sym)
         @batch_actions.delete(sym.to_sym)
@@ -58,21 +59,24 @@ module ActiveAdmin
       private
 
       # @return [ActiveAdmin::BatchAction] The default "delete" action
-      def add_default_batch_actions
+      def add_default_batch_action
         destroy_options = {
-          :priority => 100,
-          :confirm => proc { I18n.t('active_admin.batch_actions.delete_confirmation', :plural_model => active_admin_config.plural_resource_label.downcase) },
-          :if => proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
+          priority: 100,
+          confirm: proc{ I18n.t('active_admin.batch_actions.delete_confirmation', plural_model: active_admin_config.plural_resource_label.downcase) },
+          if: proc{ controller.action_methods.include?('destroy') && authorized?(ActiveAdmin::Auth::DESTROY, active_admin_config.resource_class) }
         }
 
         add_batch_action :destroy, proc { I18n.t('active_admin.delete') }, destroy_options do |selected_ids|
-          active_admin_config.resource_class.find(selected_ids).each { |r| r.destroy }
+          batch_action_collection.find(selected_ids).each do |record|
+            authorize! ActiveAdmin::Auth::DESTROY, record
+            destroy_resource(record)
+          end
 
           redirect_to active_admin_config.route_collection_path(params),
-                      :notice => I18n.t("active_admin.batch_actions.succesfully_destroyed",
-                                        :count => selected_ids.count,
-                                        :model => active_admin_config.resource_label.downcase,
-                                        :plural_model => active_admin_config.plural_resource_label(:count => selected_ids.count).downcase)
+                      notice: I18n.t("active_admin.batch_actions.succesfully_destroyed",
+                                        count: selected_ids.count,
+                                        model: active_admin_config.resource_label.downcase,
+                                        plural_model: active_admin_config.plural_resource_label(count: selected_ids.count).downcase)
         end
       end
 
@@ -83,7 +87,9 @@ module ActiveAdmin
 
     include Comparable
 
-    attr_reader :block, :title, :sym, :confirm
+    attr_reader :block, :title, :sym
+
+    DEFAULT_CONFIRM_MESSAGE = proc{ I18n.t 'active_admin.batch_actions.default_confirmation' }
 
     # Create a Batch Action
     #
@@ -92,24 +98,47 @@ module ActiveAdmin
     #   BatchAction.new :flag
     # => Will create an action that appears in the action list popover
     #
-    #   BatchAction.new( :flag ) { |selection| redirect_to collection_path, :notice => "#{selection.length} users flagged" }
+    #   BatchAction.new(:flag) { |selection| redirect_to collection_path, notice: "#{selection.length} users flagged" }
     # => Will create an action that uses a block to process the request (which receives one paramater of the selected objects)
     #
-    #   BatchAction.new( "Perform Long Operation on the" ) { |selection| }
+    #   BatchAction.new("Perform Long Operation on") { |selection| }
     # => You can create batch actions with a title instead of a Symbol
     #
-    #   BatchAction.new( :flag, :if => proc { can? :flag, AdminUser  } ) { |selection| }
-    # => You can provide an optional :if proc to optionally display the batch action
+    #   BatchAction.new(:flag, if: proc{ can? :flag, AdminUser }) { |selection| }
+    # => You can provide an `:if` proc to choose when the batch action should be displayed
+    #
+    #   BatchAction.new :flag, confirm: true
+    # => You can pass `true` to `:confirm` to use the default confirm message.
+    #
+    #   BatchAction.new(:flag, confirm: "Are you sure?") { |selection| }
+    # => You can pass a custom confirmation message through `:confirm`
+    #
+    #   BatchAction.new(:flag, form: {foo: :text, bar: :checkbox}) { |selection, inputs| }
+    # => You can pass a hash of options to `:form` that will be rendered as form input fields for the user to fill out.
     #
     def initialize(sym, title, options = {}, &block)
       @sym, @title, @options, @block, @confirm = sym, title, options, block, options[:confirm]
       @block ||= proc {}
     end
 
+    def confirm
+      if @confirm == true
+        DEFAULT_CONFIRM_MESSAGE
+      elsif !@confirm && @options[:form]
+        DEFAULT_CONFIRM_MESSAGE
+      else
+        @confirm
+      end
+    end
+
+    def inputs
+      @options[:form]
+    end
+
     # Returns the display if block. If the block was not explicitly defined
     # a default block always returning true will be returned.
     def display_if_block
-      @options[:if] || proc { true }
+      @options[:if] || proc{ true }
     end
 
     # Used for sorting