navi 0.0.2

data/features/support/env.rb

@@ -0,0 +1,61 @@
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path("../../../spec/dummy/config/environment.rb",  __FILE__)
+require File.expand_path("../../../spec/blueprints.rb",  __FILE__)
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/rspec'
+  
+require 'cucumber/rails/world'
+require 'cucumber/rails3/active_record'
+require 'cucumber/rails3/action_controller'
+require 'cucumber/web/tableish'
+
+require 'capybara/rails'
+require 'capybara/cucumber'
+require 'capybara/session'
+require 'cucumber/rails/capybara/javascript_emulation' # Lets you click links with onclick javascript handlers without using @culerity or @javascript
+
+# Tell apotomo to use this new view path, since it was looking at app/widgets and app/widgets/layouts
+# It didn't know that the app was being run from inside spec/dummy
+Apotomo::Widget.append_view_path File.join('spec', 'dummy', 'app', 'widgets')
+Apotomo::Widget.append_view_path File.join('spec', 'dummy', 'app', 'widgets', 'layouts')
+
+# Capybara defaults to XPath selectors rather than Webrat's default of CSS3. In
+# order to ease the transition to Capybara we set the default here. If you'd
+# prefer to use XPath just remove this line and adjust any selectors in your
+# steps to use the XPath syntax.
+Capybara.default_selector = :css
+
+# If you set this to false, any error raised from within your app will bubble 
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# If you set this to true, each scenario will run in a database transaction.
+# You can still turn off transactions on a per-scenario basis, simply tagging 
+# a feature or scenario with the @no-txn tag. If you are using Capybara,
+# tagging with @culerity or @javascript will also turn transactions off.
+#
+# If you set this to false, transactions will be off for all scenarios,
+# regardless of whether you use @no-txn or not.
+#
+# Beware that turning transactions off will leave data in your database 
+# after each scenario, which can lead to hard-to-debug failures in 
+# subsequent scenarios. If you do this, we recommend you create a Before
+# block that will explicitly put your database in a known state.
+
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+if defined?(ActiveRecord::Base)
+  begin
+    require 'database_cleaner'
+    DatabaseCleaner.strategy = :truncation
+  rescue LoadError => ignore_if_database_cleaner_not_present
+  end
+end

data/features/support/paths.rb

@@ -0,0 +1,33 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/features/support/selectors.rb

@@ -0,0 +1,39 @@
+module HtmlSelectorsHelpers
+  # Maps a name to a selector. Used primarily by the
+  #
+  #   When /^(.+) within (.+)$/ do |step, scope|
+  #
+  # step definitions in web_steps.rb
+  #
+  def selector_for(locator)
+    case locator
+
+    when /the page/
+      "html > body"
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #  when /the (notice|error|info) flash/
+    #    ".flash.#{$1}"
+
+    # You can also return an array to use a different selector
+    # type, like:
+    #
+    #  when /the header/
+    #    [:xpath, "//header"]
+
+    # This allows you to provide a quoted selector as the scope
+    # for "within" steps as was previously the default for the
+    # web steps:
+    when /"(.+)"/
+      $1
+
+    else
+      raise "Can't find mapping from \"#{locator}\" to a selector.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(HtmlSelectorsHelpers)

data/lib/navi/helpers.rb

@@ -0,0 +1,24 @@
+# This helper is a module that will get included into Rails via the
+# lib/navi/railtie class
+#
+# It allows us to be in the context of the controller it is being included
+# into: when this module is included to ActionView and the view/controller
+# calls the render method, "self" will refer to the view or controller
+# context
+module Navi
+  module Helpers
+    def self.included(base)
+      #puts "Navi::Helpers was included into #{base}"
+    end
+
+    def navi_render(collection)
+      renderer.render(collection)
+    end
+
+    private
+
+    def renderer
+      @renderer ||= Navi.renderer.new(self)
+    end
+  end
+end

data/lib/navi/navigable/base.rb

@@ -0,0 +1,16 @@
+require 'navi/navigable/instance_methods'
+
+module Navi
+  module Navigable
+    module Base
+      def navigable(options={})
+        cattr_accessor :navigable_config
+        self.navigable_config = options
+        has_one Navi.navigator, :as => :navigable
+        include Navi::Navigable::InstanceMethods
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend Navi::Navigable::Base

data/lib/navi/navigable/instance_methods.rb

@@ -0,0 +1,24 @@
+module Navi
+  module Navigable
+    module InstanceMethods
+      def to_navigator(options={})
+        return navigator_instance if navigator_instance
+        options.merge!(:navigable => self)
+        Navi.navigator_class.new options
+      end
+
+      def to_navigator!(options={})
+        navigator = to_navigator(options)
+        navigator.save
+        navigator
+      end
+
+      private
+
+      # Easily get the navigator instance based on the Navi.navigator setting
+      def navigator_instance
+        @navigator_instance ||= send(Navi.navigator)
+      end
+    end
+  end
+end

data/lib/navi/navigator/base.rb

@@ -0,0 +1,11 @@
+require 'navi/navigator/class_methods'
+require 'navi/navigator/instance_methods'
+
+module Navi
+  module Navigator
+    class Base < ActiveRecord::Base
+      include Navi::Navigator::ClassMethods
+      include Navi::Navigator::InstanceMethods
+    end
+  end
+end

data/lib/navi/navigator/class_methods.rb

