activeadmin 1.0.0.pre1 → 2.9.0

data/lib/active_admin/abstract_view_factory.rb

@@ -1,15 +1,19 @@
 module ActiveAdmin
-  class AbstractViewFactory
-    @@default_views = {}
+  class AbstractViewFactory < SettingsNode
 
     def self.register(view_hash)
       view_hash.each do |view_key, view_class|
-        @@default_views[view_key] = view_class
+        super view_key, view_class
+        add_writer(view_key)
+        send "#{view_key}=", view_class
       end
     end
 
-    def initialize
-      @views = {}
+    def self.add_writer(name)
+      define_singleton_method("#{name}=") do |value|
+        value.builder_method name
+        instance_variable_set :"@#{name}", value
+      end
     end
 
     # Register a new view key with the view factory
@@ -25,61 +29,19 @@ module ActiveAdmin
     #                     another_view: OtherViewClass
     #
     def register(view_hash)
-      view_hash.each do |view_key, view_class|
-        @views[view_key] = view_class
-      end
+      self.class.register view_hash
     end
 
     def default_for(key)
-      @@default_views[key.to_sym]
-    end
-
-    def has_key?(key)
-      @views.has_key?(key.to_sym) || @@default_views.has_key?(key.to_sym)
+      self.class.send key
     end
 
     def [](key)
-      get_view_for_key(key)
+      send key
     end
 
     def []=(key, value)
-      set_view_for_key(key, value)
-    end
-
-    def respond_to_missing?(method, include_private)
-      key = key_from_method_name(method)
-      if has_key?(key)
-        true
-      else
-        super
-      end
-    end
-
-    private
-
-    def method_missing(method, *args)
-      key = key_from_method_name(method)
-      if has_key?(key)
-        if method.to_s.include?('=')
-          set_view_for_key key, args.first
-        else
-          get_view_for_key key
-        end
-      else
-        super
-      end
-    end
-
-    def key_from_method_name(method)
-      method.to_s.tr('=', '').to_sym
-    end
-
-    def get_view_for_key(key)
-      @views[key.to_sym] || @@default_views[key.to_sym]
-    end
-
-    def set_view_for_key(key, view)
-      @views[key.to_sym] = view
+      send "#{key}=", value
     end
   end
 end

data/lib/active_admin/application.rb

@@ -1,123 +1,52 @@
-require 'active_admin/router'
-require 'active_admin/helpers/settings'
+require "active_admin/router"
+require "active_admin/application_settings"
+require "active_admin/namespace_settings"
 
 module ActiveAdmin
   class Application
-    include Settings
-    include Settings::Inheritance
 
-    settings_inherited_by Namespace
-
-    # The default namespace to put controllers and routes inside. Set this
-    # in config/initializers/active_admin.rb using:
-    #
-    #   config.default_namespace = :super_admin
-    #
-    setting :default_namespace, :admin
+    class << self
+      def setting(name, default)
+        ApplicationSettings.register name, default
+      end
 
-    attr_reader :namespaces
-    def initialize
-      @namespaces = Namespace::Store.new
+      def inheritable_setting(name, default)
+        NamespaceSettings.register name, default
+      end
     end
 
-    # Load paths for admin configurations. Add folders to this load path
-    # to load up other resources for administration. External gems can
-    # include their paths in this load path to provide active_admin UIs
-    setting :load_paths, [File.expand_path('app/admin', Rails.root)]
-
-    # The default number of resources to display on index pages
-    inheritable_setting :default_per_page, 30
-
-    # The title which gets displayed in the main layout
-    inheritable_setting :site_title, ""
-
-    # Set the site title link href (defaults to AA dashboard)
-    inheritable_setting :site_title_link, ""
-
-    # 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
-
-    # The view factory to use to generate all the view classes. Take
-    # a look at ActiveAdmin::ViewFactory
-    inheritable_setting :view_factory, ActiveAdmin::ViewFactory.new
-
-    # The method to call in controllers to get the current user
-    inheritable_setting :current_user_method, false
-
-    # The method to call in the controllers to ensure that there
-    # is a currently authenticated admin user
-    inheritable_setting :authentication_method, false
-
-    # The path to log user's out with. If set to a symbol, we assume
-    # that it's a method to call which returns the path
-    inheritable_setting :logout_link_path, :destroy_admin_user_session_path
-
-    # The method to use when generating the link for user logout
-    inheritable_setting :logout_link_method, :get
-
-    # Whether the batch actions are enabled or not
-    inheritable_setting :batch_actions, false
-
-    # Whether filters are enabled
-    inheritable_setting :filters, true
-
-    # 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: ',', byte_order_mark: "\xEF\xBB\xBF" }
-
-    # Default Download Links options
-    inheritable_setting :download_links, true
-
-    # The authorization adapter to use
-    inheritable_setting :authorization_adapter, ActiveAdmin::AuthorizationAdapter
-
-    # 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
-    ]
+    def settings
+      @settings ||= SettingsNode.build(ApplicationSettings)
+    end
 
