mariner 0.0.2

data/lib/mariner/unordered_list_renderer.rb

@@ -0,0 +1,202 @@
+require 'active_support/core_ext/string/inflections'
+
+module Mariner
+
+  # Public: The default renderer used. Renders the nav config to
+  # an unordered list.
+  #
+  # Examples:
+  #
+  #     Mariner.configure do
+  #
+  #       a_group do
+  #         root_path 'A link'
+  #       end
+  #
+  #     end
+  #
+  #     Mariner.configuration.render #=> returns:
+  #
+  #     <ul class=''>
+  #       <li>
+  #         <a class="root_path" href="/">A Link</a>
+  #       </li>
+  #     </ul>
+  #
+  #
+  # If you want to implement your own rendering strategy, read on
+  # for a good starting point.
+  #
+  #
+  #    class FakeRenderingStrategy
+  #
+  #      # Called from Store and Url instances. Must return something
+  #      # that responds to #render
+  #      #
+  #      def factory(type, subject)
+  #        # type - Can be `:group` or `:item`
+  #        # subject - The Store or Url instance to render
+  #        case type
+  #        when :group then FakeRenderingStrategy::GroupRenderer.new(subject, self)
+  #        when :item  then FakeRenderingStrategy::ItemRenderer.new(subject, self)
+  #        end
+  #      end
+  #
+  #      class GroupRenderer < RenderingStrategy::Base
+  #
+  #        # A group renderer must iterate its #configurations and call
+  #        # #render on each, then return the joined result.
+  #        #
+  #        def render
+  #          subject.configurations.map do |config|
+  #            _, entity = config
+  #            entity.render(rendering_strategy) # entity can be a Store or a Url
+  #          end.join
+  #        end
+  #
+  #      end
+  #
+  #      class ItemRenderer < RenderingStrategy::Base
+  #
+  #        # An item renderer just needs to return some string representation
+  #        # of the Url it's rendering.
+  #        #
+  #        def render
+  #          # render something based on #subject (e.g. markup for a link)
+  #        end
+  #
+  #      end
+  #
+  #    end
+
+  class UnorderedListRenderer
+
+    # Public: If true, will render a title list element based
+    # on the name of the group.
+    #
+    attr_accessor :render_titles
+    alias :render_titles? :render_titles
+
+    # Public: The classname that will be added to the rendered
+    # UL elements.
+    #
+    attr_accessor :group_classname
+
+    # Public: The classname that will be added to the rendered
+    # title LI elements
+    #
+    attr_accessor :title_classname
+
+    # Public: The classname that will be added to the rendered
+    # links (A elements)
+    #
+    attr_accessor :item_classname
+
+    # Public: Initialize a new renderer with options.
+    #
+    # options - The hash of options used to determine how to render:
+    #           :render_titles - Turn title rendering for Stores on or off (optional, default: false)
+    #
+    def initialize(options={})
+      defaults.merge(options).each { |k,v| send("#{k}=", v) }
+    end
+
+    # Public: Called by Store and Url instances to get a renderer.
+    #
+    # Examples:
+    #
+    #     s = UnorderedListRenderer.new
+    #     s.factory(:group, self) #=> instance of UnorderedListRenderer::GroupRenderer
+    #     s.factory(:item, self) #=> instance of UnorderedListRenderer::ItemRenderer
+    #
+    def factory(type, subject)
+      case type
+      when :group then GroupRenderer.new(subject, self)
+      when :item then ItemRenderer.new(subject, self)
+      end
+    end
+
+    private
+
+    def defaults
+      { :render_titles => false }
+    end
+
+    public
+
+    class ItemRenderer < Renderer::Base
+      include ActionView::Helpers::TagHelper
+
+      # Public: Renders an A element according to the Url properties.
+      #
+      def render
+        content_tag :a, subject.title, render_options
+      end
+
+      # Public: The options that the A element will be rendered with. These
+      # are forwarded on to ActionView::Helpers::TagHelper#content_tag
+      #
+      def render_options
+        opts = { :href => subject.href, :class => subject.name.to_s }
+        opts.merge(:class => rendering_strategy.item_classname, &merge_proc).merge(subject.options, &merge_proc)
+      end
+
+      private
+
+      # Private: Used internally to determine how to merge options. For
+      # `:class`, add the values together with a space. For everything else,
+      # replace the value.
+      #
+      def merge_proc
+        proc do |key, oldval, newval|
+          case key.to_s
+          when "class"
+            (oldval.to_s.split(" ") + newval.to_s.split(" ")).sort.join(" ")
+          else newval
+          end
+        end
+      end
+
+    end
+
+    class GroupRenderer < Renderer::Base
+
+      # Public: Render a Store as an unordererd list HTML element.
+      #
+      def render
+        open_surround = close_surround = item_open_surround = item_close_surround = ""
+
+        open_surround = "<ul class='#{rendering_strategy.group_classname}'>"
+        close_surround = "</ul>"
+
+        item_open_surround = "<li>"
+        item_close_surround = "</li>"
+
+        rendered_configurations = subject.configurations.map do |config|
+          name, entity = config
+          unless subject.virtual?
+            "#{item_open_surround}#{entity.render(rendering_strategy)}#{item_close_surround}"
+          else
+            entity.render(rendering_strategy)
+          end
+        end.join
+
+        unless subject.virtual?
+          result = ""
+          result << open_surround
+
+          if rendering_strategy.render_titles?
+            result << "<li class='#{rendering_strategy.title_classname}'>#{subject.name.to_s.titleize}#{item_close_surround}"
+          end
+
+          result << "#{rendered_configurations}#{close_surround}"
+        else
+          rendered_configurations
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/mariner/url.rb

