semantic_navigation 0.0.13 → 0.0.14

data/lib/semantic_navigation/twitter_bootstrap/tabs.rb

@@ -31,7 +31,7 @@ module SemanticNavigation
                           :class => merge_classes(:link, object.active, [object.link_classes,'dropdown-toggle'].flatten),
                           'data-toggle'=> :dropdown) do
             [object.ico ? content_tag(:i,nil,:class => "icon-#{object.ico}") : '',
-             object.name,
+             object_name(object),
              content_tag(:b,nil,:class => :caret)
             ].sum.html_safe                     
           end +
@@ -49,9 +49,9 @@ module SemanticNavigation
       def leaf(object)
         if object.ico
           name = [content_tag(:i,nil,:class => "icon-#{object.ico}"),
-                  object.name].sum
+                  object_name(object)].sum
         else
-          name = object.name
+          name = object_name(object)
         end
                 
         content_tag :li, nil, :id => show_id(:leaf, object.id),

data/lib/semantic_navigation/version.rb

@@ -1,3 +1,3 @@
 module SemanticNavigation
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

data/spec/lib/semantic_navigation/configuration_spec.rb

@@ -2,4 +2,157 @@ require 'spec_helper'
 
 describe SemanticNavigation::Configuration do
   
+  before :each do
+    SemanticNavigation::Configuration.class_variable_set("@@navigations",{})
+  end
+
+  describe "#run" do
+  	it 'should receive 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
+      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
+    end
+
+    it 'should pass received block to navigation class instance' do
+      navigation = mock
+      navigation.should_receive(:instance_eval)
+      SemanticNavigation::Core::Navigation.should_receive(:new).and_return navigation
+      SemanticNavigation::Configuration.navigate :some_menu do
+      	do_something
+      end
+    end
+
+    it 'should merge 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,
+      	                                                              :some_attr2 => 2})
+      SemanticNavigation::Configuration.navigate :some_menu, :some_attr => 1, :some_attr2 => 2
+    end
+  end
+
+  describe '#navigation' do
+  	it 'should return 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
+  	  proc_object = SemanticNavigation::Configuration.styles_for :some_renderer do
+  	  	do_something1 true
+  	  	do_something2 'some_attr'
+  	  end
+  	  styles = SemanticNavigation::Configuration.class_variable_get("@@render_styles")
+  	  styles[:some_renderer].should == proc_object
+
+  	  mock_renderer = mock
+  	  mock_renderer.should_receive(:do_something1).with(true)
+  	  mock_renderer.should_receive(:do_something2).with('some_attr')
+  	  mock_renderer.instance_eval &proc_object
+  	end
+  end
+
+  describe '#register_renderer' do
+    before :each do
+      class SomeRenderer; end
+    end
+
+    it 'should register 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
+      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 register 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
+      
+      class SomeClass
+        include SemanticNavigation::HelperMethods
+      end
+      some_class_instance = SomeClass.new
+      some_class_instance.should_receive(:navigation_for).with(:some_menu, {:as => :some_renderer})
+
+      some_class_instance.some_renderer_for :some_menu
+    end
+  end
+
+  describe '#render' do
+
+    before :each do 
+      @view_object = mock
+      @renderer = mock
+      @renderer_instance = mock
+      @renderer.should_receive(:new).and_return @renderer_instance
+      @navigation = mock
+
+      SemanticNavigation::Configuration.class_variable_set "@@renderers", {:renderer => @renderer}
+      SemanticNavigation::Configuration.class_variable_set "@@navigations", {:some_menu => @navigation}
+    end
+
+    it 'should send 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
+      @navigation.should_receive(:mark_active)
+      @navigation.should_receive(:render).with(@renderer_instance)
+      @renderer_instance.should_receive(:level=).with(1)
+      @renderer_instance.should_receive(:name=).with(:renderer)      
+      SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {:level => 1}, @view_object)      
+    end
+
+    it 'should exec 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)
+      @renderer_instance.should_receive(:name=).with(:renderer)      
+      @navigation.should_receive(:mark_active)
+      @navigation.should_receive(:render).with(@renderer_instance)
+      SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {}, @view_object)
+    end
+
+    it 'should set @@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)      
+      SemanticNavigation::Configuration.new.render(:some_menu, :renderer, {}, @view_object)
+      SemanticNavigation::Configuration.view_object.should == @view_object
+    end
+
+  end
+
 end

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