-    # Set flash message keys that shouldn't show in ActiveAdmin
-    inheritable_setting :flash_keys_to_except, ['timedout']
+    def namespace_settings
+      @namespace_settings ||= SettingsNode.build(NamespaceSettings)
+    end
 
-    # 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,
-                                      :full_name,
-                                      :name,
-                                      :username,
-                                      :login,
-                                      :title,
-                                      :email,
-                                      :to_s ]
+    def respond_to_missing?(method, include_private = false)
+      [settings, namespace_settings].any? { |sets| sets.respond_to?(method) } || super
+    end
 
-    # == Deprecated Settings
+    def method_missing(method, *args)
+      if settings.respond_to?(method)
+        settings.send(method, *args)
+      elsif namespace_settings.respond_to?(method)
+        namespace_settings.send(method, *args)
+      else
+        super
+      end
+    end
 
-    def allow_comments=(*)
-      raise "`config.allow_comments` is no longer provided in ActiveAdmin 1.x. Use `config.comments` instead."
+    attr_reader :namespaces
+    def initialize
+      @namespaces = Namespace::Store.new
     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
+    BeforeLoadEvent = "active_admin.application.before_load".freeze
+    AfterLoadEvent = "active_admin.application.after_load".freeze
 
     # Runs before the app's AA initializer
     def setup!
@@ -132,7 +61,7 @@ module ActiveAdmin
 
     # Registers a brand new configuration for the given resource.
     def register(resource, options = {}, &block)
-      ns = options.fetch(:namespace){ default_namespace }
+      ns = options.fetch(:namespace) { default_namespace }
       namespace(ns).register resource, options, &block
     end
 
@@ -144,9 +73,9 @@ module ActiveAdmin
     def namespace(name)
       name ||= :root
 
-      namespace = namespaces[name] ||= begin
+      namespace = namespaces[name.to_sym] ||= begin
         namespace = Namespace.new(self, name)
-        ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
+        ActiveSupport::Notifications.publish ActiveAdmin::Namespace::RegisterEvent, namespace
         namespace
       end
 
@@ -162,7 +91,7 @@ module ActiveAdmin
     # @&block The registration block.
     #
     def register_page(name, options = {}, &block)
-      ns = options.fetch(:namespace){ default_namespace }
+      ns = options.fetch(:namespace) { default_namespace }
       namespace(ns).register_page name, options, &block
     end
 
@@ -182,38 +111,43 @@ module ActiveAdmin
     # To reload everything simply call `ActiveAdmin.unload!`
     def load!
       unless loaded?
-        ActiveAdmin::Event.dispatch BeforeLoadEvent, self # before_load hook
-        files.each{ |file| load file }                    # load files
-        namespace(default_namespace)                      # init AA resources
-        ActiveAdmin::Event.dispatch AfterLoadEvent, self  # after_load hook
+        ActiveSupport::Notifications.publish BeforeLoadEvent, self # before_load hook
+        files.each { |file| load file } # load files
+        namespace(default_namespace) # init AA resources
+        ActiveSupport::Notifications.publish AfterLoadEvent, self # after_load hook
         @@loaded = true
       end
     end
 
     def load(file)
-      DatabaseHitDuringLoad.capture{ super }
+      DatabaseHitDuringLoad.capture { super }
     end
 
     # Returns ALL the files to be loaded
     def files
-      load_paths.flatten.compact.uniq.flat_map{ |path| Dir["#{path}/**/*.rb"] }
+      load_paths.flatten.compact.uniq.flat_map { |path| Dir["#{path}/**/*.rb"] }.sort
     end
 
-    def router
-      @router ||= Router.new(self)
-    end
-
-    # One-liner called by user's config/routes.rb file
+    # 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
+    #
+    # @param rails_router [ActionDispatch::Routing::Mapper]
     def routes(rails_router)
       load!
-      router.apply(rails_router)
+      Router.new(router: rails_router, namespaces: namespaces).apply
     end
 
     # Adds before, around and after filters to all controllers.
     # Example usage:
     #   ActiveAdmin.before_filter :authenticate_admin!
     #
-    %w(before_filter skip_before_filter after_filter skip_after_filter around_filter skip_filter).each do |name|
+    AbstractController::Callbacks::ClassMethods.public_instance_methods.
+      select { |m| m.match(/(filter|action)/) }.each do |name|
       define_method name do |*args, &block|
         controllers_for_filters.each do |controller|
           controller.public_send name, *args, &block
