simple-navigation 3.12.0 → 3.12.1

data/lib/simple_navigation/core/item_adapter.rb

@@ -1,9 +1,10 @@
 require 'forwardable'
 
 module SimpleNavigation
-
-  # This class acts as an adapter to items that are not defined using the DSL in the config/navigation.rb, but directly provided inside the application.
-  # When defining the items that way, every item you provide needs to define the following methods:
+  # This class acts as an adapter to items that are not defined using the DSL
+  # in the config/navigation.rb, but directly provided inside the application.
+  # When defining the items that way, every item you provide needs to define
+  # the following methods:
   #
   # * <tt>key</tt>
   # * <tt>name</tt>
@@ -12,10 +13,13 @@ module SimpleNavigation
   # and optionally
   #
   # * <tt>options</tt>
-  # * <tt>items</tt> - if one of your items has a subnavigation it must respond to <tt>items</tt> providing the subnavigation.
+  # * <tt>items</tt> - if one of your items has a subnavigation it must respond
+  #                    to <tt>items</tt> providing the subnavigation.
   #
-  # You can also specify your items as a list of hashes. The hashes will be converted to objects automatically.
-  # The hashes representing the items obviously must have the keys :key, :name and :url and optionally the keys :options and :items.
+  # You can also specify your items as a list of hashes.
+  # The hashes will be converted to objects automatically.
+  # The hashes representing the items obviously must have the keys :key, :name
+  # and :url and optionally the keys :options and :items.
   #
   # See SimpleNavigation::ItemContainer#item for the purpose of these methods.
   class ItemAdapter
@@ -29,14 +33,16 @@ module SimpleNavigation
       @item = item.is_a?(Hash) ? to_object(item) : item
     end
 
-    # Returns the options for this item. If the wrapped item does not implement an options method, an empty hash is returned.
+    # Returns the options for this item. If the wrapped item does not implement
+    # an options method, an empty hash is returned.
     def options
-      @item.respond_to?(:options) ? @item.options : {}
+      item.respond_to?(:options) ? item.options : {}
     end
 
-    # Returns the items (subnavigation) for this item if it responds to :items and the items-collection is not empty. Returns nil otherwise.
+    # Returns the items (subnavigation) for this item if it responds to :items
+    # and the items-collection is not empty. Returns nil otherwise.
     def items
-      (@item.respond_to?(:items) && !(@item.items.nil? || @item.items.empty?)) ? @item.items : nil
+      item.items if item.respond_to?(:items) && item.items && item.items.any?
     end
 
     # Converts this Item into a SimpleNavigation::Item
@@ -46,8 +52,8 @@ module SimpleNavigation
 
     protected
 
-    # Converts the specified hash into an object. Each key will be added as method.
-    #
+    # Converts the specified hash into an object. Each key will be added
+    # as method.
     def to_object(hash)
       mod = Module.new do
         hash.each_pair do |key, value|
@@ -58,6 +64,5 @@ module SimpleNavigation
       end
       Object.new.extend(mod)
     end
-
   end
 end

data/lib/simple_navigation/core/item_container.rb

@@ -1,117 +1,137 @@
 module SimpleNavigation
-
   # Holds the Items for a navigation 'level'.
   class ItemContainer
+    attr_accessor :auto_highlight,
+                  :dom_class,
+                  :dom_id,
+                  :renderer,
+                  :selected_class
 
     attr_reader :items, :level
-    attr_accessor :renderer, :dom_id, :dom_class, :dom_attributes, :auto_highlight, :selected_class
 
-    def initialize(level=1) #:nodoc:
+    attr_writer :dom_attributes
+
+    def initialize(level = 1) #:nodoc:
       @level = level
-      @items = []
+      @items ||= []
       @renderer = SimpleNavigation.config.renderer
       @auto_highlight = true
     end
 
     def dom_attributes
       # backward compability for #dom_id and #dom_class
