simple-navigation 4.4.1 → 4.5.0

data/spec/simple_navigation/items_provider_spec.rb

@@ -1,43 +1,46 @@
-module SimpleNavigation
-  describe ItemsProvider do
-    let(:items_provider) { ItemsProvider.new(provider) }
+# frozen_string_literal: true
 
-    describe '#items' do
-      let(:items) { double(:items) }
+RSpec.describe SimpleNavigation::ItemsProvider do
+  let(:items_provider) { described_class.new(provider) }
 
-      context 'when provider is a symbol' do
-        let(:context) { double(:context, provider_method: items) }
-        let(:provider) { :provider_method }
+  describe '#items' do
+    let(:items) { double(:items) }
 
-        before { allow(SimpleNavigation).to receive_messages(context_for_eval: context) }
+    context 'when provider is a symbol' do
+      let(:context) { double(:context, provider_method: items) }
+      let(:provider) { :provider_method }
 
-        it 'retrieves the items from the evaluation context' do
-          expect(items_provider.items).to eq items
-        end
+      before { allow(SimpleNavigation).to receive_messages(context_for_eval: context) }
+
+      it 'retrieves the items from the evaluation context' do
+        expect(items_provider.items).to eq items
       end
+    end
 
-      context 'when provider responds to :items' do
-        let(:provider) { double(:provider, items: items) }
+    context 'when provider responds to :items' do
+      let(:provider) { double(:provider, items: items) }
 
-        it 'retrieves the items from the provider object' do
-          expect(items_provider.items).to eq items
-        end
+      it 'retrieves the items from the provider object' do
+        expect(items_provider.items).to eq items
       end
+    end
 
-      context 'provider is a collection' do
-        let(:provider) { [] }
+    context 'when provider is a collection' do
+      let(:provider) { [] }
 
-        it 'retrieves the items by returning the provider' do
-          expect(items_provider.items).to eq provider
-        end
+      it 'retrieves the items by returning the provider' do
+        expect(items_provider.items).to eq provider
       end
+    end
 
-      context 'when provider is something else' do
-        let(:provider) { double(:provider) }
+    context 'when provider is something else' do
+      let(:provider) { double(:provider) }
 
-        it 'raises an exception' do
-          expect{ items_provider.items }.to raise_error(RuntimeError, /items_provider either must be a symbol .*, an object .* or an enumerable/)
-        end
+      it 'raises an exception' do
+        expect do
+          items_provider.items
+        end.to raise_error(RuntimeError,
+                           /items_provider either must be a symbol .*, an object .* or an enumerable/)
       end
     end
   end

data/spec/simple_navigation/renderer/base_spec.rb

@@ -1,238 +1,236 @@
-module SimpleNavigation
-  module Renderer
-    describe Base do
-      subject(:base) { Base.new(options) }
+# frozen_string_literal: true
 
-      let(:adapter) { double(:adapter) }
-      let(:options) { Hash.new }
+RSpec.describe SimpleNavigation::Renderer::Base do
+  subject(:base) { described_class.new(options) }
 
-      before { allow(SimpleNavigation).to receive_messages(adapter: adapter) }
+  let(:adapter) { double(:adapter) }
+  let(:options) { {} }
 
-      it 'delegates the :link_to method to adapter' do
-        allow(adapter).to receive_messages(link_to: 'link_to')
-        expect(base.link_to).to eq 'link_to'
-      end
-
-      it 'delegates the :content_tag method to adapter' do
-        allow(adapter).to receive_messages(content_tag: 'content_tag')
-        expect(base.content_tag).to eq 'content_tag'
-      end
+  before { allow(SimpleNavigation).to receive_messages(adapter: adapter) }
 
-      describe '#initialize' do
-        it "sets the renderer adapter to the SimpleNavigation one" do
-          expect(base.adapter).to be adapter
-        end
-      end
+  it 'delegates the :link_to method to adapter' do
+    allow(adapter).to receive_messages(link_to: 'link_to')
+    expect(base.link_to).to eq 'link_to'
+  end
 
