mmmenu 0.5.0

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "rspec",   "~> 2.8.0"
+  gem "jeweler", "~> 1.6.4"
+  #gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rspec (~> 2.8.0)

data/README.markdown

@@ -0,0 +1,140 @@
+Mmmenu
+======
+
+*Flexible menu generator for rails*
+
+Why another menu plugin?
+------------------------
+All menu plugins I've seen have HTML markup hardcoded into them.
+*Mmmenu* offers you a chance to define your own markup, along with
+a nice DSL to describe multi-level menu structures.
+
+INSTALLATION
+------------
+
+1. gem install mmmenu
+2. rails generate mmmenu (optional)
+
+Basic Usage
+---------------
+
+Imagine you put this into your controller:
+
+    mmmenu do |l1|
+
+      l1.add "Articles", "/articles" do |l2|
+       l2.add "Create article",   new_article_path
+       l2.add "Articles authors", "/articles/authors", :match_subpaths => true
+      end
+      l1.add "Item2", "/path2"
+      l1.add "Item3", "/path3"
+      l1.add "Item4", "/path4"
+
+    end 
+
+As you can see, we specify the paths, so our menu does not depend on the routes.
+`#mmmenu` method automatically puts your menu into @menu instance variable. If you wish to use another variable,
+you may use a more explicit syntax:
+
+    @my_menu = Mmmenu.new(:request => request) do |l1| { ... }
+
+Now let's see what happens in the views:
+
+  <%= build_mmmenu(@menu) %>
+
+And that's it, you get your menu rendered.
+
+Customizing Views
+------------------------
+Now, like I promised, the html-markup is totally
+configurable.
+
+Run `rails generate mmmenu`, you'll get your app/helpers/mmmenu_helper.rb file and a bunch of templates copied out of the plugin views/mmmenu directory into app/views/mmmenu directory, thus replacing the plugin default files. Here's what those template files are and what they mean:
+
+`_current_item.erb` 	is responsible for the current item in the menu
+`_item.erb` 		      is responsible for the non-current items
+`level_1.erb`					is a wrapper for menu level 1
+`level_2.erb`					is a wrapper for menu level 2 (submenu)
+
+If you wish to customize deeper levels of menus and items in them, you should take a look at the generated `mmmenu_helper.rb` file
+
+Customizing the Helper
+----------------------------
+
+Let's take a look at what's inside this helper:
+
+    def build_mmmenu(menu)
+      menu.item_markup(1) do |link, text, options|
+        render(:partial => "mmmenu/item", :locals => { :link => link, :text => text, :options => options })
+      end
+      menu.current_item_markup(1) do |link, text, options|
+        render(:partial => "mmmenu/current_item", :locals => { :link => link, :text => text, :options => options })
+      end
+      menu.level_markup(1) { |m| render(:partial => "mmmenu/level_1", :locals => { :menu => m }) }
+      menu.level_markup(2) { |m| render(:partial => "mmmenu/level_2", :locals => { :menu => m }) }
+      menu.build.html_safe
+    end
+
+You can see now, that `#item_markup` method defines the html markup for menu item,
+and `#level_markup` does the same for menu level wrapper. The first argument is the menu level.
+You may define as much levels as you want, but you don't need to define markup for each level: the deepest level of the markup
+defined will be used for all of the deeper levels.
+
+By default, build_mmmenu helper defines two partial templates for level 1 of the menu.
+It does so by calling two methods on a Mmmenu object:
+  #current_item_markup defines markup for the current menu item
+  #item_markup defines markup for all other menu items
+Both methods accept an optional second argument - a hash of html_options:
+
+    menu.item_markup(1, :class => "mmmenu")
+
+which is later used in the templates like this:
+
+    <li><%= link_to text, link, options %></li>
+
+Note, that this is an example from a default template and options hash may not be present in the customized template.
+
+Disclaimer: if you call Mmmenu#item_markup for a certain level, you MUST call Mmmenu#current_item_markup
+for the same level.
+
+Most of the time, you will want to customize your views, not the helper, so you may as well delete it from your application/helpers dir.
+
+
+Finally, let's take a closer look at some of the options and what they mean.
+---------------------------------------------------------------------
+##### Current item
+Mmmenu automatically marks each current menu_item with the markup, that you provide in `#current_item_markup` method's block. The item is considered current not only if the paths
+match, but also if one of the children of the item is marked as current. You may as well set the current item manually like that:
+
+    @menu.current_item = '/articles'
+
+In this case `'/articles'` would match against the second argument that you pass to the `#add` method, which is the path the menu itme points to.
+Note that unless the item with such path is not present in the menu, then no item will be makred as current. It is a useful technique when you want
+to prevent the item from being current in the controller. For example:
+
+    @menu.current_item = '/search-results-pertending-to-be-a-list' if search_query_empty?
+
+##### Paths
+For each menu item you may specify a number of paths, that should match for the item to be active.
+Unless you provide the `:path` option for `Mmmenu#add`, the second argument is used as the matching path.
+If you'd like to specify paths explicitly, do something like this:
+
+    `l1.add "Articles" articles_path, :paths => [[new_article_path, 'get'], [articles_path, 'post'], [articles_path, 'get']]`
+
+This way, the menu item will appear active even when you're on the /articles/new page.
+There's also a third array element, which must be hash. In it may list request_params that should match, for example:
+
+    `l1.add "Articles" articles_path, :paths => [[articles_path, 'get', {:filter => 'published'}]]`
+
+That way, only a request to "/articles?filter=published" will make this menu item active.
+Of course it doesn't matter, if the request contains some other params. But you can make sure it doesn't by saying something like `{:personal => nil}` 
+
+Alernatively, you can do this:
+
+    l1.add "Articles" articles_path, :match_subpaths => true
+
+Or you may use wildcards:
+
+    l1.add "Articles" articles_path, :paths => [["/articles/*"]]
+
+That's much easier usually.

