simple-navigation 3.12.0 → 3.12.1

data/lib/simple_navigation/rendering/renderer/links.rb

@@ -1,31 +1,36 @@
 module SimpleNavigation
   module Renderer
-
-    # Renders an ItemContainer as a <div> element and its containing items as <a> elements.
+    # Renders an ItemContainer as a <div> element and its containing items as
+    # <a> elements.
     # It adds the 'selected' class to the <a> element that is currently active.
     #
-    # The Links renderer cannot be used to render nested navigations. If you would like it to use with nested navigations, you have to render each level separately.
-    #
-    # By default, the renderer sets the item's key as dom_id for the rendered <a> element unless the config option <tt>autogenerate_item_ids</tt> is set to false.
-    # The id can also be explicitely specified by setting the id in the html-options of the 'item' method in the config/navigation.rb file.
-    # The ItemContainer's dom_attributes are applied to the surrounding <div> element.
+    # The Links renderer cannot be used to render nested navigations. If you
+    # would like it to use with nested navigations, you have to render each
+    # level separately.
     #
+    # By default, the renderer sets the item's key as dom_id for the rendered
+    # <a> element unless the config option <tt>autogenerate_item_ids</tt> is set
+    # to false.
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
+    # The ItemContainer's dom_attributes are applied to the surrounding <div>
+    # element.
     class Links < SimpleNavigation::Renderer::Base
       def render(item_container)
-        div_content = item_container.items.inject([]) do |list, item|
-          list << tag_for(item)
-        end.join(join_with)
-        content_tag(:div, div_content, item_container.dom_attributes)
+        div_content = item_container.items
+                                    .map { |item| tag_for(item) }
+                                    .join(join_with)
+        content_tag :div, div_content, item_container.dom_attributes
       end
 
       protected
 
       def join_with
-        @join_with ||= options[:join_with] || ""
+        @join_with ||= options[:join_with] || ''
       end
 
       def options_for(item)
-        {:method => item.method}.merge(item.html_options)
+        { method: item.method }.merge(item.html_options)
       end
     end
   end

data/lib/simple_navigation/rendering/renderer/list.rb

@@ -1,28 +1,41 @@
 module SimpleNavigation
   module Renderer
-
-    # Renders an ItemContainer as a <ul> element and its containing items as <li> elements.
-    # It adds the 'selected' class to li element AND the link inside the li element that is currently active.
+    # Renders an ItemContainer as a <ul> element and its containing items as
+    # <li> elements.
+    # It adds the 'selected' class to li element AND the link inside the li
+    # element that is currently active.
     #
-    # If the sub navigation should be included (based on the level and expand_all options), it renders another <ul> containing the sub navigation inside the active <li> element.
+    # If the sub navigation should be included (based on the level and
+    # expand_all options), it renders another <ul> containing the sub navigation
+    # inside the active <li> element.
     #
-    # By default, the renderer sets the item's key as dom_id for the rendered <li> element unless the config option <tt>autogenerate_item_ids</tt> is set to false.
-    # The id can also be explicitely specified by setting the id in the html-options of the 'item' method in the config/navigation.rb file.
+    # By default, the renderer sets the item's key as dom_id for the rendered
+    # <li> element unless the config option <tt>autogenerate_item_ids</tt> is
+    # set to false.
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
     class List < SimpleNavigation::Renderer::Base
       def render(item_container)
-        list_content = item_container.items.inject([]) do |list, item|
-          li_options = item.html_options.reject {|k, v| k == :link}
+        if skip_if_empty? && item_container.empty?
+          ''
+        else
+          tag = options[:ordered] ? :ol : :ul
+          content = list_content(item_container)
+          content_tag(tag, content, item_container.dom_attributes)
+        end
+      end
+
+      private
+
+      def list_content(item_container)
+        item_container.items.map { |item|
+          li_options = item.html_options.except(:link)
           li_content = tag_for(item)
           if include_sub_navigation?(item)
             li_content << render_sub_navigation_for(item)
           end
-          list << content_tag(:li, li_content, li_options)
-        end.join
-        if skip_if_empty? && item_container.empty?
-          ''
-        else  
-          content_tag((options[:ordered] ? :ol : :ul), list_content, item_container.dom_attributes) 
-        end
+          content_tag(:li, li_content, li_options)
+        }.join
       end
     end
   end