-      (@dom_attributes || {}).merge({id: dom_id, class: dom_class}.reject{|k, v| v.nil?})
+      dom_id_and_class = {
+        id: dom_id,
+        class: dom_class
+      }.reject { |_, v| v.nil? }
+      (@dom_attributes || {}).merge(dom_id_and_class)
     end
 
     # Creates a new navigation item.
     #
-    # The <tt>key</tt> is a symbol which uniquely defines your navigation item in the scope of the primary_navigation or the sub_navigation.
+    # The <tt>key</tt> is a symbol which uniquely defines your navigation item
+    # in the scope of the primary_navigation or the sub_navigation.
     #
-    # The <tt>name</tt> will be displayed in the rendered navigation. This can also be a call to your I18n-framework.
+    # The <tt>name</tt> will be displayed in the rendered navigation.
+    # This can also be a call to your I18n-framework.
     #
-    # The <tt>url</tt> is the address that the generated item points to. You can also use url_helpers (named routes, restful routes helper, url_for etc.) <tt>url</tt> is optional - items without URLs should not be rendered as links.
+    # The <tt>url</tt> is the address that the generated item points to.
+    # You can also use url_helpers (named routes, restful routes helper,
+    # url_for, etc). <tt>url</tt> is optional - items without URLs should not
+    # be rendered as links.
     #
     # The <tt>options</tt> can be used to specify the following things:
-    # * <tt>any html_attributes</tt> - will be included in the rendered navigation item (e.g. id, class etc.)
+    # * <tt>any html_attributes</tt> - will be included in the rendered
+    #   navigation item (e.g. id, class etc.)
     # * <tt>:if</tt> - Specifies a proc to call to determine if the item should
-    #   be rendered (e.g. <tt>:if => Proc.new { current_user.admin? }</tt>). The
-    #   proc should evaluate to a true or false value and is evaluated in the context of the view.
-    # * <tt>:unless</tt> - Specifies a proc to call to determine if the item should not
-    #   be rendered (e.g. <tt>:unless => Proc.new { current_user.admin? }</tt>). The
-    #   proc should evaluate to a true or false value and is evaluated in the context of the view.
-    # * <tt>:method</tt> - Specifies the http-method for the generated link - default is :get.
-    # * <tt>:highlights_on</tt> - if autohighlighting is turned off and/or you want to explicitly specify
-    #   when the item should be highlighted, you can set a regexp which is matched againstthe current URI.
+    #   be rendered (e.g. <tt>if: Proc.new { current_user.admin? }</tt>). The
+    #   proc should evaluate to a true or false value and is evaluated
+    #   in the context of the view.
+    # * <tt>:unless</tt> - Specifies a proc to call to determine if the item
+    #   should not be rendered
+    #   (e.g. <tt>unless: Proc.new { current_user.admin? }</tt>).
+    #   The proc should evaluate to a true or false value and is evaluated in
+    #   the context of the view.
+    # * <tt>:method</tt> - Specifies the http-method for the generated link -
+    #   default is :get.
+    # * <tt>:highlights_on</tt> - if autohighlighting is turned off and/or you
+    #   want to explicitly specify when the item should be highlighted, you can
+    #   set a regexp which is matched againstthe current URI.
     #
     # The <tt>block</tt> - if specified - will hold the item's sub_navigation.
     def item(key, name, url_or_options = {}, options_or_nil = {}, &block)
       options = url_or_options.is_a?(Hash) ? url_or_options : options_or_nil
-      (@items << SimpleNavigation::Item.new(self, key, name, url_or_options, options_or_nil, nil, &block)) if should_add_item?(options)
+      return unless should_add_item?(options)
+      items << SimpleNavigation::Item.new(self,
+                                          key,
+                                          name,
+                                          url_or_options,
+                                          options_or_nil,
+                                          nil,
+                                          &block)
     end
 
