simple-navigation 1.1.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+*1.1.1
+
+* Change plugin into a GemPlugin

data/README

@@ -0,0 +1,19 @@
+
+== Simple Navigation
+
+Simple Navigation is a plugin for creating a navigation (optionally with sub navigation) for your rails app.
+
+Source code:
+  git://github.com/andi/simple-navigation.git
+
+Documentation: 
+  http://wiki.github.com/andi/simple-navigation
+
+Online Demo:
+  http://simple-navigation-demo.andischacke.com
+
+Discussion Group for Feedback and Questions
+  http://groups.google.com/group/simple-navigation
+
+Copyright (c) 2009 Andi Schacke, released under the MIT license
+

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Generate documentation for the simple_navigation plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SimpleNavigation'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "simple-navigation"
+    gemspec.summary = "Simple Navigation is a ruby library for creating a navigation (optionally with sub navigation) for your rails app."
+    gemspec.email = "andreas.schacke@gmail.com"
+    gemspec.homepage = "http://github.com/andi/simple-navigation"
+    gemspec.description = "Simple Navigation is a ruby library for creating a navigation (optionally with sub navigation) for your rails app."
+    gemspec.authors = ["Andi Schacke"]
+    gemspec.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+    gemspec.files += ["CHANGELOG"]
+    gemspec.rubyforge_project = 'andi'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+begin
+  require 'rake/contrib/sshpublisher'
+  namespace :rubyforge do
+
+    desc "Release gem and RDoc documentation to RubyForge"
+    task :release => ["rubyforge:release:gem", "rubyforge:release:docs"]
+
+    namespace :release do
+      desc "Publish RDoc to RubyForge."
+      task :docs => [:rdoc] do
+        config = YAML.load(
+            File.read(File.expand_path('~/.rubyforge/user-config.yml'))
+        )
+
+        host = "#{config['username']}@rubyforge.org"
+        remote_dir = "/var/www/gforge-projects/simple-navigation/"
+        local_dir = 'rdoc'
+
+        Rake::SshDirPublisher.new(host, remote_dir, local_dir).upload
+      end
+    end
+  end
+rescue LoadError
+  puts "Rake SshDirPublisher is unavailable or your rubyforge environment is not configured."
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 1
+:major: 1

data/generators/navigation_config/USAGE

@@ -0,0 +1 @@
+Creates a template config file for the simple-navigation plugin. You will find the generated file in config/navigation.rb.

data/generators/navigation_config/navigation_config_generator.rb

@@ -0,0 +1,8 @@
+class NavigationConfigGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.file "config/navigation.rb", "config/navigation.rb"
+      m.readme "../../../README"
+    end
+  end
+end

data/generators/navigation_config/templates/config/navigation.rb

@@ -0,0 +1,28 @@
+# Configures your navigation
+SimpleNavigation::Configuration.run do |navigation|  
+  # Specify a custom renderer if needed. 
+  # The default renderer is SimpleNavigation::Renderer::List which renders HTML lists.
+  # navigation.renderer = Your::Custom::Renderer
+  
+  # Specify the class that will be applied to active navigation items. Defaults to 'selected'
+  # navigation.selected_class = 'your_selected_class'
+  
+  # Define the primary navigation
+  navigation.items do |primary|
+    # Add an item to the primary navigation. The following params apply:
+    # key - a symbol which uniquely defines your navigation item in the scope of the primary_navigation
+    # name - will be displayed in the rendered navigation. This can also be a call to your I18n-framework.
+    # url - the address that the generated item links to. You can also use url_helpers (named routes, restful routes helper, url_for etc.)
+    # html_options - can be used to specify attributes that will be included in the rendered navigation item (e.g. id, class etc.)
+    #
+    primary.item :key_1, 'name', url, html_options
+    
+    # Add an item which has a sub navigation (same params, but with block)
+    primary.item :key_2, 'name', url, html_options do |sub_nav|
+      # Add an item to the sub navigation (same params again)
+      sub_nav.item :key_2_1, 'name', url, html_options
+    end 
+  
+  end
+  
+end

data/lib/simple_navigation.rb

@@ -0,0 +1,21 @@
+# A plugin for generating a simple navigation. See README for resources on usage instructions.
+module SimpleNavigation
+
+  mattr_accessor :config_file
+  
+  # Reads the specified config_file and stores it for later evaluation.
+  def self.load_config(config_file)
+    self.config_file = IO.read(config_file)
+  end
+
+  # Returns the singleton instance of the SimpleNavigation::Configuration
+  def self.config 
+    Configuration.instance
+  end
+  
+  # Returns the ItemContainer that contains the items for the primary navigation
+  def self.primary_navigation
+    config.primary_navigation
+  end
+
+end

