ramenu 3.0.0

data/init.rb

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

data/lib/ramenu.rb

@@ -0,0 +1,13 @@
+require 'ramenu/menus'
+require 'ramenu/version'
+require 'ramenu/action_controller'
+require 'ramenu/railtie'
+require 'ramenu/ramenu_methods'
+require 'ramenu/ramenu_definer'
+require 'ramenu/config'
+
+module Ramenu
+
+  DEFAULT_GROUP   = :default
+
+end

data/lib/ramenu/action_controller.rb

@@ -0,0 +1,223 @@
+module Ramenu
+  module ActionController
+    extend ActiveSupport::Concern
+
+    included do
+      extend          ClassMethods
+      helper          HelperMethods
+      helper_method   :add_menu, :menus, :flags
+    end
+
+
+    module Utils
+
+      def self.instance_proc(string)
+        if string.kind_of?(String)
+          proc { |controller| controller.instance_eval(string) }
+        else
+          string
+        end
+      end
+
+      # This is an horrible method with an horrible name.
+      #
+      #   convert_to_set_of_strings(nil, [:foo, :bar])
+      #   # => nil
+      #   convert_to_set_of_strings(true, [:foo, :bar])
+      #   # => ["foo", "bar"]
+      #   convert_to_set_of_strings(:foo, [:foo, :bar])
+      #   # => ["foo"]
+      #   convert_to_set_of_strings([:foo, :bar, :baz], [:foo, :bar])
+      #   # => ["foo", "bar", "baz"]
+      #
+      def self.convert_to_set_of_strings(value, keys)
+        if value == true
+          keys.map(&:to_s).to_set
+        elsif value
+          Array(value).map(&:to_s).to_set
+        end
+      end
+
+    end
+
+    module HelperMethods
+
+      def render_ramenu(options = {}, &block)
+        # passing all flags to Builder (static + volatile)
+        options[:flags] = flags(options[:menu])
+        builder = (options.delete(:builder) || Menus::SimpleBuilder).new(self, menus(options[:menu]), options)
+        content = builder.render.html_safe
+        if block_given?
+          capture(content, &block)
+        else
+          content
+        end
+      end
+
+    end
+
+    module ClassMethods
+
+      #
+      # flags methods
+      #
+
+      # get flag value
+      def get_flag(name, filter_options = {})
+        before_filter(filter_options) do |controller|
+          controller.send(:get_flag, name, filter_options)
+        end
+      end
+
+      # set flag value
+      def set_flag(name, value, filter_options = {})
+        before_filter(filter_options) do |controller|
+          controller.send(:set_flag, name, value, filter_options)
+        end
+      end
+
+      # reset flag value
+      def reset_flag(name, filter_options = {})
+        before_filter(filter_options) do |controller|
+          controller.send(:reset_flag, name, filter_options)
+        end
+      end
+
+      #
+      # menus methods
+      #
+
+      # add a menu
+      def add_menu(name, path = nil, filter_options = {}, &block)
+        # This isn't really nice here
+        if eval = Utils.convert_to_set_of_strings(filter_options.delete(:eval), %w(name path))
+          name = Utils.instance_proc(name) if eval.include?("name")
+          unless path.nil?
+            path = Utils.instance_proc(path) if eval.include?("path")
+          end
+        end
+
+        before_filter(filter_options) do |controller|
+          # if path isn't defined, use current path
+          path = request.fullpath if path.nil?
+
+          controller.send(:add_menu, name, path, filter_options, &block)
+        end
+      end
+      alias :add_menu_for_current :add_menu
+
+      # define volatile menus/flags in a block
+      def definer(name = nil, filter_options = {}, &block)
+        before_filter(filter_options) do |controller|
+          controller.send(:definer, name, filter_options, &block)
+        end
+      end
+    end
+
+    protected
+
+    # common
+
+    def definer(name = nil, options = {}, &block)
+      static = options[:static] || false
+
+      menus = static ? static_menus(name) : volatile_menus(name)
+      flags = static ? static_flags(name) : volatile_flags(name)
+
+      # use a definer to allow block
+      rd = Ramenu::RamenuDefiner.new(menus, flags, options)
+      yield rd if block_given?
+    end
+
+    # flags
+
+    # get flag value
+    def get_flag(name, options = {})
+      # getting options
+      static = options[:static] || false
+      volatile = options[:volatile] || false
+
+      f = static_flags(options[:flagset]) if static
+      f = volatile_flags(options[:flagset]) if volatile
+      f = flags(options[:flagset]) unless static || volatile
+
+      f[name] if f.include?(name)
+    end
+
+    # reset flag value
+    def reset_flag(name, options = {})
+      set_flag(name, nil, options) unless name.nil?
+    end
+
+    # set flag value
+    def set_flag(name, value = nil, options = {})
+      # getting options
+      static = options[:static] || false
+
+      # setting flag
+      if static
+        set_static_flag(name, value, options)
+      else #if volatile
+        # default is volatile when nothing's set
+        set_volatile_flag(name, value, options)
+      end
+    end
+
+    # add a static flag, which will be kept for next instances
+    def set_static_flag(name, value, options = {})
+      flagset = options[:flagset]
+      Ramenu.set_flag_in(static_flags(flagset), name, value, options)
+    end
+
+    # add a volatile flag, only valid in the current instances
+    def set_volatile_flag(name, value, options = {})
+      flagset = options[:flagset]
+      Ramenu.set_flag_in(volatile_flags(flagset), name, value, options)
+    end
+
+    # return volatile flags defined in the current instance
+    def volatile_flags(flagset = nil)
+      flagset = :default if flagset.nil? 
+      @flags ||= {}
+      @flags[flagset] ||= {}
+      @flags[flagset]
+    end
+    # return static flags defined in the configuration
+    def static_flags(flagset = nil)
+      Ramenu.static_flags(flagset)
+    end
+    # return all defined flags, static ones first then volatile ones
+    def flags(flagset = nil)
+      static_flags(flagset).merge(volatile_flags(flagset))
+    end
+
+    # add a static menu, which will be kept for next instances
+    def add_static_menu(name, path, options = {}, &block)
+      menu = options[:menu]
+      Ramenu.add_menu_to(static_menus(menu), name, path, options, &block)
+    end
+
+    # add a volatile menu, only valid in the current instances
+    def add_volatile_menu(name, path, options = {}, &block)
+      menu = options[:menu]
+      Ramenu.add_menu_to(volatile_menus(menu), name, path, options, &block)
+    end
+    alias :add_menu :add_volatile_menu
+
+    # return volatile menus defined in the current instance
+    def volatile_menus(menu = nil)
+      menu = :default if menu.nil? 
+      @ramenu_menus ||= {}
+      @ramenu_menus[menu] ||= []
+    end
+    # return static menus defined in the configuration
+    def static_menus(menu = nil)
+      Ramenu.static_menus(menu)
+    end
+    # return all defined menus, static ones first then volatile ones
+    def menus(menu = nil)
+      static_menus(menu) + volatile_menus(menu)
+    end
+
+  end
+end

