rocket_navigation 0.1.0

data/lib/rocket_navigation/railtie.rb

@@ -0,0 +1,10 @@
+module RocketNavigation
+  class Railtie < ::Rails::Railtie
+    initializer 'rocket_navigation.init' do |app|
+      ActionController::Base.send(:include, RocketNavigation::Helpers)
+      RocketNavigation::Helpers.instance_methods.each do |m|
+        ActionController::Base.send(:helper_method, m.to_sym)
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer.rb

@@ -0,0 +1,13 @@
+require 'rocket_navigation/helpers'
+require 'rocket_navigation/renderer/base'
+
+module RocketNavigation
+  module Renderer
+    autoload :List, 'rocket_navigation/renderer/list'
+    autoload :Links, 'rocket_navigation/renderer/links'
+    autoload :Breadcrumbs, 'rocket_navigation/renderer/breadcrumbs'
+    autoload :BreadcrumbsOnRails, 'rocket_navigation/renderer/breadcrumbs_on_rails'
+    autoload :Text, 'rocket_navigation/renderer/text'
+    autoload :Json, 'rocket_navigation/renderer/json'
+  end
+end

data/lib/rocket_navigation/renderer/base.rb

@@ -0,0 +1,159 @@
+require 'forwardable'
+
+module RocketNavigation
+  module Renderer
+    # This is the base class for all renderers.
+    #
+    # A renderer is responsible for rendering an ItemContainer and its
+    # containing items to HTML.
+    class Base
+      extend Forwardable
+      attr_reader :container, :options
+
+      def_delegators :container, :view_context
+      def_delegators :view_context, :link_to, :content_tag
+
+      def initialize(container, options = {})
+        @container = container
+        @options = options
+      end
+
+      def selected_class(type)
+        container.selected_class[type] || options[:selected_class][type]
+      end
+
+      def container_html
+        @container_html ||= container.container_html.merge(options[:container_html] || {})
+      end
+
+      # override this method if needed
+      def container_options
+        container_html
+      end
+
+      def base_item_html
+        @base_item_html ||= container.item_html.merge(options[:item_html] || {})
+      end
+
+      def item_html(item)
+        classes = Array.wrap(base_item_html[:class] || [])
+        if item.selected?
+          classes.push(selected_class(:item))
+        end
+        if item.active_branch?
+          classes.push(selected_class(:branch))
+        end
+
+        base_item_html.except(:class).merge({
+          class: classes.reject { |c| c.nil? }
+        })
+      end
+
+      # override this method if needed
+      def item_options(item)
+        item_html(item)
+      end
+
+      def base_link_html
+        @base_link_html ||= container.link_html.merge(options[:link_html] || {})
+      end
+
+      def link_html(item)
+        classes = Array.wrap(base_link_html[:class] || [])
+        if item.selected?
+          classes.push(selected_class(:link))
+        end
+        ret = base_link_html.except(:class)
+        ret.merge!({
+          class: classes.reject { |c| c.nil? }
+        })
+
+        unless item.method.blank?
+          ret.merge!({
+            method: method
+          })
+        end
+        ret
+      end
+
+      # override this method if needed
+      def link_options(item)
+        link_html(item)
+      end
+
+      def expand_all?
+        !options.key?(:expand_all) || options[:expand_all] == false
+      end
+
+      def level
+        options[:level] || :all
+      end
+
+      def skip_if_empty?
+        !!options[:skip_if_empty]
+      end
+
+      def include_sub_navigation?(item)
+        consider_sub_navigation?(item) && expand_sub_navigation?(item)
+      end
+
+      def render_sub_navigation_for(item)
+        item.sub_navigation.render(options)
+      end
+
+      # Renders the specified ItemContainer to HTML.
+      #
+      # When implementing a renderer, please consider to call
+      # include_sub_navigation? to determine whether an item's sub_navigation
+      # should be rendered or not.
+      def render(item_container)
+        fail NotImplementedError, 'subclass responsibility'
+      end
+
+      def consider_sub_navigation?(item)
+        return false unless item.sub_navigation
+
+        case level
+        when :all
+          true
+        when Range
+          item.sub_navigation.level <= level.max
+        else
+          false
+        end
+      end
+
+      def expand_sub_navigation?(item)
+        expand_all? || item.selected?
+      end
+
+      # to allow overriding when there is specific logic determining
+      # when a link should not be rendered (eg. breadcrumbs renderer
+      # does not render the final breadcrumb as a link when instructed
+      # not to do so.)
+      def suppress_link?(item)
+        item.url.nil?
+      end
+
+      # determine and return link or static content depending on
+      # item/renderer conditions.
+      def tag_for(item)
+        if suppress_link?(item)
+          suppressed_tag_for(item)
+        else
+          active_tag_for(item)
+        end
+      end
+
+      # render an item as a non-active link (span)
+      def suppressed_tag_for(item)
+        content_tag('span', item.name, link_options(item).except(:method))
+      end
+
+      # render an item as an active link (a)
+      def active_tag_for(item)
+        link_to(item.name, item.url, link_options(item))
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/breadcrumbs.rb

