ramenu 3.0.0

data/lib/ramenu/railtie.rb

@@ -0,0 +1,12 @@
+module Ramenu
+
+  class Railtie < Rails::Railtie
+    initializer "ramenu.initialize" do
+    end
+  end
+
+end
+
+ActiveSupport.on_load(:action_controller) do
+  include Ramenu::ActionController
+end

data/lib/ramenu/ramenu_definer.rb

@@ -0,0 +1,23 @@
+module Ramenu
+  # A menu definer to create menus in a block
+  class RamenuDefiner
+    attr_accessor :menus, :flags, :options
+
+    def initialize(menus, flags, options = {})
+      self.menus = menus
+      self.flags = flags
+      self.options = options
+    end
+
+    # create a new flag in a block
+    def set_flag(name, value = nil, options = {})
+      Ramenu.set_flag_in(flags, name, value, options)
+    end
+
+    # create a new menu in a block
+    def add_menu(name, path = nil, options = {}, &block)
+      options[:flag] = name if @options[:flag_for_menu] == true && name.is_a?(Symbol)
+      Ramenu.add_menu_to(menus, name, path, options, &block)
+    end
+  end
+end

data/lib/ramenu/ramenu_methods.rb

@@ -0,0 +1,39 @@
+module Ramenu
+  # flags
+  def self.static_flags(flagset = nil)
+    flagset = DEFAULT_GROUP if flagset.nil? 
+    @ramenu_flags ||= {}
+    @ramenu_flags[flagset] ||= {}
+  end
+
+  # return static menus
+  def self.static_menus(menu = nil)
+    menu = DEFAULT_GROUP if menu.nil? 
+    @ramenu_menus ||= {}
+    @ramenu_menus[menu] ||= []
+  end
+
+  # add a new flag to a set of flags
+  def self.set_flag_in(flags, name, value, options = {})
+    flags.merge!({ name => value }) unless name.nil? || value.nil?
+  end
+  # add a new menu element to a set of menus
+  def self.add_menu_to(menu, name, path, options = {}, &block)
+    menu << new_ramenu_element(name, path, options, &block)
+  end
+
+  # create a new menu element
+  def self.new_ramenu_element(name, path = nil, options = {}, &block)
+    elem = Menus::Element.new(name, path, options)
+    yield elem if block_given?
+    return elem
+  end
+
+  # menus
+  def self.add_menu(name, path, options = {}, &block)
+    menu = options[:menu]
+    add_menu_to(static_menus(menu), name, path, options, &block)
+  end
+
+end
+

data/lib/ramenu/version.rb

@@ -0,0 +1,14 @@
+module Ramenu
+
+  module Version
+    MAJOR = 3
+    MINOR = 0
+    PATCH = 0
+    BUILD = nil
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+
+  VERSION = Version::STRING
+
+end

data/ramenu.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ramenu/version"
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Thomas Kienlen", "Simone Carletti"]
+  gem.email = "thomas.kienlen@lafourmi-immo.com"
+  gem.description = "Ramenu is a simple Ruby on Rails plugin for creating and managing navigation menus for a Rails project."
+  gem.summary = "Rails 'A la carte' menu plugin for creating and managing navigation menus."
+  gem.homepage = "https://github.com/lafourmi/ramenu"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.name          = "ramenu"
+  gem.require_paths = ["lib"]
+  gem.version = Ramenu::VERSION
+
+  gem.add_dependency 'rails', ">= 3.0"
+  gem.add_development_dependency 'appraisal', ">= 0"
+  gem.add_development_dependency 'mocha', "~> 0.9.10"
+  gem.add_development_dependency 'yard', ">= 0"
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rack-test'
+  unless ENV["CI"]
+    gem.add_development_dependency "turn", "~> 0.9" if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
+  end
+end

data/test/dummy.rb

@@ -0,0 +1,34 @@
+Ramenu::Routes = ActionDispatch::Routing::RouteSet.new
+Ramenu::Routes.draw do
+  match ':controller(/:action(/:id))'
+end
+
+ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+ActionController::Base.send :include, Ramenu::Routes.url_helpers
+
+class ActiveSupport::TestCase
+
+  setup do
+    @routes = Ramenu::Routes
+  end
+
+
+  def controller
+    @controller_proxy ||= ControllerProxy.new(@controller)
+  end
+
+  class ControllerProxy
+    def initialize(controller)
+      @controller = controller
+    end
+    def method_missing(method, *args)
+      @controller.instance_eval do
+        m = method(method)
+        m.call(*args)
+      end
+    end
+  end
+
+end
+
+