data/lib/simple_navigation/configuration.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+
+module SimpleNavigation
+  
+  # Responsible for evaluating and handling the config/navigation.rb file. 
+  class Configuration
+    include Singleton
+    
+    attr_accessor :renderer
+    attr_accessor :selected_class
+    attr_reader :primary_navigation
+
+    # Evals the config_file inside the specified context (usually a controller or view)
+    def self.eval_config(context)
+      context.instance_eval(SimpleNavigation.config_file)
+    end
+
+    # Starts processing the configuration
+    def self.run(&block)
+      block.call Configuration.instance
+    end    
+    
+    # Sets the config's default-settings
+    def initialize
+      @renderer = SimpleNavigation::Renderer::List
+      @selected_class = 'selected'
+    end
+  
+    # Yields an SimpleNavigation::ItemContainer for adding navigation items
+    def items(&block)
+      @primary_navigation = ItemContainer.new
+      block.call @primary_navigation
+    end
+    
+    # Returns true if the config_file has already been evaluated.
+    def loaded?
+      !@primary_navigation.nil?
+    end    
+  end  
+  
+end

data/lib/simple_navigation/controller_methods.rb

@@ -0,0 +1,74 @@
+#TODO: add :except and :only options to navigation method
+module SimpleNavigation
+  
+  # Adds methods for handling the current 'active' navigation to the controllers.
+  # 
+  # On the controller class level, use the navigation method to set the active navigation for all actions in the controller.
+  # 
+  # ==== Examples
+  #   class AccountController << ActionController
+  #     navigation :account
+  #     ...
+  #   end
+  #
+  #   class AccountSettingsController << ActionController
+  #     navigation :account, :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_primary_navigation to :account and the current_sub_navigation to :settings.
+  # 
+  # On the controller instance level, use the current_navigation method to define the active navigation for a specific action. 
+  # The navigation item that is set in current_navigation overrides the one defined on the controller class level (see navigation method).
+  #
+  # ==== Example
+  #   class AccountController << ActionController
+  #     navigation :account
+  #     
+  #     def your_special_action
+  #       ...
+  #       current_navigation :special
+  #     end
+  #   end
+  #
+  # This overrides :account as active navigation for your_special_action and sets it to :special.
+  #
+  # Note: 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
+        helper SimpleNavigation::Helpers
+      end
+    end
+  
+    module ClassMethods
+      # Sets the active navigation for all actions in this controller.
+      #
+      # The specified symbols must match the keys for your navigation items in your config/navigation.rb file.  
+      def navigation(primary_navigation, sub_navigation=nil)
+        self.class_eval do
+          define_method :set_navigation do
+            current_navigation(primary_navigation, sub_navigation)
+          end
+          before_filter :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 symbols must match the keys for your navigation items in your config/navigation.rb file.
+      def current_navigation(primary_navigation, sub_navigation=nil)
+        @current_primary_navigation = primary_navigation
+        @current_secondary_navigation = sub_navigation
+      end
+    end
+
+  end
+end

data/lib/simple_navigation/helpers.rb

@@ -0,0 +1,51 @@
+module SimpleNavigation
+  
+  # View helpers to render the navigation.
+  #
+  # Use render_primary_navigation to render your primary navigation with the configured renderer.
+  # Use render_sub_navigation to render the sub navigation belonging to the active primary navigation.
+  # Use render_navigation to render the primary navigation with the corresponding sub navigation rendered inside primary navigation item which is active.
+  # 
+  # ==== Examples (using Haml)
+  #   #primary_navigation= render_primary_navigation
+  #   
+  #   #sub_navigation= render_sub_navigation
+  #
+  #   #main_navigation= render_navigation
+  #
+  module Helpers
+    
+    # Renders the navigation according to the specified <tt>level</tt>. 
+    # 
+    # The <tt>level</tt> defaults to :nested which renders the the sub_navigation for an active primary_navigation inside that active primary_navigation item. 
+    # 
+    # Other possible levels are 
+    # 
+    # :primary which only renders the primary_navigation (also see render_primary_navigation) and :secondary which only renders the sub_navigation (see render_sub_navigation).
+    def render_navigation(level = :nested)
+      SimpleNavigation::Configuration.eval_config(self) unless SimpleNavigation.config.loaded?
+      case level
+      when :primary:
+        SimpleNavigation.primary_navigation.render(@current_primary_navigation)
+      when :secondary:
+        primary = SimpleNavigation.primary_navigation[@current_primary_navigation]
+        primary.sub_navigation.render(@current_secondary_navigation) if primary && primary.sub_navigation
+      when :nested:
+        SimpleNavigation.primary_navigation.render(@current_primary_navigation, true, @current_secondary_navigation)
+      else
+        raise ArgumentError, "Invalid navigation level: #{level}"
+      end
+    end
+    
+    # Renders the primary_navigation with the configured renderer. Calling render_navigation(:primary) has the same effect.
+    def render_primary_navigation
+      render_navigation(:primary)
+    end
+    
+    # Renders the sub_navigation with the configured renderer. Calling render_navigation(:secondary) has the same effect.
+    def render_sub_navigation
+      render_navigation(:secondary)
+    end
+    
+  end
+end