@@ -0,0 +1,58 @@
+module RocketNavigation
+  module Renderer
+    # Renders an ItemContainer as a <div> element and its containing items as
+    # <a> elements.
+    # It only renders 'selected' elements.
+    #
+    # By default, the renderer sets the item's key as dom_id for the rendered
+    # <a> element unless the config option <tt>autogenerate_item_ids</tt> is
+    # set to false.
+    #
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
+    # The ItemContainer's dom_attributes are applied to the surrounding <div>
+    # element.
+    class Breadcrumbs < RocketNavigation::Renderer::Base
+      def render(item_container)
+        content = a_tags(item_container)
+        content_tag(
+          :div,
+          prefix_for(content) + content,
+          container_html
+        )
+      end
+
+      protected
+
+      def a_tags(item_container)
+        list = ActiveSupport::SafeBuffer.new
+        item_container.items.each do |item|
+          next unless item.selected?
+          list << tag_for(item)
+
+          if include_sub_navigation?(item)
+            list << join_with
+            list << a_tags(item.sub_navigation)
+          end
+        end
+        list
+      end
+
+      def join_with
+        @join_with ||= options[:join_with] || ' '.html_safe
+      end
+
+      def suppress_link?(item)
+        super || (options[:static_leaf] && item.active_leaf?)
+      end
+
+      def prefix_for(content)
+        if !content.empty? && options[:prefix]
+          options[:prefix]
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/breadcrumbs_on_rails.rb