@@ -227,13 +161,12 @@ module ActiveAdmin
       controllers
     end
 
-  private
+    private
 
     def register_default_assets
-      register_stylesheet 'active_admin.css',       media: 'screen'
-      register_stylesheet 'active_admin/print.css', media: 'print'
-
-      register_javascript 'active_admin.js'
+      register_stylesheet "active_admin.css", media: "screen"
+      register_stylesheet "active_admin/print.css", media: "print"
+      register_javascript "active_admin.js"
     end
 
     # Since app/admin is alphabetically before app/models, we have to remove it
@@ -243,23 +176,57 @@ module ActiveAdmin
     # files from being loaded twice in production.
     def remove_active_admin_load_paths_from_rails_autoload_and_eager_load
       ActiveSupport::Dependencies.autoload_paths -= load_paths
-      Rails.application.config.eager_load_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.
+    # Hook into the Rails code reloading mechanism so that things are reloaded
+    # properly in development mode.
     #
-    # 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).
+    # If any of the app files (e.g. models) has changed, we need to reload all
+    # the admin files. If the admin files themselves has changed, we need to
+    # regenerate the routes as well.
     def attach_reloader
-      load_paths.each do |path|
-        ActiveAdmin::Engine.config.watchable_dirs[path] = [:rb]
-      end
+      Rails.application.config.after_initialize do |app|
+        unload_active_admin = -> { ActiveAdmin.application.unload! }
+
+        if app.config.reload_classes_only_on_change
+          # Rails is about to unload all the app files (e.g. models), so we
+          # should first unload the classes generated by Active Admin, otherwise
+          # they will contain references to the stale (unloaded) classes.
+          ActiveSupport::Reloader.to_prepare(prepend: true, &unload_active_admin)
+        else
+          # If the user has configured the app to always reload app files after
+          # each request, so we should unload the generated classes too.
+          ActiveSupport::Reloader.to_complete(&unload_active_admin)
+        end
+
+        admin_dirs = {}
+
+        load_paths.each do |path|
+          admin_dirs[path] = [:rb]
+        end
+
+        routes_reloader = app.config.file_watcher.new([], admin_dirs) do
+          app.reload_routes!
+        end
 
-      Rails.application.config.after_initialize do
-        ActionDispatch::Reloader.to_prepare do
-          ActiveAdmin.application.unload!
-          Rails.application.reload_routes!
+        app.reloaders << routes_reloader
+
+        ActiveSupport::Reloader.to_prepare do
+          # Rails might have reloaded the routes for other reasons (e.g.
+          # routes.rb has changed), in which case Active Admin would have been
+          # loaded via the `ActiveAdmin.routes` call in `routes.rb`.
+          #
+          # Otherwise, we should check if any of the admin files are changed
+          # and force the routes to reload if necessary. This would again causes
+          # Active Admin to load via `ActiveAdmin.routes`.
+          #
+          # Finally, if Active Admin is still not loaded at this point, then we
+          # would need to load it manually.
+          unless ActiveAdmin.application.loaded?
+            routes_reloader.execute_if_updated
+            ActiveAdmin.application.load!
+          end
         end
       end
     end

data/lib/active_admin/application_settings.rb

@@ -0,0 +1,42 @@
+require "active_admin/settings_node"
+
+module ActiveAdmin
+  class ApplicationSettings < SettingsNode
+
+    # The default namespace to put controllers and routes inside. Set this
+    # in config/initializers/active_admin.rb using:
+    #
+    #   config.default_namespace = :super_admin
+    #
+    register :default_namespace, :admin
+
+    register :app_path, Rails.root
+
+    # Load paths for admin configurations. Add folders to this load path
+    # to load up other resources for administration. External gems can
+    # include their paths in this load path to provide active_admin UIs
+    register :load_paths, [File.expand_path("app/admin", Rails.root)]
+
+    # Set default localize format for Date/Time values
+    register :localize_format, :long
+
+    # Active Admin makes educated guesses when displaying objects, this is
+    # the list of methods it tries calling in order
+    # Note that Formtastic also has 'collection_label_methods' similar to this
+    # used by auto generated dropdowns in filter or belongs_to field of Active Admin
+    register :display_name_methods, [ :display_name,
+                                      :full_name,
+                                      :name,
+                                      :username,
+                                      :login,
+                                      :title,
+                                      :email,
+                                      :to_s ]
+
+    # To make debugging easier, by default don't stream in development
+    register :disable_streaming_in, ["development"]
+
+    # Remove sensitive attributes from being displayed, made editable, or exported by default
+    register :filter_attributes, [:encrypted_password, :password, :password_confirmation]
+  end
+end

