semantic_navigation 0.1.1 → 0.1.3

data/lib/semantic_navigation/renderers/mix_in/acts_as_list.rb

@@ -0,0 +1,49 @@
+module SemanticNavigation
+  module Renderers
+    module MixIn
+      module ActsAsList
+
+        def render_navigation(object)
+          return '' unless object.render_if
+          navigation(object) do
+            while !object.class.in?([SemanticNavigation::Core::Leaf, NilClass]) &&
+                  from_level.to_i > object.level
+              object = object.sub_elements.find{|e| e.active}
+            end
+            show = !until_level.nil? && !object.nil? ? object.level <= until_level : true
+            if !object.class.in?([SemanticNavigation::Core::Leaf, NilClass]) && show
+              object.sub_elements.map{|element| element.render(self)}.compact.sum
+            end
+          end
+        end
+
+        def render_node(object)
+          if !object.id.in?([except_for].flatten) && object.render_if
+            content = render_node_content(object)
+            if content
+              node(object) do
+                content
+              end
+            else
+              render_leaf(object)
+            end
+          end
+        end
+
+        def render_node_content(object)
+          if (!until_level.nil? && until_level >= object.level) || until_level.nil?
+            node_content(object) do
+              object.sub_elements.map{|element| element.render(self)}.compact.sum
+            end
+          end
+        end
+
+        def render_leaf(object)
+          if !object.id.in?([except_for].flatten) && object.render_if
+            leaf(object)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/semantic_navigation/renderers/mix_in/render_helpers.rb

