simple-navigation 4.4.1 → 4.5.0

data/spec/simple_navigation/renderer/list_spec.rb

@@ -1,94 +1,114 @@
-module SimpleNavigation
-  module Renderer
-    describe List do
-      let!(:navigation) { setup_navigation('nav_id', 'nav_class') }
-
-      let(:item) { nil }
-      let(:options) { { level: :all } }
-      let(:output) { renderer.render(navigation) }
-      let(:renderer) { List.new(options) }
-
-      before { select_an_item(navigation[item]) if item }
-
-      describe '#render' do
-        it "renders an 'ul' tag for the navigation" do
-          expect(output).to have_css('ul')
-        end
-
-        it "sets the right html id on the rendered 'ul' tag" do
-          expect(output).to have_css('ul#nav_id')
-        end
-
-        it "sets the right html classes on the rendered 'ul' tag" do
-          expect(output).to have_css('ul.nav_class')
-        end
-
-        context 'when an item has no specified id' do
-          it "renders the item's 'li' tag with the item's stingified key as id" do
-            expect(output).to have_css('li#invoices')
-          end
-        end
-
-        context 'when an item has a specified id' do
-          it "renders the item's 'li' tag with the specified id" do
-            expect(output).to have_css('li#users_id')
-          end
-        end
-
-        context 'when no item is selected' do
-          it "renders each item as 'li' tag without any selected class" do
-            expect(output).not_to have_css('ul li.selected')
-          end
-
-          it "renders each item as 'a' tag without any selected class" do
-            expect(output).not_to have_css('ul li a.selected')
-          end
-        end
-
-        context 'when an item is selected' do
-          let(:item) { :invoices }
-
-          it "renders the item's 'li' tag with its id and selected classes" do
-            expect(output).to have_css('li#invoices.selected')
-          end
-
-          it "renders the item's 'a' tag with the selected classes" do
-            expect(output).to have_css('li#invoices a.selected')
-          end
-        end
-
-        context 'when the :ordered option is true' do
-          let(:options) {{ level: :all, ordered: true }}
-
-          it "renders an 'ol' tag for the navigation" do
-            expect(output).to have_css('ol')
-          end
-
-          it "sets the right html id on the rendered 'ol' tag" do
-            expect(output).to have_css('ol#nav_id')
-          end
-
-          it "sets the right html classes on the rendered 'ol' tag" do
-            expect(output).to have_css('ol.nav_class')
-          end
-        end
-
-        context 'when a sub navigation item is selected' do
-          before do
-            allow(navigation[:invoices]).to receive_messages(selected?: true)
-
-            allow(navigation[:invoices].sub_navigation[:unpaid]).to \
-              receive_messages(selected?: true, selected_by_condition?: true)
-          end
-
-          it 'renders the parent items as selected' do
-            expect(output).to have_css('li#invoices.selected')
-          end
-
-          it "renders the selected nested item's link as selected" do
-            expect(output).to have_css('li#unpaid.selected')
-          end
-        end
+# frozen_string_literal: true
+
+RSpec.describe SimpleNavigation::Renderer::List do
+  let!(:navigation) { setup_navigation('nav_id', 'nav_class') }
+
+  let(:options) { { level: :all } }
+  let(:output) { renderer.render(navigation) }
+  let(:renderer) { described_class.new(options) }
+
+  describe '#render' do
+    it "renders an 'ul' tag for the navigation" do
+      expect(output).to have_css('ul')
+    end
+
+    it "sets the right html id on the rendered 'ul' tag" do
+      expect(output).to have_css('ul#nav_id')
+    end
+
+    it "sets the right html classes on the rendered 'ul' tag" do
+      expect(output).to have_css('ul.nav_class')
+    end
+
+    context 'when an item has no specified id' do
+      it "renders the item's 'li' tag with the item's stingified key as id" do
+        expect(output).to have_css('li#invoices')
+      end
+    end
+
+    context 'when an item has a specified id' do
+      it "renders the item's 'li' tag with the specified id" do
+        expect(output).to have_css('li#users_id')
+      end
+    end
+
+    context 'when no item is selected' do
+      it "renders each item as 'li' tag without any selected class" do
+        expect(output).to have_no_css('ul li.selected')
+      end
+
+      it "renders each item as 'a' tag without any selected class" do
+        expect(output).to have_no_css('ul li a.selected')
+      end
+    end
+
+    context 'when an item is selected' do
+      before do
+        allow(navigation[:invoices]).to \
+          receive_messages(selected?: true, selected_by_condition?: true)
+      end
+
+      it "renders the item's 'li' tag with its id and selected classes" do
+        expect(output).to have_css('li#invoices.selected')
+      end
+
+      it "renders the item's 'a' tag with the selected classes" do
+        expect(output).to have_css('li#invoices a.selected')
+      end
+
+      it "renders the item's 'a' tag with with an 'aria-current' attribute" do
+        expect(output).to have_css('li#invoices a[aria-current=page]')
+      end
+    end
+
+    context 'when the :ordered option is true' do
+      let(:options) { { level: :all, ordered: true } }
+
+      it "renders an 'ol' tag for the navigation" do
+        expect(output).to have_css('ol')
+      end
+
+      it "sets the right html id on the rendered 'ol' tag" do
+        expect(output).to have_css('ol#nav_id')
+      end
+
+      it "sets the right html classes on the rendered 'ol' tag" do
+        expect(output).to have_css('ol.nav_class')
+      end
+    end
+
+    context 'when a sub navigation item is selected' do
+      before do
+        allow(navigation[:invoices]).to receive_messages(selected?: true)
+
+        allow(navigation[:invoices].sub_navigation[:unpaid]).to \
+          receive_messages(selected?: true, selected_by_condition?: true)
+      end
+
+      it 'renders the parent items as selected' do
+        expect(output).to have_css('li#invoices.selected')
+      end
+
+      it "renders the selected nested item's link as selected" do
+        expect(output).to have_css('li#unpaid.selected')
+      end
+
+      it "renders the selected nested item's 'a' tag with with an 'aria-current' attribute" do
+        expect(output).to have_css('li#unpaid a[aria-current=page]')
+      end
+
+      it "does not 'aria-current' to the parent item's link" do
+        expect(output).to have_no_css('li#invoices > a[aria-current=page]')
+      end
+    end
+
+    context 'when skip_if_empty is true and container is empty' do
+      let(:empty_navigation) { SimpleNavigation::ItemContainer.new(1) }
+      let(:options) { { skip_if_empty: true } }
+      let(:output) { renderer.render(empty_navigation) }
+
+      it 'returns an empty string' do
+        expect(output).to eq ''
       end
     end
   end