data/lib/simple_navigation/rendering/renderer/text.rb

@@ -1,26 +1,21 @@
 module SimpleNavigation
   module Renderer
-    
-    # Renders the 'chain' of selected navigation items as simple text items, joined with an optional separator (similar to breadcrumbs, but without markup).
-    #
+    # Renders the 'chain' of selected navigation items as simple text items,
+    # joined with an optional separator (similar to breadcrumbs, but without
+    # markup).
     class Text < SimpleNavigation::Renderer::Base
-      
       def render(item_container)
-        list(item_container).compact.join(options[:join_with] || " ")
+        list(item_container).compact.join(options[:join_with] || ' ')
       end
 
       private
 
       def list(item_container)
-        item_container.items.inject([]) do |array, item|
-          if item.selected?
-            array + [item.name(:apply_generator => false)] + (include_sub_navigation?(item) ? list(item.sub_navigation) : [])
-          else
-            array
-          end
+        item_container.items.keep_if(&:selected?).map do |item|
+          [item.name(apply_generator: false)] +
+          (include_sub_navigation?(item) ? list(item.sub_navigation) : [])
         end
       end
-
     end
   end
 end

data/lib/simple_navigation/version.rb

@@ -1,3 +1,3 @@
 module SimpleNavigation
-  VERSION = '3.12.0'
+  VERSION = '3.12.1'
 end

data/spec/lib/simple_navigation/core/item_adapter_spec.rb

@@ -62,7 +62,7 @@ module SimpleNavigation
             end
 
             context 'and items is not empty' do
-              let(:items) { double(:items, empty?: false) }
+              let(:items) { [true] }
 
               before { item.stub(items: items) }
 

data/spec/lib/simple_navigation/core/item_container_spec.rb

@@ -2,19 +2,72 @@ require 'spec_helper'
 
 module SimpleNavigation
   describe ItemContainer do
-    let(:item_container) { ItemContainer.new }
+    subject(:item_container) { ItemContainer.new }
 
-    describe '#initialize' do
-      it 'sets the renderer to the globally-configured renderer per default' do
-        expect(Configuration.instance).to receive(:renderer)
-        ItemContainer.new
+    shared_examples 'adding the item to the list' do
+      it 'adds the item to the list' do
+        Item.stub(:new).and_return(item)
+        item_container.item(*args)
+        expect(item_container.items).to include(item)
+      end
+    end
+
+    shared_examples 'not adding the item to the list' do
+      it "doesn't add the item to the list" do
+        Item.stub(:new).and_return(item)
+        item_container.item(*args)
+        expect(item_container.items).not_to include(item)
       end
+    end
 
-      it "sets an empty items array" do
+    describe '#initialize' do
+      it 'sets an empty items array' do
         expect(item_container.items).to be_empty
       end
     end
 
+    describe '#dom_attributes' do
+      let(:dom_attributes) {{ id: 'test_id', class: 'test_class' }}
+
+      before { item_container.dom_attributes = dom_attributes }
+
+      it "returns the container's dom_attributes" do
+        expect(item_container.dom_attributes).to eq dom_attributes
+      end
+
+      context 'when the dom_attributes do not contain any id or class' do
+        let(:dom_attributes) {{ test: 'test' }}
+
+        context "and the container hasn't any dom_id" do
+          it "returns the contaier's dom_attributes without any id" do
+            expect(item_container.dom_attributes).not_to include(:id)
+          end
+        end
+
+        context 'and the container has a dom_id' do
+          before { item_container.dom_id = 'test_id' }
+
+          it "returns the contaier's dom_attributes including the #dom_id" do
+            expect(item_container.dom_attributes).to include(id: 'test_id')
+          end
+        end
+
+        context "and the container hasn't any dom_class" do
+          it "returns the contaier's dom_attributes without any class" do
+            expect(item_container.dom_attributes).not_to include(:class)
+          end
+        end
+
+        context 'and the container has a dom_class' do
+          before { item_container.dom_class = 'test_class' }
+
+          it "returns the contaier's dom_attributes including the #dom_class" do
+            expect(item_container.dom_attributes).to include(class: 'test_class')
+          end
+        end
+      end
+    end
+
     describe '#items=' do
       let(:item) { double(:item) }
       let(:items) { [item] }