data/lib/simple_navigation/item.rb

@@ -0,0 +1,40 @@
+module SimpleNavigation
+  
+  # Represents an item in your navigation. Gets generated by the item method in the config-file.
+  class Item
+    attr_reader :key, :name, :url, :sub_navigation
+    
+    # see ItemContainer#item
+    def initialize(key, name, url, html_options, sub_nav_block)
+      @key = key
+      @name = name
+      @url = url
+      @html_options = html_options
+      if sub_nav_block
+        @sub_navigation = ItemContainer.new
+        sub_nav_block.call @sub_navigation
+      end
+    end
+    
+    # Returns true if this navigation item should be rendered as 'selected' for the specified current_navigation.
+    def selected?(current_navigation)
+      key == current_navigation
+    end
+        
+    # Returns the html-options hash for the item, i.e. the options specified for this item in the config-file.
+    # It also adds the 'selected' class to the list of classes if necessary. 
+    def html_options(current_navigation)
+      default_options = {:id => key.to_s}
+      options = default_options.merge(@html_options)
+      options[:class] = [@html_options[:class], self.selected_class(current_navigation)].flatten.compact.join(' ')
+      options.delete(:class) if options[:class].blank? 
+      options
+    end
+        
+    def selected_class(current_navigation) #:nodoc:
+      selected?(current_navigation) ? SimpleNavigation.config.selected_class : nil
+    end
+    
+        
+  end
+end

data/lib/simple_navigation/item_container.rb

@@ -0,0 +1,43 @@
+module SimpleNavigation
+  
+  # Holds the Items for a navigation 'level' (either the primary_navigation or a sub_navigation).
+  class ItemContainer
+    
+    attr_reader :items
+    attr_accessor :renderer, :dom_id
+    
+    def initialize #:nodoc:
+      @items = []
+      @renderer = Configuration.instance.renderer
+    end
+    
+    # Creates a new navigation item. 
+    #
+    # The <tt>key</tt> is a symbol which uniquely defines your navigation item in the scope of the primary_navigation or the sub_navigation.
+    # 
+    # The <tt>name</tt> will be displayed in the rendered navigation. This can also be a call to your I18n-framework.
+    #
+    # The <tt>url</tt> is the address that the generated item points to. You can also use url_helpers (named routes, restful routes helper, url_for etc.) 
+    #
+    # The <tt>html_options</tt> can be used to specify attributes that will be included in the rendered navigation item (e.g. id, class etc.)
+    #
+    # The <tt>block</tt> - if specified - will hold the item's sub_navigation.
+    def item(key, name, url, html_options={}, &block)
+      @items << Item.new(key, name, url, html_options, block)
+    end
+
+    # Returns the Item with the specified key, nil otherwise.
+    def [](navi_key)
+      items.find {|i| i.key == navi_key}
+    end
+  
+    # Renders the items in this ItemContainer using the configured renderer.
+    #
+    # Set <tt>include_sub_navigation</tt> to true if you want to nest the sub_navigation into the active primary_navigation
+    def render(current_navigation, include_sub_navigation=false, current_sub_navigation=nil)
+      self.renderer.new(current_navigation, current_sub_navigation).render(self, include_sub_navigation)
+    end
+    
+  end
+  
+end

data/lib/simple_navigation/renderer/base.rb

@@ -0,0 +1,30 @@
+module SimpleNavigation
+  module Renderer
+    
+    # This is the base class for all renderers.
+    #
+    # A renderer is responsible for rendering an ItemContainer (primary or a sub_navigation) and its containing items to HTML.
+    # It must be initialized with the current_navigation for the rendered ItemContainer and 
+    # optionally with the current_sub_navigation (if the sub_navigation will be nested).
+    class Base
+      include ActionView::Helpers::UrlHelper
+      include ActionView::Helpers::TagHelper
+      
+      attr_reader :current_navigation, :current_sub_navigation
+      
+      def initialize(current_navigation, current_sub_navigation=nil) #:nodoc:
+        @current_navigation = current_navigation
+        @current_sub_navigation = current_sub_navigation
+      end
+      
+      # Renders the specified ItemContainer to HTML.
+      #
+      # If <tt>include_sub_navigation</tt> is set to true, the renderer should nest the sub_navigation for the active navigation 
+      # inside that navigation item.  
+      def render(item_container, include_sub_navigation=false)
+        raise 'subclass responsibility'
+      end
+      
+    end
+  end
+end

