Class: ActiveAdmin::Namespace

Inherits:
Object
  • Object
show all
Includes:
Settings
Defined in:
lib/active_admin/namespace.rb

Overview

Namespaces are the basic organizing principle for resources within Active Admin

Each resource is registered into a namespace which defines:

* the namespaceing for routing
* the module to namespace controllers
* the menu which gets displayed (other resources in the same namespace)

For example:

ActiveAdmin.register Post, :namespace => :admin

Will register the Post model into the “admin” namespace. This will namespace the urls for the resource to “/admin/posts” and will set the controller to Admin::PostsController

You can also register to the “root” namespace, which is to say no namespace at all.

ActiveAdmin.register Post, :namespace => false

This will register the resource to an instantiated namespace called :root. The resource will be accessible from “/posts” and the controller will be PostsController.

Constant Summary collapse

RegisterEvent = 
'active_admin.namespace.register'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(application, name) ⇒ Namespace

Returns a new instance of Namespace.



37
38
39
40
41
42
43
44
 
# File 'lib/active_admin/namespace.rb', line 37

def initialize(application, name)
  @application = application
  @name = name.to_s.underscore.to_sym
  @resources = ResourceCollection.new
  register_module unless root?
  generate_dashboard_controller
  build_menu_collection
end

Instance Attribute Details

#application ⇒ Object (readonly)

Returns the value of attribute application.



35
36
37
 
# File 'lib/active_admin/namespace.rb', line 35

def application
  @application
end

#menus ⇒ Object (readonly)

Returns the value of attribute menus.



35
36
37
 
# File 'lib/active_admin/namespace.rb', line 35

def menus
  @menus
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



35
36
37
 
# File 'lib/active_admin/namespace.rb', line 35

def name
  @name
end

#resources ⇒ Object (readonly)

Returns the value of attribute resources.



35
36
37
 
# File 'lib/active_admin/namespace.rb', line 35

def resources
  @resources
end

Instance Method Details

#add_logout_button_to_menu(menu, priority = 100, html_options = {}) ⇒ Object

Add the default logout button to the menu, using the ActiveAdmin configuration settings

Parameters:

  • menu (ActiveAdmin::MenuItem) —

    The menu to add the logout link to

  • priority (Fixnum) (defaults to: 100) —

    Override the default priority of 100 to position the logout button where you want

  • html_options (Hash) (defaults to: {}) —

    An options hash to pass along to link_to



146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/active_admin/namespace.rb', line 146

