simple-navigation 4.4.1 → 4.5.0

data/spec/simple_navigation/adapters/rails_spec.rb

@@ -1,281 +1,274 @@
-module SimpleNavigation
-  module Adapters
-    describe Rails do
-      let(:action_controller) { ActionController::Base }
-      let(:adapter) { Rails.new(context) }
-      let(:context) { double(:context, controller: controller) }
-      let(:controller) { double(:controller) }
-      let(:request) { double(:request) }
-      let(:simple_navigation) { SimpleNavigation }
-      let(:template) { double(:template, request: request) }
-
-      describe '.register' do
-        before { allow(action_controller).to receive(:include) }
-
-        it 'calls set_env' do
-          app_path = RailsApp::Application.root
-          expect(simple_navigation).to receive(:set_env).with(app_path, 'test')
-          simple_navigation.register
-        end
+# frozen_string_literal: true
+
+RSpec.describe SimpleNavigation::Adapters::Rails do
+  let(:action_controller) { ActionController::Base }
+  let(:adapter) { described_class.new(context) }
+  let(:context) { double(:context, controller: controller) }
+  let(:controller) { double(:controller) }
+  let(:request) { double(:request) }
+  let(:simple_navigation) { SimpleNavigation }
+  let(:template) { double(:template, request: request) }
+
+  describe '.register' do
+    before { allow(action_controller).to receive(:include) }
+
+    it 'calls set_env' do
+      app_path = RailsApp::Application.root
+      expect(simple_navigation).to receive(:set_env).with(app_path, 'test')
+      simple_navigation.register
+    end
 
-        it 'extends the ActionController::Base with the Helpers' do
-          expect(action_controller).to receive(:include)
-                                       .with(SimpleNavigation::Helpers)
-          simple_navigation.register
-        end
+    it 'extends the ActionController::Base with the Helpers' do
+      expect(action_controller).to receive(:include).with(SimpleNavigation::Helpers)
+      simple_navigation.register
+    end
 
-        shared_examples 'installing helper method' do |method|
-          it "installs the #{method} method as helper method" do
-            simple_navigation.register
+    shared_examples 'installing helper method' do |method|
+      it "installs the #{method} method as helper method" do
+        simple_navigation.register
 
-            helper_methods = action_controller.send(:_helper_methods)
-            expect(helper_methods).to include(method)
-          end
-        end
-
-        it_behaves_like 'installing helper method', :render_navigation
-        it_behaves_like 'installing helper method', :active_navigation_item_name
-        it_behaves_like 'installing helper method', :active_navigation_item_key
-        it_behaves_like 'installing helper method', :active_navigation_item
-        it_behaves_like 'installing helper method', :active_navigation_item_container
+        helper_methods = action_controller.send(:_helper_methods)
+        expect(helper_methods).to include(method)
       end
+    end
 
-      describe '#initialize' do
-        context "when the controller's template is set" do
-          before { allow(controller).to receive_messages(instance_variable_get: template) }
-
-          it "sets the adapter's request accordingly" do
-            expect(adapter.request).to be request
-          end
-        end
+    it_behaves_like 'installing helper method', :render_navigation
+    it_behaves_like 'installing helper method', :active_navigation_item_name
+    it_behaves_like 'installing helper method', :active_navigation_item_key
+    it_behaves_like 'installing helper method', :active_navigation_item
+    it_behaves_like 'installing helper method', :active_navigation_item_container
+  end
 
-        context "when the controller's template is not set" do
-          before { allow(controller).to receive_messages(instance_variable_get: nil) }
+  describe '#initialize' do
+    context "when the controller's template is set" do
+      before { allow(controller).to receive_messages(instance_variable_get: template) }
 
-          it "sets the adapter's request to nil" do
-            expect(adapter.request).to be_nil
-          end
-        end
+      it "sets the adapter's request accordingly" do
+        expect(adapter.request).to be request
+      end
+    end
 
-        it "sets the adapter's controller to the context's controller" do
-          expect(adapter.controller).to be controller
-        end
+    context "when the controller's template is not set" do
+      before { allow(controller).to receive_messages(instance_variable_get: nil) }
 
-        context "when the controller's template is stored as instance var (Rails2)" do
-          context "when the controller's template is set" do
-            before { allow(controller).to receive_messages(instance_variable_get: template) }
+      it "sets the adapter's request to nil" do
+        expect(adapter.request).to be_nil
+      end
+    end
 