data/lib/simple_navigation/renderer/list.rb

@@ -0,0 +1,24 @@
+module SimpleNavigation
+  module Renderer
+    
+    # Renders an ItemContainer as a <ul> element and its containing items as <li> elements. 
+    # It adds the 'selected' class to li element AND the link inside the li element that is currently active.
+    # If the sub navigation should be included, it renders another <ul> containing the sub navigation inside the active <li> element.
+    #
+    # By default, the renderer sets the item's key as dom_id for the rendered <li> element. The id can be explicitely specified by setting
+    # the id in the html-options of the 'item' method in the config/navigation.rb file.
+    class List < Renderer::Base
+      
+      def render(item_container, include_sub_navigation=false)
+        list_content = item_container.items.inject([]) do |list, item|
+          html_options = item.html_options(current_navigation)
+          li_content = link_to(item.name, item.url, :class => item.selected_class(current_navigation))
+          li_content << (item.sub_navigation.render(current_sub_navigation)) if include_sub_navigation && item.sub_navigation && item.selected?(current_navigation)
+          list << content_tag(:li, li_content, html_options)
+        end
+        content_tag(:ul, list_content, {:id => item_container.dom_id})
+      end
+      
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+config_file_path = File.join(RAILS_ROOT, 'config', 'navigation.rb')
+SimpleNavigation.load_config(config_file_path) if File.exists?(config_file_path)
+ActionController::Base.send(:include, SimpleNavigation::ControllerMethods)

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SimpleNavigation do
+
+  describe 'load_config' do
+        
+    before(:each) do
+      @config_file = '"my_navigation_config"'
+      IO.stub!(:read).and_return(@config_file)
+    end
+    
+    it "should load the navigation-configfile into a string" do
+      IO.should_receive(:read).with('./config/navigation.rb')
+      SimpleNavigation.load_config('./config/navigation.rb')
+    end
+    it "should store that string in a module-var" do
+      SimpleNavigation.load_config('./config/navigation.rb')
+      SimpleNavigation.config_file.should == @config_file
+    end
+  end
+  
+  describe 'config' do
+    it {SimpleNavigation.config.should == SimpleNavigation::Configuration.instance}
+  end
+  
+end
+
+describe SimpleNavigation::Configuration do
+  
+  before(:each) do
+    @config = SimpleNavigation::Configuration.instance
+  end
+  
+  describe 'self.run' do
+    it "should yield the singleton Configuration object" do
+      SimpleNavigation::Configuration.run do |c|
+        c.should == @config
+      end
+    end
+  end
+
+  describe 'self.eval_config' do
+    before(:each) do
+      @context = mock(:context)
+      @config_file = stub(:config_file)
+      SimpleNavigation.stub!(:config_file).and_return(@config_file)
+    end
+    it "should instance_eval the config_file-string inside the context" do
+      @context.should_receive(:instance_eval).with(@config_file)
+      SimpleNavigation::Configuration.eval_config(@context)
+    end    
+  end
+
+  describe 'initialize' do
+    it "should set the List-Renderer as default upon initialize" do
+      @config.renderer.should == SimpleNavigation::Renderer::List
+    end
+    it "should set the selected_class to 'selected' as default" do
+      @config.selected_class.should == 'selected'
+    end
+  end  
+  describe 'items' do
+    before(:each) do
+      @container = stub(:items_container)
+      SimpleNavigation::ItemContainer.stub!(:new).and_return(@container)
+    end
+    it "should should yield an new ItemContainer" do
+      @config.items do |container|
+        container.should == @container
+      end
+    end
+    it "should assign the ItemContainer to an instance-var" do
+      @config.items {}
+      @config.primary_navigation.should == @container
+    end
+  end
+
+  
+end
+
+