data/Rakefile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'rspec/core/rake_task'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mmmenu"
+  gem.homepage = "http://github.com/snitko/mmmenu"
+  gem.license = "MIT"
+  gem.summary = %Q{Flexible menu generator for Rails.}
+  gem.description = %Q{Defines multilevel menu structures, uses custom html templates to render them.}
+  gem.email = "roman.snitko@gmail.com"
+  gem.authors = ["Roman Snitko"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+RSpec::Core::RakeTask.new(:default)

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/lib/generators/mmmenu/mmmenu_generator.rb

@@ -0,0 +1,14 @@
+class MmmenuGenerator < Rails::Generators::Base
+
+  source_root File.expand_path("../../templates", __FILE__)
+
+  def create_helper
+    copy_file "helpers/mmmenu_helper.rb",       "app/helpers/mmmenu_helper.rb"
+    copy_file "views/mmmenu/_item.erb",         "app/views/mmmenu/_item.erb"
+    copy_file "views/mmmenu/_current_item.erb", "app/views/mmmenu/_current_item.erb"
+    copy_file "views/mmmenu/_level_1.erb",      "app/views/mmmenu/_level_1.erb"
+    copy_file "views/mmmenu/_level_2.erb",      "app/views/mmmenu/_level_2.erb"
+  end
+
+
+end

data/lib/generators/templates/helpers/mmmenu_helper.rb

@@ -0,0 +1,16 @@
+module MmmenuHelper
+
+  def build_mmmenu(menu)
+    return nil unless menu
+    menu.item_markup(1) do |link, text, options|
+      render(:partial => "mmmenu/item", :locals => { :link => link, :text => text, :options => options })
+    end
+    menu.current_item_markup(1) do |link, text, options|
+      render(:partial => "mmmenu/current_item", :locals => { :link => link, :text => text, :options => options })
+    end
+    menu.level_markup(1) { |m| render(:partial => "mmmenu/level_1", :locals => { :menu => m }) }
+    menu.level_markup(2) { |m| render(:partial => "mmmenu/level_2", :locals => { :menu => m }) }
+    menu.build.html_safe
+  end
+
+end

data/lib/generators/templates/views/mmmenu/_current_item.erb

@@ -0,0 +1 @@
+<li><%= link_to text, link, options.merge({:class => "current"}) %></li>

data/lib/generators/templates/views/mmmenu/_item.erb

@@ -0,0 +1 @@
+<li><%= link_to text, link, options %></li>

data/lib/generators/templates/views/mmmenu/_level_1.erb

@@ -0,0 +1 @@
+<ul class="menu"><%=raw menu %></ul>

data/lib/generators/templates/views/mmmenu/_level_2.erb

@@ -0,0 +1 @@
+<ul class="submenu"><%=raw menu %></ul>

data/lib/mmmenu.rb

@@ -0,0 +1,163 @@
+require 'mmmenu/level'
+require 'mmmenu/engine'
+
+class Mmmenu
+
+  attr_accessor :current_item
+
+  def initialize(options, &block)
+    @items          = options[:items] || Mmmenu::Level.new(&block).to_a
+    @current_path   = options[:request].path.chomp('/')
+    @request_params = options[:request].params
+    @request_type   = options[:request].method.to_s.downcase
+    @item_markup            = []
+    @current_item_markup    = []
+    @level_markup           = []
+  end
+
+  # The following two methods define
+  # the markup for each menu item on the current and
+  # lower levels (unless lower levels are not redefined later).
+  # Example:
+  #   @menu.item_markup(0, options) do |link, text, options|
+  #     "<a href=\"#{link}\" #{options}>#{text}</a>"
+  #   end
+  def item_markup(level, options={}, &block)
+    level -= 1
+    @item_markup[level] = { :block => block, :options => options }
+  end
+  def current_item_markup(level, options={}, &block)
+    level -= 1
+    @current_item_markup[level] = { :block => block, :options => options }
+  end
+
+  # Defines the markup wrapper for the current menu level and
+  # lower menu levels (unless lower levels are not redefined later).
+  # Example:
+  #   @menu.level_markup(0) { |level_content| "<div>#{level_content}</div>" }
+  def level_markup(level=1, &block)
+    level -= 1
+    @level_markup[level] = block
+  end
+
+  def build
+    build_level[:output]
+  end
+
+  private
+
+    def build_level(items=@items, level=0)
+
+      item_markup   = build_item_markup(level)
+      level_markup  = build_level_markup(level)
+
+      # Parsing of a single menu level happens here
+      output          = ''
+      has_current_item = false
+
+      raise("Mmmenu object #{self} is empty, no items defined!") if items.nil? or items.empty?
+      items.each do |item|
+
+        item[:html_options] = {} unless item[:html_options]
+        child_menu = build_level(item[:children], level+1) if item[:children]
+        child_output = child_menu[:output] if child_menu
+        
+        #############################################################
+        # Here's where we check if the current item is a current item
+        # and we should use a special markup for it
+        #############################################################
+        if (
+          item[:href] == current_item                    or
+          ( current_item.nil? && (
+            item_paths_match?(item)                        or
+            (child_menu and child_menu[:has_current_item]) or
+            item_href_match?(item)
+          ))
+        ) && !has_current_item 
+                    
+              then
+                  has_current_item = true
+                  item_output = item_markup[:current][:block].call(item[:href], item[:title], item_markup[:current][:options].merge(item[:html_options]))
+        else
+          item_output = item_markup[:basic][:block].call(item[:href], item[:title], item_markup[:basic][:options].merge(item[:html_options]))
+        end
+        #############################################################
+
+        output += "#{item_output}#{child_output}"
+      end
+
+      output = level_markup.call(output)
+      { :has_current_item => has_current_item, :output => output }
+
+    end
+
+
+    # Matches menu item against :paths option
+    def item_paths_match?(item)
+      if item[:paths]
+
+        item[:paths].each do |path|
+          if path.kind_of?(Array)
+            # IF path matches perfectly
+            request_type_option = path[1] || ""
+            if ((@current_path == path[0].chomp('/') and @request_type == request_type_option.downcase)  or 
+            # OR IF * wildcard is used and path matches
+            (path[0] =~ /\*$/ and @current_path =~ /^#{path[0].chomp('*')}(.+)?$/)) and    
+            # all listed request params match
+            params_match?(path)
+              return true 
+            end
+          else
+            return true if @current_path == path
+          end
+        end
+
+      end
+      return false
+    end
+
+    # Matches menu item against the actual path it's pointing to.
+    # Is only applied when :path option is not present.
+    def item_href_match?(item)
+      if item[:href]
+        item_href = item[:href].chomp('/')
+        if (@current_path == item_href) or                                        # IF path matches perfectly
+        (item[:match_subpaths] and @current_path =~ /^#{item_href}(\/.+)?$/)      # OR IF :match_subpaths options is used and path matches
+          return true
+        end
+      end unless item[:paths]
+      return false
+    end
+
+    def build_item_markup(level)
+      if @item_markup[level]
+        { :basic => @item_markup[level], :current => @current_item_markup[level] }
+      else
+        unless @item_markup.empty?
+          { :basic => @item_markup.last, :current => @current_item_markup.last }
+        else
+          { :basic => {:block => lambda { |link,text,options| "#{text} #{link} #{options}\n" }, :options => {} }, :current => { :block => lambda { |link,text,options| "#{text} #{link} #{options} current\n" }, :options => {} } }
+        end
+      end
+    end
+
+    def build_level_markup(level)
+      if @level_markup[level]
+        @level_markup[level]
+      else
+        if @level_markup.empty?
+          lambda { |menu| menu }
+        else
+          @level_markup.last
+        end
+      end
+    end
+
+    def params_match?(path)
+      path[2].each do |k,v|
+        return false unless (@request_params[k.to_s].nil? and v.nil?) or @request_params[k.to_s] == v.to_s
+      end if path[2]
+      true
+    end
+
+end

data/lib/mmmenu/engine.rb

@@ -0,0 +1,16 @@
+class Mmmenu::Engine < Rails::Engine
+
+  paths["app/helpers"] << File.expand_path("../../generators/templates/helpers", __FILE__)
+  paths["app/views"]   << File.expand_path("../../generators/templates/views", __FILE__)
+
+end if defined?(Rails::Engine)
+
+ActionController::Base.class_eval do
+
+private
+
+  def mmmenu(&block)
+    @menu = Mmmenu.new(:request => request, &block)
+  end
+
+end if defined?(ActionController::Base)

data/lib/mmmenu/level.rb

@@ -0,0 +1,24 @@
+class Mmmenu
+
+  class Level
+
+    def initialize(&block)
+      @items = []
+      yield(self)
+    end
+
+    def add(title, href, options={}, &block)
+      children = {}
+      if block_given? # which means current item has children
+        children = { :children => self.class.new(&block).to_a }
+      end
+      @items << { :title => title, :href => href }.merge(options).merge(children)
+    end
+
+    def to_a
+      @items
+    end
+
+  end
+
+end

data/lib/mmmenu/version.rb

@@ -0,0 +1,3 @@
+class Mmmenu
+  VERSION = '0.1'
+end

data/mmmenu.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "mmmenu"
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roman Snitko"]
+  s.date = "2012-02-27"
+  s.description = "Defines multilevel menu structures, uses custom html templates to render them."
+  s.email = "roman.snitko@gmail.com"
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "lib/generators/mmmenu/mmmenu_generator.rb",
+    "lib/generators/templates/helpers/mmmenu_helper.rb",
+    "lib/generators/templates/views/mmmenu/_current_item.erb",
+    "lib/generators/templates/views/mmmenu/_item.erb",
+    "lib/generators/templates/views/mmmenu/_level_1.erb",
+    "lib/generators/templates/views/mmmenu/_level_2.erb",
+    "lib/mmmenu.rb",
+    "lib/mmmenu/engine.rb",
+    "lib/mmmenu/level.rb",
+    "lib/mmmenu/version.rb",
+    "mmmenu.gemspec",
+    "spec/lib/mmmenu_level_spec.rb",
+    "spec/lib/mmmenu_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/snitko/mmmenu"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Flexible menu generator for Rails."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/spec/lib/mmmenu_level_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/mmmenu/level')
+
+describe Mmmenu::Level do
+
+  it "builds a menu level hash representation" do
+    @menu_level = Mmmenu::Level.new do |l1|
+      l1.add "Title1", "/path1"
+      l1.add "Title2", "/path2" do |l2|
+        l2.add "SubTitle", "/path2/subpath"
+      end
+    end
+
+    @menu_level.to_a.should == [
+      {:title => "Title1", :href => "/path1"},
+      {:title => "Title2", :href => "/path2", :children => [
+        { :title => "SubTitle", :href => "/path2/subpath" }
+      ]}
+    ]
+  end
+
+end

data/spec/lib/mmmenu_spec.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/mmmenu/level')
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/mmmenu')
+
+describe Mmmenu do
+
+  before(:all) do
+    @items = [
+      { :name => :numbers, :title => 'Item1', :children => [ 
+        { :title => 'Create', :href => '/items1/new', :paths => ['/items1/new'] },
+        { :title => 'Index', :href => '/items1/'      },
+        { :title => 'Print', :href => '/items1/print' }
+      ]},
+      { :title => 'Item2', :href => '/items2' },
+      { :title => 'Item3', :href => '/items3' },
+      { :title => 'Item4', :href => '/items4' }
+    ]
+  end
+
+  before(:each) do
+    @request = mock('request')
+    @request.stub!(:path).once.and_return('/items1/new')
+    @request.stub!(:method).once.and_return('get')
+    @request.stub!(:params).once.and_return({})
+    @menu = Mmmenu.new(:items => @items, :request => @request )
+  end
+
+  it "renders one level" do
+    set_menu_markup
+    @menu.item_markup(2) do |link, text, options|
+      "  #{text}: #{link}\n"
+    end
+    @menu.current_item_markup(2) do |link, text, options|
+      "  #{text}: #{link} current\n"
+    end
+    @menu.level_markup(1) { |menu| menu }
+    @menu.build.should == <<END
+Item1:  current
+  Create: /items1/new current
+  Index: /items1/
+  Print: /items1/print
+Item2: /items2
+Item3: /items3
+Item4: /items4
+END
+
+  end
+
+  it "chooses the current item depending on request type" do
+    items = [
+      { :title => 'item1', :href => '/item1', :paths => [['/item', 'post']] },
+      { :title => 'item2', :href => '/item2', :paths => [['/item', 'get']] }
+    ]
+    request = mock('request')
+    request.should_receive(:path).once.and_return('/item')
+    request.should_receive(:method).once.and_return('get')
+    request.should_receive(:params).once.and_return({})
+    @menu = Mmmenu.new(:items => items, :request => request )
+    set_menu_markup
+    @menu.build.should == <<END
+item1: /item1
+item2: /item2 current
+END
+
+  end
+
+  it "chooses the current item with a specific request param" do
+    items = [
+      { :title => 'item1', :href => '/item1', :paths => [['/item1', 'get',  {:param => 1}]] },
+      { :title => 'item2', :href => '/item1', :paths => [['/item1', 'get',  {:param => 2}]] },
+      { :title => 'item3', :href => '/item1', :paths => [['/item1', 'get',  {:param => nil}]] }
+    ]
+    request = mock('request')
+    request.should_receive(:path).once.and_return('/item1')
+    request.should_receive(:params).once.and_return({"param" => "1"})
+    request.should_receive(:method).once.and_return('get')
+    @menu = Mmmenu.new(:items => items, :request => request )
+    set_menu_markup
+    @menu.build.should == <<END
+item1: /item1 current
+item2: /item1
+item3: /item1
+END
+  end
+
+  it "chooses current item when forced to do so by explicitly set current_item property" do
+    items = [
+      { :title => 'item1', :href => '/item1' },
+      { :title => 'item2', :href => '/item2' },
+      { :title => 'item3', :href => '/item3' }
+    ]
+    request = mock('request')
+    request.should_receive(:path).once.and_return('/item1')
+    request.should_receive(:method).once.and_return('get')
+    request.should_receive(:params).once
+    @menu = Mmmenu.new(:items => items, :request => request )
+    @menu.current_item = "/item2"
+    set_menu_markup
+
+    @menu.build.should == <<END
+item1: /item1
+item2: /item2 current
+item3: /item3
+END
+  end
+
+  it "creates menu items in a block using nice DSL" do
+    
+    @menu = Mmmenu.new(:request => @request) do |m|
+      m.add 'Item1', '/items1', :match_subpaths => true
+      m.add 'Item2', '/items2' do |subm|
+        subm.add 'New', '/item2/new'
+        subm.add 'Edit', '/item2/edit'
+      end
+    end
+    set_menu_markup
+
+    @menu.build.should == <<END
+Item1: /items1 current
+Item2: /items2
+New: /item2/new
+Edit: /item2/edit
+END
+
+  end
+
+  it "creates menu items in a block using nice DSL and additional options" do
+
+    @menu = Mmmenu.new(:request => @request) do |m|
+      m.add 'Item1', '/items1', :match_subpaths => true
+      m.add 'Item2', '/items2' do |subm|
+        subm.add 'New', '/item2/new'
+        subm.add 'Edit', '/item2/edit'
+      end
+    end
+    set_menu_markup
+
+    @menu.build.should == <<END
+Item1: /items1 current
+Item2: /items2
+New: /item2/new
+Edit: /item2/edit
+END
+
+  end
+
+  def set_menu_markup(level=1)
+    @menu.item_markup(level) do |link, text, options|
+      "#{text}: #{link}\n"
+    end
+    @menu.current_item_markup(level) do |link, text, options|
+      "#{text}: #{link} current\n"
+    end
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: mmmenu
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+  prerelease: 
+platform: ruby
+authors:
+- Roman Snitko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &24009500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *24009500
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &24007940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *24007940
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &24006480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *24006480
+description: Defines multilevel menu structures, uses custom html templates to render
+  them.
+email: roman.snitko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- VERSION
+- lib/generators/mmmenu/mmmenu_generator.rb
+- lib/generators/templates/helpers/mmmenu_helper.rb
+- lib/generators/templates/views/mmmenu/_current_item.erb
+- lib/generators/templates/views/mmmenu/_item.erb
+- lib/generators/templates/views/mmmenu/_level_1.erb
+- lib/generators/templates/views/mmmenu/_level_2.erb
+- lib/mmmenu.rb
+- lib/mmmenu/engine.rb
+- lib/mmmenu/level.rb
+- lib/mmmenu/version.rb
+- mmmenu.gemspec
+- spec/lib/mmmenu_level_spec.rb
+- spec/lib/mmmenu_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/snitko/mmmenu
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2496057170991287488
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Flexible menu generator for Rails.
+test_files: []