class ActiveAdmin::Application

Constants

AfterLoadEvent
BeforeLoadEvent

Event that gets triggered on load of Active Admin

Attributes

namespaces[R]

Public Class Methods

inheritable_setting(name, default) click to toggle source
# File lib/active_admin/application.rb, line 14
def inheritable_setting(name, default)
  NamespaceSettings.register name, default
end
new() click to toggle source
# File lib/active_admin/application.rb, line 42
def initialize
  @namespaces = Namespace::Store.new
end
setting(name, default) click to toggle source
# File lib/active_admin/application.rb, line 10
def setting(name, default)
  ApplicationSettings.register name, default
end

Public Instance Methods

controllers_for_filters() click to toggle source
# File lib/active_admin/application.rb, line 159
def controllers_for_filters
  controllers = [BaseController]
  controllers.push *Devise.controllers_for_filters if Dependency.devise?
  controllers
end
files() click to toggle source

Returns ALL the files to be loaded

# File lib/active_admin/application.rb, line 128
def files
  load_paths.flatten.compact.uniq.flat_map { |path| Dir["#{path}/**/*.rb"].sort }
end
load(file) click to toggle source
Calls superclass method
# File lib/active_admin/application.rb, line 123
def load(file)
  DatabaseHitDuringLoad.capture { super }
end
load!() click to toggle source

Loads all ruby files that are within the load_paths setting. To reload everything simply call ‘ActiveAdmin.unload!`

# File lib/active_admin/application.rb, line 113
def load!
  unless loaded?
    ActiveSupport::Notifications.instrument BeforeLoadEvent, { active_admin_application: self } # before_load hook
    files.each { |file| load file } # load files
    namespace(default_namespace) # init AA resources
    ActiveSupport::Notifications.instrument AfterLoadEvent, { active_admin_application: self } # after_load hook
    @@loaded = true
  end
end
loaded?() click to toggle source

Whether all configuration files have been loaded

# File lib/active_admin/application.rb, line 100
def loaded?
  @@loaded ||= false
end
method_missing(method, *args) click to toggle source
Calls superclass method
# File lib/active_admin/application.rb, line 31
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
namespace(name) { |namespace| ... } click to toggle source

Creates a namespace for the given name

Yields the namespace if a block is given

@return [Namespace] the new or existing namespace

# File lib/active_admin/application.rb, line 74
def namespace(name)
  name ||= :root

  namespace = namespaces[name.to_sym] ||= begin
    namespace = Namespace.new(self, name)
    ActiveSupport::Notifications.instrument ActiveAdmin::Namespace::RegisterEvent, { active_admin_namespace: namespace }
    namespace
  end

  yield(namespace) if block_given?

  namespace
end
namespace_settings() click to toggle source
# File lib/active_admin/application.rb, line 23
def namespace_settings
  @namespace_settings ||= SettingsNode.build(NamespaceSettings)
end
prepare!() click to toggle source

Runs after the app’s AA initializer

# File lib/active_admin/application.rb, line 58
def prepare!
  remove_active_admin_load_paths_from_rails_autoload_and_eager_load
  attach_reloader
end
register(resource, options = {}, &block) click to toggle source

Registers a brand new configuration for the given resource.

# File lib/active_admin/application.rb, line 64
def register(resource, options = {}, &block)
  ns = options.fetch(:namespace) { default_namespace }
  namespace(ns).register resource, options, &block
end
register_page(name, options = {}, &block) click to toggle source

Register a page

@param name [String] The page name @option [Hash] Accepts option :namespace. @&block The registration block.

# File lib/active_admin/application.rb, line 94
def register_page(name, options = {}, &block)
  ns = options.fetch(:namespace) { default_namespace }
  namespace(ns).register_page name, options, &block
end
respond_to_missing?(method, include_private = false) click to toggle source
Calls superclass method
# File lib/active_admin/application.rb, line 27
def respond_to_missing?(method, include_private = false)
  [settings, namespace_settings].any? { |sets| sets.respond_to?(method) } || super
end
routes(rails_router) click to toggle source

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]

# File lib/active_admin/application.rb, line 141
def routes(rails_router)
  load!
  Router.new(router: rails_router, namespaces: namespaces).apply
end
settings() click to toggle source
# File lib/active_admin/application.rb, line 19
def settings
  @settings ||= SettingsNode.build(ApplicationSettings)
end
setup!() click to toggle source

Runs before the app’s AA initializer

# File lib/active_admin/application.rb, line 53
def setup!
  register_default_assets
end
unload!() click to toggle source

Removes all defined controllers from memory. Useful in development, where they are reloaded on each request.

# File lib/active_admin/application.rb, line 106
def unload!
  namespaces.each &:unload!
  @@loaded = false
end

Private Instance Methods

attach_reloader() click to toggle source

Hook into the Rails code reloading mechanism so that things are reloaded properly in development mode.

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.

# File lib/active_admin/application.rb, line 188
def attach_reloader
  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

    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
register_default_assets() click to toggle source
# File lib/active_admin/application.rb, line 167
def register_default_assets
  register_stylesheet "active_admin.css", media: "all"
  register_javascript "active_admin.js"
end
remove_active_admin_load_paths_from_rails_autoload_and_eager_load() click to toggle source

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.

# File lib/active_admin/application.rb, line 177
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
end