data/spec/lib/controller_methods_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+ActionController::Base.send(:include, SimpleNavigation::ControllerMethods)
+
+describe SimpleNavigation::ControllerMethods do
+
+  def stub_loading_config
+    SimpleNavigation::Configuration.stub!(:load)
+  end
+
+  before(:each) do
+    stub_loading_config
+    class ApplicationController < ActionController::Base
+    end
+    @controller = ApplicationController.new
+  end
+  
+  describe 'when being included' do
+    it "should extend the ClassMethods" do
+      @controller.class.should respond_to(:navigation)
+    end
+    it "should include the InstanceMethods" do
+      @controller.should respond_to(:current_navigation)
+    end
+    it "should install the Helpers Module" do
+      @controller.master_helper_module.included_modules.should include(SimpleNavigation::Helpers)
+    end
+  end
+  
+  describe 'class_methods' do
+    
+    describe 'navigation' do
+      
+      def call_navigation(key1, key2=nil)
+        @controller.class_eval do
+          navigation key1, key2
+        end
+      end
+      
+      it "should not have an instance-method 'set_navigation if navigation-method has not been called" do
+        @controller.respond_to?(:set_navigation).should be_false
+      end
+      it 'should create an instance-method "set_navigation" when being called' do
+        call_navigation(:key)
+        @controller.respond_to?(:set_navigation).should be_true
+      end
+      it 'the created method should call current_navigation with the specified keys' do
+        call_navigation(:primary, :secondary)
+        @controller.should_receive(:current_navigation).with(:primary, :secondary)
+        @controller.set_navigation
+      end
+    end
+    
+  end
+  
+  describe 'instance_methods' do
+    
+    describe 'current_navigation' do
+      it "should set the current_primary_navigation as specified" do
+        @controller.current_navigation(:first)
+        @controller.instance_variable_get(:@current_primary_navigation).should == :first
+      end
+      it "should set the current_secondary_navigation as specified" do
+        @controller.current_navigation(:first, :second)
+        @controller.instance_variable_get(:@current_secondary_navigation).should == :second
+      end
+      it "should set the current_secondary_navigation to nil if no secondary is specified" do
+        @controller.current_navigation(:first)
+        @controller.instance_variable_get(:@current_secondary_navigation).should be_nil
+      end
+    end
+    
+  end
+  
+end

data/spec/lib/helpers_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SimpleNavigation::Helpers do
+  class ControllerMock
+    include SimpleNavigation::Helpers
+  end
+  
+  before(:each) do
+    @controller = ControllerMock.new
+    SimpleNavigation.config.stub!(:loaded?).and_return(true)
+    @primary_navigation = stub(:primary_navigation)
+    SimpleNavigation.stub!(:primary_navigation).and_return(@primary_navigation)
+  end
+  
+  describe 'render_navigation' do
+    context 'primary' do
+      before(:each) do
+        @controller.instance_variable_set(:@current_primary_navigation, :current_primary)
+      end
+      it "should call render on the primary_navigation" do
+        @primary_navigation.should_receive(:render).with(:current_primary)
+        @controller.render_navigation(:primary)
+      end
+    end
+    
+    context 'secondary' do
+      context 'with current_primary_navigation set' do
+        before(:each) do
+          @sub_navigation = stub(:sub_navigation, :null_object => true)
+          @primary_navigation.stub!(:[]).and_return(@sub_navigation)
+          @controller.instance_variable_set(:@current_primary_navigation, :current_primary)
+          @controller.instance_variable_set(:@current_secondary_navigation, :current_secondary)
+        end
+        it "should find the sub_navigation belonging to the current primary_navigation" do
+          @primary_navigation.should_receive(:[]).with(:current_primary)
+          @controller.render_navigation(:secondary)
+        end
+        it "should call render on the current primary_navigation's sub_navigation" do
+          @sub_navigation.should_receive(:render).with(:current_secondary)
+          @controller.render_navigation(:secondary)
+        end
+      end
+      context 'without current_primary_navigation set' do
+        before(:each) do
+          @primary_navigation.stub!(:[]).and_return(nil)
+          @controller.instance_variable_set(:@current_primary_navigation, nil)
+        end
+        it "should not raise an error" do
+          lambda{@controller.render_navigation(:secondary)}.should_not raise_error
+        end
+      end
+      
+    end
+    
+    context 'nested' do
+      before(:each) do
+        @controller.instance_variable_set(:@current_primary_navigation, :current_primary)
+        @controller.instance_variable_set(:@current_secondary_navigation, :current_secondary)
+      end
+      it "should call render on the primary navigation" do
+        @primary_navigation.should_receive(:render).with(anything, anything, anything)
+        @controller.render_navigation(:nested)
+      end
+      it "should call render with the current_primary_navigation" do
+        @primary_navigation.should_receive(:render).with(:current_primary, anything, anything)
+        @controller.render_navigation(:nested)
+      end
+      it "should call render with the include_subnavigation option set" do
+        @primary_navigation.should_receive(:render).with(anything, true, anything)
+        @controller.render_navigation(:nested)
+      end
+      it "should call render with the current_sub_navigation" do
+        @primary_navigation.should_receive(:render).with(anything, anything, :current_secondary)
+        @controller.render_navigation(:nested)
+      end
+    end
+    
+    context 'unknown level' do
+      it {lambda {@controller.render_navigation(:unknown)}.should raise_error(ArgumentError)}
+    end
+  end
+  
+  describe 'render_primary_navigation' do  
+    it "should delegate to render_navigation(:primary)" do
+      @controller.should_receive(:render_navigation).with(:primary)
+      @controller.render_primary_navigation
+    end
+  end
+  
+  describe 'render_sub_navigation' do
+    it "should delegate to render_navigation(:secondary)" do
+      @controller.should_receive(:render_navigation).with(:secondary)
+      @controller.render_sub_navigation
+    end
+  end
+  
+end