@@ -8,16 +8,66 @@ describe SemanticNavigation::Core::Leaf do
       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
 
+    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	

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

@@ -51,6 +51,34 @@ describe SemanticNavigation::Core::Navigation do
                       :symbolic_name,
                       ['array','like','url']]
     end
+
+    it "should receive item with Proc url and decode it to normal url (leaf)" do
+      @navigation.item :leaf_id, proc{'some' + 'func'}
+      @navigation.sub_elements.first.url.should == 'somefunc'
+    end
+
+    it 'should receive item with array of urls one of each is a Proc (leaf)' do
+      @navigation.item :leaf_id, ['string_url',proc{'some' + 'func'}]
+      urls = @navigation.sub_elements.first.send :urls
+      urls.should == ['string_url', 'somefunc']
+    end
+
+    it "should receive item with Proc url and decode it to normal url (node)" do
+      @navigation.item :leaf_id, proc{'some' + 'func'} do
+        item :first_value, '#'
+        item :second_value, '#'
+      end
+      @navigation.sub_elements.first.url.should == 'somefunc'
+    end
+
+    it 'should receive item with array of urls one of each is a Proc (node)' do
+      @navigation.item :leaf_id, ['string_url',proc{'some' + 'func'}] do
+        item :first_value, '#'
+        item :second_value, '#'
+      end
+      urls = @navigation.sub_elements.first.send :urls
+      urls.should == ['string_url', 'somefunc']
+    end 
   end
 
   describe '#header' do
@@ -117,6 +145,13 @@ describe SemanticNavigation::Core::Navigation do
       navigation = SemanticNavigation::Core::Navigation.new({:render_if => proc{false}})
       navigation.render_if.should be_false
     end
+
+    it 'should pass self to passed proc' do
+      navigation = SemanticNavigation::Core::Navigation.new({:id => :some_id, :render_if => proc{|o| o.id == :some_id}})
+      navigation.render_if.should be_true
+      navigation = SemanticNavigation::Core::Navigation.new({:id => :another_id, :render_if => proc{|o| o.id == :some_id}})
+      navigation.render_if.should be_false
+    end
   end
 
   describe '#render' do

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

@@ -4,6 +4,31 @@ describe SemanticNavigation::Core::Node do
   
   describe '#name' do
 
+    it 'should return basic name even if renderer name sended' do
+      node = SemanticNavigation::Core::Node.new({:id => :first, :name => 'first'},1)
+      node.name(:renderer_name).should == 'first'      
+    end
+
+    it 'should return the name for renderer' do
+      node = SemanticNavigation::Core::Node.new({:id => :first, 
+                                                 :name => {:some_renderer => 'some_renderer_name'}},
+                                                 1)
+      node.name(:some_renderer).should == 'some_renderer_name'
+    end
+
+    it 'should return default name for unexpected renderer' do
+      node = SemanticNavigation::Core::Node.new({:id => :first, 
+                                                 :name => {:default => 'default_name',
+                                                           :some_renderer => 'some_renderer_name'}},
+                                                 1)
+      node.name(:unexpected_renderer).should == 'default_name'
+    end
+
+    it 'should return nil if no name defined' do
+      node = SemanticNavigation::Core::Node.new({:id => :first}, 1)
+      node.name.should == ''
+    end    
+
     it 'should return passed name while creating node' do
       node = SemanticNavigation::Core::Node.new({:name => 'some name'}, 1)
       node.name.should == 'some name'