data/lib/active_admin/authorization_adapter.rb

@@ -2,15 +2,14 @@ module ActiveAdmin
 
   # Default Authorization permissions for Active Admin
   module Authorization
-    READ    = :read
-    CREATE  = :create
-    UPDATE  = :update
+    READ = :read
+    CREATE = :create
+    UPDATE = :update
     DESTROY = :destroy
   end
 
   Auth = Authorization
 
-
   # Active Admin's default authorization adapter. This adapter returns true
   # for all requests to `#authorized?`. It should be the starting point for
   # implementing your own authorization adapter.
@@ -19,7 +18,6 @@ module ActiveAdmin
   class AuthorizationAdapter
     attr_reader :resource, :user
 
-
     # Initialize a new authorization adapter. This happens on each and
     # every request to a controller.
     #
@@ -47,14 +45,13 @@ module ActiveAdmin
     #        the class of the subject also. For example, Active Admin uses the class
     #        of the resource to decide if the resource should be displayed in the
     #        global navigation. To deal with this nicely in a case statement, take
-    #        a look at `#normalized(klasss)`
+    #        a look at `#normalized(klass)`
     #
     # @return [Boolean]
     def authorized?(action, subject = nil)
       true
     end
 
-
     # A hook method for authorization libraries to scope the collection. By
     # default, we just return the same collection. The returned scope is used
     # as the starting point for all queries to the db in the controller.

data/lib/active_admin/base_controller/authorization.rb

@@ -1,16 +1,15 @@
 module ActiveAdmin
   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,
+        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
       }
 
@@ -19,6 +18,7 @@ module ActiveAdmin
 
         helper_method :authorized?
         helper_method :authorize!
+        helper_method :active_admin_authorization
       end
 
       protected
@@ -38,7 +38,6 @@ module ActiveAdmin
         active_admin_authorization.authorized?(action, subject)
       end
 
-
       # Authorize the action and subject. Available in the controller
       # as well as all the views. If the action is not allowd, it raises
       # an ActiveAdmin::AccessDenied exception.
@@ -53,9 +52,10 @@ module ActiveAdmin
       #                 an ActiveAdmin::AccessDenied.
       def authorize!(action, subject = nil)
         unless authorized? action, subject
-          raise ActiveAdmin::AccessDenied.new(current_active_admin_user,
-                                              action,
-                                              subject)
+          raise ActiveAdmin::AccessDenied.new(
+            current_active_admin_user,
+            action,
+            subject)
         end
       end
 
@@ -101,7 +101,7 @@ module ActiveAdmin
       end
 
       def dispatch_active_admin_access_denied(exception)
-        call_method_or_exec_proc active_admin_namespace.on_unauthorized_access, exception
+        instance_exec(self, exception, &active_admin_namespace.on_unauthorized_access.to_proc)
       end
 
       def rescue_active_admin_access_denied(exception)
@@ -113,19 +113,14 @@ module ActiveAdmin
             redirect_backwards_or_to_root
           end
 
-          format.csv  { render text:          error,           status: :unauthorized }
-          format.json { render json: { error: error },         status: :unauthorized }
-          format.xml  { render xml: "<error>#{error}</error>", status: :unauthorized }
+          format.csv { render body: error, status: :unauthorized }
+          format.json { render json: { error: error }, status: :unauthorized }
+          format.xml { render xml: "<error>#{error}</error>", status: :unauthorized }
         end
       end
 
       def redirect_backwards_or_to_root
-        if request.headers.key? "HTTP_REFERER"
-          redirect_to :back
-        else
-          controller, action = active_admin_namespace.root_to.split '#'
-          redirect_to controller: controller, action: action
-        end
+        redirect_back fallback_location: active_admin_root
       end
 
     end

data/lib/active_admin/base_controller/menu.rb

@@ -4,7 +4,7 @@ module ActiveAdmin
       extend ActiveSupport::Concern
 
       included do
-        before_filter :set_current_tab
+        before_action :set_current_tab
         helper_method :current_menu
       end
 
@@ -18,15 +18,15 @@ module ActiveAdmin
       # Get's called through a before filter
       def set_current_tab
         @current_tab = if current_menu && active_admin_config.belongs_to? && parent?
-          parent_item = active_admin_config.belongs_to_config.target.menu_item
-          if current_menu.include? parent_item
-            parent_item
-          else
-            active_admin_config.menu_item
-          end
-        else
-          active_admin_config.menu_item
-        end
+                         parent_item = active_admin_config.belongs_to_config.target.menu_item
+                         if current_menu.include? parent_item
+                           parent_item
+                         else
+                           active_admin_config.menu_item
+                         end
+                       else
+                         active_admin_config.menu_item
+                       end
       end
 
     end