data/spec/simple_navigation/renderer/text_spec.rb

@@ -1,49 +1,47 @@
-module SimpleNavigation
-  module Renderer
-    describe Text do
-      let!(:navigation) { setup_navigation('nav_id', 'nav_class') }
-
-      let(:item) { nil }
-      let(:options) {{ level: :all }}
-      let(:output) { renderer.render(navigation) }
-      let(:renderer) { Text.new(options) }
-
-      before { select_an_item(navigation[item]) if item }
-
-      describe '#render' do
-        context 'when no item is selected' do
-          it 'renders an empty string' do
-            expect(output).to eq ''
-          end
-        end
+# frozen_string_literal: true
 
-        context 'when an item is selected' do
-          let(:item) { :invoices }
+RSpec.describe SimpleNavigation::Renderer::Text do
+  let!(:navigation) { setup_navigation('nav_id', 'nav_class') }
 
-          it "renders the selected item's name" do
-            expect(output).to eq 'Invoices'
-          end
-        end
+  let(:item) { nil }
+  let(:options) { { level: :all } }
+  let(:output) { renderer.render(navigation) }
+  let(:renderer) { described_class.new(options) }
+
+  before { select_an_item(navigation[item]) if item }
+
+  describe '#render' do
+    context 'when no item is selected' do
+      it 'renders an empty string' do
+        expect(output).to eq ''
+      end
+    end
 
-        context 'when a sub navigation item is selected' do
-          before do
-            allow(navigation[:invoices]).to receive_messages(selected?: true)
+    context 'when an item is selected' do
+      let(:item) { :invoices }
 
-            allow(navigation[:invoices].sub_navigation[:unpaid]).to \
-              receive_messages(selected?: true, selected_by_condition?: true)
-          end
+      it "renders the selected item's name" do
+        expect(output).to eq 'Invoices'
+      end
+    end
+
+    context 'when a sub navigation item is selected' do
+      before do
+        allow(navigation[:invoices]).to receive_messages(selected?: true)
 
-          it 'separates the items with a space' do
-            expect(output).to eq 'Invoices Unpaid'
-          end
+        allow(navigation[:invoices].sub_navigation[:unpaid]).to \
+          receive_messages(selected?: true, selected_by_condition?: true)
+      end
+
+      it 'separates the items with a space' do
+        expect(output).to eq 'Invoices Unpaid'
+      end
 