data/spec/lib/semantic_navigation/helper_methods_spec.rb

@@ -1 +1,83 @@
+require 'spec_helper'
 
+describe SemanticNavigation::HelperMethods do
+  before :each do
+    class ViewObject
+      include SemanticNavigation::HelperMethods
+    end
+    @view_instance = ViewObject.new
+  end
+
+  describe "#navigation_for" do
+
+    before :each do 
+      SemanticNavigation::Configuration.stub!(:new).and_return (@config_instance = mock)
+    end
+
+    it 'default renderer should be :list' do
+      @config_instance.should_receive(:render).with(:some_menu, :list, {}, @view_instance)
+      @view_instance.navigation_for :some_menu
+    end
+
+    it 'should send defined renderer name' do
+      @config_instance.should_receive(:render).with(:some_menu, :some_renderer, {}, @view_instance)
+      @view_instance.navigation_for :some_menu, :as => :some_renderer
+    end
+
+    it 'should send received properties' do
+      @config_instance.should_receive(:render).with(:some_menu, :some_renderer, {:level => 1, :except_for => :some_id}, @view_instance)
+      @view_instance.navigation_for :some_menu, :as => :some_renderer, :level => 1, :except_for => :some_id
+    end
+  end
+
+  describe "#active_item_for" do
+
+    it 'should return empty string if navigation is empty from items' do
+      SemanticNavigation::Configuration.navigate :some_menu do
+      end
+      result = @view_instance.active_item_for :some_menu
+      result.should be_empty
+    end
+
+    it 'should return name for an active item' do
+      SemanticNavigation::Configuration.navigate :some_menu do
+      	item :first, '/first', :name => 'First'
+      	item :second, '/second', :name => 'Second'
+  	  end
+  	  @view_instance.should_receive(:current_page?).with('/first').and_return false
+  	  @view_instance.should_receive(:current_page?).with('/second').and_return true
+  	  result = @view_instance.active_item_for :some_menu
+  	  result.should == 'Second'
+    end
+
+    it 'should return name for a last level' do
+      SemanticNavigation::Configuration.navigate :some_menu do
+      	item :first_node, '/first_node', :name => 'First node' do
+      	  item :first, '/first', :name => 'First'
+      	end
+      	item :second_node, 'second_node', :name => 'Second node' do
+      	  item :second, '/second', :name => 'Second'
+      	end
+  	  end
+  	  @view_instance.should_receive(:current_page?).exactly(4).times.and_return(false, false,true,false) # First, First node, Second, Second node
+  	  result = @view_instance.active_item_for :some_menu
+  	  result.should == 'Second'
+    end    
+
+    it 'should return name for a requested level' do
+      SemanticNavigation::Configuration.navigate :some_menu do
+      	item :first_node, '/first_node', :name => 'First node' do
+      	  item :first, '/first', :name => 'First'
+      	end
+      	item :second_node, 'second_node', :name => 'Second node' do
+      	  item :second, '/second', :name => 'Second'
+      	end
+  	  end
+  	  @view_instance.should_receive(:current_page?).exactly(4).times.and_return(false, false,true,false) # First, First node, Second, Second node
+  	  result = @view_instance.active_item_for :some_menu, 1
+  	  result.should == 'Second node'
+    end  
+
+  end
+
+end