data/spec/lib/item_container_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SimpleNavigation::ItemContainer do  
+  before(:each) do
+    @item_container = SimpleNavigation::ItemContainer.new
+  end
+  describe 'initialize' do
+    it "should set the renderer to the globally-configured renderer per default" do
+      SimpleNavigation::Configuration.instance.should_receive(:renderer)
+      @item_container = SimpleNavigation::ItemContainer.new
+    end
+    it "should have an empty items-array" do
+      @item_container = SimpleNavigation::ItemContainer.new
+      @item_container.items.should be_empty
+    end
+  end
+
+  describe 'item' do
+    
+    context 'block given' do    
+      before(:each) do
+        @sub_container = stub(:sub_container)
+        SimpleNavigation::ItemContainer.stub!(:new).and_return(@sub_container)
+      end
+      
+      it "should should yield an new ItemContainer" do
+        @item_container.item('key', 'name', 'url', 'options') do |container|
+          container.should == @sub_container
+        end
+      end
+      it "should create a new Navigation-Item with the given params and the specified block" do
+        SimpleNavigation::Item.should_receive(:new).with('key', 'name', 'url', 'options', @proc)
+        @item_container.item('key', 'name', 'url', 'options', &@proc)
+      end
+      it "should add the created item to the list of items" do
+        @item_container.items.should_receive(:<<)
+        @item_container.item('key', 'name', 'url', 'options') {}
+      end
+    end
+    
+    context 'no block given' do
+      it "should create a new Navigation_item with the given params and nil as sub_navi" do
+        SimpleNavigation::Item.should_receive(:new).with('key', 'name', 'url', 'options', nil)
+        @item_container.item('key', 'name', 'url', 'options')
+      end
+      it "should add the created item to the list of items" do
+        @item_container.items.should_receive(:<<)
+        @item_container.item('key', 'name', 'url', 'options')
+      end
+    end
+    
+  end
+  
+  describe '[]' do
+    
+    before(:each) do
+      @item_container.item(:first, 'first', 'bla')
+      @item_container.item(:second, 'second', 'bla')
+      @item_container.item(:third, 'third', 'bla')
+    end
+  
+    it "should return the item with the specified navi_key" do
+      @item_container[:second].name.should == 'second'
+    end
+    it "should return nil if no item exists for the specified navi_key" do
+      @item_container[:invalid].should be_nil
+    end
+  end
+  
+  describe 'render' do
+    before(:each) do
+      @renderer = stub(:renderer)
+      @renderer_instance = stub(:renderer_instance, :null_object => true)
+      @renderer.stub!(:new).and_return(@renderer_instance)
+      @item_container.stub!(:renderer).and_return(@renderer)
+      @items = stub(:items)
+      @item_container.stub!(:items).and_return(@items)
+    end
+    it "should instatiate a renderer with the current_primary and current_secondary" do
+      @renderer.should_receive(:new).with(:current_navigation, nil)
+      @item_container.render(:current_navigation)
+    end
+    it "should call render on the renderer and pass self" do
+      @renderer_instance.should_receive(:render).with(@item_container, anything)
+      @item_container.render(:current_navigation)
+    end
+    it "should call render on the renderer and pass the include_sub_navigation option" do
+      @renderer_instance.should_receive(:render).with(anything, true)
+      @item_container.render(:current_navigation, true, :current_sub_navigation)
+    end
+    
+  end
+  
+end

