rocket_navigation 0.1.0

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RocketNavigation'
+  rdoc.options << '--inline-source'
+  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rocket_navigation"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rocket_navigation.rb

@@ -0,0 +1,32 @@
+require "rocket_navigation/version"
+
+# cherry picking active_support stuff
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'rocket_navigation/configuration'
+require 'rocket_navigation/item'
+require 'rocket_navigation/item_container'
+require 'rocket_navigation/renderer'
+
+if defined?(Rails)
+  require "rocket_navigation/railtie"
+end
+
+module RocketNavigation
+  mattr_accessor :default_renderer
+  mattr_accessor :registered_renderers
+
+  self.default_renderer = :list
+
+  self.registered_renderers = {
+    list:                 RocketNavigation::Renderer::List,
+    links:                RocketNavigation::Renderer::Links,
+    breadcrumbs:          RocketNavigation::Renderer::Breadcrumbs,
+    breadcrumbs_on_rails: RocketNavigation::Renderer::BreadcrumbsOnRails,
+    text:                 RocketNavigation::Renderer::Text,
+    json:                 RocketNavigation::Renderer::Json
+  }
+end
+

data/lib/rocket_navigation/configuration.rb

@@ -0,0 +1,21 @@
+module RocketNavigation
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  def self.config
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  class Configuration
+    attr_accessor :renderer
+
+    def initialize
+      @renderer = RocketNavigation::Renderer::List
+    end
+  end
+end
+

data/lib/rocket_navigation/helpers.rb

