simple-navigation 3.14.0 → 4.0.0

data/spec/lib/simple_navigation/rails_controller_methods_spec.rb

@@ -1,270 +0,0 @@
-require 'spec_helper'
-require 'simple_navigation/rails_controller_methods'
-
-class TestController
-  include SimpleNavigation::ControllerMethods
-
-  def self.helper_method(*args)
-    @helper_methods = args
-  end
-
-  def self.before_filter(*args)
-    @before_filters = args
-  end
-end
-
-module SimpleNavigation
-  describe 'Explicit navigation in rails' do
-    it 'enhances ActionController after loading the extensions' do
-      methods = ActionController::Base.instance_methods.map(&:to_s)
-      expect(methods).to include 'current_navigation'
-    end
-  end
-
-  describe ControllerMethods do
-    let(:controller) { TestController.new }
-
-    before { SimpleNavigation::Configuration.stub(:load) }
-
-    describe 'when the module is included' do
-      it 'extends the ClassMethods module' do
-        expect(controller.class).to respond_to(:navigation)
-      end
-
-      it "includes the InstanceMethods module" do
-        expect(controller).to respond_to(:current_navigation)
-      end
-    end
-  end
-
-  module ControllerMethods
-    describe ClassMethods do
-      let(:controller) { TestController.new }
-
-      describe '#navigation' do
-        context 'when the navigation method is not called' do
-          it "doesn't have any instance method called 'sn_set_navigation'" do
-            has_method = controller.respond_to?(:sn_set_navigation, true)
-            expect(has_method).to be_false
-          end
-        end
-
-        context 'when the navigation method is called' do
-          before do
-            controller.class_eval { navigation(:primary, :secondary) }
-          end
-
-          it 'creates an instance method called "sn_set_navigation"' do
-            has_method = controller.respond_to?(:sn_set_navigation, true)
-            expect(has_method).to be_true
-          end
-
-          it 'does not create a public method' do
-            methods = controller.public_methods.map(&:to_s)
-            expect(methods).not_to include 'sn_set_navigation'
-          end
-
-          it 'creates a protected method' do
-            methods = controller.protected_methods.map(&:to_s)
-            expect(methods).to include 'sn_set_navigation'
-          end
-
-          it 'creates a method that calls current_navigation with the specified keys' do
-            expect(controller).to receive(:current_navigation)
-                                 .with(:primary, :secondary)
-            controller.send(:sn_set_navigation)
-          end
-        end
-      end
-    end
-
-    describe InstanceMethods do
-      let(:controller) { TestController.new }
-
-      describe '#current_navigation' do
-        shared_examples 'setting the correct sn_current_navigation_args' do |args|
-          it 'sets the sn_current_navigation_args as specified' do
-            controller.current_navigation(*args)
-            args = controller.instance_variable_get(:@sn_current_navigation_args)
-            expect(args).to eq args
-          end
-        end
-
-        it_behaves_like 'setting the correct sn_current_navigation_args', [:first]
-        it_behaves_like 'setting the correct sn_current_navigation_args', [:first, :second]
-      end
-    end
-  end
-
-  describe 'SimpleNavigation module additions' do
-    let(:adapter) { double(:adapter, controller: controller) }
-    let(:controller) { double(:controller) }
-    let(:simple_navigation) { SimpleNavigation }
-
-    before { simple_navigation.stub(adapter: adapter) }
-
-    describe '.handle_explicit_navigation' do
-      def args(*args)
-        keys = args.compact.empty? ? nil : args
-        simple_navigation.stub(explicit_navigation_args: keys)
-      end
-
-      context 'when there is an explicit navigation set' do
-        context 'and it is a list of navigations' do
-          before { args :first, :second, :third }
-
-          it 'sets the correct instance var in the controller' do
-            expect(controller).to receive(:instance_variable_set)
-                                 .with(:@sn_current_navigation_3, :third)
-            simple_navigation.handle_explicit_navigation
-          end
-        end
-
-        context 'and it is a single navigation' do
-          context 'and the specified key is a valid navigation item' do
-            let(:primary) { double(:primary, level_for_item: 2) }
-
-            before do
-              simple_navigation.stub(primary_navigation: primary)
-              args :key
-            end
-
-            it 'sets the correct instance var in the controller' do
-              expect(controller).to receive(:instance_variable_set)
-                                    .with(:@sn_current_navigation_2, :key)
-              simple_navigation.handle_explicit_navigation
-            end
-          end
-
-          context 'and the specified key is an invalid navigation item' do
-            let(:primary) { double(:primary, level_for_item: nil) }
-
-            before do
-              subject.stub(primary_navigation: primary)
-              args :key
-            end
-
-            it 'raises an exception' do
-              expect{ subject.handle_explicit_navigation }.to raise_error
-            end
-          end
-        end
-
-        context 'and the argument is a one-level hash' do
-          before { args level_2: :key }
-
-          it 'sets the correct instance var in the controller' do
-            expect(controller).to receive(:instance_variable_set)
-                                  .with(:@sn_current_navigation_2, :key)
-            simple_navigation.handle_explicit_navigation
-          end
-        end
-
-        context 'when the argument is a multiple levels hash' do
-          before { args level_2: :key, level_1: :bla }
-
-          it 'sets the correct instance var in the controller' do
-            expect(controller).to receive(:instance_variable_set)
-                                  .with(:@sn_current_navigation_2, :key)
-            simple_navigation.handle_explicit_navigation
-          end
-        end
-      end
-
-      context 'when no explicit navigation is set' do
-        before { args nil }
-
-        it "doesn't set the current_navigation instance var in the controller" do
-          expect(controller).not_to receive(:instance_variable_set)
-          simple_navigation.handle_explicit_navigation
-        end
-      end
-    end
-
-    describe '#current_navigation_for' do
-      it 'accesses the correct instance var in the controller' do
-        expect(controller).to receive(:instance_variable_get)
-                              .with(:@sn_current_navigation_1)
-        simple_navigation.current_navigation_for(1)
-      end
-    end
-  end
-
-  describe Item do
-    let(:item) { Item.new(item_container, :my_key, 'name', 'url', {}) }
-    let(:item_container) { double(:item_container, level: 1) }
-    let(:simple_navigation) { SimpleNavigation }
-
-    before do
-      item_container.stub(:dom_attributes=)
-      simple_navigation.stub(current_navigation_for: navigation_key)
-    end
-
-    describe '#selected_by_config?' do
-      context 'when the navigation explicitly set' do
-        context 'when current matches the key' do
-          let(:navigation_key) { :my_key }
-
-          it 'selects the item' do
-            expect(item).to be_selected_by_config
-          end
-        end
-
-        context "when current doesn't match the key" do
-          let(:navigation_key) { :other_key }
-
-          it "doesn't select the item" do
-            expect(item).not_to be_selected_by_config
-          end
-        end
-      end
-
-      context 'when the navigation is not explicitly set' do
-        let(:navigation_key) { nil }
-
-        it "doesn't select the item" do
-          expect(item).not_to be_selected_by_config
-        end
-      end
-    end
-  end
-
-  describe ItemContainer do
-    describe '#selected_item' do
-      let(:item_container) { SimpleNavigation::ItemContainer.new }
-      let(:item_1) { double(:item, selected?: false) }
-      let(:item_2) { double(:item, selected?: false) }
-
-      before do
-        SimpleNavigation.stub(:current_navigation_for)
-        item_container.instance_variable_set(:@items, [item_1, item_2])
-      end
-
-      context 'when a navigation is explicitely set' do
-        before { item_container.stub(:[] => item_1) }
-
-        it 'returns the explicitely selected item' do
-          expect(item_container.selected_item).to be item_1
-        end
-      end
-
-      context 'when no navigation is explicitely set' do
-        before { item_container.stub(:[] => nil) }
-
-        context 'and no item is selected' do
-          it 'returns nil' do
-            expect(item_container.selected_item).to be_nil
-          end
-        end
-
-        context 'and one item is selected' do
-          before { item_1.stub(selected?: true) }
-
-          it 'returns the selected item' do
-            expect(item_container.selected_item).to be item_1
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/simple_navigation_spec.rb