-    def items=(items)
-      items.each do |item|
-        item = SimpleNavigation::ItemAdapter.new(item)
-        (@items << item.to_simple_navigation_item(self)) if should_add_item?(item.options)
-      end
+    def items=(new_items)
+      @items += new_items.map { |item| ItemAdapter.new(item) }
+                         .keep_if { |item| should_add_item?(item.options) }
     end
 
     # Returns the Item with the specified key, nil otherwise.
     #
     def [](navi_key)
-      items.find {|i| i.key == navi_key}
+      items.find { |item| item.key == navi_key }
     end
 
     # Returns the level of the item specified by navi_key.
-    # Recursively works its way down the item's sub_navigations if the desired item is not found directly in this container's items.
-    # Returns nil item cannot be found.
+    # Recursively works its way down the item's sub_navigations if the desired
+    # item is not found directly in this container's items.
+    # Returns nil if item cannot be found.
     #
     def level_for_item(navi_key)
-      my_item = self[navi_key]
-      return self.level if my_item
-      items.each do |i|
-        if i.sub_navigation
-          level = i.sub_navigation.level_for_item(navi_key)
-          return level unless level.nil?
-        end
+      return level if self[navi_key]
+
+      items.each do |item|
+        next unless item.sub_navigation
+        level = item.sub_navigation.level_for_item(navi_key)
+        return level if level
       end
       return nil
     end
 
     # Renders the items in this ItemContainer using the configured renderer.
     #
-    # The options are the same as in the view's render_navigation call (they get passed on)
-    def render(options={})
-      renderer_instance = if options[:renderer]
-        if options[:renderer].instance_of?(Symbol) && SimpleNavigation.registered_renderers.key?(options[:renderer])
-          SimpleNavigation.registered_renderers[options[:renderer]].new(options)
-        else
-          options[:renderer].new(options)
-        end
-      else
-        self.renderer.new(options)
-      end
-      renderer_instance.render(self)
+    # The options are the same as in the view's render_navigation call
+    # (they get passed on)
+    def render(options = {})
+      renderer_instance(options).render(self)
     end
 
     # Returns true if any of this container's items is selected.
     #
     def selected?
-      items.any? {|i| i.selected?}
+      items.any?(&:selected?)
     end
 
     # Returns the currently selected item, nil if no item is selected.
     #
     def selected_item
-      items.find {|i| i.selected?}
+      items.find(&:selected?)
     end
 
     # Returns the active item_container for the specified level
-    # (recursively looks up items in selected sub_navigation if level is deeper than this container's level).
-    #
+    # (recursively looks up items in selected sub_navigation if level is deeper
+    # than this container's level).
     def active_item_container_for(desired_level)
-      return self if self.level == desired_level
-      return nil unless selected_sub_navigation?
-      return selected_item.sub_navigation.active_item_container_for(desired_level)
+      if level == desired_level
+        self
+      elsif selected_sub_navigation?
+        selected_item.sub_navigation.active_item_container_for(desired_level)
+      end
     end
-    
-    # Returns the deepest possible active item_container. 
-    # (recursively searches in the sub_navigation if this container has a selected sub_navigation). 
+
+    # Returns the deepest possible active item_container.
+    # (recursively searches in the sub_navigation if this container has a
+    # selected sub_navigation).
     def active_leaf_container
       if selected_sub_navigation?
         selected_item.sub_navigation.active_leaf_container
@@ -127,26 +147,33 @@ module SimpleNavigation
 
     private
 
+    # FIXME: raise an exception if :rederer is a symbol and it is not registred
+    #        in SimpleNavigation.registered_renderers
+    def renderer_instance(options)
+      return renderer.new(options) unless options[:renderer]
+
+      if options[:renderer].is_a?(Symbol)
+        registered_renderer = SimpleNavigation.registered_renderers[options[:renderer]]
+        registered_renderer.new(options)
+      else
+        options[:renderer].new(options)
+      end
+    end
+
     def selected_sub_navigation?
       !!(selected_item && selected_item.sub_navigation)
     end
 
