simple-navigation 3.14.0 → 4.0.0

data/lib/simple_navigation/core.rb

@@ -1,5 +0,0 @@
-require 'simple_navigation/core/configuration'
-require 'simple_navigation/core/item_adapter'
-require 'simple_navigation/core/item'
-require 'simple_navigation/core/item_container'
-require 'simple_navigation/core/items_provider'

data/lib/simple_navigation/rails_controller_methods.rb

@@ -1,164 +0,0 @@
-module SimpleNavigation
-  def self.explicit_navigation_args
-    adapter.controller.instance_variable_get(:'@sn_current_navigation_args')
-  end
-
-  # Reads the current navigation for the specified level from the controller.
-  # Returns nil if there is no current navigation set for level.
-  def self.current_navigation_for(level)
-    adapter.controller.instance_variable_get(:"@sn_current_navigation_#{level}")
-  end
-
-  # If any navigation has been explicitely set in the controller this method
-  # evaluates the specified args set in the controller and sets the correct
-  # instance variable in the controller.
-  def self.handle_explicit_navigation
-    return unless explicit_navigation_args
-    level, navigation = parse_explicit_navigation_args
-    navigation_level = :"@sn_current_navigation_#{level}"
-    adapter.controller.instance_variable_set(navigation_level, navigation)
-  end
-
-  def self.parse_explicit_navigation_args
-    args = if explicit_navigation_args.empty?
-             [{}]
-           else
-             explicit_navigation_args
-           end
-    indexed_args = args_indexed_by_level(args)
-    deepest = deepest_level_and_item(indexed_args)
-
-    if deepest.first.zero?
-      fail ArgumentError, 'Invalid level specified or item key not found'
-    end
-
-    deepest
-  end
-
-  private
-
-  def self.deepest_level_and_item(navigation_args)
-    navigation_args.map { |k, v| [k.to_s[/level_(\d)/, 1].to_i, v] }
-                   .max
-  end
-
-  def self.args_indexed_by_level(navigation_args)
-    if navigation_args.first.is_a?(Hash)
-      navigation_args.first
-    elsif navigation_args.size == 1
-      level = primary_navigation.level_for_item(navigation_args.first)
-      level ? { :"level_#{level}" => navigation_args.first } : {}
-    else
-      navigation_args.each_with_index
-                     .with_object({}) do |(arg, i), h|
-                       h[:"level_#{i + 1}"] = arg
-                     end
-    end
-  end
-
-  # Adds methods for explicitely setting the current 'active' navigation to
-  # the controllers.
-  # Since version 2.0.0 the simple_navigation plugin determines the active
-  # navigation based on the current url by default (auto highlighting),
-  # so explicitely defining the active navigation in the controllers is only
-  # needed for edge cases where automatic highlighting does not work.
-  #
-  # On the controller class level, use the <tt>navigation</tt> method to set the
-  # active navigation for all actions in the controller.
-  # Let's assume that we have a primary navigation item :account which in turn
-  # has a sub navigation item :settings.
-  #
-  # ==== Examples
-  #   class AccountController << ActionController
-  #     navigation :account
-  #     ...
-  #   end
-  #
-  #   class AccountSettingsController << ActionController
-  #     navigation :settings
-  #     ...
-  #   end
-  #
-  # The first example sets the current primary navigation to :account for all
-  # actions. No active sub_navigation.
-  # The second example sets the current sub navigation to :settings and since
-  # it is a child of :account the current primary navigation is set to :account.
-  #
-  # On the controller instance level, use the <tt>current_navigation</tt> method
-  # to define the active navigation for a specific action.
-  # The navigation item that is set in <tt>current_navigation</tt> overrides the
-  # one defined on the controller class level (see <tt>navigation</tt> method).
-  # Thus if you have an :account primary item with a :special
-  # sub navigation item:
-  #
-  # ==== Example
-  #   class AccountController << ActionController
-  #     navigation :account
-  #
-  #     def your_special_action
-  #       ...
-  #       current_navigation :special
-  #     end
-  #   end
-  #
-  # The code above still sets the active primary navigation to :account for all
-  # actions, but sets the sub_navigation to :account -> :special for
-  # 'your_special_action'.
-  #
-  # Note 1: As you can see above you just have to set the navigation item of
-  #         your 'deepest' navigation level as active and all its parents are
-  #         marked as active, too.
-  #
-  # Note 2: The specified symbols must match the keys for your navigation
-  #         items in your config/navigation.rb file.
-  module ControllerMethods
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-      end
-    end
-
-    module ClassMethods
-      # Sets the active navigation for all actions in this controller.
-      #
-      # The specified symbol must match the keys for your navigation items
-      # in your config/navigation.rb file.
-      def navigation(*args)
-        class_eval do
-          define_method :sn_set_navigation do
-            current_navigation(*args)
-          end
-          protected :sn_set_navigation
-          before_filter :sn_set_navigation
-        end
-      end
-    end
-
-    module InstanceMethods
-      # Sets the active navigation. Call this method in any action to override
-      # the controller-wide active navigation specified by navigation.
-      #
-      # The specified symbol must match the keys for your navigation items in
-      # your config/navigation.rb file.
-      def current_navigation(*args)
-        @sn_current_navigation_args = args
-      end
-    end
-  end
-
-  class Item
-    def selected_by_config?
-      key == SimpleNavigation.current_navigation_for(container.level)
-    end
-  end
-
-  class ItemContainer
-    def selected_item
-      self[SimpleNavigation.current_navigation_for(level)] ||
-      items.find(&:selected?)
-    end
-  end
-end
-
-ActionController::Base.send(:include, SimpleNavigation::ControllerMethods)