@@ -0,0 +1,120 @@
+module RocketNavigation
+  # View helpers to render the navigation.
+  #
+  # Use render_navigation as following to render your navigation:
+  # * call <tt>render_navigation</tt> without :level option to render your
+  #   complete navigation as nested tree.
+  # * call <tt>render_navigation(level: x)</tt> to render a specific
+  #   navigation level (e.g. level: 1 to render your primary navigation,
+  #   level: 2 to render the sub navigation and so forth)
+  # * call <tt>render_navigation(:level => 2..3)</tt> to render navigation
+  #   levels 2 and 3).
+  #
+  # For example, you could use render_navigation(level: 1) to render your
+  # primary navigation as tabs and render_navigation(level: 2..3) to render
+  # the rest of the navigation as a tree in a sidebar.
+  #
+  # ==== Examples (using Haml)
+  #   #primary_navigation= render_navigation(level: 1)
+  #
+  #   #sub_navigation= render_navigation(level: 2)
+  #
+  #   #nested_navigation= render_navigation
+  #
+  #   #top_navigation= render_navigation(level: 1..2)
+  #   #sidebar_navigation= render_navigation(level: 3)
+  module Helpers
+    # Renders the navigation according to the specified options-hash.
+    #
+    # The following options are supported:
+    # * <tt>:level</tt> - defaults to :all which renders the the sub_navigation
+    #   for an active primary_navigation inside that active
+    #   primary_navigation item.
+    #   Specify a specific level to only render that level of navigation
+    #   (e.g. level: 1 for primary_navigation, etc).
+    #   Specifiy a Range of levels to render only those specific levels
+    #   (e.g. level: 1..2 to render both your first and second levels, maybe
+    #   you want to render your third level somewhere else on the page)
+    # * <tt>:expand_all</tt> - defaults to false. If set to true the all
+    #   specified levels will be rendered as a fully expanded
+    #   tree (always open). This is useful for javascript menus like Superfish.
+    # * <tt>:items</tt> - you can specify the items directly (e.g. if items are
+    #   dynamically generated from database).
+    #   See SimpleNavigation::ItemsProvider for documentation on what to
+    #   provide as items.
+    # * <tt>:renderer</tt> - specify the renderer to be used for rendering the
+    #   navigation. Either provide the Class or a symbol matching a registered
+    #   renderer. Defaults to :list (html list renderer).
+    #
+    # Instead of using the <tt>:items</tt> option, a block can be passed to
+    # specify the items dynamically
+    #
+    # ==== Examples
+    #   render_navigation do |menu|
+    #     menu.item :posts, "Posts", posts_path
+    #   end
+    #
+    def render_navigation(options = {}, &block)
+      container = ItemContainer.new(1, options)
+      container.view_context = view_context
+      if block_given?
+        yield container
+      end
+      container.render(options)
+    end
+
+    # Returns true or false based on the provided path and condition
+    # Possible condition values are:
+    #                  Boolean -> true | false
+    #                   Symbol -> :exclusive | :inclusive
+    #                    Regex -> /regex/
+    #   Controller/Action Pair -> [[:controller], [:action_a, :action_b]]
+    #
+    # Example usage:
+    #
+    #   is_active_nav_link?('/root', true)
+    #   is_active_nav_link?('/root', :exclusive)
+    #   is_active_nav_link?('/root', /^\/root/)
+    #   is_active_nav_link?('/root', ['users', ['show', 'edit']])
+    #
+    # Source: https://github.com/comfy/active_link_to/blob/master/lib/active_link_to/active_link_to.rb
+    # Copyright (c) 2009-17 Oleg Khabarov
+    # MIT License
+    def is_active_nav_link?(url, condition = nil)
+      @is_active_link ||= {}
+      @is_active_link[[url, condition]] ||= begin
+        original_url = url
+        url = Addressable::URI::parse(url).path
+        path = request.original_fullpath
+        case condition
+        when :inclusive, nil
+          !path.match(/^#{Regexp.escape(url).chomp('/')}(\/.*|\?.*)?$/).blank?
+        when :exclusive
+          !path.match(/^#{Regexp.escape(url)}\/?(\?.*)?$/).blank?
+        when :exact
+          path == original_url
+        when Proc
+          condition.call(original_url)
+        when Regexp
+          !path.match(condition).blank?
+        when Array
+          controllers = Array.wrap(condition[0])
+          actions     = Array.wrap(condition[1])
+          (controllers.blank? || controllers.member?(params[:controller])) &&
+          (actions.blank? || actions.member?(params[:action])) ||
+          controllers.any? do |controller, action|
+            params[:controller] == controller.to_s && params[:action] == action.to_s
+          end
+        when TrueClass
+          true
+        when FalseClass
+          false
+        when Hash
+          condition.all? do |key, value|
+            params[key].to_s == value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rocket_navigation/item.rb

@@ -0,0 +1,114 @@
+module RocketNavigation
+  # Represents an item in your navigation.
+  class Item
+    extend Forwardable
+
+    attr_reader :key,
+                :name,
+                :sub_navigation,
+                :url,
+                :options
+
+    def_delegators :container, :view_context
+    def_delegators :view_context, :is_active_nav_link?
+
+    # see ItemContainer#item
+    #
+    # The subnavigation (if any) is either provided by a block or
+    # passed in directly as <tt>items</tt>
+    def initialize(container, key, name, url = nil, opts = {}, &sub_nav_block)
+      self.container = container
+      self.key = key
+      self.name = name.respond_to?(:call) ? name.call : name
+      self.url =  url.respond_to?(:call) ? url.call : url
+      self.options = opts
+
+      setup_sub_navigation(options[:items], &sub_nav_block)
+    end
+
+    # Returns the item's name.
+    # If :apply_generator option is set to true (default),
+    # the name will be passed to the name_generator specified
+    # in the configuration.
+    #
+    def name(options = {})
+      @name
+    end
+
+    # Returns true if this navigation item should be rendered as 'selected'.
+    # An item is selected if
+    #
+    # * it has a subnavigation and one of its subnavigation items is selected or
+    # * its url matches the url of the current request (auto highlighting)
+    #
+    def selected?
+      @selected ||= selected_by_subnav? || selected_by_condition?
+    end
+
+    def active_branch?
+      @active_branch ||= selected_by_subnav? && !selected_by_condition?
+    end
+
+    def active_leaf?
+      @active_leaf ||= selected_by_condition?
+    end
+
+    # Returns the :highlights_on option as set at initialization
+    def highlights_on
+      @highlights_on ||= options[:highlights_on]
+    end
+
+    # Returns the :method option as set at initialization
+    def method
+      @method ||= options[:method]
+    end
+
+    # Returns true if item has a subnavigation and
+    # the sub_navigation is selected
+    def selected_by_subnav?
+      sub_navigation && sub_navigation.selected?
+    end
+
+    # Returns true if the item's url matches the request's current url.
+    def selected_by_condition?
+      is_active_nav_link?(url, highlights_on)
+    end
+
+    # Returns true if both the item's url and the request's url are root_path
+    def root_path_match?
+      url == '/'
+    end
+
+    private
+
+    attr_accessor :container,
+                  :options
+
+    attr_writer :key,
+                :name,
+                :sub_navigation,
+                :url
+
+
+    def remove_anchors(url_with_anchors)
+      url_with_anchors && url_with_anchors.split('#').first
+    end
+
+    def remove_query_params(url_with_params)
+      url_with_params && url_with_params.split('?').first
+    end
+
+    def setup_sub_navigation(items = nil, &sub_nav_block)
+      return unless sub_nav_block || items
+
+      self.sub_navigation = container.new_child
+
+      if sub_nav_block
+        sub_nav_block.call sub_navigation
+      else
+        sub_navigation.items = items
+      end
+    end
+  end
+end
+

data/lib/rocket_navigation/item_container.rb

@@ -0,0 +1,135 @@
+module RocketNavigation
+  class ItemContainer
+    attr_accessor :renderer, :view_context, :options
+    attr_reader :items, :level
+
+    attr_accessor :container_html, :item_html, :link_html, :selected_class
+
+    def default_html_options
+      if options[:no_default_classes]
+        @container_html = {}
+        @item_html = {}
+        @link_html = {}
+        @selected_class = {}
+      else
+        @container_html = {class: "nav"}
+        @item_html = {class: 'nav-item'}
+        @link_html = {class: 'nav-link'}
+        @selected_class = {branch: "active-branch", item: "active", link: "active"}
+      end
+    end
+
+    def initialize(level = 1, options = {})
+      @level = level
+      @items ||= []
+      @options = options
+      @renderer = RocketNavigation.config.renderer
+      default_html_options
+    end
+
+    def new_child
+      child = ItemContainer.new(level + 1, options)
+      child.view_context = view_context
+      child
+    end
+
+    def item(key, name, url = nil, options = {}, &block)
+      return unless should_add_item?(options)
+      key = url if key.nil?
+      item = Item.new(self, key, name, url, options, &block)
+      add_item item, options
+    end
+
+    def items=(new_items)
+      new_items.each do |item|
+        item_adapter = ItemAdapter.new(item)
+        next unless should_add_item?(item_adapter.options)
+        add_item item_adapter.to_simple_navigation_item(self), item_adapter.options
+      end
+    end
+
+    # Returns the Item with the specified key, nil otherwise.
+    #
+    def [](navi_key)
+      items.find { |item| item.key == navi_key }
+    end
+
+    # Returns the level of the item specified by navi_key.
+    # Recursively works its way down the item's sub_navigations if the desired
+    # item is not found directly in this container's items.
+    # Returns nil if item cannot be found.
+    #
+    def level_for_item(navi_key)
+      return level if self[navi_key]
+
+      items.each do |item|
+        next unless item.sub_navigation
+        level = item.sub_navigation.level_for_item(navi_key)
+        return level if level
+      end
+      return nil
+    end
+
+    # Renders the items in this ItemContainer using the configured renderer.
+    #
+    # The options are the same as in the view's render_navigation call
+    # (they get passed on)
+    def render(options = {})
+      renderer_instance(options).render(self)
+    end
+
+    # Returns true if any of this container's items is selected.
+    #
+    def selected?
+      items.any?(&:selected?)
+    end
+
+    # Returns the currently selected item, nil if no item is selected.
+    #
+    def selected_item
+      items.find(&:selected?)
+    end
+
+    # Returns true if there are no items defined for this container.
+    def empty?
+      items.empty?
+    end
+
+    def inspect
+"#<RocketNavigation::ItemContainer:#{object_id}
+  @renderer=#{@renderer.inspect}
+  @options=#{@options.inspect}
+  @items=#{@items.inspect}
+  @level=#{@level.inspect}
+  @container_html=#{@container_html.inspect}
+  @item_html=#{@item_html.inspect}
+  @link_html=#{@link_html.inspect}
+  @selected_class=#{@selected_class.inspect}
+  @view_context=#{view_context.nil? ? nil : "[rails view context, hidden from inspect]"}
+>"
+    end
+
+    private
+
+    def add_item(item, options)
+      items << item
+    end
+
+    def should_add_item?(options)
+      [options[:if]].flatten.compact.all? { |m| evaluate_method(m) } &&
+      [options[:unless]].flatten.compact.none? { |m| evaluate_method(m) }
+    end
+
+    def renderer_instance(options)
+      return renderer.new(self, options) unless options[:renderer]
+
+      if options[:renderer].is_a?(Symbol)
+        registered_renderer = SimpleNavigation.registered_renderers[options[:renderer]]
+        registered_renderer.new(self, options)
+      else
+        options[:renderer].new(self, options)
+      end
+    end
+  end
+end
+