-            it "sets the adapter's template accordingly" do
-              expect(adapter.template).to be template
-            end
-          end
+    it "sets the adapter's controller to the context's controller" do
+      expect(adapter.controller).to be controller
+    end
 
-          context "when the controller's template is not set" do
-            before { allow(controller).to receive_messages(instance_variable_get: nil) }
+    context "when the controller's template is stored as instance var (Rails2)" do
+      context "when the controller's template is set" do
+        before { allow(controller).to receive_messages(instance_variable_get: template) }
 
-            it "set the adapter's template to nil" do
-              expect(adapter.template).to be_nil
-            end
-          end
+        it "sets the adapter's template accordingly" do
+          expect(adapter.template).to be template
         end
+      end
 
-        context "when the controller's template is stored as view_context (Rails3)" do
-          context 'and the template is set' do
-            before { allow(controller).to receive_messages(view_context: template) }
+      context "when the controller's template is not set" do
+        before { allow(controller).to receive_messages(instance_variable_get: nil) }
 
-            it "sets the adapter's template accordingly" do
-              expect(adapter.template).to be template
-            end
-          end
+        it "set the adapter's template to nil" do
+          expect(adapter.template).to be_nil
+        end
+      end
+    end
 
-          context 'and the template is not set' do
-            before { allow(controller).to receive_messages(view_context: nil) }
+    context "when the controller's template is stored as view_context (Rails3)" do
+      context 'when the template is set' do
+        before { allow(controller).to receive_messages(view_context: template) }
 
-            it "sets the adapter's template to nil" do
-              expect(adapter.template).to be_nil
-            end
-          end
+        it "sets the adapter's template accordingly" do
+          expect(adapter.template).to be template
         end
       end
 
-      describe '#request_uri' do
-        context "when the adapter's request is set" do
-          before { allow(adapter).to receive_messages(request: request) }
+      context 'when the template is not set' do
+        before { allow(controller).to receive_messages(view_context: nil) }
 
-          context 'and request.fullpath is defined' do
-            let(:request) { double(:request, fullpath: '/fullpath') }
-
-            it "sets the adapter's request_uri to the request.fullpath" do
-              expect(adapter.request_uri).to eq '/fullpath'
-            end
-          end
+        it "sets the adapter's template to nil" do
+          expect(adapter.template).to be_nil
+        end
+      end
+    end
+  end
 
-          context 'and request.fullpath is not defined' do
-            let(:request) { double(:request, request_uri: '/request_uri') }
+  describe '#request_uri' do
+    context "when the adapter's request is set" do
+      before { allow(adapter).to receive_messages(request: request) }
 
-            before { allow(adapter).to receive_messages(request: request) }
+      context 'when request.fullpath is defined' do
+        let(:request) { double(:request, fullpath: '/fullpath') }
 
-            it "sets the adapter's request_uri to the request.request_uri" do
-              expect(adapter.request_uri).to eq '/request_uri'
-            end
-          end
+        it "sets the adapter's request_uri to the request.fullpath" do
+          expect(adapter.request_uri).to eq '/fullpath'
         end
+      end
 
-        context "when the adapter's request is not set" do
-          before { allow(adapter).to receive_messages(request: nil) }
+      context 'when request.fullpath is not defined' do
+        let(:request) { double(:request, request_uri: '/request_uri') }
 
-          it "sets the adapter's request_uri to an empty string" do
-            expect(adapter.request_uri).to eq ''
-          end
+        before { allow(adapter).to receive_messages(request: request) }
+
+        it "sets the adapter's request_uri to the request.request_uri" do
+          expect(adapter.request_uri).to eq '/request_uri'
         end
       end
+    end
 
-      describe '#request_path' do
-        context "when the adapter's request is set" do
-          let(:request) { double(:request, path: '/request_path') }
+    context "when the adapter's request is not set" do
+      before { allow(adapter).to receive_messages(request: nil) }
 
-          before { allow(adapter).to receive_messages(request: request) }
+      it "sets the adapter's request_uri to an empty string" do
+        expect(adapter.request_uri).to eq ''
+      end
+    end
+  end
 
-          it "sets the adapter's request_path to the request.path" do
-            expect(adapter.request_path).to eq '/request_path'
-          end
-        end
+  describe '#request_path' do
+    context "when the adapter's request is set" do
+      let(:request) { double(:request, path: '/request_path') }
 
