Class: ActiveAdmin::Namespace

Inherits:
Object
  • Object
show all
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.



33
34
35
36
37
38
39
40
 
# File 'lib/active_admin/namespace.rb', line 33

def initialize(application, name)
  @application = application
  @name = name.to_s.underscore.to_sym
  @resources = {}
  @menu = Menu.new
  register_module unless root?
  generate_dashboard_controller
end

Instance Attribute Details

#application ⇒ Object (readonly)

Returns the value of attribute application.



31
32
33
 
# File 'lib/active_admin/namespace.rb', line 31

def application
  @application
end

#menu ⇒ Object (readonly)

Returns the value of attribute menu.



31
32
33
 
# File 'lib/active_admin/namespace.rb', line 31

def menu
  @menu
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



31
32
33
 
# File 'lib/active_admin/namespace.rb', line 31

def name
  @name
end

#resources ⇒ Object (readonly)

Returns the value of attribute resources.



31
32
33
 
# File 'lib/active_admin/namespace.rb', line 31

def resources
  @resources
end

Instance Method Details

#dashboard_controller_name ⇒ Object

Returns the name of the dashboard controller for this namespace



80
81
82
 
# File 'lib/active_admin/namespace.rb', line 80

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

#dsl ⇒ Object (protected) 



166
167
168
 
# File 'lib/active_admin/namespace.rb', line 166

def dsl
  @dsl ||= DSL.new
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



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/active_admin/namespace.rb', line 117

def find_or_build_resource(resource_class, options)
  resource = Resource.new(self, resource_class, options)

  # If we've already registered this resource, use the existing
  if @resources.has_key? resource.camelized_resource_name
    existing_resource = @resources[resource.camelized_resource_name]

    if existing_resource.resource != resource_class
      raise ActiveAdmin::ResourceMismatchError, 
        "Tried to register #{resource_class} as #{resource.camelized_resource_name} but already registered to #{resource.resource}"
    end

    resource = existing_resource
  else
    @resources[resource.camelized_resource_name] = resource
  end

  resource
end

#generate_dashboard_controller ⇒ Object (protected)

Creates a dashboard controller for this config



175
176
177
 
# File 'lib/active_admin/namespace.rb', line 175

def generate_dashboard_controller
  eval "class ::#{dashboard_controller_name} < ActiveAdmin::Dashboards::DashboardController; end"
end

#load_menu! ⇒ Object

The menu gets built by Active Admin once all the resources have been loaded. This method gets called to register each resource with the menu system.



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

def load_menu!
  register_dashboard
  resources.values.each do |config|
    register_with_menu(config) if config.include_in_menu?
  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



74
75
76
77
 
# File 'lib/active_admin/namespace.rb', line 74

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

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



170
171
172
 
# File 'lib/active_admin/namespace.rb', line 170

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

#register(resource, 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.



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/active_admin/namespace.rb', line 45

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

  # Register the resource
  register_resource_controller(config)
  parse_registration_block(config, &block) if block_given?
  register_with_menu(config) if config.include_in_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_dashboard ⇒ Object (protected)

Adds the dashboard to the menu



180
181
182
183
 
# File 'lib/active_admin/namespace.rb', line 180

def register_dashboard
  dashboard_path = root? ? :dashboard_path : "#{name}_dashboard_path".to_sym
  menu.add(I18n.t("active_admin.dashboard"), dashboard_path, 1) unless menu[I18n.t("active_admin.dashboard")]
end

#register_module ⇒ Object (protected)

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



157
158
159
 
# File 'lib/active_admin/namespace.rb', line 157

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

#register_resource_controller(config) ⇒ Object (protected) 



161
162
163
164
 
# File 'lib/active_admin/namespace.rb', line 161

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

#register_with_menu(config) ⇒ Object (protected)

Does all the work of registernig a config with the menu system



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/active_admin/namespace.rb', line 186

def register_with_menu(config)
  # The menu we're going to add this resource to
  add_to = menu

  # Adding as a child
  if config.parent_menu_item_name
    # Create the parent if it doesn't exist
    menu.add(config.parent_menu_item_name, '#') unless menu[config.parent_menu_item_name]
    add_to = menu[config.parent_menu_item_name]
  end

  # Check if this menu item has already been created
  if add_to[config.menu_item_name]
    # Update the url if it's already been created
    add_to[config.menu_item_name].url = config.route_collection_path
  else
    add_to.add(config.menu_item_name, config.route_collection_path, config.menu_item_priority, { :if => config.menu_item_display_if })
  end
end

#resource_for(klass) ⇒ Object

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



101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/active_admin/namespace.rb', line 101

def resource_for(klass)
  actual = resources.values.find{|config| config.resource == klass }
  return actual if actual

  if klass.respond_to?(:base_class)
    base_class = klass.base_class
    resources.values.find{|config| config.resource == base_class }
  else
    nil
  end
end

#root? ⇒ Boolean

Returns:

  • (Boolean) 


63
64
65
 
# File 'lib/active_admin/namespace.rb', line 63

def root?
  name == :root
end

#unload! ⇒ Object

Unload all the registered resources for this namespace



85
86
87
88
89
 
# File 'lib/active_admin/namespace.rb', line 85

def unload!
  unload_resources!
  unload_dashboard!
  unload_menu!
end

#unload_dashboard! ⇒ Object (protected) 



147
148
149
150
 
# File 'lib/active_admin/namespace.rb', line 147

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

#unload_menu! ⇒ Object (protected) 



152
153
154
 
# File 'lib/active_admin/namespace.rb', line 152

def unload_menu!
  @menu = Menu.new
end

#unload_resources! ⇒ Object (protected) 



137
138
139
140
141
142
143
144
145
 
# File 'lib/active_admin/namespace.rb', line 137

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