-    # partially borrowed from ActionSupport::Callbacks
-    def should_add_item?(options) #:nodoc:
+    def should_add_item?(options)
       [options.delete(:if)].flatten.compact.all? { |m| evaluate_method(m) } &&
-      ![options.delete(:unless)].flatten.compact.any? { |m| evaluate_method(m) }
+      [options.delete(:unless)].flatten.compact.none? { |m| evaluate_method(m) }
     end
 
-    # partially borrowed from ActionSupport::Callbacks
-    def evaluate_method(method) #:nodoc:
+    def evaluate_method(method)
       case method
-        when Proc, Method
-          method.call
-        else
-          raise ArgumentError, ":if or :unless must be procs or lambdas"
+      when Proc, Method then method.call
+      else fail(ArgumentError, ':if or :unless must be procs or lambdas')
       end
     end
-
   end
-
 end

data/lib/simple_navigation/core/items_provider.rb

@@ -1,18 +1,19 @@
 module SimpleNavigation
-
-  # Acts as a proxy to navigation items that are passed into the SimpleNavigation::Configuration#items method. It hides the logic
-  # for finding items from the Configuration object.
+  # Acts as a proxy to navigation items that are passed into the
+  # SimpleNavigation::Configuration#items method.
+  # It hides the logic for finding items from the Configuration object.
   #
   class ItemsProvider
-
     attr_reader :provider
 
     # It accepts the following types of provider:
-    # * methodname as symbol - the specified method should return the relevant items and has to be available in the view (a helper method)
+    # * methodname as symbol - the specified method should return the relevant
+    #   items and has to be available in the view (a helper method)
     # * object that responds to :items
     # * enumerable object that represents the items
     #
-    # See SimpleNavigation::ItemAdapter for the requirements that need to be fulfilled by the provided items.
+    # See SimpleNavigation::ItemAdapter for the requirements that need to be
+    # fulfilled by the provided items.
     #
     def initialize(provider)
       @provider = provider
@@ -20,16 +21,17 @@ module SimpleNavigation
 
     # Returns the navigation items
     def items
-      if provider.instance_of?(Symbol)
+      if provider.is_a?(Symbol)
         SimpleNavigation.context_for_eval.send(provider)
       elsif provider.respond_to?(:items)
         provider.items
       elsif provider.respond_to?(:each)
         provider
       else
-        raise "items_provider either must be a symbol specifying the helper-method to call, an object with an items-method defined or an enumerable representing the items"
+        fail('items_provider either must be a symbol specifying the '         \
+             'helper-method to call, an object with an items-method defined ' \
+             'or an enumerable representing the items')
       end
     end
-
   end
-end
+end

data/lib/simple_navigation/rails_controller_methods.rb

@@ -1,60 +1,73 @@
 module SimpleNavigation
+  def self.explicit_navigation_args
+    adapter.controller.instance_variable_get(:'@sn_current_navigation_args')
+  end
 
-  class << self
+  # Reads the current navigation for the specified level from the controller.
+  # Returns nil if there is no current navigation set for level.
+  def self.current_navigation_for(level)
+    adapter.controller.instance_variable_get(:"@sn_current_navigation_#{level}")
+  end
 
-    def explicit_navigation_args
-      self.adapter.controller.instance_variable_get(:"@sn_current_navigation_args")
-    end
+  # If any navigation has been explicitely set in the controller this method
+  # evaluates the specified args set in the controller and sets the correct
+  # instance variable in the controller.
+  def self.handle_explicit_navigation
+    return unless explicit_navigation_args
+    level, navigation = parse_explicit_navigation_args
+    navigation_level = :"@sn_current_navigation_#{level}"
+    adapter.controller.instance_variable_set(navigation_level, navigation)
+  end
 