@@ -0,0 +1,110 @@
+module SemanticNavigation
+  module Renderers
+    module MixIn
+      module RenderHelpers
+
+        def self.included(base)
+          base.send :include, InstanceMethods
+          base.extend(ClassMethods)
+          base.class_eval do
+            [:navigation, :node, :leaf, :link].each do |e|
+              style_accessor :"#{e}_active_class" => [:active],
+                             :"show_#{e}_active_class" => true,
+                             :"show_#{e}_id" => true,
+                             :"#{e}_default_classes" => []
+            end
+            style_accessor menu_tag: :ul
+          end
+        end
+
+        module ClassMethods
+
+          def style_accessor(hash)
+            hash.keys.each do |key|
+              class_eval "
+               @@#{key} = nil
+               @#{key} = nil
+
+               def self.#{key}(value)
+                 @@#{key}= value
+               end
+
+               def #{key}(value = nil)
+                 @#{key} = value unless value.nil?
+                 @#{key}.nil? ? @@#{key} : @#{key}
+               end
+
+               def #{key}=(value)
+                 @#{key} = value
+               end
+              "
+              send key, hash[key]
+            end
+          end
+
+          def property_for(class_name,name)
+            class_object = "semantic_navigation/core/#{class_name}".classify.constantize
+            class_object.class_eval "
+              unless defined?(#{name})
+                def #{name}
+                  @#{name}
+                end
+              end
+            "
+          end
+        end
+
+        module InstanceMethods
+          attr_accessor :from_level, :until_level, :except_for, :name
+
+          def level=(level)
+            @from_level = level
+            @until_level = level
+          end
+
+          def levels=(level_range)
+            @from_level = level_range.first
+            @until_level = level_range.last
+          end
+
+          def initialize
+            @view_object = SemanticNavigation::Configuration.view_object
+          end
+
+          private
+
+          def content_tag(tag_name, content = nil, options={}, &block)
+            @view_object.content_tag(tag_name, content, options) {yield if block_given?}
+          end
+
+          def link_to(link_name, url, options={})
+            @view_object.link_to(link_name, url, options)
+          end
+
+          def merge_classes(name, active, object_classes = [])
+            default_classes = send("#{name}_default_classes")
+            active_classes = active && send("show_#{name}_active_class") ? send("#{name}_active_class") : nil
+
+            classes = [*default_classes, *active_classes, *object_classes]
+            !classes.empty? ? classes : nil
+          end
+
+          def show_id(name, id)
+            id if send("show_#{name}_id")
+          end
+
+          def object_name(object)
+            object.name(self.name)
+          end
+
+          def content_menu_tag(parameters)
+            content_tag menu_tag, nil, parameters do
+              yield
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/semantic_navigation/twitter_bootstrap/breadcrumb.rb

@@ -1,8 +1,8 @@
 module SemanticNavigation
   module TwitterBootstrap
     class Breadcrumb
-      include SemanticNavigation::Renderers::RenderHelpers
-      include SemanticNavigation::Renderers::ActsAsBreadcrumb
+      include SemanticNavigation::Renderers::MixIn::RenderHelpers
+      include SemanticNavigation::Renderers::MixIn::ActsAsBreadcrumb
 
       style_accessor last_as_link: false,
                      breadcrumb_separator: '/'
@@ -36,7 +36,7 @@ module SemanticNavigation
                               }.merge(object.html)) do
           [object.ico ? content_tag(:i, nil, class: "icon-#{object.ico}") : ''.html_safe,
           link_to(object_name(object),
-                  object.url, 
+                  object.url,
                   {id: show_id(:link, object.id),
                    class: merge_classes(:link, object.active, object.link_classes)
                   }.merge(object.link_html)),
@@ -51,8 +51,8 @@ module SemanticNavigation
                               }.merge(object.html) do
           [object.ico ? content_tag(:i, nil, class: "icon-#{object.ico}") : ''.html_safe,
           if last_as_link
-            link_to(object_name(object), 
-                    object.url, 
+            link_to(object_name(object),
+                    object.url,
                     {id: show_id(:link, object.id),
                      class: merge_classes(:link, object.active, object.link_classes)
                     }.merge(object.link_html))

data/lib/semantic_navigation/twitter_bootstrap/list.rb

@@ -1,8 +1,8 @@
 module SemanticNavigation
   module TwitterBootstrap
     class List
-      include SemanticNavigation::Renderers::RenderHelpers
-      include SemanticNavigation::Renderers::ActsAsList
+      include SemanticNavigation::Renderers::MixIn::RenderHelpers
+      include SemanticNavigation::Renderers::MixIn::ActsAsList
 
       navigation_default_classes [:nav, 'nav-list']
       show_navigation_id false

data/lib/semantic_navigation/twitter_bootstrap/tabs.rb

@@ -1,8 +1,8 @@
 module SemanticNavigation
   module TwitterBootstrap
     class Tabs
-      include SemanticNavigation::Renderers::RenderHelpers
-      include SemanticNavigation::Renderers::ActsAsList
+      include SemanticNavigation::Renderers::MixIn::RenderHelpers
+      include SemanticNavigation::Renderers::MixIn::ActsAsList
 
       style_accessor direction: 'left'
 

data/lib/semantic_navigation/version.rb

@@ -1,3 +1,3 @@
 module SemanticNavigation
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/semantic_navigation.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-   s.add_development_dependency "rspec", ">=2.0.1"
+   s.add_development_dependency "rspec", ">= 2.0.1"
    s.add_development_dependency "simplecov"
-   s.add_runtime_dependency "rails", ">=3.0.0"
+   s.add_development_dependency "appraisal"
+   s.add_runtime_dependency "rails", ">= 3.2.0"
 end

data/spec/lib/semantic_navigation/configuration_spec.rb

@@ -7,33 +7,38 @@ describe SemanticNavigation::Configuration do
   end
 
   describe "#run" do
-    it 'should receive class eval if block passed' do
+    it 'receives class eval if block passed' do
       SemanticNavigation::Configuration.should_receive(:class_eval)
       SemanticNavigation::Configuration.run do
         do_something
       end
     end
 
-    it 'should not receive class_eval if block not passed' do
+    it 'doesnt receive class_eval if block not passed' do
       SemanticNavigation::Configuration.run
     end
   end
 
   describe '#navigate' do
-    it 'should receive at least only id and save navigation instance in class variables' do
-      nav_instance = SemanticNavigation::Configuration.navigate :some_menu
-      navigations = SemanticNavigation::Configuration.class_variable_get("@@navigations")
-      navigations.keys.should == [:some_menu]
-      navigations[:some_menu].should == nav_instance
-    end
 
-    it 'should receive id and pass to Navigation instance create options hash' do
-      SemanticNavigation::Core::Navigation.should_receive(:new).with({:id=>:some_menu,
-                                                                      :i18n_name=>"semantic_navigation.some_menu"})
-      SemanticNavigation::Configuration.navigate :some_menu
+    context :receives do
+
+      it 'at least only id and save navigation instance in class variables' do
+        nav_instance = SemanticNavigation::Configuration.navigate :some_menu
+        navigations = SemanticNavigation::Configuration.class_variable_get("@@navigations")
+        navigations.keys.should == [:some_menu]
+        navigations[:some_menu].should == nav_instance
+      end
+
+      it 'id and pass to Navigation instance create options hash' do
+        SemanticNavigation::Core::Navigation.should_receive(:new).with({:id=>:some_menu,
+                                                                        :i18n_name=>"semantic_navigation.some_menu"})
+        SemanticNavigation::Configuration.navigate :some_menu
+      end
+
     end
 
-    it 'should pass received block to navigation class instance' do
+    it 'passes received block to navigation class instance' do
       navigation = mock
       navigation.should_receive(:instance_eval)
       SemanticNavigation::Core::Navigation.should_receive(:new).and_return navigation
@@ -42,7 +47,7 @@ describe SemanticNavigation::Configuration do
       end
     end
 
-    it 'should merge id, i18n_name and received params and pass them to navigation instance create method' do
+    it 'merges id, i18n_name and received params and pass them to navigation instance create method' do
       SemanticNavigation::Core::Navigation.should_receive(:new).with({:id => :some_menu,
                                                                       :i18n_name=>"semantic_navigation.some_menu",
                                                                       :some_attr => 1,
@@ -52,14 +57,14 @@ describe SemanticNavigation::Configuration do
   end
 
   describe '#navigation' do
-    it 'should return navigation instance by name' do
+    it 'returns navigation instance by name' do
       nav_instance = SemanticNavigation::Configuration.navigate :some_menu
       SemanticNavigation::Configuration.navigation(:some_menu).should == nav_instance
     end
   end
 
   describe '#styles_for' do
-    it 'should save styles block as a proc' do
+    it 'saves styles block as a proc' do
       proc_object = SemanticNavigation::Configuration.styles_for :some_renderer do
         do_something1 true
         do_something2 'some_attr'
@@ -79,21 +84,21 @@ describe SemanticNavigation::Configuration do
       class SomeRenderer; end
     end
 
-    it 'should register renderer by passed name and class' do
+    it 'registers renderer by passed name and class' do
       SemanticNavigation::Configuration.register_renderer :some_renderer, SomeRenderer
       renderers = SemanticNavigation::Configuration.class_variable_get("@@renderers")
       renderers[:some_renderer].should_not be_nil
       renderers[:some_renderer].should == SomeRenderer
     end
 
-    it 'should register renderer by passed classes and generate the name for it' do
+    it 'registers renderer by passed classes and generate the name for it' do
       SemanticNavigation::Configuration.register_renderer SomeRenderer
       renderers = SemanticNavigation::Configuration.class_variable_get("@@renderers")
       renderers[:some_renderer].should_not be_nil
       renderers[:some_renderer].should == SomeRenderer
     end
 
-    it 'should reregister the renderer class regigstered before' do
+    it 'registers the renderer class regigstered before' do
       SemanticNavigation::Configuration.register_renderer SomeRenderer
       SemanticNavigation::Configuration.register_renderer :another_name, :some_renderer
       renderers = SemanticNavigation::Configuration.class_variable_get("@@renderers")
@@ -101,7 +106,7 @@ describe SemanticNavigation::Configuration do
       renderers[:another_name].should == SomeRenderer
     end
 
-    it 'should register a new helper method based on name of a renderer and depending on method navigation_for' do
+    it 'registers a new helper method based on name of a renderer and depending on method navigation_for' do
       SemanticNavigation::Configuration.register_renderer SomeRenderer
       SemanticNavigation::HelperMethods.method_defined?(:some_renderer_for).should be_true
 
@@ -128,14 +133,14 @@ describe SemanticNavigation::Configuration do
       SemanticNavigation::Configuration.class_variable_set "@@navigations", {:some_menu => @navigation}
     end
 
-    it 'should send render method to Renderer class; mark active navigation elements;' do
+    it 'sends render method to Renderer class; mark active navigation elements;' do
       @navigation.should_receive(:mark_active)
       @navigation.should_receive(:render).with(@renderer_instance)
       @renderer_instance.should_receive(:name=).with(:renderer)
       SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {}, @view_object)
     end
 
-    it 'should send renderer options' do
+    it 'sends renderer options' do
       @navigation.should_receive(:mark_active)
       @navigation.should_receive(:render).with(@renderer_instance)
       @renderer_instance.should_receive(:level=).with(1)
@@ -143,7 +148,7 @@ describe SemanticNavigation::Configuration do
       SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {:level => 1}, @view_object)
     end
 
-    it 'should exec default renderer styles from configuration' do
+    it 'execs default renderer styles from configuration' do
       render_styles = proc{}
       SemanticNavigation::Configuration.class_variable_set "@@render_styles", {:renderer => render_styles}
       @renderer_instance.should_receive(:instance_eval).with(&render_styles)
@@ -153,7 +158,7 @@ describe SemanticNavigation::Configuration do
       SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {}, @view_object)
     end
 
-    it 'should set @@view_object in configuration class' do
+    it 'sets @@view_object in configuration class' do
       @navigation.should_receive(:mark_active)
       @navigation.should_receive(:render).with(@renderer_instance)
       @renderer_instance.should_receive(:name=).with(:renderer)

data/spec/lib/semantic_navigation/core/leaf_spec.rb

@@ -2,81 +2,84 @@ require 'spec_helper'
 
 describe SemanticNavigation::Core::Leaf do
   describe '#name' do
-  	
-  	it 'should return saved name' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :name => 'first'},1)
-      leaf.name.should == 'first'
-  	end
-
-    it 'should return basic name even if renderer name sended' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :name => 'first'},1)
-      leaf.name(:renderer_name).should == 'first'      
-    end
-
-    it 'should return the name for renderer' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, 
-                                                 :name => {:some_renderer => 'some_renderer_name'}},
-                                                 1)
-      leaf.name(:some_renderer).should == 'some_renderer_name'
-    end
-
-    it 'should return default name for unexpected renderer' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, 
-                                                 :name => {:default => 'default_name',
-                                                           :some_renderer => 'some_renderer_name'}},
-                                                 1)
-      leaf.name(:unexpected_renderer).should == 'default_name'
-    end
 