-      describe '#options' do
-        it "returns the renderer's options" do
-          expect(base.options).to be options
-        end
-      end
+  it 'delegates the :content_tag method to adapter' do
+    allow(adapter).to receive_messages(content_tag: 'content_tag')
+    expect(base.content_tag).to eq 'content_tag'
+  end
 
-      describe '#render' do
-        it "raise an exception to indicate it's a subclass responsibility" do
-          expect{ base.render(:container) }.to raise_error(NotImplementedError, 'subclass responsibility')
-        end
-      end
+  describe '#initialize' do
+    it 'sets the renderer adapter to the SimpleNavigation one' do
+      expect(base.adapter).to be adapter
+    end
+  end
 
-      describe '#expand_all?' do
-        context 'when :options is set' do
-          context 'and the :expand_all option is true' do
-            let(:options) {{ expand_all: true }}
+  describe '#options' do
+    it "returns the renderer's options" do
+      expect(base.options).to be options
+    end
+  end
 
-            it 'returns true' do
-              expect(base.expand_all?).to be true
-            end
-          end
+  describe '#render' do
+    it "raise an exception to indicate it's a subclass responsibility" do
+      expect { base.render(:container) }.to raise_error(NotImplementedError, 'subclass responsibility')
+    end
+  end
 
-          context 'and the :expand_all option is false' do
-            let(:options) {{ expand_all: false }}
+  describe '#expand_all?' do
+    context 'when :options is set' do
+      context 'when the :expand_all option is true' do
+        let(:options) { { expand_all: true } }
 
-            it 'returns false' do
-              expect(base.expand_all?).to be false
-            end
-          end
+        it 'returns true' do
+          expect(base.expand_all?).to be true
         end
+      end
 
-        context "when :options isn't set" do
-          let(:options) { Hash.new }
+      context 'when the :expand_all option is false' do
+        let(:options) { { expand_all: false } }
 
-          it 'returns false' do
-            expect(base.expand_all?).to be false
-          end
+        it 'returns false' do
+          expect(base.expand_all?).to be false
         end
       end
+    end
 
-      describe '#skip_if_empty?' do
-        context 'when :options is set' do
-          context 'and the :skip_if_empty option is true' do
-            let(:options) {{ skip_if_empty: true }}
+    context "when :options isn't set" do
+      let(:options) { {} }
 
-            it 'returns true' do
-              expect(base.skip_if_empty?).to be true
-            end
-          end
+      it 'returns false' do
+        expect(base.expand_all?).to be false
+      end
+    end
+  end
 
-          context 'and the :skip_if_empty option is false' do
-            let(:options) {{ skip_if_empty: false }}
+  describe '#skip_if_empty?' do
+    context 'when :options is set' do
+      context 'when the :skip_if_empty option is true' do
+        let(:options) { { skip_if_empty: true } }
 
-            it 'returns true' do
-              expect(base.skip_if_empty?).to be false
-            end
-          end
+        it 'returns true' do
+          expect(base.skip_if_empty?).to be true
         end
+      end
 
-        context "when :options isn't set" do
-          let(:options) { Hash.new }
+      context 'when the :skip_if_empty option is false' do
+        let(:options) { { skip_if_empty: false } }
 
-          it 'returns true' do
-            expect(base.skip_if_empty?).to be false
-          end
+        it 'returns true' do
+          expect(base.skip_if_empty?).to be false
         end
       end
+    end
 
-      describe '#level' do
-        context 'and the :level option is set' do
-          let(:options) {{ level: 1 }}
+    context "when :options isn't set" do
+      let(:options) { {} }
 
-          it 'returns the specified level' do
-            expect(base.level).to eq 1
-          end
-        end
+      it 'returns true' do
+        expect(base.skip_if_empty?).to be false
+      end
+    end
+  end
 
-        context "and the :level option isn't set" do
-          let(:options) { Hash.new }
+  describe '#level' do
+    context 'when the :level option is set' do
+      let(:options) { { level: 1 } }
 