data/lib/ramenu/config.rb

@@ -0,0 +1,44 @@
+require 'active_support/configurable'
+
+module Ramenu
+  # Configures global settings for Ramenu
+  def self.configure(&block)
+    yield @config ||= Ramenu::Configuration.new
+  end
+
+  # Global settings for Ramenu
+  def self.config
+    @config
+  end
+
+  # need a Class for 3.0
+  class Configuration #:nodoc:
+    include ActiveSupport::Configurable
+    config_accessor :menus
+    config_accessor :flags
+
+    # common
+    def definer(name = nil, options = {}, &block)
+      # menus
+      menus = Ramenu.static_menus(name)
+      # flags
+      flags = Ramenu.static_flags(name)
+
+      # use a definer to allow block
+      rd = RamenuDefiner.new(menus, flags, options)
+      yield rd if block_given?
+    end
+
+    # create a new static flag in the configuration
+    def set_flag(name, value = nil, options = {})
+      flags = Ramenu.static_flags(options[:flagset])
+      Ramenu.set_flag_in(flags, name, value, options)
+    end
+
+    # create a new static menus in the configuration
+    def add_menu(name, path = nil, options = {}, &block)
+      menus = Ramenu.static_menus(options[:menu])
+      Ramenu.add_menu_to(menus, name, path, options, &block)
+    end
+  end
+end

data/lib/ramenu/menus.rb