data/test/minitest_helper.rb

@@ -0,0 +1,19 @@
+require 'turn/autorun'
+# http://www.mattsears.com/articles/2011/12/10/minitest-quick-reference
+
+Turn.config do |c|
+ # use one of output formats:
+ # :outline  - turn's original case/test outline mode [default]
+ # :progress - indicates progress with progress bar
+ # :dotted   - test/unit's traditional dot-progress mode
+ # :pretty   - new pretty reporter
+ # :marshal  - dump output as YAML (normal run mode only)
+ # :cue      - interactive testing
+ #c.format  = :outline
+ c.format  = :progress
+ # turn on invoke/execute tracing, enable full backtrace
+ c.trace   = true
+ # use humanized test names (works only with :outline format)
+ c.natural = true
+end
+

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+
+#require 'mocha'
+#require 'dummy'
+
+# minitest and turn
+#require 'minitest_helper'
+
+ENV["RAILS_ENV"] = "test"
+
+require "active_support"
+require "action_controller"
+require "rails/railtie"
+#require "i18n"
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'ramenu'
+
+#ActionController::Base.view_paths = File.join(File.dirname(__FILE__), 'views')
+
+

data/test/unit/action_controller_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require 'dummy'
+
+Ramenu.configure do |config|
+  config.add_menu :static_menu, :root_path
+  config.add_menu :static_menu_bis, :root_path, :menu => :default
+
+  config.definer :user_menu, :flag_for_menu => true do |d|
+    d.add_menu :home, :root_path
+    d.add_menu :users, :users_path, :flag => :users do |menu|
+      menu.add_menu :dashboard, :dashboard_users_path
+      menu.add_menu :help, :help_users_path
+    end
+    
+    d.set_flag :home, true
+    d.set_flag :users, false
+  end
+
+end
+
+
+class MenusTestController < ActionController::Base
+  add_menu :root, :extranet_root_path
+  add_menu :footab, :root_path
+  add_menu_for_current :current_page 
+
+  set_flag :foo, true
+  set_flag :bar, false
+
+  definer :user_menu, :flag_for_menu => true do |d|
+    d.add_menu :dashboard, :root_path
+    d.add_menu :main_screen, :root_path
+
+    d.set_flag :dashboard, false
+    d.set_flag :dashboard_icon, :none
+    d.set_flag :main_screen_value, 2
+  end
+
+
+  def index
+    render :text => ''
+  end
+
+  def show
+    set_flag :bar, true
+    render :text => ''
+  end
+end
+
+class MenusTest < ActionController::TestCase
+  tests MenusTestController
+
+  def test_add_volatile_menu
+    get :index
+    assert_equal(:root, controller.volatile_menus(:default).first.name)
+  end
+
+  def test_add_menu_for_current
+    get :show
+    assert_equal('/menus_test/show', controller.volatile_menus(:default).last.path)
+  end
+
+  def test_add_static_menu
+    get :index
+    assert_equal(:static_menu, controller.menus(:default).first.name)
+  end
+
+  def test_static_and_volatile_menus
+    get :index
+    assert_equal(5, controller.menus(:default).count)
+  end
+
+  def test_set_volatile_flag
+    get :index
+    assert_equal(true, controller.flags(:default)[:foo])
+  end
+
+  def test_set_static_flag
+    get :index
+    assert_equal(true, controller.flags(:user_menu)[:home])
+  end
+
+  def test_static_and_volatile_flags
+    get :index
+    assert_equal(5, controller.flags(:user_menu).count)
+  end
+
+  def test_set_flag_within_method
+    get :show
+    assert_equal(true, controller.flags(:default)[:bar])
+  end
+
+  def test_add_menu_with_definer
+    get :index
+    assert_equal(:main_screen, controller.menus(:user_menu).last.name)
+  end
+
+  def test_definer_with_flag_for_menu_set
+    get :index
+    assert_equal(:main_screen, controller.menus(:user_menu).last.options[:flag])
+  end
+
+  def test_set_flag_with_definer
+    get :index
+    assert_equal(:none, controller.flags(:user_menu)[:dashboard_icon])
+  end
+
+end
+