-    it 'should return nil if no name defined' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first}, 1)
-      leaf.name.should == ''
-    end
-
-  	it 'should return i18n name if @name is nil' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
-      I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return 'first'
-      leaf.name.should == 'first'
-  	end
+    context :returns do
+
+      it 'saved name' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :name => 'first'},1)
+        leaf.name.should == 'first'
+      end
+
+      it 'basic name even if renderer name sended' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :name => 'first'},1)
+        leaf.name(:renderer_name).should == 'first'
+      end
+
+      it 'the name for renderer' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first,
+                                                   :name => {:some_renderer => 'some_renderer_name'}},
+                                                   1)
+        leaf.name(:some_renderer).should == 'some_renderer_name'
+      end
+
+      it 'default name for unexpected renderer' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first,
+                                                   :name => {:default => 'default_name',
+                                                             :some_renderer => 'some_renderer_name'}},
+                                                   1)
+        leaf.name(:unexpected_renderer).should == 'default_name'
+      end
+
+      it 'nil if no name defined' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first}, 1)
+        leaf.name.should == ''
+      end
+
+      it 'i18n name if @name is nil' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
+        I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return 'first'
+        leaf.name.should == 'first'
+      end
+
+      it 'i18n_name if @name is even if renderer name is sended' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
+        I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return 'first'
+        leaf.name(:renderer_name).should == 'first'
+      end
+
+      it 'i18n_name for requested renderer' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
+        I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:requested_renderer => 'requested_renderer_name'})
+        leaf.name(:requested_renderer).should == 'requested_renderer_name'
+      end
+
+      it 'default i18n_name for unexpected renderer' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
+        I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:default => 'default_name', :requested_renderer => 'requested_renderer_name'})
+        leaf.name(:unexpected_renderer).should == 'default_name'
+      end
+
+      it 'empty string if default i18n_name was not defined' do
+        leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
+        I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:requested_renderer => 'requested_renderer_name'})
+        leaf.name(:unexpected_renderer).should == ''
+      end
+
+      it 'result of proc block if name is_a? proc' do
+        leaf = SemanticNavigation::Core::Leaf.new({:name => proc{["first", "item"].join(' ')}},1)
+        leaf.name.should == "first item"
+      end
 