-    # Reads the current navigation for the specified level from the controller.
-    # Returns nil if there is no current navigation set for level.
-    def current_navigation_for(level)
-      self.adapter.controller.instance_variable_get(:"@sn_current_navigation_#{level}")
-    end
+  def self.parse_explicit_navigation_args
+    args = if explicit_navigation_args.empty?
+             [{}]
+           else
+             explicit_navigation_args
+           end
+    indexed_args = args_indexed_by_level(args)
+    deepest = deepest_level_and_item(indexed_args)
 
-    # If any navigation has been explicitely set in the controller this method evaluates the specified args set in the controller and sets
-    # the correct instance variable in the controller.
-    def handle_explicit_navigation
-      if SimpleNavigation.explicit_navigation_args
-        level, navigation = parse_explicit_navigation_args
-        self.adapter.controller.instance_variable_set(:"@sn_current_navigation_#{level}", navigation)
-      end
+    if deepest.first.zero?
+      fail ArgumentError, 'Invalid level specified or item key not found'
     end
 
-    # TODO: refactor this ugly thing to make it nice and short
-    def parse_explicit_navigation_args
-      args = SimpleNavigation.explicit_navigation_args
-      args = [Hash.new] if args.empty?
-      if args.first.kind_of? Hash
-        options = args.first
-      else # args is a list of current navigation for several levels
-        options = {}
-        if args.size == 1 #only one navi-key has been specified, try to find out level
-          level = SimpleNavigation.primary_navigation.level_for_item(args.first)
-          options[:"level_#{level}"] = args.first if level
-        else
-          args.each_with_index {|arg, i| options[:"level_#{i + 1}"] = arg}
-        end
-      end
-      #only the deepest level is relevant
-      level = options.inject(0) do |max, kv|
-        kv.first.to_s =~ /level_(\d)/
-        max = $1.to_i if $1.to_i > max
-        max
-      end
-      raise ArgumentError, "Invalid level specified or item key not found" if level == 0
-      [level, options[:"level_#{level}"]]
+    deepest
+  end
+
+  private
+
+  def self.deepest_level_and_item(navigation_args)
+    navigation_args.map { |k, v| [k.to_s[/level_(\d)/, 1].to_i, v] }
+                   .max
+  end
+
+  def self.args_indexed_by_level(navigation_args)
+    if navigation_args.first.is_a?(Hash)
+      navigation_args.first
+    elsif navigation_args.size == 1
+      level = primary_navigation.level_for_item(navigation_args.first)
+      level ? { :"level_#{level}" => navigation_args.first } : {}
+    else
+      navigation_args.each_with_index
+                     .with_object({}) do |(arg, i), h|
+                       h[:"level_#{i + 1}"] = arg
+                     end
     end
-    
-  end  
-  
-  # Adds methods for explicitely setting the current 'active' navigation to the controllers.
-  # Since version 2.0.0 the simple_navigation plugin determines the active navigation based on the current url by default (auto highlighting),
-  # so explicitely defining the active navigation in the controllers is only needed for edge cases where automatic highlighting does not work.
-  # 
-  # On the controller class level, use the <tt>navigation</tt> method to set the active navigation for all actions in the controller.
-  # Let's assume that we have a primary navigation item :account which in turn has a sub navigation item :settings.
-  # 
+  end
+
+  # Adds methods for explicitely setting the current 'active' navigation to
+  # the controllers.
+  # Since version 2.0.0 the simple_navigation plugin determines the active
+  # navigation based on the current url by default (auto highlighting),
+  # so explicitely defining the active navigation in the controllers is only
+  # needed for edge cases where automatic highlighting does not work.
+  #
+  # On the controller class level, use the <tt>navigation</tt> method to set the
+  # active navigation for all actions in the controller.
+  # Let's assume that we have a primary navigation item :account which in turn
+  # has a sub navigation item :settings.
+  #
   # ==== Examples
   #   class AccountController << ActionController
   #     navigation :account
@@ -66,28 +79,38 @@ module SimpleNavigation
   #     ...
   #   end
   #