@@ -31,23 +84,13 @@ module SimpleNavigation
       end
 
       context 'when item should be added' do
-        let(:simple_navigation_item) { double(:simple_navigation_item) }
+        let(:wrapped_item) { double(:wrapped_item).as_null_object }
 
-        before do
-          item_container.stub(should_add_item?: true)
-          item_adapter.stub(to_simple_navigation_item: simple_navigation_item)
-        end
+        before { ItemAdapter.stub(:new).with(item).and_return(wrapped_item) }
 
-        it 'converts the item to an Item' do
-          expect(item_adapter).to receive(:to_simple_navigation_item)
-                                  .with(item_container)
-          item_container.items = items
-        end
-
-        it 'adds the item to the items-collection' do
-          expect(item_container.items).to receive(:<<)
-                                          .with(simple_navigation_item)
+        it 'converts item to an Item and adds it to the items collection' do
           item_container.items = items
+          expect(item_container.items).to include(wrapped_item)
         end
       end
 
@@ -177,65 +220,54 @@ module SimpleNavigation
     end
 
     describe '#item' do
-      context 'when the item has no :if or :unless option' do
-        let(:options) { Hash.new }
-
-        before { item_container.stub(:should_add_item?).and_return(true) }
-
-        context 'when a block is given' do
-          let(:sub_container) { double(:sub_container) }
-          let(:block) { proc{} }
-
-          before { ItemContainer.stub(:new).with(2).and_return(sub_container) }
+      let(:options) { Hash.new }
+      let(:item) { double(:item) }
 
-          it 'yields a new ItemContainer' do
-            expect{ |blk|
-              item_container.item('key', 'name', 'url', options, &blk)
-            }.to yield_with_args(sub_container)
-          end
+      context 'when a block is given' do
+        let(:block) { proc{} }
+        let(:sub_container) { double(:sub_container) }
 
-          it "creates a new Navigation-Item with the given params and block" do
-            expect(Item).to receive(:new)
-                            .with(item_container, 'key', 'name', 'url',
-                                  options, nil, &block)
-            item_container.item('key', 'name', 'url', options, &block)
-          end
+        it 'yields a new ItemContainer' do
+          Item.any_instance
+              .stub(:sub_navigation)
+              .and_return(sub_container)
 
-          it 'adds the created item to the list of items' do
-            expect(item_container.items).to receive(:<<)
-            item_container.item('key', 'name', 'url', options) {}
-          end
+          expect{ |blk|
+            item_container.item('key', 'name', 'url', options, &blk)
+          }.to yield_with_args(sub_container)
         end
 
-        context 'when no block is given' do
-          it "creates a new Navigation_item with the given params and nil as sub_navigation" do
-            expect(Item).to receive(:new)
-                            .with(item_container, 'key', 'name', 'url', options, nil)
-            item_container.item('key', 'name', 'url', options)
-          end
+        it "creates a new Item with the given params and block" do
+          Item.stub(:new)
+              .with(item_container, 'key', 'name', 'url', options, nil, &block)
+              .and_return(item)
+          item_container.item('key', 'name', 'url', options, &block)
+          expect(item_container.items).to include(item)
+        end
 
-          it 'adds the created item to the list of items' do
-            expect(item_container.items).to receive(:<<)
-            item_container.item('key', 'name', 'url', options)
-          end
+        it 'adds the created item to the list of items' do
+          item_container.item('key', 'name', 'url', options) {}
+          expect(item_container.items).not_to include(item)
         end
       end
 
-      describe 'Optional url and optional options' do
-        shared_examples 'adding the item to the list' do
-          it 'adds the item to the list' do
-            expect(item_container.items).to receive(:<<)
-            item_container.item(*args)
-          end
+      context 'when no block is given' do
+        it 'creates a new Item with the given params and no sub navigation' do
+          Item.stub(:new)
+              .with(item_container, 'key', 'name', 'url', options, nil)
+              .and_return(item)
+          item_container.item('key', 'name', 'url', options)
+          expect(item_container.items).to include(item)
         end
 