-        context "when the adapter's request is not set" do
-          before { allow(adapter).to receive_messages(request: nil) }
+      before { allow(adapter).to receive_messages(request: request) }
 
-          it "sets the adapter's request_path to an empty string" do
-            expect(adapter.request_path).to eq ''
-          end
-        end
+      it "sets the adapter's request_path to the request.path" do
+        expect(adapter.request_path).to eq '/request_path'
       end
+    end
 
-      describe '#context_for_eval' do
-        context "when the adapter's controller is set" do
-          before { adapter.instance_variable_set(:@controller, controller) }
+    context "when the adapter's request is not set" do
+      before { allow(adapter).to receive_messages(request: nil) }
 
-          context "and the adapter's template is set" do
-            before { adapter.instance_variable_set(:@template, template) }
+      it "sets the adapter's request_path to an empty string" do
+        expect(adapter.request_path).to eq ''
+      end
+    end
+  end
 
-            it "sets the adapter's context_for_eval to the template" do
-              expect(adapter.context_for_eval).to be template
-            end
-          end
+  describe '#context_for_eval' do
+    context "when the adapter's controller is set" do
+      before { adapter.instance_variable_set(:@controller, controller) }
 
-          context "and the adapter's template is not set" do
-            before { adapter.instance_variable_set(:@template, nil) }
+      context "when the adapter's template is set" do
+        before { adapter.instance_variable_set(:@template, template) }
 
-            it "sets the adapter's context_for_eval to the controller" do
-              expect(adapter.context_for_eval).to be controller
-            end
-          end
+        it "sets the adapter's context_for_eval to the template" do
+          expect(adapter.context_for_eval).to be template
         end
+      end
 
-        context "when the adapter's controller is not set" do
-          before { adapter.instance_variable_set(:@controller, nil) }
+      context "when the adapter's template is not set" do
+        before { adapter.instance_variable_set(:@template, nil) }
 
-          context "and the adapter's template is set" do
-            before { adapter.instance_variable_set(:@template, template) }
+        it "sets the adapter's context_for_eval to the controller" do
+          expect(adapter.context_for_eval).to be controller
+        end
+      end
+    end
 
-            it "sets the adapter's context_for_eval to the template" do
-              expect(adapter.context_for_eval).to be template
-            end
-          end
+    context "when the adapter's controller is not set" do
+      before { adapter.instance_variable_set(:@controller, nil) }
 
-          context "and the adapter's template is not set" do
-            before { adapter.instance_variable_set(:@template, nil) }
+      context "when the adapter's template is set" do
+        before { adapter.instance_variable_set(:@template, template) }
 
-            it 'raises an exception' do
-              expect{ adapter.context_for_eval }.to raise_error(RuntimeError, 'no context set for evaluation the config file')
-            end
-          end
+        it "sets the adapter's context_for_eval to the template" do
+          expect(adapter.context_for_eval).to be template
         end
       end
 
-      describe '#current_page?' do
-        context "when the adapter's template is set" do
-          before { allow(adapter).to receive_messages(template: template) }
+      context "when the adapter's template is not set" do
+        before { adapter.instance_variable_set(:@template, nil) }
 
-          it 'delegates the call to the template' do
-            expect(template).to receive(:current_page?).with(:page)
-            adapter.current_page?(:page)
-          end
+        it 'raises an exception' do
+          expect do
+            adapter.context_for_eval
+          end.to raise_error(RuntimeError, 'no context set for evaluation the config file')
         end
+      end
+    end
+  end
 
-        context "when the adapter's template is not set" do
-          before { allow(adapter).to receive_messages(template: nil) }
-
-          it 'returns false' do
-            expect(adapter.current_page?(:page)).to be_falsey
-          end
-        end
+  describe '#current_page?' do
+    context "when the adapter's template is set" do
+      before { allow(adapter).to receive_messages(template: template) }
 
-        context 'when the given url is nil' do
-          it 'returns false' do
-            expect(adapter.current_page?(nil)).to be_falsey
-          end
-        end
+      it 'delegates the call to the template' do
+        expect(template).to receive(:current_page?).with(:page)
+        adapter.current_page?(:page)
       end
+    end
 
-      describe '#link_to' do
-        let(:options) { double(:options) }
+    context "when the adapter's template is not set" do
+      before { allow(adapter).to receive_messages(template: nil) }
 