-          it 'returns :all' do
-            expect(base.level).to eq :all
-          end
-        end
+      it 'returns the specified level' do
+        expect(base.level).to eq 1
       end
+    end
 
-      describe '#consider_sub_navigation?' do
-        let(:item) { double(:item) }
+    context "when the :level option isn't set" do
+      let(:options) { {} }
 
-        before { allow(item).to receive_messages(sub_navigation: sub_navigation) }
+      it 'returns :all' do
+        expect(base.level).to eq :all
+      end
+    end
+  end
 
-        context 'when the item has no sub navigation' do
-          let(:sub_navigation) { nil }
+  describe '#consider_sub_navigation?' do
+    let(:item) { double(:item) }
 
-          it 'returns false' do
-            expect(base.send(:consider_sub_navigation?, item)).to be false
-          end
-        end
+    before { allow(item).to receive_messages(sub_navigation: sub_navigation) }
 
-        context 'when the item has sub navigation' do
-          let(:sub_navigation) { double(:sub_navigation) }
+    context 'when the item has no sub navigation' do
+      let(:sub_navigation) { nil }
 
-          context 'and the renderer has an unknown level' do
-            before { allow(base).to receive_messages(level: 'unknown') }
+      it 'returns false' do
+        expect(base.send(:consider_sub_navigation?, item)).to be false
+      end
+    end
 
-            it 'returns false' do
-              expect(base.send(:consider_sub_navigation?, item)).to be false
-            end
-          end
+    context 'when the item has sub navigation' do
+      let(:sub_navigation) { double(:sub_navigation) }
 
-          context 'and the renderer has a level set to :all' do
-            before { allow(base).to receive_messages(level: :all) }
+      context 'when the renderer has an unknown level' do
+        before { allow(base).to receive_messages(level: 'unknown') }
 
-            it 'returns false' do
-              expect(base.send(:consider_sub_navigation?, item)).to be true
-            end
-          end
+        it 'returns false' do
+          expect(base.send(:consider_sub_navigation?, item)).to be false
+        end
+      end
 
-          context "when the renderer's level is a number" do
-            before { allow(base).to receive_messages(level: 2) }
+      context 'when the renderer has a level set to :all' do
+        before { allow(base).to receive_messages(level: :all) }
 
-            it 'returns false' do
-              expect(base.send(:consider_sub_navigation?, item)).to be false
-            end
-          end
+        it 'returns false' do
+          expect(base.send(:consider_sub_navigation?, item)).to be true
+        end
+      end
 
-          context "when the renderer's level is a Range" do
-            before { allow(base).to receive_messages(level: 2..3) }
+      context "when the renderer's level is a number" do
+        before { allow(base).to receive_messages(level: 2) }
 
-            context "and sub navigation's level is greater than range.max" do
-              before { allow(sub_navigation).to receive_messages(level: 4) }
+        it 'returns false' do
+          expect(base.send(:consider_sub_navigation?, item)).to be false
+        end
+      end
 
-              it 'returns false' do
-                expect(base.send(:consider_sub_navigation?, item)).to be false
-              end
-            end
+      context "when the renderer's level is a Range" do
+        before { allow(base).to receive_messages(level: 2..3) }
 
-            context "and sub navigation's level is equal to range.max" do
-              before { allow(sub_navigation).to receive_messages(level: 3) }
+        context "when sub navigation's level is greater than range.max" do
+          before { allow(sub_navigation).to receive_messages(level: 4) }
 
-              it 'returns true' do
-                expect(base.send(:consider_sub_navigation?, item)).to be true
-              end
-            end
+          it 'returns false' do
+            expect(base.send(:consider_sub_navigation?, item)).to be false
+          end
+        end
 
-            context "and sub navigation's level is equal to range.min" do
-              before { allow(sub_navigation).to receive_messages(level: 2) }
+        context "when sub navigation's level is equal to range.max" do
+          before { allow(sub_navigation).to receive_messages(level: 3) }
 