-    it 'should return i18n_name if @name is even if renderer name is sended' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
-      I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return 'first'
-      leaf.name(:renderer_name).should == 'first'      
     end
-
-    it 'should return i18n_name for requested renderer' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
-      I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:requested_renderer => 'requested_renderer_name'})
-      leaf.name(:requested_renderer).should == 'requested_renderer_name'
-    end
-
-    it 'should return default i18n_name for unexpected renderer' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
-      I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:default => 'default_name', :requested_renderer => 'requested_renderer_name'})
-      leaf.name(:unexpected_renderer).should == 'default_name'
-    end    
-
-    it 'should return empty string if default i18n_name was not defined' do
-      leaf = SemanticNavigation::Core::Leaf.new({:id => :first, :i18n_name => 'some_navigation'},1)
-      I18n.should_receive(:t).with("some_navigation.first", {:default => ""}).and_return({:requested_renderer => 'requested_renderer_name'})
-      leaf.name(:unexpected_renderer).should == ''      
-    end
-
-  	it 'should return result of proc block if name is_a? proc' do
-      leaf = SemanticNavigation::Core::Leaf.new({:name => proc{["first", "item"].join(' ')}},1)
-      leaf.name.should == "first item"
-  	end
-
   end
 
-  describe '#url' do	
-    it 'should return passed url' do
+  describe '#url' do
+    it 'returns passed url' do
       leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => 'controller', :action => 'action'}},1)
       leaf.url.should == {:controller => 'controller', :action => 'action'}
     end
 
