##// END OF EJS Templates
jro_apps » redmine
RSS
Missing html_safe....
Jean-Philippe Lang -
r8270:38843eb7aa31
parent child
Show More
Side by Side Unified
Context file:
r8270:38843eb7aa31 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,438 +1,438
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2011 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 module Redmine
19 19 module MenuManager
20 20 class MenuError < StandardError #:nodoc:
21 21 end
22 22
23 23 module MenuController
24 24 def self.included(base)
25 25 base.extend(ClassMethods)
26 26 end
27 27
28 28 module ClassMethods
29 29 @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}}
30 30 mattr_accessor :menu_items
31 31
32 32 # Set the menu item name for a controller or specific actions
33 33 # Examples:
34 34 # * menu_item :tickets # => sets the menu name to :tickets for the whole controller
35 35 # * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only
36 36 # * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only
37 37 #
38 38 # The default menu item name for a controller is controller_name by default
39 39 # Eg. the default menu item name for ProjectsController is :projects
40 40 def menu_item(id, options = {})
41 41 if actions = options[:only]
42 42 actions = [] << actions unless actions.is_a?(Array)
43 43 actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id}
44 44 else
45 45 menu_items[controller_name.to_sym][:default] = id
46 46 end
47 47 end
48 48 end
49 49
50 50 def menu_items
51 51 self.class.menu_items
52 52 end
53 53
54 54 # Returns the menu item name according to the current action
55 55 def current_menu_item
56 56 @current_menu_item ||= menu_items[controller_name.to_sym][:actions][action_name.to_sym] ||
57 57 menu_items[controller_name.to_sym][:default]
58 58 end
59 59
60 60 # Redirects user to the menu item of the given project
61 61 # Returns false if user is not authorized
62 62 def redirect_to_project_menu_item(project, name)
63 63 item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name.to_s == name.to_s}
64 64 if item && User.current.allowed_to?(item.url, project) && (item.condition.nil? || item.condition.call(project))
65 65 redirect_to({item.param => project}.merge(item.url))
66 66 return true
67 67 end
68 68 false
69 69 end
70 70 end
71 71
72 72 module MenuHelper
73 73 # Returns the current menu item name
74 74 def current_menu_item
75 75 controller.current_menu_item
76 76 end
77 77
78 78 # Renders the application main menu
79 79 def render_main_menu(project)
80 80 render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project)
81 81 end
82 82
83 83 def display_main_menu?(project)
84 84 menu_name = project && !project.new_record? ? :project_menu : :application_menu
85 85 Redmine::MenuManager.items(menu_name).children.present?
86 86 end
87 87
88 88 def render_menu(menu, project=nil)
89 89 links = []
90 90 menu_items_for(menu, project) do |node|
91 91 links << render_menu_node(node, project)
92 92 end
93 93 links.empty? ? nil : content_tag('ul', links.join("\n").html_safe)
94 94 end
95 95
96 96 def render_menu_node(node, project=nil)
97 97 if node.children.present? || !node.child_menus.nil?
98 98 return render_menu_node_with_children(node, project)
99 99 else
100 100 caption, url, selected = extract_node_details(node, project)
101 101 return content_tag('li',
102 102 render_single_menu_node(node, caption, url, selected))
103 103 end
104 104 end
105 105
106 106 def render_menu_node_with_children(node, project=nil)
107 107 caption, url, selected = extract_node_details(node, project)
108 108
109 109 html = [].tap do |html|
110 110 html << '<li>'
111 111 # Parent
112 112 html << render_single_menu_node(node, caption, url, selected)
113 113
114 114 # Standard children
115 standard_children_list = "".tap do |child_html|
115 standard_children_list = "".html_safe.tap do |child_html|
116 116 node.children.each do |child|
117 117 child_html << render_menu_node(child, project)
118 118 end
119 119 end
120 120
121 121 html << content_tag(:ul, standard_children_list, :class => 'menu-children') unless standard_children_list.empty?
122 122
123 123 # Unattached children
124 124 unattached_children_list = render_unattached_children_menu(node, project)
125 125 html << content_tag(:ul, unattached_children_list, :class => 'menu-children unattached') unless unattached_children_list.blank?
126 126
127 127 html << '</li>'
128 128 end
129 return html.join("\n")
129 return html.join("\n").html_safe
130 130 end
131 131
132 132 # Returns a list of unattached children menu items
133 133 def render_unattached_children_menu(node, project)
134 134 return nil unless node.child_menus
135 135
136 "".tap do |child_html|
136 "".html_safe.tap do |child_html|
137 137 unattached_children = node.child_menus.call(project)
138 138 # Tree nodes support #each so we need to do object detection
139 139 if unattached_children.is_a? Array
140 140 unattached_children.each do |child|
141 141 child_html << content_tag(:li, render_unattached_menu_item(child, project))
142 142 end
143 143 else
144 144 raise MenuError, ":child_menus must be an array of MenuItems"
145 145 end
146 146 end
147 147 end
148 148
149 149 def render_single_menu_node(item, caption, url, selected)
150 150 link_to(h(caption), url, item.html_options(:selected => selected))
151 151 end
152 152
153 153 def render_unattached_menu_item(menu_item, project)
154 154 raise MenuError, ":child_menus must be an array of MenuItems" unless menu_item.is_a? MenuItem
155 155
156 156 if User.current.allowed_to?(menu_item.url, project)
157 157 link_to(h(menu_item.caption),
158 158 menu_item.url,
159 159 menu_item.html_options)
160 160 end
161 161 end
162 162
163 163 def menu_items_for(menu, project=nil)
164 164 items = []
165 165 Redmine::MenuManager.items(menu).root.children.each do |node|
166 166 if allowed_node?(node, User.current, project)
167 167 if block_given?
168 168 yield node
169 169 else
170 170 items << node # TODO: not used?
171 171 end
172 172 end
173 173 end
174 174 return block_given? ? nil : items
175 175 end
176 176
177 177 def extract_node_details(node, project=nil)
178 178 item = node
179 179 url = case item.url
180 180 when Hash
181 181 project.nil? ? item.url : {item.param => project}.merge(item.url)
182 182 when Symbol
183 183 send(item.url)
184 184 else
185 185 item.url
186 186 end
187 187 caption = item.caption(project)
188 188 return [caption, url, (current_menu_item == item.name)]
189 189 end
190 190
191 191 # Checks if a user is allowed to access the menu item by:
192 192 #
193 193 # * Checking the conditions of the item
194 194 # * Checking the url target (project only)
195 195 def allowed_node?(node, user, project)
196 196 if node.condition && !node.condition.call(project)
197 197 # Condition that doesn't pass
198 198 return false
199 199 end
200 200
201 201 if project
202 202 return user && user.allowed_to?(node.url, project)
203 203 else
204 204 # outside a project, all menu items allowed
205 205 return true
206 206 end
207 207 end
208 208 end
209 209
210 210 class << self
211 211 def map(menu_name)
212 212 @items ||= {}
213 213 mapper = Mapper.new(menu_name.to_sym, @items)
214 214 if block_given?
215 215 yield mapper
216 216 else
217 217 mapper
218 218 end
219 219 end
220 220
221 221 def items(menu_name)
222 222 @items[menu_name.to_sym] || MenuNode.new(:root, {})
223 223 end
224 224 end
225 225
226 226 class Mapper
227 227 def initialize(menu, items)
228 228 items[menu] ||= MenuNode.new(:root, {})
229 229 @menu = menu
230 230 @menu_items = items[menu]
231 231 end
232 232
233 233 # Adds an item at the end of the menu. Available options:
234 234 # * param: the parameter name that is used for the project id (default is :id)
235 235 # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true
236 236 # * caption that can be:
237 237 # * a localized string Symbol
238 238 # * a String
239 239 # * a Proc that can take the project as argument
240 240 # * before, after: specify where the menu item should be inserted (eg. :after => :activity)
241 241 # * parent: menu item will be added as a child of another named menu (eg. :parent => :issues)
242 242 # * children: a Proc that is called before rendering the item. The Proc should return an array of MenuItems, which will be added as children to this item.
243 243 # eg. :children => Proc.new {|project| [Redmine::MenuManager::MenuItem.new(...)] }
244 244 # * last: menu item will stay at the end (eg. :last => true)
245 245 # * html_options: a hash of html options that are passed to link_to
246 246 def push(name, url, options={})
247 247 options = options.dup
248 248
249 249 if options[:parent]
250 250 subtree = self.find(options[:parent])
251 251 if subtree
252 252 target_root = subtree
253 253 else
254 254 target_root = @menu_items.root
255 255 end
256 256
257 257 else
258 258 target_root = @menu_items.root
259 259 end
260 260
261 261 # menu item position
262 262 if first = options.delete(:first)
263 263 target_root.prepend(MenuItem.new(name, url, options))
264 264 elsif before = options.delete(:before)
265 265
266 266 if exists?(before)
267 267 target_root.add_at(MenuItem.new(name, url, options), position_of(before))
268 268 else
269 269 target_root.add(MenuItem.new(name, url, options))
270 270 end
271 271
272 272 elsif after = options.delete(:after)
273 273
274 274 if exists?(after)
275 275 target_root.add_at(MenuItem.new(name, url, options), position_of(after) + 1)
276 276 else
277 277 target_root.add(MenuItem.new(name, url, options))
278 278 end
279 279
280 280 elsif options[:last] # don't delete, needs to be stored
281 281 target_root.add_last(MenuItem.new(name, url, options))
282 282 else
283 283 target_root.add(MenuItem.new(name, url, options))
284 284 end
285 285 end
286 286
287 287 # Removes a menu item
288 288 def delete(name)
289 289 if found = self.find(name)
290 290 @menu_items.remove!(found)
291 291 end
292 292 end
293 293
294 294 # Checks if a menu item exists
295 295 def exists?(name)
296 296 @menu_items.any? {|node| node.name == name}
297 297 end
298 298
299 299 def find(name)
300 300 @menu_items.find {|node| node.name == name}
301 301 end
302 302
303 303 def position_of(name)
304 304 @menu_items.each do |node|
305 305 if node.name == name
306 306 return node.position
307 307 end
308 308 end
309 309 end
310 310 end
311 311
312 312 class MenuNode
313 313 include Enumerable
314 314 attr_accessor :parent
315 315 attr_reader :last_items_count, :name
316 316
317 317 def initialize(name, content = nil)
318 318 @name = name
319 319 @children = []
320 320 @last_items_count = 0
321 321 end
322 322
323 323 def children
324 324 if block_given?
325 325 @children.each {|child| yield child}
326 326 else
327 327 @children
328 328 end
329 329 end
330 330
331 331 # Returns the number of descendants + 1
332 332 def size
333 333 @children.inject(1) {|sum, node| sum + node.size}
334 334 end
335 335
336 336 def each &block
337 337 yield self
338 338 children { |child| child.each(&block) }
339 339 end
340 340
341 341 # Adds a child at first position
342 342 def prepend(child)
343 343 add_at(child, 0)
344 344 end
345 345
346 346 # Adds a child at given position
347 347 def add_at(child, position)
348 348 raise "Child already added" if find {|node| node.name == child.name}
349 349
350 350 @children = @children.insert(position, child)
351 351 child.parent = self
352 352 child
353 353 end
354 354
355 355 # Adds a child as last child
356 356 def add_last(child)
357 357 add_at(child, -1)
358 358 @last_items_count += 1
359 359 child
360 360 end
361 361
362 362 # Adds a child
363 363 def add(child)
364 364 position = @children.size - @last_items_count
365 365 add_at(child, position)
366 366 end
367 367 alias :<< :add
368 368
369 369 # Removes a child
370 370 def remove!(child)
371 371 @children.delete(child)
372 372 @last_items_count -= +1 if child && child.last
373 373 child.parent = nil
374 374 child
375 375 end
376 376
377 377 # Returns the position for this node in it's parent
378 378 def position
379 379 self.parent.children.index(self)
380 380 end
381 381
382 382 # Returns the root for this node
383 383 def root
384 384 root = self
385 385 root = root.parent while root.parent
386 386 root
387 387 end
388 388 end
389 389
390 390 class MenuItem < MenuNode
391 391 include Redmine::I18n
392 392 attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last
393 393
394 394 def initialize(name, url, options)
395 395 raise ArgumentError, "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call)
396 396 raise ArgumentError, "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash)
397 397 raise ArgumentError, "Cannot set the :parent to be the same as this item" if options[:parent] == name.to_sym
398 398 raise ArgumentError, "Invalid option :children for menu item '#{name}'" if options[:children] && !options[:children].respond_to?(:call)
399 399 @name = name
400 400 @url = url
401 401 @condition = options[:if]
402 402 @param = options[:param] || :id
403 403 @caption = options[:caption]
404 404 @html_options = options[:html] || {}
405 405 # Adds a unique class to each menu item based on its name
406 406 @html_options[:class] = [@html_options[:class], @name.to_s.dasherize].compact.join(' ')
407 407 @parent = options[:parent]
408 408 @child_menus = options[:children]
409 409 @last = options[:last] || false
410 410 super @name.to_sym
411 411 end
412 412
413 413 def caption(project=nil)
414 414 if @caption.is_a?(Proc)
415 415 c = @caption.call(project).to_s
416 416 c = @name.to_s.humanize if c.blank?
417 417 c
418 418 else
419 419 if @caption.nil?
420 420 l_or_humanize(name, :prefix => 'label_')
421 421 else
422 422 @caption.is_a?(Symbol) ? l(@caption) : @caption
423 423 end
424 424 end
425 425 end
426 426
427 427 def html_options(options={})
428 428 if options[:selected]
429 429 o = @html_options.dup
430 430 o[:class] += ' selected'
431 431 o
432 432 else
433 433 @html_options
434 434 end
435 435 end
436 436 end
437 437 end
438 438 end
General Comments 0
You need to be logged in to leave comments. Login now