@@ -0,0 +1,27 @@
+module RocketNavigation
+  module Renderer
+    # Renders an ItemContainer as a <div> element and its containing items as
+    # <a> elements.
+    # It only renders 'selected' elements.
+    #
+    # By default, the renderer sets the item's key as dom_id for the rendered
+    # <a> element unless the config option <tt>autogenerate_item_ids</tt> is
+    # set to false.
+    #
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
+    # The ItemContainer's dom_attributes are applied to the surrounding <div>
+    # element.
+    class BreadcrumbsOnRails < RocketNavigation::Renderer::Base
+      def render(item_container)
+        item_container.items.each do |item|
+          next unless item.selected?
+          add_breadcrumb(item.name, item.url, item_html(item))
+          if include_sub_navigation?(item)
+            render(item.sub_navigation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/json.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+module RocketNavigation
+  module Renderer
+    # Renders the navigation items as a object tree serialized as a json string,
+    # can also output raw ruby Hashes
+    class Json < RocketNavigation::Renderer::Base
+      def render(item_container)
+        results = hash_render(item_container)
+        options[:as_hash] ? results : results.to_json
+      end
+
+      private
+
+      def hash_render(item_container)
+        return nil unless item_container
+
+        item_container.items.map do |item|
+          {
+            items: hash_render(item.sub_navigation),
+            name: item.name,
+            selected: item.selected?,
+            url: item.url
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/links.rb

@@ -0,0 +1,35 @@
+module RocketNavigation
+  module Renderer
+    # Renders an ItemContainer as a <div> element and its containing items as
+    # <a> elements.
+    # It adds the 'selected' class to the <a> element that is currently active.
+    #
+    # The Links renderer cannot be used to render nested navigations. If you
+    # would like it to use with nested navigations, you have to render each
+    # level separately.
+    #
+    # By default, the renderer sets the item's key as dom_id for the rendered
+    # <a> element unless the config option <tt>autogenerate_item_ids</tt> is set
+    # to false.
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
+    # The ItemContainer's dom_attributes are applied to the surrounding <div>
+    # element.
+    class Links < RocketNavigation::Renderer::Base
+      def render(item_container)
+        div_content = ActiveSupport::SafeBuffer.new
+        item_container.items.each_with_index do |item, index|
+          div_content << tag_for(item)
+          unless index == item_container.items.length - 1
+            div_content << join_with
+          end
+        end
+        content_tag :div, div_content, container_html
+      end
+
+      def join_with
+        @join_with ||= options[:join_with] || ''.html_safe
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/list.rb

@@ -0,0 +1,45 @@
+module RocketNavigation
+  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 (based on the level and
+    # expand_all options), 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 unless the config option <tt>autogenerate_item_ids</tt> is
+    # set to false.
+    # The id can also be explicitely specified by setting the id in the
+    # html-options of the 'item' method in the config/navigation.rb file.
+    class List < RocketNavigation::Renderer::Base
+      def render(item_container)
+        if skip_if_empty? && item_container.empty?
+          ''.html_safe
+        else
+          tag = options[:ordered] ? :ol : :ul
+          content = list_content(item_container)
+          content_tag(tag, content, container_html)
+        end
+      end
+
+      def render_item(item)
+        li_content = tag_for(item)
+        if include_sub_navigation?(item)
+          li_content << render_sub_navigation_for(item)
+        end
+        content_tag(:li, li_content, item_options(item))
+      end
+
+      def list_content(item_container)
+        ret = ActiveSupport::SafeBuffer.new
+        item_container.items.each do |item|
+          ret << render_item(item)
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/rocket_navigation/renderer/text.rb

@@ -0,0 +1,21 @@
+module RocketNavigation
+  module Renderer
+    # Renders the 'chain' of selected navigation items as simple text items,
+    # joined with an optional separator (similar to breadcrumbs, but without
+    # markup).
+    class Text < RocketNavigation::Renderer::Base
+      def render(item_container)
+        list(item_container).compact.join(options[:join_with] || ' ')
+      end
+
+      private
+
+      def list(item_container)
+        item_container.items.keep_if(&:selected?).map do |item|
+          [item.name] +
+          (include_sub_navigation?(item) ? list(item.sub_navigation) : [])
+        end
+      end
+    end
+  end
+end

data/lib/rocket_navigation/version.rb

@@ -0,0 +1,3 @@
+module RocketNavigation
+  VERSION = "0.1.0"
+end

data/rocket_navigation.gemspec

@@ -0,0 +1,38 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rocket_navigation/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rocket_navigation"
+  spec.version       = RocketNavigation::VERSION
+  spec.authors       = ["Gleb Tv"]
+  spec.email         = ["glebtv@gmail.com"]
+
+  spec.summary       = %q{rocket_navigation is a gem for creating navigation / menu (for Rails).}
+  spec.description   = %q{Currently alpha qualiy, use at your own risk.}
+  spec.homepage      = "https://github.com/rs-pro/rocket_navigation"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport', '>= 5.0'
+  spec.add_runtime_dependency 'actionpack', '>= 5.0'
+  spec.add_runtime_dependency 'actionview', '>= 5.0'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency 'guard-rspec', '~> 4.2'
+  spec.add_development_dependency 'capybara'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'tzinfo', '>= 0'
+end