jordanyeo-simple-navigation 3.11.0

data/lib/generators/navigation_config/navigation_config_generator.rb

@@ -0,0 +1,12 @@
+class NavigationConfigGenerator < Rails::Generators::Base
+  def self.source_root
+    @source_root ||= File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','generators','navigation_config', 'templates'))
+  end
+
+  desc 'Creates a template config file for the simple-navigation plugin. You will find the generated file in config/navigation.rb.'
+  def navigation_config
+    copy_file('config/navigation.rb', 'config/navigation.rb')    
+    say File.read(File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','README')))
+  end
+  
+end

data/lib/simple-navigation.rb

@@ -0,0 +1 @@
+require 'simple_navigation'

data/lib/simple_navigation.rb

@@ -0,0 +1,167 @@
+# 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 'simple_navigation/core'
+require 'simple_navigation/rendering'
+require 'simple_navigation/adapters'
+
+require 'forwardable'
+
+# A plugin for generating a simple navigation. See README for resources on usage instructions.
+module SimpleNavigation
+  
+  mattr_accessor :adapter_class, :adapter, :config_files, :config_file_paths, :default_renderer, :registered_renderers, :root, :environment
+
+  # Cache for loaded config files
+  self.config_files = {}
+
+  # Allows for multiple config_file_paths. Needed if a plugin itself uses simple-navigation and therefore has its own config file
+  self.config_file_paths = []
+  
+  # Maps renderer keys to classes. The keys serve as shortcut in the render_navigation calls (:renderer => :list)
+  self.registered_renderers = {
+    :list         => SimpleNavigation::Renderer::List,
+    :links        => SimpleNavigation::Renderer::Links,
+    :breadcrumbs  => SimpleNavigation::Renderer::Breadcrumbs,
+    :text         => SimpleNavigation::Renderer::Text,
+    :json         => SimpleNavigation::Renderer::Json
+  }
+  
+  class << self
+    extend Forwardable
+    
+    def_delegators :adapter, :request, :request_uri, :request_path, :context_for_eval, :current_page?
+    def_delegators :adapter_class, :register
+
+    # Sets the root path and current environment as specified. Also sets the default config_file_path.
+    def set_env(root, environment)
+      self.root = root
+      self.environment = environment
+      self.config_file_paths << SimpleNavigation.default_config_file_path
+    end
+
+    # Returns the current framework in which the plugin is running.
+    def framework
+      return :rails if defined?(Rails)
+      return :padrino if defined?(Padrino)
+      return :sinatra if defined?(Sinatra)
+      return :nanoc if defined?(Nanoc3)
+      raise 'simple_navigation currently only works for Rails, Sinatra and Padrino apps'
+    end
+    
+    # Loads the adapter for the current framework
+    def load_adapter
+      self.adapter_class = case framework
+      when :rails
+        SimpleNavigation::Adapters::Rails
+      when :sinatra
+        SimpleNavigation::Adapters::Sinatra
+      when :padrino
+        SimpleNavigation::Adapters::Padrino
+      when :nanoc
+        SimpleNavigation::Adapters::Nanoc
+      end
+    end
+
+    # Creates a new adapter instance based on the context in which render_navigation has been called.
+    def init_adapter_from(context)
+      self.adapter = self.adapter_class.new(context)
+    end
+  
+    def default_config_file_path
+      File.join(SimpleNavigation.root, 'config')
+    end
+
+    # Returns true if the config_file for specified context does exist.
+    def config_file?(navigation_context = :default)
+      !!config_file(navigation_context)
+    end
+
+    # Returns the path to the config file for the given navigation context or nil if no matching config file can be found.
+    # If multiple config_paths are set, it returns the first matching path.
+    def config_file(navigation_context = :default)
+      config_file_paths.collect { |path| File.join(path, config_file_name(navigation_context)) }.detect {|full_path| File.exists?(full_path)}
+    end
+
+    # Returns the name of the config file for the given navigation_context
+    def config_file_name(navigation_context = :default)
+      prefix = navigation_context == :default ? '' : "#{navigation_context.to_s.underscore}_"
+      "#{prefix}navigation.rb"      
+    end
+    
+    # Resets the list of config_file_paths to the specified path
+    def config_file_path=(path)
+      self.config_file_paths = [path]
+    end
+
+    # Reads the config_file for the specified navigation_context and stores it for later evaluation.
+    def load_config(navigation_context = :default)
+      raise "Config file '#{config_file_name(navigation_context)}' not found in path(s) #{config_file_paths.join(', ')}!" unless config_file?(navigation_context)      
+      if self.environment == 'production'
+        self.config_files[navigation_context] ||= IO.read(config_file(navigation_context))
+      else
+        self.config_files[navigation_context] = IO.read(config_file(navigation_context))
+      end
+    end
+
+    # Returns the singleton instance of the SimpleNavigation::Configuration
+    def config
+      SimpleNavigation::Configuration.instance
+    end
+
+    # Returns the ItemContainer that contains the items for the primary navigation
+    def primary_navigation
+      config.primary_navigation
+    end
+
+    # Returns the active item container for the specified level. Valid levels are
+    # * :all - in this case the primary_navigation is returned.
+    # * :leaves - the 'deepest' active item_container will be returned
+    # * a specific level - the active item_container for the specified level will be returned
+    # * a range of levels - the active item_container for the range's minimum will be returned
+    #
+    # Returns nil if there is no active item_container for the specified level.
+    def active_item_container_for(level)
+      case level
+      when :all
+        self.primary_navigation
+      when :leaves
+        self.primary_navigation.active_leaf_container
+      when Integer
+        self.primary_navigation.active_item_container_for(level)
+      when Range
+        self.primary_navigation.active_item_container_for(level.min)
+      else
+        raise ArgumentError, "Invalid navigation level: #{level}"
+      end
+    end
+        
+    # Registers a renderer.
+    #
+    # === Example
+    # To register your own renderer:
+    #
+    #   SimpleNavigation.register_renderer :my_renderer => My::RendererClass
+    #
+    # Then in the view you can call:
+    #
+    #   render_navigation(:renderer => :my_renderer)
+    def register_renderer(renderer_hash)
+      self.registered_renderers.merge!(renderer_hash)
+    end
+    
+    private
+    
+    def apply_defaults(options)
+      options[:level] = options.delete(:levels) if options[:levels]
+      {:context => :default, :level => :all}.merge(options)
+    end
+    
+
+  end
+
+end
+
+SimpleNavigation.load_adapter

data/lib/simple_navigation/adapters.rb

@@ -0,0 +1,10 @@
+require 'simple_navigation/adapters/base'
+
+module SimpleNavigation
+  module Adapters
+    autoload :Rails, 'simple_navigation/adapters/rails'
+    autoload :Padrino, 'simple_navigation/adapters/padrino'
+    autoload :Sinatra, 'simple_navigation/adapters/sinatra'
+    autoload :Nanoc, 'simple_navigation/adapters/nanoc'
+  end
+end

data/lib/simple_navigation/adapters/base.rb

@@ -0,0 +1,37 @@
+module SimpleNavigation
+  module Adapters
+    
+    # This is the base class for all adapters. This class mainly exists for documenting reasons.
+    # It lists all the methods that an adapter should implement.
+    #
+    class Base
+      attr_reader :context, :request
+      
+      # This method is usually called when the framework is initialized. 
+      # It should call SimpleNavigation.set_env and install SimpleNavigation::Helpers where appropriate.
+      def self.register; end
+      
+      # Returns the full path incl. query params
+      def request_uri; end
+      
+      # Returns the path without query params
+      def request_path; end
+      
+      # Returns the context in which the config files will be evaluated
+      def context_for_eval; end
+      
+      # Returns true if the current request's url matches the specified url. 
+      # Used to determine if an item should be autohighlighted.
+      def current_page?(url); end
+      
+      # Returns a link with the specified name, url and options.
+      # Used for rendering.
+      def link_to(name, url, options={}); end
+      
+      # Returns a tag of the specified type, content and options.
+      # Used for rendering.
+      def content_tag(type, content, options={}); end
+      
+    end
+  end
+end

data/lib/simple_navigation/adapters/nanoc.rb

@@ -0,0 +1,45 @@
+module SimpleNavigation
+  module Adapters
+    class Nanoc < Base
+      class << self
+        def register(root)
+          SimpleNavigation.set_env(root, 'development')
+          Nanoc3::Context.send(:include, SimpleNavigation::Helpers)
+        end
+      end
+
+      def initialize(ctx)
+        @context = ctx
+      end
+
+      # Returns the context in which the config files will be evaluated
+      def context_for_eval
+        context
+      end
+      
+      # Returns true if the current request's url matches the specified url. 
+      # Used to determine if an item should be autohighlighted.
+      def current_page?(url)
+        path = context.item.path
+        path && path.chop == url
+      end
+      
+      # Returns a link with the specified name, url and options.
+      # Used for rendering.
+      def link_to(name, url, options={})
+        "<a href='#{url}' #{to_attributes(options)}>#{name}</a>"
+      end
+
+      # Returns a tag of the specified type, content and options.
+      # Used for rendering.
+      def content_tag(type, content, options={})
+        "<#{type} #{to_attributes(options)}>#{content}</#{type}>"
+      end
+
+      private
+      def to_attributes(options)
+        options.map {|k, v| v.nil? ? nil : "#{k}='#{v}'"}.compact.join(' ')
+      end
+    end
+  end
+end

data/lib/simple_navigation/adapters/padrino.rb

@@ -0,0 +1,20 @@
+module SimpleNavigation
+  module Adapters
+    class Padrino < Sinatra
+      
+      def self.register
+        SimpleNavigation.set_env(PADRINO_ROOT, PADRINO_ENV)
+        ::Padrino::Application.send(:helpers, SimpleNavigation::Helpers)
+      end
+            
+      def link_to(name, url, options={})
+        context.link_to(name, url, options)
+      end
+      
+      def content_tag(type, content, options={})
+        context.content_tag(type, content.html_safe, options)
+      end
+      
+    end
+  end
+end

data/lib/simple_navigation/adapters/rails.rb

@@ -0,0 +1,93 @@
+module SimpleNavigation
+  module Adapters
+    class Rails < Base
+            
+      attr_reader :controller, :template
+
+      def self.register
+        SimpleNavigation.set_env(rails_root, rails_env)        
+        ActionController::Base.send(:include, SimpleNavigation::Helpers)
+        SimpleNavigation::Helpers.instance_methods.each do |m|
+          ActionController::Base.send(:helper_method, m.to_sym)
+        end
+      end
+      
+      def initialize(context)
+        @controller = extract_controller_from context
+        @template = template_from @controller
+        @request = @template.request if @template
+      end
+      
+      def request_uri
+        return '' unless request
+        return request.fullpath if request.respond_to?(:fullpath)
+        request.request_uri
+      end
+      
+      def request_path
+        return '' unless request
+        request.path
+      end
+      
+      def context_for_eval
+        raise 'no context set for evaluation the config file' unless template || controller
+        template || controller
+      end
+      
+      def current_page?(url)
+        template.current_page?(url) if template
+      end
+      
+      def link_to(name, url, options={})
+        template.link_to(html_safe(name), url, options) if template
+      end
+      
+      def content_tag(type, content, options={})
+        template.content_tag(type, html_safe(content), options) if template
+      end
+      
+      protected
+      
+      def self.rails_root
+        gte_rails3? ? ::Rails.root : ::RAILS_ROOT
+      end
+      
+      def self.rails_env
+        gte_rails3? ? ::Rails.env : ::RAILS_ENV
+      end
+      
+      def self.gte_rails3?
+        ::Rails::VERSION::MAJOR >= 3
+      end
+      
+      def template_from(controller)
+        controller.respond_to?(:view_context) ? controller.view_context : controller.instance_variable_get(:@template)
+      end
+      
+      # Marks the specified input as html_safe (for Rails3). Does nothing if html_safe is not defined on input. 
+      #
+      def html_safe(input)
+        input.respond_to?(:html_safe) ? input.html_safe : input
+      end
+      
+      # Extracts a controller from the context.
+      def extract_controller_from(context)
+        context.respond_to?(:controller) ?
+          context.controller || context :
+          context
+      end
+         
+    end
+  end
+end
+
+# Initializer for Rails3
+if defined?(Rails) && SimpleNavigation::Adapters::Rails.gte_rails3?
+  module SimpleNavigation                                                                                                
+    class Railtie < Rails::Railtie                                                                                       
+      initializer "simple_navigation.register" do |app|                                                             
+        SimpleNavigation.register
+      end                                                                                                                
+    end                                                                                                                  
+  end
+end

data/lib/simple_navigation/adapters/sinatra.rb

@@ -0,0 +1,69 @@
+require 'cgi'
+
+module SimpleNavigation
+  module Adapters
+    class Sinatra < Base
+
+      def self.register
+        SimpleNavigation.set_env(sinatra_root, sinatra_environment)
+        ::Sinatra::Application.send(:helpers, SimpleNavigation::Helpers)
+      end
+
+      def initialize(context)
+        @context = context
+        @request = context.request
+      end
+
+      def context_for_eval
+        raise 'no context set for evaluation the config file' unless context
+        context
+      end
+
+      def request_uri
+        request.fullpath
+      end
+
+      def request_path
+        request.path
+      end
+
+      def current_page?(url)
+        url_string = CGI.unescape(url)
+        if url_string.index("?")
+          uri = request_uri
+        else
+          uri = request_uri.split('?').first
+        end
+        uri = CGI.unescape(uri)
+        if url_string =~ /^\w+:\/\//
+          url_string == "#{request.scheme}://#{request.host_with_port}#{uri}"
+        else
+          url_string == uri
+        end
+      end
+
+      def link_to(name, url, options={})
+        "<a href='#{url}'#{to_attributes(options)}>#{name}</a>"
+      end
+
+      def content_tag(type, content, options={})
+        "<#{type}#{to_attributes(options)}>#{content}</#{type}>"
+      end
+
+      protected
+
+      def self.sinatra_root
+        ::Sinatra::Application.root
+      end
+
+      def self.sinatra_environment
+        ::Sinatra::Application.environment
+      end
+
+      def to_attributes(options)
+        options.map {|k, v| v.nil? ? '' : " #{k}='#{v}'"}.join
+      end
+
+    end
+  end
+end