data/spec/lib/semantic_navigation/renderers/bread_crumb_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe SemanticNavigation::Renderers::BreadCrumb do
+  before :each do
+  	class ViewObject
+  	  attr_accessor :output_buffer
+  	  include ActionView::Helpers::TagHelper
+  	  include SemanticNavigation::HelperMethods
+  	  include ActionView::Helpers::UrlHelper
+  	end
+    @configuration = SemanticNavigation::Configuration
+  	@configuration.register_renderer :breadcrumb, SemanticNavigation::Renderers::BreadCrumb
+  	@view_object = ViewObject.new
+  end
+
+  it 'should render empty ul tag for empty navigation' do
+  
+    @configuration.run do
+      navigate :menu do
+      end
+    end
+    
+    result = @view_object.navigation_for :menu, :as => :breadcrumb
+    result.should == "<ul class=\"breadcrumb\" id=\"menu\"></ul>"
+  end  
+
+  it 'should render one level navigation breadcrumb' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1'
+      	item :url2, 'url2', :name => 'url2'
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(false,true)
+
+    result = @view_object.navigation_for :menu, :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+                        "<li id=\"url2\">",
+                          "url2",
+                        "</li>",
+                      "</ul>"].join
+  end
+
+it 'should render one multilevel navigation breadcrumb' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1'
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2'
+      	end
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(true,false,false,false)
+
+    result = @view_object.navigation_for :menu, :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+                        "<li id=\"url1\">",
+                          "<a href=\"url1\" id=\"url1\">",
+                            "url1",
+                          "</a>",
+                        "</li>",
+                        "<li>/",
+                        "</li>",
+                        "<li id=\"suburl1\">",
+                          "suburl1",
+                        "</li>",
+                      "</ul>"].join
+  end  
+
+  it 'should render last item as link if :last_as_link => true' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1'
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2'
+      	end
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(true,false,false,false)
+
+    result = @view_object.navigation_for :menu, :as => :breadcrumb, :last_as_link => true
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+                        "<li id=\"url1\">",
+                          "<a href=\"url1\" id=\"url1\">",
+                            "url1",
+                          "</a>",
+                        "</li>",
+                        "<li>",
+                          "/",
+                        "</li>",
+                        "<li id=\"suburl1\">",
+                          "<a href=\"suburl1\" id=\"suburl1\">",
+                            "suburl1",
+                          "</a>",
+                        "</li>",
+                      "</ul>"].join  	
+  end
+
+  it 'should render only root level' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1'
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2'
+      	end
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(true,false,false,false)
+
+    result = @view_object.navigation_for :menu, :level => 0, :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+    	                "<li id=\"url1\">",
+    	                  "url1",
+    	                "</li>",
+                      "</ul>"].join  	
+  end
+
+  it 'should render second level' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1'
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2'
+      	end
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(true, false, false, false)
+
+    result = @view_object.navigation_for :menu, :level => 1, :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+                        "<li id=\"suburl1\">",
+                          "suburl1",
+                        "</li>",
+                      "</ul>"].join  	
+  end
+
+  it 'should render the exact levels' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1' do
+          	item :subsub1, 'subsub1', :name => 'subsub1'
+          end
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2' do
+          	item :subsub2, 'subsub2', :name => 'subsub2'
+          end
+      	end
+      end
+    end
+
+    @view_object.should_receive(:current_page?).and_return(true, false, false, false, false, false)
+
+    result = @view_object.navigation_for :menu, :levels => 0..1, :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+                        "<li id=\"url1\">",
+                          "<a href=\"url1\" id=\"url1\">",
+                            "url1",
+                          "</a>",
+                        "</li>",
+                        "<li>/",
+                        "</li>",
+                        "<li id=\"suburl1\">",
+                          "suburl1",
+                        "</li>",
+                      "</ul>"].join
+  end
+
+  it 'should render navigation except some item' do
+    @configuration.run do
+      navigate :menu do
+      	item :url1, 'url1', :name => 'url1' do
+          item :suburl1, 'suburl1', :name => 'suburl1'
+      	end
+      	item :url2, 'url2', :name => 'url2' do
+          item :suburl2, 'suburl2', :name => 'suburl2'
+      	end
+      end
+    end
+    
+    @view_object.should_receive(:current_page?).and_return(true, false, false, false)
+    result = @view_object.navigation_for :menu, :except_for => [:suburl1], :as => :breadcrumb
+    result.should == ["<ul class=\"breadcrumb\" id=\"menu\">",
+    	                  "<li id=\"url1\">",
+    	                    "url1",
+                        "</li>",
+                      "</ul>"].join  	
+  end
+end