-        shared_examples 'not adding the item to the list' do
-          it "doesn't add the item to the list" do
-            expect(item_container.items).not_to receive(:<<)
-            item_container.item(*args)
-          end
+        it 'adds the created item to the list of items' do
+          Item.stub(:new).and_return(item)
+          item_container.item('key', 'name', 'url', options) {}
+          expect(item_container.items).to include(item)
         end
+      end
 
+      describe 'Optional url and optional options' do
         context 'when item specifed without url or options' do
           it_behaves_like 'adding the item to the list' do
             let(:args) { ['key', 'name'] }
@@ -302,7 +334,7 @@ module SimpleNavigation
           context 'and it evals to true' do
             let(:condition) { true }
 
-            it 'creates a new Navigation-Item' do
+            it 'creates a new Item' do
               expect(Item).to receive(:new)
               item_container.item('key', 'name', 'url', options)
             end
@@ -311,7 +343,7 @@ module SimpleNavigation
           context 'and it evals to false' do
             let(:condition) { false }
 
-            it "doesn't create a new Navigation-Item" do
+            it "doesn't create a new Item" do
               expect(Item).not_to receive(:new)
               item_container.item('key', 'name', 'url', options)
             end
@@ -429,6 +461,24 @@ module SimpleNavigation
       end
     end
 
+    describe '#renderer' do
+      context 'when no renderer is set explicitly' do
+        it 'returns globally-configured renderer' do
+          expect(item_container.renderer).to be Configuration.instance.renderer
+        end
+      end
+
+      context 'when a renderer is set explicitly' do
+        let(:renderer) { double(:renderer) }
+
+        before { item_container.renderer = renderer }
+
+        it 'returns the specified renderer' do
+          expect(item_container.renderer).to be renderer
+        end
+      end
+    end
+
     describe '#level_for_item' do
       before(:each) do
         item_container.item(:p1, 'p1', 'p1')

data/spec/lib/simple_navigation_spec.rb

@@ -45,7 +45,7 @@ describe SimpleNavigation do
       before { subject.config_file_paths = ['my_config_file_path'] }
 
       context 'and the requested config file exists' do
-        before { File.stub(exists?: true) }
+        before { File.stub(exist?: true) }
 
         it 'returns the path to the config_file' do
           expect(subject.config_file).to eq 'my_config_file_path/navigation.rb'
@@ -53,7 +53,7 @@ describe SimpleNavigation do
       end
 
       context 'and the requested config file does not exist' do
-        before { File.stub(exists?: false) }
+        before { File.stub(exist?: false) }
 
         it 'returns nil' do
           expect(subject.config_file).to be_nil
@@ -65,7 +65,7 @@ describe SimpleNavigation do
       before { subject.config_file_paths = ['first_path', 'second_path'] }
 
       context 'and the requested config file exists' do
-        before { File.stub(exists?: true) }
+        before { File.stub(exist?: true) }
 
         it 'returns the path to the first matching config_file' do
           expect(subject.config_file).to eq 'first_path/navigation.rb'
@@ -73,7 +73,7 @@ describe SimpleNavigation do
       end
 
       context 'and the requested config file does not exist' do
-        before { File.stub(exists?: false) }
+        before { File.stub(exist?: false) }
 
         it 'returns nil' do
           expect(subject.config_file).to be_nil
@@ -196,7 +196,7 @@ describe SimpleNavigation do
       before do
         subject.config_file_path = 'path_to_config'
         IO.stub(:read).and_return('file_content')
-        File.stub(exists?: true)
+        File.stub(exist?: true)
       end
 
       after { subject.config_files = {} }
@@ -286,4 +286,15 @@ describe SimpleNavigation do
     it_behaves_like 'loading the right adapter', :padrino, :Padrino
     it_behaves_like 'loading the right adapter', :sinatra, :Sinatra
   end
+
+  describe '.init_adapter_from' do
+    let(:adapter) { double(:adapter) }
+    let(:adapter_class) { double(:adapter_class, new: adapter) }
+
+    it 'sets the adapter to a new instance of adapter_class' do
+      subject.adapter_class = adapter_class
+      subject.init_adapter_from(:default)
+      expect(subject.adapter).to be adapter
+    end
+  end
 end