-        context "when the adapter's template is set" do
-          before { allow(adapter).to receive_messages(template: template, html_safe: 'safe_text') }
+      it 'returns false' do
+        expect(adapter).not_to be_current_page(:page)
+      end
+    end
 
-          context 'with considering item names as safe' do
-            before { SimpleNavigation.config.consider_item_names_as_safe = true }
-            after { SimpleNavigation.config.consider_item_names_as_safe = false }
+    context 'when the given url is nil' do
+      it 'returns false' do
+        expect(adapter).not_to be_current_page(nil)
+      end
+    end
+  end
 
-            it 'delegates the call to the template (with html_safe text)' do
-              expect(template).to receive(:link_to)
-                                  .with('safe_text', 'url', options)
-              adapter.link_to('text', 'url', options)
-            end
-          end
+  describe '#link_to' do
+    let(:options) { double(:options) }
 
-          context 'with considering item names as UNsafe (default)' do
+    context "when the adapter's template is set" do
+      before { allow(adapter).to receive_messages(template: template, html_safe: 'safe_text') }
 
-            it 'delegates the call to the template (with html_safe text)' do
-              expect(template).to receive(:link_to)
-                                  .with('text', 'url', options)
-              adapter.link_to('text', 'url', options)
-            end
-          end
+      context 'with considering item names as safe' do
+        before { SimpleNavigation.config.consider_item_names_as_safe = true }
+        after { SimpleNavigation.config.consider_item_names_as_safe = false }
 
+        it 'delegates the call to the template (with html_safe text)' do
+          expect(template).to receive(:link_to).with('safe_text', 'url', options)
+          adapter.link_to('text', 'url', options)
         end
+      end
 
-        context "when the adapter's template is not set" do
-          before { allow(adapter).to receive_messages(template: nil) }
-
-          it 'returns nil' do
-            expect(adapter.link_to('text', 'url', options)).to be_nil
-          end
+      context 'with considering item names as UNsafe (default)' do
+        it 'delegates the call to the template (with html_safe text)' do
+          expect(template).to receive(:link_to).with('text', 'url', options)
+          adapter.link_to('text', 'url', options)
         end
       end
+    end
 
-      describe '#content_tag' do
-        let(:options) { double(:options) }
+    context "when the adapter's template is not set" do
+      before { allow(adapter).to receive_messages(template: nil) }
 
-        context "when the adapter's template is set" do
-          before { allow(adapter).to receive_messages(template: template, html_safe: 'safe_text') }
+      it 'returns nil' do
+        expect(adapter.link_to('text', 'url', options)).to be_nil
+      end
+    end
+  end
 
-          it 'delegates the call to the template (with html_safe text)' do
-            expect(template).to receive(:content_tag)
-                                .with(:div, 'safe_text', options)
-            adapter.content_tag(:div, 'text', options)
-          end
-        end
+  describe '#content_tag' do
+    let(:options) { double(:options) }
 
-        context "when the adapter's template is not set" do
-          before { allow(adapter).to receive_messages(template: nil) }
+    context "when the adapter's template is set" do
+      before { allow(adapter).to receive_messages(template: template, html_safe: 'safe_text') }
 
-          it 'returns nil' do
-            expect(adapter.content_tag(:div, 'text', options)).to be_nil
-          end
-        end
+      it 'delegates the call to the template (with html_safe text)' do
+        expect(template).to receive(:content_tag).with(:div, 'safe_text', options)
+        adapter.content_tag(:div, 'text', options)
       end
+    end
 
+    context "when the adapter's template is not set" do
+      before { allow(adapter).to receive_messages(template: nil) }
+
+      it 'returns nil' do
+        expect(adapter.content_tag(:div, 'text', options)).to be_nil
+      end
     end
   end
 end

data/spec/simple_navigation/adapters/sinatra_spec.rb

@@ -1,15 +1,32 @@
-describe SimpleNavigation::Adapters::Sinatra do
-  let(:adapter) { SimpleNavigation::Adapters::Sinatra.new(context) }
+# frozen_string_literal: true
+
+RSpec.describe SimpleNavigation::Adapters::Sinatra do
+  let(:adapter) { described_class.new(context) }
   let(:context) { double(:context) }
   let(:request) { double(:request, fullpath: '/full?param=true', path: '/full') }
 
   before { allow(context).to receive_messages(request: request) }
 