data/test/unit/builder_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+class BuilderTest < ActionView::TestCase
+
+  def setup
+    @template = self
+  end
+
+
+  def test_initialize_should_require_context_and_elements
+    assert_raise(ArgumentError) { Ramenu::Menus::Builder.new }
+    assert_raise(ArgumentError) { Ramenu::Menus::Builder.new(@template) }
+    assert_nothing_raised { Ramenu::Menus::Builder.new(@template, []) }
+  end
+
+  def test_initialize_should_allow_options
+    assert_nothing_raised { Ramenu::Menus::Builder.new(@template, [], {}) }
+  end
+
+  def test_initialize_should_set_context
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    assert_equal(@template, builder.instance_variable_get(:'@context'))
+  end
+
+  def test_initialize_should_set_elements
+    builder= Ramenu::Menus::Builder.new(@template, [1, 2])
+    assert_equal([1, 2], builder.instance_variable_get(:'@elements'))
+  end
+
+
+  def test_compute_name_with_symbol
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(:method_for_name, nil)
+
+    assert_equal("name from symbol", builder.send(:compute_name, element))
+  end
+
+  def test_compute_name_with_proc
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(proc { |template| template.send(:proc_for_name) }, nil)
+
+    assert_equal("name from proc", builder.send(:compute_name, element))
+  end
+
+  def test_compute_name_with_string
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new("name from string", nil)
+
+    assert_equal("name from string", builder.send(:compute_name, element))
+  end
+
+
+  def test_compute_path_with_symbol
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(nil, :method_for_path)
+
+    assert_equal("http://localhost/#symbol", builder.send(:compute_path, element))
+  end
+
+  def test_compute_path_with_proc
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(nil, proc { |template| template.send(:proc_for_path) })
+
+    assert_equal("http://localhost/#proc", builder.send(:compute_path, element))
+  end
+
+  def test_compute_path_with_hash
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(nil, { :foo => "bar" })
+
+    assert_equal("http://localhost?foo=bar", builder.send(:compute_path, element))
+  end
+
+  def test_compute_path_with_string
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(nil, "http://localhost/#string")
+
+    assert_equal("http://localhost/#string", builder.send(:compute_path, element))
+  end
+
+  def test_empty_associated_flagset
+    builder = Ramenu::Menus::Builder.new(@template, [])
+    element = Ramenu::Menus::Element.new(nil, "http://localhost/")
+
+    assert_equal(nil, builder.send(:flag_for, element))
+  end
+
+  def test_associated_flagset
+    builder = Ramenu::Menus::Builder.new(@template, [], :flags => {:activated => true, :seen => 5})
+    element = Ramenu::Menus::Element.new(nil, "http://localhost/", :flag => :activated)
+
+    assert_equal(true, builder.send(:flag_for, element, :flag))
+  end
+
+  def url_for(params)
+    "http://localhost?" + params.to_param
+  end
+
+  protected
+
+  def method_for_name
+    "name from symbol"
+  end
+
+  def proc_for_name
+    "name from proc"
+  end
+
+  def method_for_path
+    "http://localhost/#symbol"
+  end
+
+  def proc_for_path
+    "http://localhost/#proc"
+  end
+
+end

data/test/unit/element_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class ElementTest < ActiveSupport::TestCase
+
+  def test_initialize_should_require_name_and_path
+    assert_raise(ArgumentError) { Ramenu::Menus::Element.new }
+    assert_raise(ArgumentError) { Ramenu::Menus::Element.new(nil) }
+    assert_nothing_raised { Ramenu::Menus::Element.new(nil, nil) }
+  end
+
+  def test_initialize_should_set_name
+    element = Ramenu::Menus::Element.new(:homepage, nil)
+    assert_equal :homepage, element.name
+  end
+
+  def test_initialize_should_set_path
+    element = Ramenu::Menus::Element.new(nil, "/")
+    assert_equal "/", element.path
+  end
+
+  def test_initialize_should_allow_options
+    element = Ramenu::Menus::Element.new(:homepage, "/", :title => "Go to the Homepage")
+    assert_equal({ :title => "Go to the Homepage" }, element.options)
+  end
+
+  def test_initialize_should_allow_childs
+    element = Ramenu::Menus::Element.new(:homepage, "/", :title => "Go to the Homepage")
+    element.add_child(nil, '/')
+    element.add_child(:homepage, nil)
+    assert_equal(2, element.childs.count)
+  end
+
+
+  def test_name
+    element = Ramenu::Menus::Element.new(nil, nil)
+    element.name = :the_name
+    assert_equal :the_name, element.name
+  end
+
+  def test_path
+    element = Ramenu::Menus::Element.new(nil, nil)
+    element.path = { :controller => "index", :action => "index" }
+    assert_equal({ :controller => "index", :action => "index" }, element.path)
+  end
+
+  def test_options
+    element = Ramenu::Menus::Element.new(nil, nil)
+    element.options = { :title => "Go to the Homepage" }
+    assert_equal({ :title => "Go to the Homepage" }, element.options)
+  end
+
+end