@@ -0,0 +1,27 @@
+module Navi
+  module Navigator
+    module ClassMethods
+      extend ActiveSupport::Concern
+      included do |child|
+        # So that Rails won't consider this to be an STI table.
+        # The actual project can have a model and inherit it this way:
+        #   class MyNavItem < Navigable::NavigationItem::Base
+        #
+        # Then the navigable classes must tell the gem that the name of
+        # the nav item is :my_nav_item, this way: navigable :navigator => :my_nav_item
+        self.abstract_class = true
+
+        belongs_to :navigable, :polymorphic => true
+
+        # Calling ordered_tree on the child is important because
+        # of this: http://stackoverflow.com/q/6262033/61018
+        # where ordered_tree was picking up the Navi::Navigator::Base's
+        # information, rather than whatever inherits Base class
+        def self.inherited(child)
+          child.send 'ordered_tree'
+          super # super, so that Rails can continue to do what it's needs
+        end
+      end
+    end
+  end
+end

data/lib/navi/navigator/instance_methods.rb

@@ -0,0 +1,57 @@
+module Navi
+  module Navigator
+    module InstanceMethods
+      def label
+        db_value = self.read_attribute :label
+        return db_value if db_value
+        return navigable.send navigable_config(:label) if navigable && navigable_config(:label)
+        nil
+      end
+
+      def link
+        db_value = self.read_attribute :link
+        return db_value if db_value
+        return navigable if navigable
+        nil
+      end
+
+      def title
+        db_value = self.read_attribute :title
+        return db_value if db_value
+        if navigable && navigable_config(:title)
+          config = navigable_config :title
+          return case config
+        when Symbol then navigable.send config
+        when String then config
+        when Proc then config.call navigable
+        end
+      end
+      return self.label
+    end
+
+    def highlights_on
+      db_value = self.read_attribute :highlights_on
+      value = if db_value
+                Regexp.new db_value
+              else # db_value.nil?
+                if navigable && navigable_config(:highlights_on)
+                  config = navigable_config(:highlights_on)
+                  case config
+                  when Proc then config.call navigable
+                  else config
+                  end
+                else
+                  self.link
+                end
+              end
+    end
+
+    private
+
+    def navigable_config(key)
+      navigable.class.navigable_config[key]
+    end
+
+  end
+end
+end

data/lib/navi/railtie.rb

@@ -0,0 +1,11 @@
+# What is a railtie?
+# tl;dr => Allows us to hook into Rails add add stuff to it
+# http://www.rorexperts.com/what-is-railtie-t1898.html
+
+module Navi
+  class Railtie < Rails::Railtie
+    initializer "navi.helpers" do
+      ActionView::Base.send :include, Navi::Helpers
+    end
+  end
+end

data/lib/navi/renderers/base.rb

@@ -0,0 +1,31 @@
+module Navi
+  module Renderers
+    class Base
+      attr_accessor :context, :controller, :template
+
+      def initialize(context)
+        @context = context
+        @controller = controller_from @context
+        @template = template_from @controller
+      end
+
+      def render(collection)
+        raise NotImplementedError
+      end
+
+      private
+
+      # Pretty much lifted from 
+      # https://github.com/andi/simple-navigation/blob/master/lib/simple_navigation/adapters/rails.rb
+      def controller_from(context)
+        context.respond_to?(:controller) ? context.controller : context
+      end
+
+      # Pretty much lifted from 
+      # https://github.com/andi/simple-navigation/blob/master/lib/simple_navigation/adapters/rails.rb
+      def template_from(controller)
+        controller.respond_to?(:view_context) ? controller.view_context : controller.instance_variable_get(:@template)
+      end
+    end
+  end
+end

data/lib/navi/renderers/simple_navigation.rb

@@ -0,0 +1,30 @@
+module Navi
+  module Renderers
+    class SimpleNavigation < Navi::Renderers::Base
+
+      def render(collection)
+        items = create_dynamic_items(collection)
+        @template.render_navigation :items => items, :expand_all => true
+      end
+
+      private
+
+      # Create an array of hashes that can be easily fed into SimpleNavigation
+      # like in the following like:
+      # https://github.com/andi/simple-navigation/wiki/Dynamic-Navigation-Items
+      def create_dynamic_items(collection)
+        nav = []
+        collection.each do |nav_item|
+          nav << {
+            :key => @template.dom_id(nav_item).to_sym,
+            :name => nav_item.label,
+            :url => @template.polymorphic_path(nav_item.link),
+            :options => {:title => nav_item.title, :class => nav_item.class.name.underscore},
+            :items => create_dynamic_items(nav_item.children)
+          }
+        end
+        nav
+      end
+    end
+  end
+end

data/lib/navi.rb

@@ -0,0 +1,29 @@
+require 'active_support'
+require "active_support/core_ext/module" # so we can use mattr_accessor
+require 'active_record'
+require 'ordered_tree'
+require 'navi/navigable/base'
+require 'navi/railtie' if defined?(Rails) # so we can include the rendering helper into Rails
+
+module Navi
+  autoload :Helpers, 'navi/helpers'
+
+  module Navigator
+    autoload :Base, 'navi/navigator/base'
+  end
+
+  module Renderers
+    autoload :Base, 'navi/renderers/base'
+    autoload :SimpleNavigation, 'navi/renderers/simple_navigation'
+  end
+
+  def self.navigator_class
+    self.navigator.to_s.classify.constantize
+  end
+
+  mattr_accessor :navigator
+  @@navigator ||= :nav_item
+
+  mattr_accessor :renderer
+  @@renderer ||= Navi::Renderers::SimpleNavigation
+end