+  describe '.register' do
+    let(:sinatra_app) { double(:app, root: '/sinatra/root', environment: 'test') }
+
+    before do
+      allow(SimpleNavigation).to receive(:set_env)
+    end
+
+    it 'calls SimpleNavigation.set_env with app root and environment' do
+      expect(SimpleNavigation).to receive(:set_env).with('/sinatra/root', 'test')
+      described_class.register(sinatra_app)
+    end
+  end
+
   describe '#context_for_eval' do
     context "when adapter's context is not set" do
       it 'raises an exception' do
         allow(adapter).to receive_messages(context: nil)
-        expect{ adapter.context_for_eval }.to raise_error(RuntimeError, 'no context set for evaluation the config file')
+        expect do
+          adapter.context_for_eval
+        end.to raise_error(RuntimeError, 'no context set for evaluation the config file')
       end
     end
 
@@ -57,8 +74,7 @@ describe SimpleNavigation::Adapters::Sinatra do
 
     context 'when URL is encoded' do
       before do
-        allow(request).to receive_messages(fullpath: '/full%20with%20spaces?param=true',
-                     path: '/full%20with%20spaces')
+        allow(request).to receive_messages(fullpath: '/full%20with%20spaces?param=true', path: '/full%20with%20spaces')
       end
 
       it_behaves_like 'detecting current page', '/full%20with%20spaces?param=true', true

data/spec/simple_navigation/config_file_finder_spec.rb

@@ -1,48 +1,52 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'simple_navigation/config_file_finder'
 
-module SimpleNavigation
-  describe ConfigFileFinder do
-    subject(:finder) { ConfigFileFinder.new(paths) }
+RSpec.describe SimpleNavigation::ConfigFileFinder do
+  subject(:finder) { described_class.new(paths) }
 
-    let(:paths) { ['/path/one', '/path/two'] }
+  let(:paths) { ['/path/one', '/path/two'] }
 
-    describe '#find', memfs: true do
-      before { FileUtils.mkdir_p(paths) }
+  describe '#find', :memfs do
+    before { FileUtils.mkdir_p(paths) }
 
-      context 'when the context is :default' do
-        let(:context) { :default }
+    context 'when the context is :default' do
+      let(:context) { :default }
 
-        context 'and a navigation.rb file is found in one of the paths' do
-          before { FileUtils.touch('/path/one/navigation.rb') }
+      context 'when a navigation.rb file is found in one of the paths' do
+        before { FileUtils.touch('/path/one/navigation.rb') }
 
-          it 'returns its full path' do
-            expect(finder.find(context)).to eq '/path/one/navigation.rb'
-          end
+        it 'returns its full path' do
+          expect(finder.find(context)).to eq '/path/one/navigation.rb'
         end
+      end
 
-        context 'and no navigation.rb file is found in the paths' do
-          it 'raises an exception' do
-            expect { finder.find(context) }.to raise_error(RuntimeError, /Config file 'navigation.rb' not found in path\(s\)/)
-          end
+      context 'when no navigation.rb file is found in the paths' do
+        it 'raises an exception' do
+          expect do
+            finder.find(context)
+          end.to raise_error(RuntimeError, /Config file 'navigation.rb' not found in path\(s\)/)
         end
       end
+    end
 
-      context 'when the context is :other' do
-        let(:context) { :other }
+    context 'when the context is :other' do
+      let(:context) { :other }
 
-        context 'and a other_navigation.rb file is found in one of the paths' do
-          before { FileUtils.touch('/path/two/other_navigation.rb') }
+      context 'when a other_navigation.rb file is found in one of the paths' do
+        before { FileUtils.touch('/path/two/other_navigation.rb') }
 
-          it 'returns its full path' do
-            expect(finder.find(context)).to eq '/path/two/other_navigation.rb'
-          end
+        it 'returns its full path' do
+          expect(finder.find(context)).to eq '/path/two/other_navigation.rb'
         end
+      end
 
-        context 'and no other_navigation.rb file is found in the paths' do
-          it 'raise an exception' do
-            expect{ finder.find(context) }.to raise_error(RuntimeError, /Config file 'other_navigation.rb' not found in path\(s\)/)
-          end
+      context 'when no other_navigation.rb file is found in the paths' do
+        it 'raise an exception' do
+          expect do
+            finder.find(context)
+          end.to raise_error(RuntimeError, /Config file 'other_navigation.rb' not found in path\(s\)/)
         end
       end
     end