@@ -0,0 +1,54 @@
+module Mariner
+
+  # Public: Represents a Url configuration.
+  #
+  # Examples:
+  #
+  #     Mariner.configure do
+  #       a_group do
+  #         root_path "A Link" # <= This ends up being a Url instance.
+  #       end
+  #     end
+  #
+  class Url
+
+    attr_accessor :name, :title, :options
+
+    # Public: Create a new Url
+    #
+    # name    - The method name that corresponds to a Rails route helper
+    # title   - The text that should be rendered to represent a url.
+    # options - Any link options that should be present. Used by the
+    #           renderer (default: {})
+    #
+    def initialize(name, title, options={})
+      @name, @title, @options = name, title, options
+    end
+
+    # Public: Renders itself through a rendering strategy.
+    #
+    # rendering_strategy - The rendering strategy to use. Must respond to
+    #                      #render (default: UnorderedListRenderer.new)
+    #
+    def render(rendering_strategy=Mariner.rendering_strategies[:default])
+      rendering_strategy.factory(:item, self).render
+    end
+
+    # Public: Calls the Rails route helper method to get its href.
+    #
+    def href
+      begin
+        # The link's name should be the method name
+        # for a rails route helper. We're including the route
+        # helpers in an initializer, so this will only fail if
+        # the route is undefined.
+        #
+        send(name)
+      rescue NoMethodError => e
+        raise ::Mariner::Errors::InvalidUrlHelperMethod.new(name)
+      end
+    end
+
+  end
+
+end

data/lib/mariner/version.rb

@@ -0,0 +1,3 @@
+module Mariner
+  VERSION = "0.0.2"
+end

data/mariner.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mariner/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jesse Trimble", "Adam Albrecht"]
+  gem.email         = ["jlowelltrim@gmail.com", "adam.albrecht@gmail.com"]
+  gem.description   = %q{A DSL for creating navigation structures based on the Rails routing table using Abyss.}
+  gem.summary       = %q{A DSL for creating navigation structures based on the Rails routing table using Abyss.}
+  gem.homepage      = ""
+
+  gem.add_dependency 'abyss'
+  gem.add_dependency 'rails', '~> 3.2.0'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "mariner"
+  gem.require_paths = ["lib"]
+  gem.version       = Mariner::VERSION
+end