-          context "and the :join_with option is set" do
-            let(:options) {{ level: :all, join_with: ' | ' }}
+      context 'when the :join_with option is set' do
+        let(:options) { { level: :all, join_with: ' | ' } }
 
-            it 'separates the items with the specified separator' do
-              expect(output).to eq 'Invoices | Unpaid'
-            end
-          end
+        it 'separates the items with the specified separator' do
+          expect(output).to eq 'Invoices | Unpaid'
         end
       end
     end

data/spec/simple_navigation_spec.rb

@@ -1,64 +1,68 @@
-describe SimpleNavigation do
-  before { subject.config_file_path = 'path_to_config' }
+# frozen_string_literal: true
+
+RSpec.describe SimpleNavigation do
+  subject(:simple_navigation) { described_class }
+
+  before { simple_navigation.config_file_path = 'path_to_config' }
 
   describe 'config_file_path=' do
-    before { subject.config_file_paths = ['existing_path'] }
+    before { simple_navigation.config_file_paths = ['existing_path'] }
 
     it 'overrides the config_file_paths' do
-      subject.config_file_path = 'new_path'
-      expect(subject.config_file_paths).to eq ['new_path']
+      simple_navigation.config_file_path = 'new_path'
+      expect(simple_navigation.config_file_paths).to eq ['new_path']
     end
   end
 
   describe '.default_config_file_path' do
-    before { allow(subject).to receive_messages(root: 'root') }
+    before { allow(simple_navigation).to receive_messages(root: 'root') }
 
     it 'returns the config file path according to :root setting' do
-      expect(subject.default_config_file_path).to eq 'root/config'
+      expect(simple_navigation.default_config_file_path).to eq 'root/config'
     end
   end
 
   describe 'Regarding renderers' do
     it 'registers the builtin renderers by default' do
-      expect(subject.registered_renderers).not_to be_empty
+      expect(simple_navigation.registered_renderers).not_to be_empty
     end
 
     describe '.register_renderer' do
       let(:renderer) { double(:renderer) }
 
       it 'adds the specified renderer to the list of renderers' do
-        subject.register_renderer(my_renderer: renderer)
-        expect(subject.registered_renderers[:my_renderer]).to be renderer
+        simple_navigation.register_renderer(my_renderer: renderer)
+        expect(simple_navigation.registered_renderers[:my_renderer]).to be renderer
       end
     end
   end
 
   describe '.set_env' do
     before do
-      subject.config_file_paths = []
-      allow(subject).to receive_messages(default_config_file_path: 'default_path')
-      subject.set_env('root', 'my_env')
+      simple_navigation.config_file_paths = []
+      allow(simple_navigation).to receive_messages(default_config_file_path: 'default_path')
+      simple_navigation.set_env('root', 'my_env')
     end
 
     it 'sets the root' do
-      expect(subject.root).to eq 'root'
+      expect(simple_navigation.root).to eq 'root'
     end
 
     it 'sets the environment' do
-      expect(subject.environment).to eq 'my_env'
+      expect(simple_navigation.environment).to eq 'my_env'
     end
 
     it 'adds the default-config path to the list of config_file_paths' do
-      expect(subject.config_file_paths).to eq ['default_path']
+      expect(simple_navigation.config_file_paths).to eq ['default_path']
     end
   end
 
-  describe '.load_config', memfs: true do
+  describe '.load_config', :memfs do
     let(:paths) { ['/path/one', '/path/two'] }
 
     before do
       FileUtils.mkdir_p(paths)
-      allow(subject).to receive_messages(config_file_paths: paths)
+      allow(simple_navigation).to receive_messages(config_file_paths: paths)
     end
 
     context 'when the config file for the context exists' do
@@ -69,60 +73,62 @@ describe SimpleNavigation do
 
       context 'when no context is provided' do
         it 'stores the configuration in config_files for the default context' do
-          subject.load_config
-          expect(subject.config_files[:default]).to eq "default content\n"
+          simple_navigation.load_config
+          expect(simple_navigation.config_files[:default]).to eq "default content\n"
         end
       end
 
       context 'when a context is provided' do
         it 'stores the configuration in config_files for the given context' do
-          subject.load_config(:other)
-          expect(subject.config_files[:other]).to eq "other content\n"
+          simple_navigation.load_config(:other)
+          expect(simple_navigation.config_files[:other]).to eq "other content\n"
         end
       end
 
-      context 'and environment is production' do
-        before { allow(subject).to receive_messages(environment: 'production') }
+      context 'when environment is production' do
+        before { allow(simple_navigation).to receive_messages(environment: 'production') }
 
         it 'loads the config file only for the first call' do