-    it 'should return first url if passed array of urls' do
+    it 'returns first url if passed array of urls' do
       leaf = SemanticNavigation::Core::Leaf.new({:url => [{:controller => 'controller1', :action => 'action'},
                                                           {:controller => 'controller2', :action => 'action'}]},1)
       leaf.url.should == {:controller => 'controller1', :action => 'action'}
@@ -85,54 +88,58 @@ describe SemanticNavigation::Core::Leaf do
 
   describe '#mark_active' do
 
-  	before :each do
-  	  @view_object = mock
-  	  SemanticNavigation::Configuration.stub!(:view_object).and_return @view_object
-  	end
-  	
-  	it 'should set as active if have active url with symbol names' do
-      leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => :first, :action => :index}}, 1)
-      @view_object.stub(:params).and_return({:controller => 'first', :action => 'index'})
-      leaf.mark_active.should be_true
-      leaf.active.should be_true
-  	end
-
-  	it 'should set as active if have active url with string names' do
-      leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => "first", :action => "index"}}, 1)
-      @view_object.stub(:params).and_return({:controller => 'first', :action => 'index'})
-      leaf.mark_active.should be_true
-      leaf.active.should be_true  		
-  	end
-
-  	it 'should set as inactive if have inactive url with symbol names' do
-      leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => :first, :action => :index}}, 1)  		
-  	  @view_object.stub(:params).and_return({controller: "second", action: 'index'})
-  	  leaf.mark_active.should be_false
-  	  leaf.active.should be_false
-  	end
-
-  	it 'should set as inactive if have inactive url with string names' do
-      leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => "first", :action => "index"}}, 1)  		
-  	  @view_object.stub(:params).and_return({controller: "second", action: 'index'})
-  	  leaf.mark_active.should be_false
-  	  leaf.active.should be_false
-  	end
-
-  	it 'should set as inactive if have nil url' do
-      leaf = SemanticNavigation::Core::Leaf.new({},1)
-      leaf.mark_active.should be_false
-      leaf.active.should be_false
-  	end
-
-    it 'should be active if at least one url in passed array is active' do
-      leaf = SemanticNavigation::Core::Leaf.new({:url => [{:controller => :leaf_controller1, :action => :action},
-      	                                                  {:controller => :leaf_controller2, :action => :action}]},1)
-      @view_object.stub(:params).and_return(:controller => 'leaf_controller2', :action => 'action')
-      leaf.mark_active
-      leaf.active.should be_true
+    before :each do
+      @view_object = mock
+      SemanticNavigation::Configuration.stub!(:view_object).and_return @view_object
     end
 