data/spec/lib/item_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe SimpleNavigation::Item do
+  
+  describe 'initialize' do
+  
+  end
+  
+  describe 'selected?' do
+    before(:each) do
+      @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', {}, nil)
+    end
+    it {@item.selected?(:my_key).should be_true}
+    it {@item.selected?(:my_other_key).should be_false}
+  end
+  
+  describe 'selected_class' do
+    before(:each) do
+      @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', {}, nil)
+    end
+    
+    context 'item is selected' do
+      before(:each) do
+        @item.stub!(:selected?).and_return(true)
+      end
+      it {@item.instance_eval {selected_class(:bla).should == 'selected'}}
+    end
+    
+    context 'item is not selected' do
+      before(:each) do
+        @item.stub!(:selected?).and_return(false)
+      end
+      it {@item.instance_eval {selected_class(:bla).should == nil}}
+    end
+  end
+  
+  describe 'html_options' do
+    describe 'class' do
+      context 'with classes defined in options' do
+        before(:each) do
+          @options = {:class => 'my_class'}
+          @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', @options, nil)
+        end
+        context 'with item selected' do
+          before(:each) do
+            @item.stub!(:selected?).and_return(true)
+          end
+          it {@item.html_options(:bla)[:class].should == 'my_class selected'}
+        end
+      
+        context 'with item not selected' do
+          before(:each) do
+            @item.stub!(:selected?).and_return(false)
+          end
+          it {@item.html_options(:bla)[:class].should == 'my_class'}
+        end
+      end
+    
+      context 'without classes in options' do
+        before(:each) do
+          @options = {}
+          @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', @options, nil)
+        end
+        context 'with item selected' do
+          before(:each) do
+            @item.stub!(:selected?).and_return(true)
+          end
+          it {@item.html_options(:bla)[:class].should == 'selected'}
+        end
+      
+        context 'with item not selected' do
+          before(:each) do
+            @item.stub!(:selected?).and_return(false)
+          end
+          it {@item.html_options(:bla)[:class].should be_blank}
+        end
+      end
+    end
+    
+    describe 'id' do
+      context 'with id defined in options' do
+        before(:each) do
+          @options = {:id => 'my_id'}
+          @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', @options, nil)
+        end
+        it {@item.html_options(:bla)[:id].should == 'my_id'}
+      end
+      
+      context 'with no id definied in options (using default id)' do
+        before(:each) do
+          @options = {}
+          @item = SimpleNavigation::Item.new(:my_key, 'name', 'url', @options, nil)
+        end
+        it {@item.html_options(:bla)[:id].should == 'my_key'}
+      end
+    end
+    
+  end
+  
+
+end

data/spec/lib/renderer/base_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe SimpleNavigation::Renderer::Base do
+  before(:each) do
+    @base_renderer = SimpleNavigation::Renderer::Base.new(:current_primary, :current_secondary)
+  end
+  it "should inclue ActionView::Helpers::UrlHelper" do
+    @base_renderer.should respond_to(:link_to)
+  end
+  it "should include ActionView::Helpers::TagHelper" do
+    @base_renderer.should respond_to(:content_tag)
+  end
+  it {@base_renderer.current_navigation.should == :current_primary}
+  it {@base_renderer.current_sub_navigation.should == :current_secondary}
+end