data/spec/integrations/unordered_list_renderer_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+# This test suite is kind of a hack just to access
+# the capybara matchers.
+
+# TODO: Figure out how to do this better.
+
+module Mariner
+
+  describe UnorderedListRenderer do
+
+    before do
+      Mariner.configure do
+        quick_links do
+          root_path "Home"
+        end
+      end
+    end
+
+    after { Mariner.configuration = nil }
+
+    # Work within the context of an anonymous controller
+    #
+    describe Class.new(ActionController::Base), :type => :controller do
+
+      subject { get :index; response.body }
+
+      describe "rendered element classnames" do
+
+        controller do
+          def index
+            render_options = {
+              :render_titles => true,
+              :group_classname => 'nav-list',
+              :title_classname => 'nav-title',
+              :item_classname => 'nav-item'
+            }
+            strategy = UnorderedListRenderer.new(render_options)
+            render :text => Mariner.configuration.render(strategy)
+          end
+        end
+
+        it "uses the classnames provided" do
+          subject.should have_css "ul.nav-list li:first-child.nav-title"
+          subject.should have_css "ul.nav-list li:last-child a.nav-item"
+        end
+
+      end
+
+      describe "the rendering of titles" do
+
+        context "when render_titles is false on the rendering strategy" do
+
+          controller do
+            def index
+              strategy = UnorderedListRenderer.new(:render_titles => false)
+              render :text => Mariner.configuration.render(strategy)
+            end
+          end
+
+          it "suppresses titles" do
+            subject.should_not have_css 'ul li:first-child', :text => 'Quick Links'
+            subject.should have_css 'ul li:last-child a[href="/"]', :text => 'Home'
+          end
+
+        end
+
+        context "when render_titles is true" do
+
+          controller do
+            def index
+              strategy = UnorderedListRenderer.new(:render_titles => true)
+              render :text => Mariner.configuration.render(strategy)
+            end
+          end
+
+          it "suppresses titles" do
+            subject.should have_css 'ul li:first-child', :text => 'Quick Links'
+            subject.should have_css 'ul li:last-child a[href="/"]', :text => 'Home'
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/mariner_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Mariner
+
+  describe ".configure" do
+
+    before { Mariner.configuration = nil }
+    after  { Mariner.configuration = nil }
+
+    it 'is shorthand for the navigation Config API' do
+      expected_block = Proc.new { }
+      fake_config = mock().as_null_object
+      Store.stub(:new).and_return(fake_config)
+      fake_config.should_receive(:instance_eval).with(&expected_block)
+
+      Mariner.configure &expected_block
+    end
+
+    it 'sets the root-level group as virtual' do
+      fake_config = mock
+      fake_config.should_receive(:virtual=).with(true)
+      Store.stub(:new).and_return(fake_config)
+
+      Mariner.configure {}
+    end
+
+  end
+
+end

data/spec/navigation/helper_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Mariner
+
+  describe Helper, :type => :helper do
+
+    before do
+      Mariner.configure do
+        a_group do
+          root_path "A Thing!"
+          a_sub_group {}
+        end
+      end
+    end
+
+    after { Mariner.configuration = nil }
+
+    describe "#render_navigation" do
+
+      context "with no args" do
+
+        it "renders the root level configuration" do
+          Mariner.configuration.should_receive(:render)
+          render_navigation
+        end
+
+      end
+
+      context "with one arg" do
+
+        it "renders the correct configuration" do
+          Mariner.configuration.should_not_receive(:render)
+          Mariner.configuration.a_group.should_receive(:render)
+          render_navigation :a_group
+        end
+
+      end
+
+      context "with two args" do
+
+        context "when renderer is a symbol" do
+
+          it "gets its renderer from Mariner.rendering_strategies" do
+            fake_renderer = stub(:render => nil)
+            Mariner.rendering_strategies[:fake] = fake_renderer
+
+            Mariner.configuration.should_not_receive(:render)
+            Mariner.configuration.a_group.should_receive(:render).with(fake_renderer)
+
+            render_navigation :a_group, :fake
+          end
+
+          it "raises an error if the specified renderer doesn't exist" do
+            Mariner.rendering_strategies[:nonexistent] = nil
+            expect {
+              render_navigation :a_group, :nonexistent
+            }.to raise_error /rendering strategy not found/i
+          end
+
+        end
+
+        context "when renderer is not a symbol" do
+
+          it "renders with a specified strategy" do
+            fake_renderer = stub(:render => nil)
+            Mariner.configuration.should_not_receive(:render)
+            Mariner.configuration.a_group.should_receive(:render).with(fake_renderer)
+
+            render_navigation :a_group, fake_renderer
+          end
+
+        end
+
+      end
+
+      context "with a string path" do
+
+        it "calls through to #render properly" do
+          Mariner.configuration.should_not_receive(:render)
+          Mariner.configuration.a_group.should_receive(:render)
+
+          render_navigation "a_group"
+        end
+
+      end
+
+      context "with a deep string path" do
+
+        it "calls through to #render properly" do
+          Mariner.configuration.should_not_receive(:render)
+          Mariner.configuration.a_group.should_not_receive(:render)
+          Mariner.configuration.a_group.a_sub_group.should_receive(:render)
+          render_navigation "a_group/a_sub_group"
+        end
+
+      end
+
+    end
+
+    describe "#render_navigations" do
+
+      before do
+        Mariner.configure do
+          root_path "Top"
+
+          group_one do
+            root_path "One"
+          end
+
+          group_two do
+            root_path "Two"
+          end
+        end
+      end
+
+      it "renders the navigations within the target group without rendering the target itself" do
+        Mariner.configuration.should_not_receive(:render)
+
+        Mariner.configuration.configurations.each do |c|
+          _, entity = c
+          entity.should_receive(:render)
+        end
+
+        render_navigations
+      end
+
+    end
+
+  end
+
+end