-              it 'returns true' do
-                expect(base.send(:consider_sub_navigation?, item)).to be true
-              end
-            end
+          it 'returns true' do
+            expect(base.send(:consider_sub_navigation?, item)).to be true
           end
         end
-      end
 
-      describe '#include_sub_navigation?' do
-        let(:item) { double(:item) }
+        context "when sub navigation's level is equal to range.min" do
+          before { allow(sub_navigation).to receive_messages(level: 2) }
 
-        context 'when consider_sub_navigation? is true' do
-          before { allow(base).to receive_messages(consider_sub_navigation?: true) }
+          it 'returns true' do
+            expect(base.send(:consider_sub_navigation?, item)).to be true
+          end
+        end
+      end
+    end
+  end
 
-          context 'and expand_sub_navigation? is true' do
-            before { allow(base).to receive_messages(expand_sub_navigation?: true) }
+  describe '#include_sub_navigation?' do
+    let(:item) { double(:item) }
 
-            it 'returns true' do
-              expect(base.include_sub_navigation?(item)).to be true
-            end
-          end
+    context 'when consider_sub_navigation? is true' do
+      before { allow(base).to receive_messages(consider_sub_navigation?: true) }
 
-          context 'and expand_sub_navigation? is false' do
-            before { allow(base).to receive_messages(expand_sub_navigation?: false) }
+      context 'when expand_sub_navigation? is true' do
+        before { allow(base).to receive_messages(expand_sub_navigation?: true) }
 
-            it 'returns false' do
-              expect(base.include_sub_navigation?(item)).to be false
-            end
-          end
+        it 'returns true' do
+          expect(base.include_sub_navigation?(item)).to be true
         end
+      end
 
-        context 'consider_sub_navigation? is false' do
-          before { allow(base).to receive_messages(consider_sub_navigation?: false) }
+      context 'when expand_sub_navigation? is false' do
+        before { allow(base).to receive_messages(expand_sub_navigation?: false) }
 
-          context 'and expand_sub_navigation? is true' do
-            before { allow(base).to receive_messages(expand_sub_navigation?: true) }
+        it 'returns false' do
+          expect(base.include_sub_navigation?(item)).to be false
+        end
+      end
+    end
 
-            it 'returns false' do
-              expect(base.include_sub_navigation?(item)).to be false
-            end
-          end
+    context 'when consider_sub_navigation? is false' do
+      before { allow(base).to receive_messages(consider_sub_navigation?: false) }
 
-          context 'and expand_sub_navigation? is false' do
-            before { allow(base).to receive_messages(expand_sub_navigation?: false) }
+      context 'when expand_sub_navigation? is true' do
+        before { allow(base).to receive_messages(expand_sub_navigation?: true) }
 
-            it 'returns false' do
-              expect(base.include_sub_navigation?(item)).to be false
-            end
-          end
+        it 'returns false' do
+          expect(base.include_sub_navigation?(item)).to be false
         end
       end
 
-      describe '#render_sub_navigation_for' do
-        let(:item) { double(:item, sub_navigation: sub_navigation) }
-        let(:sub_navigation) { double(:sub_navigation) }
+      context 'when expand_sub_navigation? is false' do
+        before { allow(base).to receive_messages(expand_sub_navigation?: false) }
 
-        it 'renders the sub navigation passing it the options' do
-          expect(sub_navigation).to receive(:render).with(options)
-          base.render_sub_navigation_for(item)
+        it 'returns false' do
+          expect(base.include_sub_navigation?(item)).to be false
         end
       end
     end
   end
+
+  describe '#render_sub_navigation_for' do
+    let(:item) { double(:item, sub_navigation: sub_navigation) }
+    let(:sub_navigation) { double(:sub_navigation) }
+
+    it 'renders the sub navigation passing it the options' do
+      expect(sub_navigation).to receive(:render).with(options)
+      base.render_sub_navigation_for(item)
+    end
+  end
 end