data/lib/simple_navigation/rendering.rb

@@ -1,12 +0,0 @@
-require 'simple_navigation/rendering/helpers'
-require 'simple_navigation/rendering/renderer/base'
-
-module SimpleNavigation
-  module Renderer
-    autoload :List, 'simple_navigation/rendering/renderer/list'
-    autoload :Links, 'simple_navigation/rendering/renderer/links'
-    autoload :Breadcrumbs, 'simple_navigation/rendering/renderer/breadcrumbs'
-    autoload :Text, 'simple_navigation/rendering/renderer/text'
-    autoload :Json, 'simple_navigation/rendering/renderer/json'
-  end
-end

data/rails/init.rb

@@ -1 +0,0 @@
-SimpleNavigation.register

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

@@ -1,703 +0,0 @@
-require 'spec_helper'
-
-module SimpleNavigation
-  describe Item do
-    let!(:item_container) { ItemContainer.new }
-
-    let(:adapter) { double(:adapter) }
-    let(:item_args) { [item_container, :my_key, 'name', url, options, items] }
-    let(:item) { Item.new(*item_args) }
-    let(:items) { nil }
-    let(:options) { Hash.new }
-    let(:url) { 'url' }
-
-    before { SimpleNavigation.stub(adapter: adapter) }
-
-    describe '#initialize' do
-      context 'when there is a sub_navigation' do
-        let(:subnav_container) { double(:subnav_container).as_null_object }
-
-        before { ItemContainer.stub(new: subnav_container) }
-
-        context 'when a block is given' do
-          it 'creates a new ItemContainer with a level+1' do
-            expect(ItemContainer).to receive(:new).with(2)
-            Item.new(*item_args) {}
-          end
-
-          it 'calls the block' do
-            expect{ |blk|
-              Item.new(*item_args, &blk)
-            }.to yield_with_args(subnav_container)
-          end
-        end
-
-        context 'when no block is given' do
-          context 'and items are given' do
-            let(:items) { double(:items) }
-
-            it 'creates a new ItemContainer with a level+1' do
-              expect(ItemContainer).to receive(:new).with(2)
-              Item.new(*item_args)
-            end
-
-            it "sets the items on the subnav_container" do
-              expect(subnav_container).to receive(:items=).with(items)
-              Item.new(*item_args)
-            end
-          end
-
-          context 'and no items are given' do
-            it "doesn't create a new ItemContainer" do
-              expect(ItemContainer).not_to receive(:new)
-              Item.new(*item_args)
-            end
-          end
-        end
-      end
-
-      context 'when a :method option is given' do
-        let(:options) {{ method: :delete }}
-
-        it "sets the item's method" do
-          expect(item.method).to eq :delete
-        end
-
-        it 'sets the html options without the method' do
-          meth = item.instance_variable_get(:@html_options).key?(:method)
-          expect(meth).to be_false
-        end
-      end
-
-      context 'when no :method option is given' do
-        it "sets the item's method to nil" do
-          expect(item.method).to be_nil
-        end
-      end
-
-      context 'setting class and id on the container' do
-        let!(:create) { item }
-
-        let(:options) {{
-          container_class: 'container_class',
-          container_id: 'container_id',
-          container_attributes: { 'ng-show' => 'false' }
-        }}
-
-        it "fills in the container's dom_attributes" do
-          expect(item_container.dom_attributes).to eq({
-            id: 'container_id',
-            class: 'container_class',
-            'ng-show' => 'false'
-          })
-        end
-      end
-
-      context 'when a :highlights_on option is given' do
-        it "sets the item's highlights_on to nil" do
-          expect(item.highlights_on).to be_nil
-        end
-      end
-
-      context 'when no :highlights_on option is given' do
-        let(:highlights_on) { double(:highlights_on) }
-        let(:options) {{ highlights_on: highlights_on }}
-
-        it "sets the item's highlights_on" do
-          expect(item.highlights_on).to eq highlights_on
-        end
-
-        it 'sets the html options without the method' do
-          html_options = item.instance_variable_get(:@html_options)
-          expect(html_options).not_to have_key(:highlights_on)
-        end
-      end
-
-      context 'when a url is given' do
-        context 'and it is a string' do
-          it "sets the item's url accordingly" do
-            expect(item.url).to eq 'url'
-          end
-        end
-
-        context 'and it is a proc' do
-          let(:url) { proc{ "my_" + "url" } }
-
-          it "sets the item's url accordingly" do
-            expect(item.url).to eq 'my_url'
-          end
-        end
-
-        context 'and it is nil' do
-          let(:url) { nil }
-
-          it "sets the item's url accordingly" do
-            expect(item.url).to be_nil
-          end
-        end
-      end
-
-      describe 'Optional url and optional options' do
-        context 'when no parameter is specified' do
-          let(:item_args) { [item_container, :my_key, 'name'] }
-
-          it "sets the item's url to nil" do
-            expect(item.url).to be_nil
-          end
-
-          it "sets the item's html_options to an empty hash" do
-            expect(item.instance_variable_get(:@html_options)).to eq({})
-          end
-        end
-
-        context 'when only a url is given' do
-          let(:item_args) { [item_container, :my_key, 'name', 'url'] }
-
-          it "set the item's url accordingly" do
-            expect(item.url).to eq 'url'
-          end
-
-          it "sets the item's html_options to an empty hash" do
-            expect(item.instance_variable_get(:@html_options)).to eq({})
-          end
-        end
-
-        context 'when only options are given' do
-          let(:item_args) { [item_container, :my_key, 'name', { option: true }] }
-
-          it "sets the item's url to nil" do
-            expect(item.url).to be_nil
-          end
-
-          it "sets the item's html_options accordingly" do
-            html_options = item.instance_variable_get(:@html_options)
-            expect(html_options).to eq({ option: true })
-          end
-        end
-
-        context 'when url and options are given' do
-          let(:options) {{ option: true }}
-
-          it "set the item's url accordingly" do
-            expect(item.url).to eq 'url'
-          end
-
-          it "sets the item's html_options accordingly" do
-            html_options = item.instance_variable_get(:@html_options)
-            expect(html_options).to eq({ option: true })
-          end
-        end
-      end
-    end
-
-    describe '#name' do
-      before do
-        SimpleNavigation.config.stub(
-          name_generator: proc{ |name| "<span>#{name}</span>" })
-      end
-
-      context 'when no option is given' do
-        context 'and the name_generator uses only the name' do
-          it 'uses the default name_generator' do
-            expect(item.name).to eq '<span>name</span>'
-          end
-        end
-
-        context 'and the name_generator uses only the item itself' do
-          before do
-            SimpleNavigation.config.stub(
-              name_generator: proc{ |name, item| "<span>#{item.key}</span>" })
-          end
-
-          it 'uses the default name_generator' do
-            expect(item.name).to eq '<span>my_key</span>'
-          end
-        end
-      end
-
-      context 'when the :apply_generator is false' do
-        it "returns the item's name" do
-          expect(item.name(apply_generator: false)).to eq 'name'
-        end
-      end
-    end
-
-    describe '#selected?' do
-      context 'when the item is explicitly selected' do
-        before { item.stub(selected_by_config?: true) }
-
-        it 'is selected' do
-          expect(item).to be_selected
-        end
-
-        # FIXME: testing the implementation not the behavior here
-        it "doesn't check for selection by sub navigation" do
-          expect(item).not_to receive(:selected_by_subnav?)
-          item.selected?
-        end
-
-        # FIXME: testing the implementation not the behavior here
-        it "doesn't check for selection by highlighting condition" do
-          expect(item).not_to receive(:selected_by_condition?)
-          item.selected?
-        end
-      end
-
-      context "when the item isn't explicitly selected" do
-        before { item.stub(selected_by_config?: false) }
-
-        context 'and it is selected by sub navigation' do
-          before { item.stub(selected_by_subnav?: true) }
-
-          it 'is selected' do
-            expect(item).to be_selected
-          end
-        end
-
-        context "and it isn't selected by sub navigation" do
-          before { item.stub(selected_by_subnav?: false) }
-
-          context 'and it is selected by a highlighting condition' do
-            before { item.stub(selected_by_condition?: true) }
-
-            it 'is selected' do
-              expect(item).to be_selected
-            end
-          end
-
-          context "and it isn't selected by any highlighting condition" do
-            before { item.stub(selected_by_condition?: false) }
-
-            it "isn't selected" do
-              expect(item).not_to be_selected
-            end
-          end
-        end
-      end
-    end
-
-    describe '#selected_class' do
-      context 'when the item is selected' do
-        before { item.stub(selected?: true) }
-
-        it 'returns the default selected_class' do
-          expect(item.selected_class).to eq 'selected'
-        end
-
-        context 'and selected_class is defined in the context' do
-          before { item_container.stub(selected_class: 'defined') }
-
-          it "returns the context's selected_class" do
-            expect(item.selected_class).to eq 'defined'
-          end
-        end
-      end
-  
-      context 'when the item is not selected' do
-        before { item.stub(selected?: false) }
-
-        it 'returns nil' do
-          expect(item.selected_class).to be_nil
-        end
-      end
-    end
-
-    describe ':html_options argument' do
-      let(:selected_classes) { 'selected simple-navigation-active-leaf' }
-
-      context 'when the :class option is given' do
-        let(:options) {{ class: 'my_class' }}
-
-        context 'and the item is selected' do
-          before { item.stub(selected?: true, selected_by_condition?: true) }
-
-          it "adds the specified class to the item's html classes" do
-            expect(item.html_options[:class]).to include('my_class')
-          end
-
-          it "doesn't replace the default html classes of a selected item" do
-            expect(item.html_options[:class]).to include(selected_classes)
-          end
-        end
-
-        context "and the item isn't selected" do
-          before { item.stub(selected?: false, selected_by_condition?: false) }
-
-          it "sets the specified class as the item's html classes" do
-            expect(item.html_options[:class]).to include('my_class')
-          end
-        end
-      end
-
-      context "when the :class option isn't given" do
-        context 'and the item is selected' do
-          before { item.stub(selected?: true, selected_by_condition?: true) }
-
-          it "sets the default html classes of a selected item" do
-            expect(item.html_options[:class]).to include(selected_classes)
-          end
-        end
-
-        context "and the item isn't selected" do
-           before { item.stub(selected?: false, selected_by_condition?: false) }
-
-           it "doesn't set any html class on the item" do
-             expect(item.html_options[:class]).to be_blank
-           end
-        end
-      end
-
-      shared_examples 'generating id' do |id|
-        it "sets the item's html id to the specified id" do
-          expect(item.html_options[:id]).to eq id
-        end
-      end
-
-      describe 'when the :id option is given' do
-        let(:options) {{ id: 'my_id' }}
-
-        before do
-          item.stub(selected?: false,
-                    selected_by_condition?: false,
-                    autogenerate_item_ids?: generate_ids)
-        end
-
-        context 'and :autogenerate_item_ids is true' do
-          let(:generate_ids) { true }
-
-          it_behaves_like 'generating id', 'my_id'
-        end
-
-        context 'and :autogenerate_item_ids is false' do
-          let(:generate_ids) { false }
-
-          it_behaves_like 'generating id', 'my_id'
-        end
-      end
-
-      context "when the :id option isn't given" do
-        before do
-          item.stub(selected?: false,
-                    selected_by_condition?: false,
-                    autogenerate_item_ids?: generate_ids)
-        end
-
-        context 'and :autogenerate_item_ids is true' do
-          let(:generate_ids) { true }
-
-          it_behaves_like 'generating id', 'my_key'
-        end
-
-        context 'and :autogenerate_item_ids is false' do
-          let(:generate_ids) { false }
-
-          it "doesn't set any html id on the item" do
-            expect(item.html_options[:id]).to be_blank
-          end
-        end
-      end
-    end
-
-    describe '#selected_by_subnav?' do
-      before { item.stub(sub_navigation: sub_navigation) }
-
-      context 'the item has a sub_navigation' do
-        let(:sub_navigation) { double(:sub_navigation) }
-
-        context 'and an item of the sub_navigation is selected' do
-          before do
-            sub_navigation.stub(selected?: true, selected_by_condition?: true)
-          end
-
-          it 'returns true' do
-            expect(item).to be_selected_by_subnav
-          end
-        end
-
-        context 'and no item of the sub_navigation is selected' do
-          before do
-            sub_navigation.stub(selected?: false, selected_by_condition?: true)
-          end
-
-          it 'returns false' do
-            expect(item).not_to be_selected_by_subnav
-          end
-        end
-      end
-
-      context "when the item doesn't have any sub_navigation" do
-        let(:sub_navigation) { nil }
-
-        it 'returns false' do
-          expect(item).not_to be_selected_by_subnav
-        end
-      end
-    end
-
-    describe '#selected_by_condition?' do
-      let(:current_url) { '' }
-
-      before { adapter.stub(request_uri: current_url) }
-
-      context 'when the :highlights_on option is set' do
-        before { item.stub(highlights_on: /^\/matching/) }
-
-        context 'and :highlights_on is a regexp' do
-          context 'and it matches the current url' do
-            let(:current_url) { '/matching_url' }
-
-            it 'returns true' do
-              expect(item).to be_selected_by_condition
-            end
-          end
-
-          context "and it doesn't match current url" do
-            let(:current_url) { '/other_url' }
-
-            it 'returns false' do
-              expect(item).not_to be_selected_by_condition
-            end
-          end
-        end
-
-        context 'and :highlights_on is a lambda' do
-          context 'and it is truthy' do
-            before { item.stub(highlights_on: ->{ true }) }
-
-            it 'returns true' do
-              expect(item).to be_selected_by_condition
-            end
-          end
-
-          context 'falsey lambda results in no selection' do
-            before { item.stub(highlights_on: ->{ false }) }
-
-            it 'returns false' do
-              expect(item).not_to be_selected_by_condition
-            end
-          end
-        end
-
-        context 'and :highlights_on is :subpath' do
-          before { item.stub(url: '/path', highlights_on: :subpath) }
-
-          context "and the current url is a sub path of the item's url" do
-            let(:current_url) { '/path/sub-path' }
-
-            it 'returns true' do
-              expect(item).to be_selected_by_condition
-            end
-          end
-
-          context "and the current url starts with item's url" do
-            let(:current_url) { '/path_group/id' }
-
-            it 'returns false' do
-              expect(item).not_to be_selected_by_condition
-            end
-          end
-
-          context "and the current url is totally different from the item's url" do
-            let(:current_url) { '/other_path/id' }
-
-            it 'returns false' do
-              expect(item).not_to be_selected_by_condition
-            end
-          end
-        end
-
-        context 'when :highlights_on something else' do
-          before { item.stub(highlights_on: 'nothing') }
-
-          it 'raises an exception' do
-            expect{ item.send(:selected_by_condition?) }.to raise_error
-          end
-        end
-      end
-
-      context 'when :auto_highlight is true' do
-        before { item.stub(auto_highlight?: true) }
-
-        context 'and root path matches' do
-          before { item.stub(root_path_match?: true) }
-
-          it 'returns true' do
-            expect(item).to be_selected_by_condition
-          end
-        end
-
-        context "and root path doesn't match" do
-          before { item.stub(root_path_match?: false) }
-
-          context "and the current url matches the item's url" do
-            let(:url) { 'url#anchor' }
-
-            before { adapter.stub(current_page?: true) }
-
-            it 'returns true' do
-              expect(item).to be_selected_by_condition
-            end
-
-            # FIXME: testing the implementation not the behavior here
-            it "removes anchors before testing the item's url" do
-              expect(adapter).to receive(:current_page?).with('url')
-              item.send(:selected_by_condition?)
-            end
-
-            context 'when url is nil' do
-              let(:url) { nil }
-
-              it "doesn't check the url" do
-                expect(adapter).not_to receive(:current_page?)
-                item.send(:selected_by_condition?)
-              end
-            end
-          end
-
-          context "and the current url doesn't match the item's url" do
-            before { adapter.stub(current_page?: false) }
-
-            it 'returns false' do
-              expect(item).not_to be_selected_by_condition
-            end
-          end
-        end
-      end
-
-      context 'when :auto_highlight is false' do
-        before { item.stub(auto_highlight?: false) }
-
-        it 'returns false' do
-          expect(item).not_to be_selected_by_condition
-        end
-      end
-    end
-
-    describe '#root_path_match?' do
-      context "when current url is /" do
-        before { adapter.stub(request_path: '/') }
-
-        context "and the item's url is /" do
-          let(:url) { '/' }
-
-          it 'returns true' do
-            expect(item.send(:root_path_match?)).to be_true
-          end
-        end
-
-        context "and the item's url isn't /" do
-          let(:url) { '/other' }
-
-          it 'returns false' do
-            expect(item.send(:root_path_match?)).to be_false
-          end
-        end
-      end
-
-      context "when current url isn't /" do
-        before { adapter.stub(request_path: '/other') }
-
-        context "and the item's url is /" do
-          let(:url) { '/' }
-
-          it 'returns false' do
-            expect(item.send(:root_path_match?)).to be_false
-          end
-        end
-
-        context "and the item's url is nil" do
-          let(:url) { nil }
-
-          it 'returns false' do
-            expect(item.send(:root_path_match?)).to be_false
-          end
-        end
-      end
-
-      context "when current url doesn't match the item's url" do
-        let(:url) { '/path' }
-
-        before { adapter.stub(request_path: '/other') }
-
-        it 'returns false' do
-          expect(item.send(:root_path_match?)).to be_false
-        end
-      end
-
-      context "when current url doesn't match the item's url" do
-        let(:url) { nil }
-
-        before { adapter.stub(request_path: '/other') }
-
-        it 'returns false' do
-          expect(item.send(:root_path_match?)).to be_false
-        end
-      end
-    end
-
-    describe '#auto_highlight?' do
-      let(:global) { double(:config) }
-
-      before { SimpleNavigation.stub(config: global) }
-
-      context 'when :auto_highlight is globally true' do
-        before { global.stub(auto_highlight: true) }
-
-        context "and container's :auto_highlight is true" do
-          before { item_container.stub(auto_highlight: true) }
-
-          it 'returns true' do
-            expect(item.send(:auto_highlight?)).to be_true
-          end
-        end
-
-        context "and container's :auto_highlight is false" do
-          before { item_container.stub(auto_highlight: false) }
-
-          it 'returns false' do
-            expect(item.send(:auto_highlight?)).to be_false
-          end
-        end
-      end
-
-      context 'when :auto_highlight is globally false' do
-        before { global.stub(auto_highlight: false) }
-
-        context 'when :auto_highlight is globally true' do
-          before { item_container.stub(auto_highlight: true) }
-
-          it 'returns false' do
-            expect(item.send(:auto_highlight?)).to be_false
-          end
-        end
-
-        context "and container's :auto_highlight is false" do
-          before { item_container.stub(auto_highlight: false) }
-
-          it 'returns false' do
-            expect(item.send(:auto_highlight?)).to be_false
-          end
-        end
-      end
-    end
-
-    describe '#autogenerated_item_id' do
-      context 'when no generator is configured' do
-        let(:id_generator) { double(:id_generator) }
-
-        before { SimpleNavigation.config.stub(id_generator: id_generator) }
-
-        it 'calls the globally configured id generator' do
-          expect(id_generator).to receive(:call).with(:my_key)
-          item.send(:autogenerated_item_id)
-        end
-      end
-
-      context 'when no generator is configured' do
-        it 'uses the default generator' do
-          expect(item.send(:autogenerated_item_id)).to eq 'my_key'
-        end
-      end
-    end
-  end
-end