-  # The first example sets the current primary navigation to :account for all actions. No active sub_navigation.
-  # The second example sets the current sub navigation to :settings and since it is a child of :account the current primary navigation is set to :account.
-  # 
-  # On the controller instance level, use the <tt>current_navigation</tt> method to define the active navigation for a specific action. 
-  # The navigation item that is set in <tt>current_navigation</tt> overrides the one defined on the controller class level (see <tt>navigation</tt> method).
-  # Thus if you have an :account primary item with a :special sub navigation item:
+  # The first example sets the current primary navigation to :account for all
+  # actions. No active sub_navigation.
+  # The second example sets the current sub navigation to :settings and since
+  # it is a child of :account the current primary navigation is set to :account.
+  #
+  # On the controller instance level, use the <tt>current_navigation</tt> method
+  # to define the active navigation for a specific action.
+  # The navigation item that is set in <tt>current_navigation</tt> overrides the
+  # one defined on the controller class level (see <tt>navigation</tt> method).
+  # Thus if you have an :account primary item with a :special
+  # sub navigation item:
   #
   # ==== Example
   #   class AccountController << ActionController
   #     navigation :account
-  #     
+  #
   #     def your_special_action
   #       ...
   #       current_navigation :special
   #     end
   #   end
   #
-  # The code above still sets the active primary navigation to :account for all actions, but sets the sub_navigation to :account -> :special for 'your_special_action'.
+  # The code above still sets the active primary navigation to :account for all
+  # actions, but sets the sub_navigation to :account -> :special for
+  # 'your_special_action'.
   #
-  # Note 1: As you can see above you just have to set the navigation item of your 'deepest' navigation level as active and all its parents are marked as active, too.
+  # Note 1: As you can see above you just have to set the navigation item of
+  #         your 'deepest' navigation level as active and all its parents are
+  #         marked as active, too.
   #
-  # Note 2: The specified symbols must match the keys for your navigation items in your config/navigation.rb file.
+  # Note 2: The specified symbols must match the keys for your navigation
+  #         items in your config/navigation.rb file.
   module ControllerMethods
     def self.included(base) #:nodoc:
       base.class_eval do
@@ -95,13 +118,14 @@ module SimpleNavigation
         include InstanceMethods
       end
     end
-  
+
     module ClassMethods
       # Sets the active navigation for all actions in this controller.
       #
-      # The specified symbol must match the keys for your navigation items in your config/navigation.rb file.  
+      # The specified symbol must match the keys for your navigation items
+      # in your config/navigation.rb file.
       def navigation(*args)
-        self.class_eval do
+        class_eval do
           define_method :sn_set_navigation do
             current_navigation(*args)
           end
@@ -110,35 +134,31 @@ module SimpleNavigation
         end
       end
     end
-  
+
     module InstanceMethods
-      # Sets the active navigation. Call this method in any action to override the controller-wide active navigation
-      # specified by navigation.
+      # Sets the active navigation. Call this method in any action to override
+      # the controller-wide active navigation specified by navigation.
       #
-      # The specified symbol must match the keys for your navigation items in your config/navigation.rb file.
+      # The specified symbol must match the keys for your navigation items in
+      # your config/navigation.rb file.
       def current_navigation(*args)
         @sn_current_navigation_args = args
       end
     end
-
   end
-  
+
   class Item
-    
     def selected_by_config?
-      key == SimpleNavigation.current_navigation_for(@container.level)
+      key == SimpleNavigation.current_navigation_for(container.level)
     end
-    
   end
-  
+
   class ItemContainer
-    
     def selected_item
-      self[SimpleNavigation.current_navigation_for(self.level)] || items.find {|i| i.selected?}
+      self[SimpleNavigation.current_navigation_for(level)] ||
+      items.find(&:selected?)
     end
-    
   end
-  
 end
-  
-ActionController::Base.send(:include, SimpleNavigation::ControllerMethods)
+
+ActionController::Base.send(:include, SimpleNavigation::ControllerMethods)