class ActiveAdmin::Application

def attach_reloader 

def attach_reloader
  ActiveAdmin::Reloader.build(Rails.application, self, Rails.version).attach!
end

def dashboard_section(name, options = {}, &block)

Helper method to add a dashboard section 
def dashboard_section(name, options = {}, &block)
  ActiveAdmin::Dashboards.add_section(name, options, &block)
end

def files

Returns ALL the files to be loaded 
def files
  load_paths.flatten.compact.uniq.map{ |path| Dir["#{path}/**/*.rb"] }.flatten
end

def generate_stylesheets 

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__))
  end
end

def initialize 

def initialize
  @namespaces = {}
end

def load!

To reload everything simply call `ActiveAdmin.unload!`
Loads all ruby files that are within the load_paths setting. 
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
    @@loaded = true
  end
end

def loaded?

Whether all configuration files have been loaded 
def loaded?
  @@loaded ||= false
end

def namespace(name)

@returns [Namespace] the new or existing namespace

Yields the namespace if a block is given

Creates a namespace for the given name 
def namespace(name)
  name ||= :root
  if namespaces[name]
    namespace = namespaces[name]
  else
    namespace = namespaces[name] = Namespace.new(self, name)
    ActiveAdmin::Event.dispatch ActiveAdmin::Namespace::RegisterEvent, namespace
  end
  yield(namespace) if block_given?
  namespace
end

def namespace_name(options)

Return either the passed in namespace or the default 
def namespace_name(options)
  options.fetch(:namespace){ default_namespace }
end

def prepare! 

def prepare!
  remove_active_admin_load_paths_from_rails_autoload_and_eager_load
  attach_reloader
  generate_stylesheets
end

def register(resource, options = {}, &block)

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
end

def register_default_assets 

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_javascript 'active_admin.js'
end

def register_page(name, options = {}, &block)

Parameters:
  • name (String) -- The page name 
def register_page(name, options = {}, &block)
  ns_name = namespace_name(options)
  namespace(ns_name).register_page name, options, &block
end

def remove_active_admin_load_paths_from_rails_autoload_and_eager_load

If not, file naming becomes very important and can cause clashes.
to remove our paths from the ActiveSupport autoload paths.
Since we're dealing with all our own file loading, we need 
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
end

def router 

def router
  @router ||= Router.new(self)
end

def routes(rails_router)

One-liner called by user's config/routes.rb file 
def routes(rails_router)
  load!
  router.apply(rails_router)
end

def setup! 

def setup!
  register_default_assets
end

def unload!

development, where they are reloaded on each request.
Removes all defined controllers from memory. Useful in 
def unload!
  namespaces.values.each{ |namespace| namespace.unload! }
  @@loaded = false
end