def add_logout_button_to_menu(menu, priority=100, html_options={})
  if logout_link_path
    logout_method = logout_link_method || :get
    menu.add :id           => 'logout',
             :priority     => priority,
             :label        => proc{ I18n.t('active_admin.logout') },
             :html_options => html_options.reverse_merge(:method => logout_method),
             :url          => proc{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
             :if           => proc{ current_active_admin_user? }
  end
end

#build_default_utility_nav ⇒ Object (protected)

Builds the default utility navigation in top right header with current user & logout button



177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/active_admin/namespace.rb', line 177

def build_default_utility_nav
  return if @menus.exists? :utility_navigation
  @menus.menu :utility_navigation do |menu|
    menu.add  :label  => proc{ display_name current_active_admin_user },
              :url    => '#',
              :id     => 'current_user',
              :if     => proc{ current_active_admin_user? }
              
    add_logout_button_to_menu menu
  end
end

#build_menu(name = DEFAULT_MENU, &block) ⇒ Object

Add a callback to be ran when we build the menu

Parameters:

  • name (Symbol) (defaults to: DEFAULT_MENU) —

    The name of the menu. Default: :default

  • block (Proc) —

    The block to be ran when the menu is built



131
132
133
134
135
136
137
 
# File 'lib/active_admin/namespace.rb', line 131

def build_menu(name = DEFAULT_MENU, &block)
  @menus.before_build do |menus|
    menus.menu name do |menu|
      block.call(menu)
    end
  end
end

#build_menu_collection ⇒ Object (protected) 



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/active_admin/namespace.rb', line 160

def build_menu_collection
  @menus = MenuCollection.new

  @menus.on_build do |menus|
    # Support for deprecated dashboards...
    Dashboards.add_to_menu(self, menus.menu(DEFAULT_MENU))

    # Build the default utility navigation
    build_default_utility_nav

    resources.each do |resource|
      resource.add_to_menu(@menus)
    end
  end
end

#build_page(name, options) ⇒ Object (protected) 



195
196
197
 
# File 'lib/active_admin/namespace.rb', line 195

def build_page(name, options)
  resources.add Page.new(self, name, options)
end

#dashboard_controller_name ⇒ Object

Returns the name of the dashboard controller for this namespace



95
96
97
 
# File 'lib/active_admin/namespace.rb', line 95

def dashboard_controller_name
  [module_name, "DashboardController"].compact.join("::")
end

#fetch_menu(name) ⇒ Object 



117
118
119
 
# File 'lib/active_admin/namespace.rb', line 117

def fetch_menu(name)
  @menus.fetch(name)
end

#find_or_build_resource(resource_class, options) ⇒ Object (protected)

Either returns an existing Resource instance or builds a new one for the resource and options



191
192
193
 
# File 'lib/active_admin/namespace.rb', line 191

def find_or_build_resource(resource_class, options)
  resources.add Resource.new(self, resource_class, options)
end

#generate_dashboard_controller ⇒ Object (protected)

Creates a dashboard controller for this config



245
246
247
248
249
250
251
 
# File 'lib/active_admin/namespace.rb', line 245

def generate_dashboard_controller
  return unless ActiveAdmin::Dashboards.built?

  eval "class ::#{dashboard_controller_name} < ActiveAdmin::PageController
          include ActiveAdmin::Dashboards::DashboardController
        end"
end

#module_name ⇒ Object

Returns the name of the module if required. Will be nil if none is required.

eg:

Namespace.new(:admin).module_name # => 'Admin'
Namespace.new(:root).module_name # => nil



89
90
91
92
 
# File 'lib/active_admin/namespace.rb', line 89

def module_name
  return nil if root?
  @module_name ||= name.to_s.camelize
end

#parse_page_registration_block(config, &block) ⇒ Object (protected) 



240
241
242
 
# File 'lib/active_admin/namespace.rb', line 240

def parse_page_registration_block(config, &block)
  PageDSL.new(config).run_registration_block(&block)
end

#parse_registration_block(config, &block) ⇒ Object (protected) 



235
236
237
238
 
# File 'lib/active_admin/namespace.rb', line 235

def parse_registration_block(config, &block)
  config.dsl = ResourceDSL.new(config)
  config.dsl.run_registration_block(&block)
end

#read_default_setting(name) ⇒ Object

Override from ActiveAdmin::Settings to inherit default attributes from the application



113
114
115
 
# File 'lib/active_admin/namespace.rb', line 113

def read_default_setting(name)
  application.send(name)
end

#register(resource_class, options = {}, &block) ⇒ Object

Register a resource into this namespace. The preffered method to access this is to use the global registration ActiveAdmin.register which delegates to the proper namespace instance.



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/active_admin/namespace.rb', line 49

def register(resource_class, options = {}, &block)
  config = find_or_build_resource(resource_class, options)

  # Register the resource
  register_resource_controller(config)
  parse_registration_block(config, &block) if block_given?
  reset_menu!

  # Ensure that the dashboard is generated
  generate_dashboard_controller

  # Dispatch a registration event
  ActiveAdmin::Event.dispatch ActiveAdmin::Resource::RegisterEvent, config

  # Return the config
  config
end

#register_module ⇒ Object (protected)

Creates a ruby module to namespace all the classes in if required



226
227
228
 
# File 'lib/active_admin/namespace.rb', line 226

def register_module
  eval "module ::#{module_name}; end"
end

#register_page(name, options = {}, &block) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
 
# File 'lib/active_admin/namespace.rb', line 67

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

  # Register the resource
  register_page_controller(config)
  parse_page_registration_block(config, &block) if block_given?
  reset_menu!

  config
end

#register_page_controller(config) ⇒ Object (protected) 



199
200
201
202
 
# File 'lib/active_admin/namespace.rb', line 199

def register_page_controller(config)
  eval "class ::#{config.controller_name} < ActiveAdmin::PageController; end"
  config.controller.active_admin_config = config
end

#register_resource_controller(config) ⇒ Object (protected) 



230
231
232
233
 
# File 'lib/active_admin/namespace.rb', line 230

def register_resource_controller(config)
  eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
  config.controller.active_admin_config = config
end

#reset_menu! ⇒ Object 



121
122
123
 
# File 'lib/active_admin/namespace.rb', line 121

def reset_menu!
  @menus.clear!
end

#resource_for(klass) ⇒ Object

Returns the first registered ActiveAdmin::Resource instance for a given class



107
108
109
 
# File 'lib/active_admin/namespace.rb', line 107

def resource_for(klass)
  resources.find_by_resource_class(klass)
end

#root? ⇒ Boolean

Returns:

  • (Boolean) 


78
79
80
 
# File 'lib/active_admin/namespace.rb', line 78

def root?
  name == :root
end

#unload! ⇒ Object

Unload all the registered resources for this namespace



100
101
102
103
104
 
# File 'lib/active_admin/namespace.rb', line 100

def unload!
  unload_resources!
  unload_dashboard!
  reset_menu!
end

#unload_dashboard! ⇒ Object (protected) 



220
221
222
223
 
# File 'lib/active_admin/namespace.rb', line 220

def unload_dashboard!
  # TODO: Only clear out my sections
  Dashboards.clear_all_sections!
end

#unload_resources! ⇒ Object (protected) 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/active_admin/namespace.rb', line 204

def unload_resources!
  resources.each do |resource|
    parent = (module_name || 'Object').constantize
    const_name = resource.controller_name.split('::').last
    # Remove the const if its been defined
    parent.send(:remove_const, const_name) if parent.const_defined?(const_name)

    # Remove circular references
    resource.controller.active_admin_config = nil
    if resource.is_a?(Resource) && resource.dsl
      resource.dsl.run_registration_block { @config = nil }
    end
  end
  @resources = ResourceCollection.new
end