@@ -1,300 +0,0 @@
-require 'spec_helper'
-
-describe SimpleNavigation do
-  before { subject.config_file_path = 'path_to_config' }
-
-  describe 'config_file_name' do
-    context 'when the navigation_context is :default' do
-      it 'returns the name of the default config file' do
-        expect(subject.config_file_name).to eq 'navigation.rb'
-      end
-    end
-
-    context 'when the navigation_context is NOT :default' do
-      it 'returns the name of the config file matching the specified context' do
-        file_name = subject.config_file_name(:my_other_context)
-        expect(file_name).to eq 'my_other_context_navigation.rb'
-      end
-
-      it 'converts camelcase-contexts to underscore' do
-        file_name = subject.config_file_name(:WhyWouldYouDoThis)
-        expect(file_name).to eq 'why_would_you_do_this_navigation.rb'
-      end
-    end
-  end
-
-  describe 'config_file_path=' do
-    before { subject.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']
-    end
-  end
-
-  describe 'config_file' do
-    context 'when no config_file_paths are set' do
-      before { subject.config_file_paths = [] }
-
-      it 'returns nil' do
-        expect(subject.config_file).to be_nil
-      end
-    end
-
-    context 'when one config_file_path is set' do
-      before { subject.config_file_paths = ['my_config_file_path'] }
-
-      context 'and the requested config file exists' do
-        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'
-        end
-      end
-
-      context 'and the requested config file does not exist' do
-        before { File.stub(exist?: false) }
-
-        it 'returns nil' do
-          expect(subject.config_file).to be_nil
-        end
-      end
-    end
-
-    context 'when multiple config_file_paths are set' do
-      before { subject.config_file_paths = ['first_path', 'second_path'] }
-
-      context 'and the requested config file exists' do
-        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'
-        end
-      end
-
-      context 'and the requested config file does not exist' do
-        before { File.stub(exist?: false) }
-
-        it 'returns nil' do
-          expect(subject.config_file).to be_nil
-        end
-      end
-    end
-  end
-
-  describe '.config_file?' do
-    context 'when config_file is present' do
-      before { subject.stub(config_file: 'file') }
-
-      it 'returns true' do
-        expect(subject.config_file?).to be_true
-      end
-    end
-
-    context 'when config_file is not present' do
-      before { subject.stub(config_file: nil) }
-
-      it 'returns false' do
-        expect(subject.config_file?).to be_false
-      end
-    end
-  end
-
-  describe '.default_config_file_path' do
-    before { subject.stub(root: 'root') }
-
-    it 'returns the config file path according to :root setting' do
-      expect(subject.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
-    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
-      end
-    end
-  end
-
-  describe '.set_env' do
-    before do
-      subject.config_file_paths = []
-      subject.stub(default_config_file_path: 'default_path')
-      subject.set_env('root', 'my_env')
-    end
-
-    it 'sets the root' do
-      expect(subject.root).to eq 'root'
-    end
-
-    it 'sets the environment' do
-      expect(subject.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']
-    end
-  end
-
-  describe '.load_config' do
-    context 'when config_file_path is set' do
-      before { subject.stub(config_file: 'path_to_config_file') }
-
-      context 'and config_file exists' do
-        before do
-          subject.stub(config_file?: true)
-          IO.stub(read: 'file_content')
-        end
-
-        it "doesn't raise any error" do
-          expect{ subject.load_config }.not_to raise_error
-        end
-
-        it 'reads the specified config file from disc' do
-          expect(IO).to receive(:read).with('path_to_config_file')
-          subject.load_config
-        end
-
-        it 'stores the read content in the module (default context)' do
-          expect(subject).to receive(:config_file).with(:default)
-          subject.load_config
-          expect(subject.config_files[:default]).to eq 'file_content'
-        end
-
-        it 'stores the content in the module (non default context)' do
-          expect(subject).to receive(:config_file).with(:my_context)
-          subject.load_config(:my_context)
-          expect(subject.config_files[:my_context]).to eq 'file_content'
-        end
-      end
-
-      context 'and config_file does not exist' do
-        before { subject.stub(config_file?: false) }
-
-        it 'raises an exception' do
-        expect{ subject.load_config }.to raise_error
-        end
-      end
-    end
-
-    context 'when config_file_path is not set' do
-      before { subject.config_file_path = nil }
-
-      it 'raises an exception' do
-        expect{ subject.load_config }.to raise_error
-      end
-    end
-
-    describe 'Regarding caching of the config-files' do
-      before do
-        subject.config_file_path = 'path_to_config'
-        IO.stub(:read).and_return('file_content')
-        File.stub(exist?: true)
-      end
-
-      after { subject.config_files = {} }
-
-      shared_examples 'loading config file' do |env, count|
-        context "when environment is '#{env}'" do
-          before { subject.stub(environment: env) }
-
-          it "loads the config file #{count}" do
-            expect(IO).to receive(:read).exactly(count)
-            2.times { subject.load_config }
-          end
-        end
-      end
-
-      it_behaves_like 'loading config file', nil,           :twice
-      it_behaves_like 'loading config file', 'production',  :once
-      it_behaves_like 'loading config file', 'development', :twice
-      it_behaves_like 'loading config file', 'test',        :twice
-    end
-  end
-
-  describe '.config' do
-    it 'returns the Configuration singleton instance' do
-      expect(subject.config).to be SimpleNavigation::Configuration.instance
-    end
-  end
-
-  describe '.active_item_container_for' do
-    let(:primary) { double(:primary) }
-
-    before { subject.config.stub(primary_navigation: primary) }
-
-    context 'when level is :all' do
-      it 'returns the primary_navigation' do
-        nav = subject.active_item_container_for(:all)
-        expect(nav).to be primary
-      end
-    end
-
-    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)
-      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)
-      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)
-      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
-      end
-    end
-  end
-
-  describe '.load_adapter' do
-    shared_examples 'loading the right adapter' do |framework, adapter|
-      context "when the context is #{framework}" do
-        before do
-          subject.stub(framework: framework)
-          subject.load_adapter
-        end
-
-        it "returns the #{framework} adapter" do
-          adapter_class = SimpleNavigation::Adapters.const_get(adapter)
-          expect(subject.adapter_class).to be adapter_class
-        end
-      end
-    end
-
-    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
-  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