data/spec/lib/renderer/list_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'html/document' unless defined? HTML::Document
+
+describe SimpleNavigation::Renderer::List do
+    
+  describe 'render' do
+    
+    def sub_items
+      [
+        SimpleNavigation::Item.new(:subnav1, 'subnav1', 'subnav1_url', {}, nil),
+        SimpleNavigation::Item.new(:subnav2, 'subnav2', 'subnav2_url', {}, nil)
+      ]
+    end
+    
+    def primary_items
+      @item1 = SimpleNavigation::Item.new(:users, 'users', 'first_url', {:id => 'my_id'}, nil)
+      @item2 = SimpleNavigation::Item.new(:invoices, 'invoices', 'second_url', {}, nil)
+      @item3 = SimpleNavigation::Item.new(:accounts, 'accounts', 'third_url', {:style => 'float:right'}, nil)
+      @item2.instance_variable_set(:@sub_navigation, item_container(sub_items))
+      [@item1, @item2, @item3]
+    end
+
+    def item_container(items)
+      container = SimpleNavigation::ItemContainer.new
+      container.dom_id = 'nav_dom_id'
+      container.instance_variable_set(:@items, items)
+      container
+    end
+
+    def primary_navigation
+      @item_container = item_container(primary_items)
+      @item_container
+    end
+
+    def render(current_navigation=nil, include_subnav=false)
+      @renderer = SimpleNavigation::Renderer::List.new(current_navigation)
+      HTML::Document.new(@renderer.render(primary_navigation, include_subnav)).root
+    end
+      
+    it "should render a ul-tag around the items" do
+      HTML::Selector.new('ul').select(render).should have(1).entries
+    end
+    it "the rendered ul-tag should have the specified dom_id" do
+      HTML::Selector.new('ul#nav_dom_id').select(render).should have(1).entries
+    end
+    it "should render a li tag for each item" do
+      HTML::Selector.new('li').select(render).should have(3).entries
+    end
+    it "should render an a-tag inside each li-tag" do
+      HTML::Selector.new('li a').select(render).should have(3).entries
+    end
+    it "should pass the specified html_options to the li element" do
+      HTML::Selector.new('li[style=float:right]').select(render).should have(1).entries
+    end
+    it "should give the li the id specified in the html_options" do
+      HTML::Selector.new('li#my_id').select(render).should have(1).entries
+    end
+    it "should give the li the default id (stringified key) if no id is specified in the html_options" do
+      HTML::Selector.new('ul li#invoices').select(render).should have(1).entries
+    end
+    it "should not apply the the default id where there is an id specified in the html_options" do
+      HTML::Selector.new('ul li#users').select(render).should be_empty
+    end
+    
+    context 'with current_navigation set' do
+      it "should mark the matching li-item as selected (with the css_class specified in configuration)" do
+        HTML::Selector.new('li.selected').select(render(:invoices)).should have(1).entries
+      end
+      it "should also mark the links inside the selected li's as selected" do
+        HTML::Selector.new('li.selected a.selected').select(render(:invoices)).should have(1).entries
+      end
+      
+    end
+    
+    context 'without current_navigation set' do
+      it "should not mark any of the items as selected" do
+        HTML::Selector.new('li.selected').select(render).should be_empty
+      end
+      it "should not mark any links as selected" do
+        HTML::Selector.new('a.selected').select(render).should be_empty
+      end
+    end
+    
+    context 'nested sub_navigation' do
+      it "should nest the current_primary's subnavigation inside the selected li-element" do
+        HTML::Selector.new('li.selected ul li').select(render(:invoices, true)).should have(2).entries
+      end
+      it "should be possible to identify sub items using an html selector (using ids)" do
+        HTML::Selector.new('#invoices #subnav1').select(render(:invoices, true)).should have(1).entries
+      end
+    end
+    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+ENV["RAILS_ENV"] = "test"
+require 'rubygems'
+require 'spec'
+require 'active_support'
+require 'action_controller'
+
+RAILS_ROOT = './' unless defined? RAILS_ROOT
+
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+require 'simple_navigation/configuration'
+require 'simple_navigation/helpers'
+require 'simple_navigation/controller_methods'
+require 'simple_navigation/item'
+require 'simple_navigation/item_container'
+require 'simple_navigation/renderer/base'
+require 'simple_navigation/renderer/list'
+
+require 'simple_navigation'
+
+# Spec::Runner.configure do |config|
+  # no special config
+# endx

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: simple-navigation
+version: !ruby/object:Gem::Version 
+  version: 1.1.1
+platform: ruby
+authors: 
+- Andi Schacke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-14 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Simple Navigation is a ruby library for creating a navigation (optionally with sub navigation) for your rails app.
+email: andreas.schacke@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- CHANGELOG
+- Rakefile
+- VERSION.yml
+- generators/navigation_config/USAGE
+- generators/navigation_config/navigation_config_generator.rb
+- generators/navigation_config/templates/config/navigation.rb
+- lib/simple_navigation.rb
+- lib/simple_navigation/configuration.rb
+- lib/simple_navigation/controller_methods.rb
+- lib/simple_navigation/helpers.rb
+- lib/simple_navigation/item.rb
+- lib/simple_navigation/item_container.rb
+- lib/simple_navigation/renderer/base.rb
+- lib/simple_navigation/renderer/list.rb
+- rails/init.rb
+- spec/lib/configuration_spec.rb
+- spec/lib/controller_methods_spec.rb
+- spec/lib/helpers_spec.rb
+- spec/lib/item_container_spec.rb
+- spec/lib/item_spec.rb
+- spec/lib/renderer/base_spec.rb
+- spec/lib/renderer/list_spec.rb
+- spec/spec_helper.rb
+- README
+has_rdoc: true
+homepage: http://github.com/andi/simple-navigation
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: andi
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Simple Navigation is a ruby library for creating a navigation (optionally with sub navigation) for your rails app.
+test_files: 
+- spec/lib/configuration_spec.rb
+- spec/lib/controller_methods_spec.rb
+- spec/lib/helpers_spec.rb
+- spec/lib/item_container_spec.rb
+- spec/lib/item_spec.rb
+- spec/lib/renderer/base_spec.rb
+- spec/lib/renderer/list_spec.rb
+- spec/spec_helper.rb