navtastic 0.0.1

data/lib/navtastic/menu.rb

@@ -0,0 +1,127 @@
+module Navtastic
+  # Stores items generated by a definition block
+  class Menu
+    include Enumerable
+
+    # @return [Array<Item>] the items in this menu
+    attr_reader :items
+
+    # @return [Menu,nil] this parent of this menu
+    attr_reader :parent
+
+    # Create a new empty menu
+    #
+    # @param root [Menu] the root menu of this is a submenu
+    def initialize(parent = nil)
+      @parent = parent
+
+      @current_item = nil
+      @items = []
+      @items_by_url = {}
+    end
+
+    # @return [true] if this menu is the root menu
+    # @return [false] if this menu is a submenu
+    def root?
+      @parent.nil?
+    end
+
+    # The depth of this menu
+    #
+    # The root menu always has depth 0.
+    #
+    # @return [Integer] the depth of this menu
+    def depth
+      if @parent
+        @parent.depth + 1
+      else
+        0
+      end
+    end
+
+    # Add a new item at the end of the menu
+    #
+    # @param name [String]the name to display in the menu
+    # @param url [String] the url to link to, if the item is a link
+    #
+    # @yield [submenu] block to generate a sub menu
+    # @yieldparam submenu [Menu] the menu to be initialized
+    def item(name, url = nil)
+      item = Item.new(self, name, url)
+
+      if block_given?
+        submenu = Menu.new(self)
+        yield submenu
+        item.submenu = submenu
+      end
+
+      @items << item
+      register_item(item)
+
+      item
+    end
+
+    def each
+      @items.each do |item|
+        yield item
+      end
+    end
+
+    # Find an item in this menu matching the url
+    #
+    # @param url [String] the url of the item
+    #
+    # @return [Item] if an item with that url exists
+    # @return [nil] if the item doens't exist
+    def [](url)
+      @items_by_url[url]
+    end
+
+    # Sets the current active item by url
+    #
+    # @private
+    #
+    # @param current_url [String] the url of the current page
+    def current_url=(current_url)
+      @current_item = nil
+      return if current_url.nil?
+
+      # Sort urls from longest to shortest and find the first matching substring
+      matching_item = @items_by_url
+                      .sort_by { |url, _item| -url.length }.to_h
+                      .find { |url, _item| current_url.start_with? url }
+
+      @current_item = matching_item[1] if matching_item
+    end
+
+    # @see file:README.md#Current_item documentation on how the current item is
+    #   selected
+    #
+    # @return [Item,nil] the current active item
+    def current_item
+      if root?
+        @current_item
+      else
+        @parent.current_item
+      end
+    end
+
+    protected
+
+    # Register a newly added item
+    #
+    # @param item [Item] the new item to register
+    def register_item(item)
+      return unless item.url
+
+      @items_by_url[item.url] = item
+
+      if root?
+        # The first item with a url is the default current item
+        @current_item = item if @current_item.nil? && item.url
+      else
+        @parent.register_item(item)
+      end
+    end
+  end
+end

data/lib/navtastic/renderer.rb

@@ -0,0 +1,87 @@
+require 'arbre'
+
+module Navtastic
+  # Generate HTML based on a menu
+  #
+  # The actual HTML generation is done using the
+  # [Arbre](https://github.com/activeadmin/arbre) gem.
+  #
+  # Calling `#to_s` will return the HTML.
+  class Renderer < Arbre::Context
+    # Create a new renderer
+    #
+    # @param menu [Menu]
+    #
+    # @return [Renderer]
+    def self.render(menu)
+      new(menu: menu) do
+        menu(menu)
+      end
+    end
+
+    # Starting a new root menu or submenu (e.g. `<ul>` tag)
+    #
+    # @param menu [Menu]
+    # @return [Arbre::HTML::Tag]
+    def menu(menu)
+      ul do
+        menu.each do |item|
+          item_container item
+        end
+      end
+    end
+
+    # The container for every menu item (e.g. `<li>` tags)
+    #
+    # @param item [Item]
+    # @return [Arbre::HTML::Tag]
+    def item_container(item)
+      li(class: css_classes_string(item, :item_container)) do
+        item_content item
+
+        menu(item.submenu) if item.submenu?
+      end
+    end
+
+    # The item itself (e.g. `<a>` tag for links)
+    #
+    # @param item [Item]
+    # @return [Arbre::HTML::Tag]
+    def item_content(item)
+      if item.url
+        a(href: item.url) { item.name }
+      else
+        span item.name
+      end
+    end
+
+    # Decide which css classes are needed for this item
+    #
+    # For example, the {#item_container} uses this to retrieve the css class for
+    # the current active item.
+    #
+    # @param item [Item] the current item that is rendered
+    # @param context [Symbol] which method is asking for the css classes
+    #
+    # @return [Array<String>] list of css classes to apply to the HTML element
+    def css_classes(item, context)
+      classes = []
+
+      case context
+      when :item_container
+        classes << 'current' if item.current?
+      end
+
+      classes
+    end
+
+    # Same as {css_classes} method, but joins classes together in a string
+    #
+    # @see css_classes
+    #
+    # @return [String]
+    def css_classes_string(item, context)
+      css_classes(item, context).join ' '
+    end
+  end
+end