@@ -0,0 +1,167 @@
+module Ramenu
+
+  module Menus
+
+    # The Builder class represents the abstract class for any custom Builder.
+    #
+    # To create a custom Builder, just extend this class
+    # and implement the following abstract methods:
+    #
+    # * <tt>#render</tt>: Renders and returns the collection of navigation elements
+    #
+    class Builder
+
+      # Initializes a new Builder with <tt>context</tt>,
+      # <tt>element</tt> and <tt>options</tt>.
+      #
+      # @param [ActionView::Base] context The view context.
+      # @param [Array<Element>] elements The collection of Elements.
+      # @param [Hash] options Hash of options to customize the rendering behavior.
+      #
+      def initialize(context, elements, options = {})
+        @context  = context
+        @elements = elements
+        @options  = options
+      end
+
+      # Renders Elements and returns the Breadcrumb navigation for the view.
+      #
+      # @return [String] The result of the menu rendering.
+      #
+      # @abstract You must implement this method in your custom Builder.
+      def render
+        raise NotImplementedError
+      end
+
+      # get flag associated to element
+      def flag_for(element, option = :flag)
+        flag = nil
+        flag_selector = element.options[option]
+        unless flag_selector.nil?
+          flag = @options[:flags][flag_selector] if @options[:flags].include?(flag_selector)
+        end
+        return flag
+      end
+
+      protected
+
+        def compute_name(element)
+          case name = element.name
+          when Symbol
+            begin
+              @context.send(name)
+            rescue NoMethodError
+              key = 'ramenu.menus.' + @options[:menu].to_s + element.translation_key
+              I18n.t(key)
+            end
+          when Proc
+            name.call(@context)
+          else
+            name.to_s
+          end
+        end
+
+        def compute_path(element)
+          case path = element.path
+          when Symbol
+            @context.send(path)
+          when Proc
+            path.call(@context)
+          when Hash
+            @context.url_for(path)
+          else
+            path.to_s
+          end
+        end
+
+    end
+
+    # The SimpleBuilder is the default menu builder.
+    # It provides basic functionalities to render a menu navigation.
+    #
+    # The SimpleBuilder accepts a limited set of options.
+    # If you need more flexibility, create a custom Builder and
+    # pass the option :builder => BuilderClass to the <tt>render_menus</tt> helper method.
+    #
+    class SimpleBuilder < Builder
+
+      def render
+        @elements.collect do |element|
+          render_element(element)
+        end.join(@options[:separator] || " &raquo; ")
+      end
+
+      def render_element(element)
+        content = @context.link_to_unless_current(compute_name(element), compute_path(element), element.options)
+
+        # rendering sub-elements
+        if (element.childs.length > 0)
+          content = content + " |"
+          element.childs.each do |child|
+            content = content + @context.link_to_unless_current(compute_name(child), compute_path(child)) + "|"
+          end
+        end
+
+        if @options[:tag]
+          @context.content_tag(@options[:tag], content)
+        else
+          content
+        end
+      end
+
+    end
+
+
+    # Represents a navigation element in the menu collection.
+    #
+    class Element
+
+      # @return [String] The element/link name.
+      attr_accessor :name
+      # @return [String] The element/link URL.
+      attr_accessor :path
+      # @return [Hash] The element/link childs
+      attr_accessor :childs
+      # @return [Element] The element/link parent
+      attr_accessor :parent
+      # @return [Hash] The element/link URL.
+      attr_accessor :options
+
+      # Initializes the Element with given parameters.
+      #
+      # @param  [String] name The element/link name.
+      # @param  [String] path The element/link URL.
+      # @param  [Hash] options The element/link URL.
+      # @return [Element]
+      #
+      def initialize(name, path, options = {})
+        self.name     = name
+        self.path     = path
+        self.childs   = []
+        #self.parent   = @options[:parent]
+        self.parent   = options.delete(:parent)
+        self.options  = options
+      end
+
+      def translation_key
+        key = ''
+        elem = self
+        while !elem.nil? do
+          key = '.' + elem.name.to_s + key if elem.name.is_a?(Symbol)
+          key = '.' + elem.name.to_sym.to_s + key if elem.name.is_a?(String)
+          elem = elem.parent
+        end
+        key += '.root' if self.childs.count > 0
+        return key
+      end
+
+      def add_menu(name, path, options = {}, &block)
+        opts = options.merge({:parent => self})
+        self.childs << Ramenu.new_ramenu_element(name, path, opts, &block)
+      end
+      alias :add_child :add_menu
+    end
+
+  end
+
+end