-    it 'should accept array like urls with other urls' do
+    context :marked do
+
+      it 'as active if have active url with symbol names' do
+        leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => :first, :action => :index}}, 1)
+        @view_object.stub(:params).and_return({:controller => 'first', :action => 'index'})
+        leaf.mark_active.should be_true
+        leaf.active.should be_true
+      end
+
+      it 'as active if have active url with string names' do
+        leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => "first", :action => "index"}}, 1)
+        @view_object.stub(:params).and_return({:controller => 'first', :action => 'index'})
+        leaf.mark_active.should be_true
+        leaf.active.should be_true
+      end
+
+      it 'as inactive if have inactive url with symbol names' do
+        leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => :first, :action => :index}}, 1)
+        @view_object.stub(:params).and_return({controller: "second", action: 'index'})
+        leaf.mark_active.should be_false
+        leaf.active.should be_false
+      end
+
+      it 'as inactive if have inactive url with string names' do
+        leaf = SemanticNavigation::Core::Leaf.new({:url => {:controller => "first", :action => "index"}}, 1)
+        @view_object.stub(:params).and_return({controller: "second", action: 'index'})
+        leaf.mark_active.should be_false
+        leaf.active.should be_false
+      end
+
+      it 'as inactive if have nil url' do
+        leaf = SemanticNavigation::Core::Leaf.new({},1)
+        leaf.mark_active.should be_false
+        leaf.active.should be_false
+      end
+
+      it 'as active if at least one url in passed array is active' do
+        leaf = SemanticNavigation::Core::Leaf.new({:url => [{:controller => :leaf_controller1, :action => :action},
+                                                            {:controller => :leaf_controller2, :action => :action}]},1)
+        @view_object.stub(:params).and_return(:controller => 'leaf_controller2', :action => 'action')
+        leaf.mark_active
+        leaf.active.should be_true
+      end
+
+    end
+
+    it 'accepts array like urls with other urls' do
       leaf = SemanticNavigation::Core::Leaf.new({:url => [['url','with','id'],
                                                           :symbol_url_name,
                                                           {:controller => 'hash', :action => 'url'},
@@ -142,7 +149,7 @@ describe SemanticNavigation::Core::Leaf do
       leaf.should_receive(:current_page?).with({:controller => 'hash', :action => 'url'})
       leaf.should_receive(:current_page?).with("string_url")
       leaf.mark_active
-    end  	
+    end
 
   end
-end
+end