data/lib/navtastic/version.rb

@@ -0,0 +1,3 @@
+module Navtastic
+  VERSION = '0.0.1'.freeze
+end

data/navtastic.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'navtastic/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'navtastic'
+  s.version  = Navtastic::VERSION
+  s.summary  = "Define and render complex navigation menus"
+  s.authors  = ["Aram Visser"]
+  s.email    = "hello@aramvisser.com"
+  s.homepage = "http://github.com/aramvisser/navtastic"
+  s.license  = 'MIT'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.extra_rdoc_files = ['README.md']
+
+  s.add_dependency 'arbre', '~> 1.1'
+
+  s.add_development_dependency 'redcarpet', '~> 3.4'
+  s.add_development_dependency 'rspec', '~> 3.6'
+  s.add_development_dependency 'rubocop', '~> 0.48'
+  s.add_development_dependency 'rubocop-rspec', '~> 1.15'
+  s.add_development_dependency 'yard', '~> 0.9'
+end

data/spec/demo/index.rhtml

@@ -0,0 +1,29 @@
+<%
+Navtastic.define :main_menu do |menu|
+  menu.item "Home", '/' do |submenu|
+    submenu.item "Posts", '/posts'
+    submenu.item "About", '/about'
+  end
+
+  menu.item "Settings" do |submenu|
+    submenu.item "General", '/settings'
+    submenu.item "Profile", '/settings/profile'
+  end
+end
+%>
+
+<html>
+  <head>
+    <title>Navtastic Demo Server</title>
+    <style type="text/css">
+      .current { font-weight: bold }
+      .current ul { font-weight: normal }
+    </style>
+  </head>
+
+  <body>
+    <%= Navtastic.render :main_menu, current_url %>
+
+    <pre>current_url: <%= current_url %></pre>
+  </body>
+</html>

data/spec/demo/server.rb

@@ -0,0 +1,54 @@
+$LOAD_PATH.push File.expand_path('../../../lib', __FILE__)
+
+require 'navtastic'
+require 'erb'
+require 'webrick'
+
+class DemoServer
+  def initialize(port)
+    @port = port
+  end
+
+  def start
+    s = WEBrick::HTTPServer.new Port: @port, DocumentRoot: 'demo/', RequestCallback: -> (req, res) do
+      # A poor man's hot reload. Just reload everything on every request.
+      Object.send(:remove_const, :Navtastic) if Object.constants.include?(:Navtastic)
+
+      Dir.glob('lib/**/*.rb').each do |file|
+        load file
+      end
+    end
+
+    # Add a mime type for *.rhtml files
+    WEBrick::HTTPUtils::DefaultMimeTypes.store('rhtml', 'text/html')
+
+    # Mount servlets
+    #s.mount('/', HTTPServlet::FileHandler, Dir.pwd)
+    s.mount '/', MenuServlet
+
+    # Trap signals so as to shutdown cleanly.
+    ['TERM', 'INT'].each do |signal|
+      trap(signal){ s.shutdown }
+    end
+
+    # Start the server and block on input.
+    s.start
+  end
+end
+
+class MenuServlet < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(request, response)
+    response.status = 200
+    response['Content-Type'] = 'text/html'
+    response.body = render_page request
+  end
+
+  def render_page(request)
+    template_file = File.expand_path('../index.rhtml', __FILE__)
+    template_string = File.read template_file
+
+    current_url = request.path
+
+    ERB.new(template_string).result(binding)
+  end
+end

data/spec/navtastic/item_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe Navtastic::Item do
+  describe '#current?' do
+    let(:menu) { Navtastic::Menu.new }
+    let!(:item) { menu.item "Home", '/' }
+
+    it "calls the Menu#current_item method" do
+      allow(menu).to receive :current_item
+      item.current?
+      expect(menu).to have_received :current_item
+    end
+  end
+end