-          subject.load_config
+          simple_navigation.load_config
           File.open('/path/two/navigation.rb', 'w') { |f| f.puts 'new content' }
-          subject.load_config
-          expect(subject.config_files[:default]).to eq "default content\n"
+          simple_navigation.load_config
+          expect(simple_navigation.config_files[:default]).to eq "default content\n"
         end
       end
 
-      context "and environment isn't production" do
+      context "when environment isn't production" do
         it 'loads the config file for every call' do
-          subject.load_config
+          simple_navigation.load_config
           File.open('/path/two/navigation.rb', 'w') { |f| f.puts 'new content' }
-          subject.load_config
-          expect(subject.config_files[:default]).to eq "new content\n"
+          simple_navigation.load_config
+          expect(simple_navigation.config_files[:default]).to eq "new content\n"
         end
       end
     end
 
     context "when the config file for the context doesn't exists" do
       it 'raises an exception' do
-        expect{ subject.load_config }.to raise_error(RuntimeError, /Config file 'navigation.rb' not found in path\(s\)/)
+        expect do
+          simple_navigation.load_config
+        end.to raise_error(RuntimeError, /Config file 'navigation.rb' not found in path\(s\)/)
       end
     end
   end
 
   describe '.config' do
     it 'returns the Configuration singleton instance' do
-      expect(subject.config).to be SimpleNavigation::Configuration.instance
+      expect(simple_navigation.config).to be SimpleNavigation::Configuration.instance
     end
   end
 
   describe '.active_item_container_for' do
     let(:primary) { double(:primary) }
 
-    before { allow(subject.config).to receive_messages(primary_navigation: primary) }
+    before { allow(simple_navigation.config).to receive_messages(primary_navigation: primary) }
 
     context 'when level is :all' do
       it 'returns the primary_navigation' do
-        nav = subject.active_item_container_for(:all)
+        nav = simple_navigation.active_item_container_for(:all)
         expect(nav).to be primary
       end
     end
@@ -130,29 +136,29 @@ describe SimpleNavigation do
     context 'when level is :leaves' do
       it 'returns the currently active leaf-container' do
         expect(primary).to receive(:active_leaf_container)
-        subject.active_item_container_for(:leaves)
+        simple_navigation.active_item_container_for(:leaves)
       end
     end
 
     context 'when level is a Range' do
       it 'takes the min of the range to lookup the active container' do
         expect(primary).to receive(:active_item_container_for).with(2)
-        subject.active_item_container_for(2..3)
+        simple_navigation.active_item_container_for(2..3)
       end
     end
 
     context 'when level is an Integer' do
       it 'considers the Integer to lookup the active container' do
         expect(primary).to receive(:active_item_container_for).with(1)
-        subject.active_item_container_for(1)
+        simple_navigation.active_item_container_for(1)
       end
     end
 
     context 'when level is something else' do
       it 'raises an exception' do
-        expect{
-          subject.active_item_container_for('something else')
-        }.to raise_error(ArgumentError, 'Invalid navigation level: something else')
+        expect do
+          simple_navigation.active_item_container_for('something else')
+        end.to raise_error(ArgumentError, 'Invalid navigation level: something else')
       end
     end
   end
@@ -161,13 +167,13 @@ describe SimpleNavigation do
     shared_examples 'loading the right adapter' do |framework, adapter|
       context "when the context is #{framework}" do
         before do
-          allow(subject).to receive_messages(framework: framework)
-          subject.load_adapter
+          allow(simple_navigation).to receive_messages(framework: framework)
+          simple_navigation.load_adapter
         end
 
         it "returns the #{framework} adapter" do
           adapter_class = SimpleNavigation::Adapters.const_get(adapter)
-          expect(subject.adapter_class).to be adapter_class
+          expect(simple_navigation.adapter_class).to be adapter_class
         end
       end
     end
@@ -175,6 +181,7 @@ describe SimpleNavigation do
     it_behaves_like 'loading the right adapter', :rails,   :Rails
     it_behaves_like 'loading the right adapter', :padrino, :Padrino
     it_behaves_like 'loading the right adapter', :sinatra, :Sinatra
+    it_behaves_like 'loading the right adapter', :nanoc,   :Nanoc
   end
 
   describe '.init_adapter_from' do
@@ -182,9 +189,9 @@ describe SimpleNavigation do
     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
+      simple_navigation.adapter_class = adapter_class
+      simple_navigation.init_adapter_from(:default)
+      expect(simple_navigation.adapter).to be adapter
     end
   end
 end