From 6dd831e3febb4d1c91a9e4fb53eaeff4e31dbbc3 Mon Sep 17 00:00:00 2001 From: Gregor Schmidt Date: Wed, 9 Mar 2011 16:02:09 +0100 Subject: [PATCH 1/2] [#269] Extracting classes and modules from menu manager into separate files --- lib/redmine/menu_manager.rb | 354 +------------------- lib/redmine/menu_manager/mapper.rb | 87 +++++ lib/redmine/menu_manager/menu_controller.rb | 48 +++ lib/redmine/menu_manager/menu_error.rb | 2 + lib/redmine/menu_manager/menu_helper.rb | 137 ++++++++ lib/redmine/menu_manager/menu_item.rb | 47 +++ 6 files changed, 333 insertions(+), 342 deletions(-) create mode 100644 lib/redmine/menu_manager/mapper.rb create mode 100644 lib/redmine/menu_manager/menu_controller.rb create mode 100644 lib/redmine/menu_manager/menu_error.rb create mode 100644 lib/redmine/menu_manager/menu_helper.rb create mode 100644 lib/redmine/menu_manager/menu_item.rb diff --git a/lib/redmine/menu_manager.rb b/lib/redmine/menu_manager.rb index 51f8ed64..67b74428 100644 --- a/lib/redmine/menu_manager.rb +++ b/lib/redmine/menu_manager.rb @@ -104,348 +104,18 @@ unless Tree::TreeNode.included_modules.include?(TreeNodePatch) Tree::TreeNode.send(:include, TreeNodePatch) end -module Redmine - module MenuManager - class MenuError < StandardError #:nodoc: +module Redmine::MenuManager + def self.map(menu_name) + @items ||= {} + mapper = Mapper.new(menu_name.to_sym, @items) + if block_given? + yield mapper + else + mapper end - - module MenuController - def self.included(base) - base.extend(ClassMethods) - end - - module ClassMethods - @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}} - mattr_accessor :menu_items - - # Set the menu item name for a controller or specific actions - # Examples: - # * menu_item :tickets # => sets the menu name to :tickets for the whole controller - # * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only - # * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only - # - # The default menu item name for a controller is controller_name by default - # Eg. the default menu item name for ProjectsController is :projects - def menu_item(id, options = {}) - if actions = options[:only] - actions = [] << actions unless actions.is_a?(Array) - actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id} - else - menu_items[controller_name.to_sym][:default] = id - end - end - end - - def menu_items - self.class.menu_items - end - - # Returns the menu item name according to the current action - def current_menu_item - @current_menu_item ||= menu_items[controller_name.to_sym][:actions][action_name.to_sym] || - menu_items[controller_name.to_sym][:default] - end - - # Redirects user to the menu item of the given project - # Returns false if user is not authorized - def redirect_to_project_menu_item(project, name) - item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name.to_s == name.to_s} - if item && User.current.allowed_to?(item.url, project) && (item.condition.nil? || item.condition.call(project)) - redirect_to({item.param => project}.merge(item.url)) - return true - end - false - end - end - - module MenuHelper - # Returns the current menu item name - def current_menu_item - @controller.current_menu_item - end - - # Renders the application main menu - def render_main_menu(project) - render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project) - end - - def display_main_menu?(project) - menu_name = project && !project.new_record? ? :project_menu : :application_menu - Redmine::MenuManager.items(menu_name).size > 1 # 1 element is the root - end - - def render_menu(menu, project=nil) - links = [] - menu_items_for(menu, project) do |node| - links << render_menu_node(node, project) - end - links.empty? ? nil : content_tag('ul', links.join("\n")) - end - - def render_menu_node(node, project=nil) - if node.hasChildren? || !node.child_menus.nil? - return render_menu_node_with_children(node, project) - else - caption, url, selected = extract_node_details(node, project) - return content_tag('li', - render_single_menu_node(node, caption, url, selected)) - end - end - - def render_menu_node_with_children(node, project=nil) - caption, url, selected = extract_node_details(node, project) - - html = [].tap do |html| - html << '
  • ' - # Parent - html << render_single_menu_node(node, caption, url, selected) - - # Standard children - standard_children_list = "".tap do |child_html| - node.children.each do |child| - child_html << render_menu_node(child, project) - end - end - - html << content_tag(:ul, standard_children_list, :class => 'menu-children') unless standard_children_list.empty? - - # Unattached children - unattached_children_list = render_unattached_children_menu(node, project) - html << content_tag(:ul, unattached_children_list, :class => 'menu-children unattached') unless unattached_children_list.blank? - - html << '
    • ' - end - return html.join("\n") - end - - # Returns a list of unattached children menu items - def render_unattached_children_menu(node, project) - return nil unless node.child_menus - - "".tap do |child_html| - unattached_children = node.child_menus.call(project) - # Tree nodes support #each so we need to do object detection - if unattached_children.is_a? Array - unattached_children.each do |child| - child_html << content_tag(:li, render_unattached_menu_item(child, project)) - end - else - raise MenuError, ":child_menus must be an array of MenuItems" - end - end - end - - def render_single_menu_node(item, caption, url, selected) - link_to(h(caption), url, item.html_options(:selected => selected)) - end - - def render_unattached_menu_item(menu_item, project) - raise MenuError, ":child_menus must be an array of MenuItems" unless menu_item.is_a? MenuItem - - if User.current.allowed_to?(menu_item.url, project) - link_to(h(menu_item.caption), - menu_item.url, - menu_item.html_options) - end - end - - def menu_items_for(menu, project=nil) - items = [] - Redmine::MenuManager.items(menu).root.children.each do |node| - if allowed_node?(node, User.current, project) - if block_given? - yield node - else - items << node # TODO: not used? - end - end - end - return block_given? ? nil : items - end - - def extract_node_details(node, project=nil) - item = node - url = case item.url - when Hash - project.nil? ? item.url : {item.param => project}.merge(item.url) - when Symbol - send(item.url) - else - item.url - end - caption = item.caption(project) - return [caption, url, (current_menu_item == item.name)] - end - - # Checks if a user is allowed to access the menu item by: - # - # * Checking the conditions of the item - # * Checking the url target (project only) - def allowed_node?(node, user, project) - if node.condition && !node.condition.call(project) - # Condition that doesn't pass - return false - end - - if project - return user && user.allowed_to?(node.url, project) - else - # outside a project, all menu items allowed - return true - end - end - end - - class << self - def map(menu_name) - @items ||= {} - mapper = Mapper.new(menu_name.to_sym, @items) - if block_given? - yield mapper - else - mapper - end - end - - def items(menu_name) - @items[menu_name.to_sym] || Tree::TreeNode.new(:root, {}) - end - end - - class Mapper - def initialize(menu, items) - items[menu] ||= Tree::TreeNode.new(:root, {}) - @menu = menu - @menu_items = items[menu] - end - - @@last_items_count = Hash.new {|h,k| h[k] = 0} - - # Adds an item at the end of the menu. Available options: - # * param: the parameter name that is used for the project id (default is :id) - # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true - # * caption that can be: - # * a localized string Symbol - # * a String - # * a Proc that can take the project as argument - # * before, after: specify where the menu item should be inserted (eg. :after => :activity) - # * parent: menu item will be added as a child of another named menu (eg. :parent => :issues) - # * 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. - # eg. :children => Proc.new {|project| [Redmine::MenuManager::MenuItem.new(...)] } - # * last: menu item will stay at the end (eg. :last => true) - # * html_options: a hash of html options that are passed to link_to - def push(name, url, options={}) - options = options.dup - - if options[:parent] - subtree = self.find(options[:parent]) - if subtree - target_root = subtree - else - target_root = @menu_items.root - end - - else - target_root = @menu_items.root - end - - # menu item position - if first = options.delete(:first) - target_root.prepend(MenuItem.new(name, url, options)) - elsif before = options.delete(:before) - - if exists?(before) - target_root.add_at(MenuItem.new(name, url, options), position_of(before)) - else - target_root.add(MenuItem.new(name, url, options)) - end - - elsif after = options.delete(:after) - - if exists?(after) - target_root.add_at(MenuItem.new(name, url, options), position_of(after) + 1) - else - target_root.add(MenuItem.new(name, url, options)) - end - - elsif options[:last] # don't delete, needs to be stored - target_root.add_last(MenuItem.new(name, url, options)) - else - target_root.add(MenuItem.new(name, url, options)) - end - end - - # Removes a menu item - def delete(name) - if found = self.find(name) - @menu_items.remove!(found) - end - end - - # Checks if a menu item exists - def exists?(name) - @menu_items.any? {|node| node.name == name} - end - - def find(name) - @menu_items.find {|node| node.name == name} - end - - def position_of(name) - @menu_items.each do |node| - if node.name == name - return node.position - end - end - end - end - - class MenuItem < Tree::TreeNode - include Redmine::I18n - attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last - - def initialize(name, url, options) - raise ArgumentError, "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call) - raise ArgumentError, "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash) - raise ArgumentError, "Cannot set the :parent to be the same as this item" if options[:parent] == name.to_sym - raise ArgumentError, "Invalid option :children for menu item '#{name}'" if options[:children] && !options[:children].respond_to?(:call) - @name = name - @url = url - @condition = options[:if] - @param = options[:param] || :id - @caption = options[:caption] - @html_options = options[:html] || {} - # Adds a unique class to each menu item based on its name - @html_options[:class] = [@html_options[:class], @name.to_s.dasherize].compact.join(' ') - @parent = options[:parent] - @child_menus = options[:children] - @last = options[:last] || false - super @name.to_sym - end - - def caption(project=nil) - if @caption.is_a?(Proc) - c = @caption.call(project).to_s - c = @name.to_s.humanize if c.blank? - c - else - if @caption.nil? - l_or_humanize(name, :prefix => 'label_') - else - @caption.is_a?(Symbol) ? l(@caption) : @caption - end - end - end - - def html_options(options={}) - if options[:selected] - o = @html_options.dup - o[:class] += ' selected' - o - else - @html_options - end - end - end + end + + def self.items(menu_name) + @items[menu_name.to_sym] || Tree::TreeNode.new(:root, {}) end end diff --git a/lib/redmine/menu_manager/mapper.rb b/lib/redmine/menu_manager/mapper.rb new file mode 100644 index 00000000..bdb01c15 --- /dev/null +++ b/lib/redmine/menu_manager/mapper.rb @@ -0,0 +1,87 @@ +class Redmine::MenuManager::Mapper + def initialize(menu, items) + items[menu] ||= Tree::TreeNode.new(:root, {}) + @menu = menu + @menu_items = items[menu] + end + + @@last_items_count = Hash.new {|h,k| h[k] = 0} + + # Adds an item at the end of the menu. Available options: + # * param: the parameter name that is used for the project id (default is :id) + # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true + # * caption that can be: + # * a localized string Symbol + # * a String + # * a Proc that can take the project as argument + # * before, after: specify where the menu item should be inserted (eg. :after => :activity) + # * parent: menu item will be added as a child of another named menu (eg. :parent => :issues) + # * 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. + # eg. :children => Proc.new {|project| [Redmine::MenuManager::MenuItem.new(...)] } + # * last: menu item will stay at the end (eg. :last => true) + # * html_options: a hash of html options that are passed to link_to + def push(name, url, options={}) + options = options.dup + + if options[:parent] + subtree = self.find(options[:parent]) + if subtree + target_root = subtree + else + target_root = @menu_items.root + end + + else + target_root = @menu_items.root + end + + # menu item position + if first = options.delete(:first) + target_root.prepend(Redmine::MenuManager::MenuItem.new(name, url, options)) + elsif before = options.delete(:before) + + if exists?(before) + target_root.add_at(Redmine::MenuManager::MenuItem.new(name, url, options), position_of(before)) + else + target_root.add(Redmine::MenuManager::MenuItem.new(name, url, options)) + end + + elsif after = options.delete(:after) + + if exists?(after) + target_root.add_at(Redmine::MenuManager::MenuItem.new(name, url, options), position_of(after) + 1) + else + target_root.add(Redmine::MenuManager::MenuItem.new(name, url, options)) + end + + elsif options[:last] # don't delete, needs to be stored + target_root.add_last(Redmine::MenuManager::MenuItem.new(name, url, options)) + else + target_root.add(Redmine::MenuManager::MenuItem.new(name, url, options)) + end + end + + # Removes a menu item + def delete(name) + if found = self.find(name) + @menu_items.remove!(found) + end + end + + # Checks if a menu item exists + def exists?(name) + @menu_items.any? {|node| node.name == name} + end + + def find(name) + @menu_items.find {|node| node.name == name} + end + + def position_of(name) + @menu_items.each do |node| + if node.name == name + return node.position + end + end + end +end diff --git a/lib/redmine/menu_manager/menu_controller.rb b/lib/redmine/menu_manager/menu_controller.rb new file mode 100644 index 00000000..7d5923bc --- /dev/null +++ b/lib/redmine/menu_manager/menu_controller.rb @@ -0,0 +1,48 @@ +module Redmine::MenuManager::MenuController + def self.included(base) + base.extend(ClassMethods) + end + + module ClassMethods + @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}} + mattr_accessor :menu_items + + # Set the menu item name for a controller or specific actions + # Examples: + # * menu_item :tickets # => sets the menu name to :tickets for the whole controller + # * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only + # * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only + # + # The default menu item name for a controller is controller_name by default + # Eg. the default menu item name for ProjectsController is :projects + def menu_item(id, options = {}) + if actions = options[:only] + actions = [] << actions unless actions.is_a?(Array) + actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id} + else + menu_items[controller_name.to_sym][:default] = id + end + end + end + + def menu_items + self.class.menu_items + end + + # Returns the menu item name according to the current action + def current_menu_item + @current_menu_item ||= menu_items[controller_name.to_sym][:actions][action_name.to_sym] || + menu_items[controller_name.to_sym][:default] + end + + # Redirects user to the menu item of the given project + # Returns false if user is not authorized + def redirect_to_project_menu_item(project, name) + item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name.to_s == name.to_s} + if item && User.current.allowed_to?(item.url, project) && (item.condition.nil? || item.condition.call(project)) + redirect_to({item.param => project}.merge(item.url)) + return true + end + false + end +end diff --git a/lib/redmine/menu_manager/menu_error.rb b/lib/redmine/menu_manager/menu_error.rb new file mode 100644 index 00000000..e5301c67 --- /dev/null +++ b/lib/redmine/menu_manager/menu_error.rb @@ -0,0 +1,2 @@ +class Redmine::MenuManager::MenuError < StandardError #:nodoc: +end diff --git a/lib/redmine/menu_manager/menu_helper.rb b/lib/redmine/menu_manager/menu_helper.rb new file mode 100644 index 00000000..186b1335 --- /dev/null +++ b/lib/redmine/menu_manager/menu_helper.rb @@ -0,0 +1,137 @@ +module Redmine::MenuManager::MenuHelper + # Returns the current menu item name + def current_menu_item + @controller.current_menu_item + end + + # Renders the application main menu + def render_main_menu(project) + render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project) + end + + def display_main_menu?(project) + menu_name = project && !project.new_record? ? :project_menu : :application_menu + Redmine::MenuManager.items(menu_name).size > 1 # 1 element is the root + end + + def render_menu(menu, project=nil) + links = [] + menu_items_for(menu, project) do |node| + links << render_menu_node(node, project) + end + links.empty? ? nil : content_tag('ul', links.join("\n")) + end + + def render_menu_node(node, project=nil) + if node.hasChildren? || !node.child_menus.nil? + return render_menu_node_with_children(node, project) + else + caption, url, selected = extract_node_details(node, project) + return content_tag('li', + render_single_menu_node(node, caption, url, selected)) + end + end + + def render_menu_node_with_children(node, project=nil) + caption, url, selected = extract_node_details(node, project) + + html = [].tap do |html| + html << '
  • ' + # Parent + html << render_single_menu_node(node, caption, url, selected) + + # Standard children + standard_children_list = "".tap do |child_html| + node.children.each do |child| + child_html << render_menu_node(child, project) + end + end + + html << content_tag(:ul, standard_children_list, :class => 'menu-children') unless standard_children_list.empty? + + # Unattached children + unattached_children_list = render_unattached_children_menu(node, project) + html << content_tag(:ul, unattached_children_list, :class => 'menu-children unattached') unless unattached_children_list.blank? + + html << '
    • ' + end + return html.join("\n") + end + + # Returns a list of unattached children menu items + def render_unattached_children_menu(node, project) + return nil unless node.child_menus + + "".tap do |child_html| + unattached_children = node.child_menus.call(project) + # Tree nodes support #each so we need to do object detection + if unattached_children.is_a? Array + unattached_children.each do |child| + child_html << content_tag(:li, render_unattached_menu_item(child, project)) + end + else + raise Redmine::MenuManager::MenuError, ":child_menus must be an array of MenuItems" + end + end + end + + def render_single_menu_node(item, caption, url, selected) + link_to(h(caption), url, item.html_options(:selected => selected)) + end + + def render_unattached_menu_item(menu_item, project) + raise Redmine::MenuManager::MenuError, ":child_menus must be an array of MenuItems" unless menu_item.is_a? Redmine::MenuManager::MenuItem + + if User.current.allowed_to?(menu_item.url, project) + link_to(h(menu_item.caption), + menu_item.url, + menu_item.html_options) + end + end + + def menu_items_for(menu, project=nil) + items = [] + Redmine::MenuManager.items(menu).root.children.each do |node| + if allowed_node?(node, User.current, project) + if block_given? + yield node + else + items << node # TODO: not used? + end + end + end + return block_given? ? nil : items + end + + def extract_node_details(node, project=nil) + item = node + url = case item.url + when Hash + project.nil? ? item.url : {item.param => project}.merge(item.url) + when Symbol + send(item.url) + else + item.url + end + caption = item.caption(project) + return [caption, url, (current_menu_item == item.name)] + end + + # Checks if a user is allowed to access the menu item by: + # + # * Checking the conditions of the item + # * Checking the url target (project only) + def allowed_node?(node, user, project) + if node.condition && !node.condition.call(project) + # Condition that doesn't pass + return false + end + + if project + return user && user.allowed_to?(node.url, project) + else + # outside a project, all menu items allowed + return true + end + end +end diff --git a/lib/redmine/menu_manager/menu_item.rb b/lib/redmine/menu_manager/menu_item.rb new file mode 100644 index 00000000..46547f95 --- /dev/null +++ b/lib/redmine/menu_manager/menu_item.rb @@ -0,0 +1,47 @@ +class Redmine::MenuManager::MenuItem < Tree::TreeNode + include Redmine::I18n + attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last + + def initialize(name, url, options) + raise ArgumentError, "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call) + raise ArgumentError, "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash) + raise ArgumentError, "Cannot set the :parent to be the same as this item" if options[:parent] == name.to_sym + raise ArgumentError, "Invalid option :children for menu item '#{name}'" if options[:children] && !options[:children].respond_to?(:call) + @name = name + @url = url + @condition = options[:if] + @param = options[:param] || :id + @caption = options[:caption] + @html_options = options[:html] || {} + # Adds a unique class to each menu item based on its name + @html_options[:class] = [@html_options[:class], @name.to_s.dasherize].compact.join(' ') + @parent = options[:parent] + @child_menus = options[:children] + @last = options[:last] || false + super @name.to_sym + end + + def caption(project=nil) + if @caption.is_a?(Proc) + c = @caption.call(project).to_s + c = @name.to_s.humanize if c.blank? + c + else + if @caption.nil? + l_or_humanize(name, :prefix => 'label_') + else + @caption.is_a?(Symbol) ? l(@caption) : @caption + end + end + end + + def html_options(options={}) + if options[:selected] + o = @html_options.dup + o[:class] += ' selected' + o + else + @html_options + end + end +end From 28b7f6cc7292e267398ce0a859b53a59c35f954b Mon Sep 17 00:00:00 2001 From: Gregor Schmidt Date: Wed, 9 Mar 2011 16:26:36 +0100 Subject: [PATCH 2/2] [#269] Instead of patching rubytree, creating a custom sub class and using that everywhere --- lib/redmine/menu_manager.rb | 92 +-------------------------- lib/redmine/menu_manager/mapper.rb | 2 +- lib/redmine/menu_manager/menu_item.rb | 2 +- lib/redmine/menu_manager/tree_node.rb | 75 ++++++++++++++++++++++ 4 files changed, 78 insertions(+), 93 deletions(-) create mode 100644 lib/redmine/menu_manager/tree_node.rb diff --git a/lib/redmine/menu_manager.rb b/lib/redmine/menu_manager.rb index 67b74428..9c29d71a 100644 --- a/lib/redmine/menu_manager.rb +++ b/lib/redmine/menu_manager.rb @@ -14,96 +14,6 @@ # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - -require 'tree' # gem install rubytree - -# Monkey patch the TreeNode to add on a few more methods :nodoc: -module TreeNodePatch - def self.included(base) - base.class_eval do - attr_reader :last_items_count - - def initialize_with_redmine(name, content = nil) - extend InstanceMethods - @last_items_count = 0 - - initialize_without_redmine(name, content) - end - alias_method_chain :initialize, :redmine - end - end - - module InstanceMethods - # Adds the specified child node to the receiver node. The child node's - # parent is set to be the receiver. The child is added as the first child in - # the current list of children for the receiver node. - def prepend(child) - raise "Child already added" if @childrenHash.has_key?(child.name) - - @childrenHash[child.name] = child - @children = [child] + @children - child.parent = self - return child - - end - - # Adds the specified child node to the receiver node. The child node's - # parent is set to be the receiver. The child is added at the position - # into the current list of children for the receiver node. - def add_at(child, position) - raise "Child already added" if @childrenHash.has_key?(child.name) - - @childrenHash[child.name] = child - @children = @children.insert(position, child) - child.parent = self - return child - - end - - def add_last(child) - raise "Child already added" if @childrenHash.has_key?(child.name) - - @childrenHash[child.name] = child - @children << child - @last_items_count += 1 - child.parent = self - return child - - end - - # Adds the specified child node to the receiver node. The child node's - # parent is set to be the receiver. The child is added as the last child in - # the current list of children for the receiver node. - def add(child) - raise "Child already added" if @childrenHash.has_key?(child.name) - - @childrenHash[child.name] = child - position = @children.size - @last_items_count - @children.insert(position, child) - child.parent = self - return child - - end - - # Wrapp remove! making sure to decrement the last_items counter if - # the removed child was a last item - def remove!(child) - @last_items_count -= +1 if child && child.last - super - end - - - # Will return the position (zero-based) of the current child in - # it's parent - def position - self.parent.children.index(self) - end - end -end -unless Tree::TreeNode.included_modules.include?(TreeNodePatch) - Tree::TreeNode.send(:include, TreeNodePatch) -end - module Redmine::MenuManager def self.map(menu_name) @items ||= {} @@ -116,6 +26,6 @@ module Redmine::MenuManager end def self.items(menu_name) - @items[menu_name.to_sym] || Tree::TreeNode.new(:root, {}) + @items[menu_name.to_sym] || Redmine::MenuManager::TreeNode.new(:root, {}) end end diff --git a/lib/redmine/menu_manager/mapper.rb b/lib/redmine/menu_manager/mapper.rb index bdb01c15..f643194b 100644 --- a/lib/redmine/menu_manager/mapper.rb +++ b/lib/redmine/menu_manager/mapper.rb @@ -1,6 +1,6 @@ class Redmine::MenuManager::Mapper def initialize(menu, items) - items[menu] ||= Tree::TreeNode.new(:root, {}) + items[menu] ||= Redmine::MenuManager::TreeNode.new(:root, {}) @menu = menu @menu_items = items[menu] end diff --git a/lib/redmine/menu_manager/menu_item.rb b/lib/redmine/menu_manager/menu_item.rb index 46547f95..5b7be3ad 100644 --- a/lib/redmine/menu_manager/menu_item.rb +++ b/lib/redmine/menu_manager/menu_item.rb @@ -1,4 +1,4 @@ -class Redmine::MenuManager::MenuItem < Tree::TreeNode +class Redmine::MenuManager::MenuItem < Redmine::MenuManager::TreeNode include Redmine::I18n attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last diff --git a/lib/redmine/menu_manager/tree_node.rb b/lib/redmine/menu_manager/tree_node.rb new file mode 100644 index 00000000..9891d895 --- /dev/null +++ b/lib/redmine/menu_manager/tree_node.rb @@ -0,0 +1,75 @@ +require 'tree' # gem install rubytree + +class Redmine::MenuManager::TreeNode < Tree::TreeNode + attr_reader :last_items_count + + def initialize(name, content = nil) + @last_items_count = 0 + super + end + + # Adds the specified child node to the receiver node. The child node's + # parent is set to be the receiver. The child is added as the first child in + # the current list of children for the receiver node. + def prepend(child) + raise "Child already added" if @childrenHash.has_key?(child.name) + + @childrenHash[child.name] = child + @children = [child] + @children + child.parent = self + return child + + end + + # Adds the specified child node to the receiver node. The child node's + # parent is set to be the receiver. The child is added at the position + # into the current list of children for the receiver node. + def add_at(child, position) + raise "Child already added" if @childrenHash.has_key?(child.name) + + @childrenHash[child.name] = child + @children = @children.insert(position, child) + child.parent = self + return child + + end + + def add_last(child) + raise "Child already added" if @childrenHash.has_key?(child.name) + + @childrenHash[child.name] = child + @children << child + @last_items_count += 1 + child.parent = self + return child + + end + + # Adds the specified child node to the receiver node. The child node's + # parent is set to be the receiver. The child is added as the last child in + # the current list of children for the receiver node. + def add(child) + raise "Child already added" if @childrenHash.has_key?(child.name) + + @childrenHash[child.name] = child + position = @children.size - @last_items_count + @children.insert(position, child) + child.parent = self + return child + + end + + # Wrapp remove! making sure to decrement the last_items counter if + # the removed child was a last item + def remove!(child) + @last_items_count -= +1 if child && child.last + super + end + + + # Will return the position (zero-based) of the current child in + # it's parent + def position + self.parent.children.index(self) + end +end