data/spec/navtastic/menu_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+require 'support/matchers/current_item.rb'
+
+RSpec.describe Navtastic::Menu do
+  subject(:menu) do
+    menu = described_class.new
+
+    menu.item "Home" do |submenu|
+      submenu.item "Posts", '/posts'
+      submenu.item "Featured", '/posts/featured'
+    end
+
+    menu.item "About", '/about'
+
+    menu
+  end
+
+  describe '.new' do
+    subject(:menu) { described_class.new }
+
+    context "when the menu has no parent" do
+      specify { expect(menu.items).to be_empty }
+      specify { expect(menu).not_to have_current_item }
+
+      it "has a depth of 0" do
+        expect(menu.depth).to eq 0
+      end
+    end
+
+    context "when the menu has a parent" do
+      subject(:submenu) { described_class.new(menu) }
+
+      specify { expect(submenu.items).to be_empty }
+      specify { expect(submenu).not_to have_current_item }
+
+      it "has a depth of parent.depth + 1" do
+        expect(submenu.depth).to eq(menu.depth + 1)
+      end
+    end
+  end
+
+  describe '#item' do
+    specify { expect { menu.item "Test" }. to change { menu.items.size }.by 1 }
+
+    it "returns the inserted item" do
+      expect(menu.item("Test")).to eq menu.items.last
+    end
+
+    context "with 1 argument" do
+      before { menu.item name }
+
+      let(:name) { "Test" }
+      let(:item) { menu.items.last }
+
+      it "sets the name" do
+        expect(item.name).to eq name
+      end
+
+      it "leaves the url empty" do
+        expect(item.url).to eq nil
+      end
+    end
+
+    context "with 2 arguments" do
+      before { menu.item name, url }
+
+      let(:name) { "Test" }
+      let(:url) { "/url" }
+      let(:item) { menu.items.last }
+
+      it "sets the name" do
+        expect(item.name).to eq name
+      end
+
+      it "sets the url" do
+        expect(item.url).to eq url
+      end
+    end
+
+    context "when the item has a submenu" do
+      let(:item) { menu.items.first }
+
+      it "adds the menu to the itme" do
+        expect(item.submenu).not_to eq nil
+      end
+    end
+  end
+
+  describe '#items' do
+    it "includes every item defined in this menu" do
+      expect(menu.items.count).to eq 2
+    end
+  end
+
+  describe '#each' do
+    specify { expect { |b| menu.each(&b) }.to yield_control.exactly(2).times }
+    specify { expect(menu).to all be_a Navtastic::Item }
+  end
+
+  describe '#[]' do
+    it "returns the item for the given url in this menu" do
+      expect(menu['/about'].name).to eql 'About'
+    end
+
+    it "returns the item for the given url in a submenu" do
+      expect(menu['/posts/featured'].name).to eql 'Featured'
+    end
+
+    it "returns nil when the url doesn't exist" do
+      expect(menu['/foo']).to be nil
+    end
+  end
+
+  describe '#current_item' do
+    subject(:current_item) { menu.current_item }
+
+    context "when the menu has no items" do
+      let(:menu) { described_class.new }
+
+      it { is_expected.to eq nil }
+    end
+
+    context "when the current url was not set" do
+      it "points to the first item with a url" do
+        expect(current_item).to eq menu['/posts']
+      end
+    end
+
+    context "when the current url was set" do
+      before { menu.current_url = url }
+
+      let(:url) { '/about' }
+
+      it "points to the item matching the url" do
+        expect(current_item).to eq menu[url]
+      end
+    end
+
+    context "when the current url matches an item in a submenu" do
+      before { menu.current_url = url }
+
+      let(:url) { '/posts' }
+
+      it "points to the item in the submenu" do
+        expect(current_item).to eq menu[url]
+      end
+    end
+
+    context "when the current menu has a parent" do
+      before { menu.current_url = url }
+
+      subject(:submenu) { menu.items.first.submenu }
+
+      let(:url) { '/about' }
+
+      it "asks the parent menu for the current item" do
+        allow(menu).to receive :current_item
+        submenu.current_item
+        expect(menu).to have_received :current_item
+      end
+    end
+  end
+
+  describe '#current_url=' do
+    before { menu.current_url = current_url }
+
+    context "when the url matches an item directly" do
+      let(:current_url) { '/posts' }
+
+      it "sets the item matching the url as current" do
+        expect(menu).to have_current_item(menu[current_url])
+      end
+    end
+
+    context "when the url matches the beginning of an item" do
+      let(:current_url) { '/posts/featured/2' }
+
+      it "sets the item with the longest matching url as current" do
+        expect(menu).to have_current_item(menu['/posts/featured'])
+      end
+    end
+
+    context "when the url matches nothing without a root item" do
+      let(:current_url) { '/foo/bar' }
+
+      it { is_expected.not_to have_current_item }
+    end
+
+    context "when the url matches nothing with a root item" do
+      subject(:menu) do
+        menu = described_class.new
+        menu.item "Home", '/'
+        menu
+      end
+
+      let(:current_url) { '/foo/bar' }
+
+      it "sets the root item as current" do
+        expect(menu).to have_current_item(menu['/'])
+      end
+    end
+  end
+end