waiter 0.0.1 → 2.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmQ1YzdlZmU3MDM4ZDgwOWQ0ZmNhMjI5MDcwNGYxZTUwMTE5YzI1MQ==
+  data.tar.gz: !binary |-
+    ZTg1ZmIzMDc1MmQ4MDQ0MDk1ZDRmZjIwNzViMDVmYmFlYzBjYzhiNQ==
+SHA512:
+  metadata.gz: !binary |-
+    NTBhMTMxOWQ4ZmNiZWEwZmNkMDkwMDBiZDA3YjIyODNhYTM1M2ZhNDgwYjY2
+    OThhODZmYmQ3MDVhMWQzYTY4YWM4NWMwNGFiNzg5MTk4NWM1OTlkODIxMDM3
+    ZTAwYjFhMTE1YWU3ZDhjYzE5ZDkyODI1ZjllNjdmMDEyZTY2ZGQ=
+  data.tar.gz: !binary |-
+    MGVjZTZmMWY4NmY3MTM4NDI0NGQyNjBkMTc1MTFkZGM4OWFkYjU1YTc2MmIz
+    MWNkNWYwNjhiMWY5YTRhNGQ2NWNkMzdjMDQzZDA3YzBkN2FlNzEwMzc4OTIz
+    NzU4YmZjZTA2YjFhNDVmNWEwMTM2NTJhMzk1ZGIyOTZkMzVjNGY=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/README.md

@@ -24,33 +24,41 @@ Or install it yourself as:
 
 To create a new menu:
 
-    Waiter::Menu.serve do |menu|
-      menu.file
-      menu.edit
-      menu.view
+    Waiter::Menu.serve(:my_menu) do
+      file
+      edit
+      view
       # ...
     end
 
-The above defines a menu with three items. By default, each item name (ie. "file", "edit", etc.) corresponds both to the I18n string to use (so `menu.file` will call `I18n.t(:file)`) as well as to the controller to use (`menu.file` will correspond to `FileController`, and the menu item will link to `FileController#index` by default).
+The above defines a menu with three items. By default, each item name (ie. "file", "edit", etc.) corresponds both to the
+I18n string to use (so `file` will call `I18n.t(:file, scope: [:menu, :my_menu])`) as well as to the controller to use
+(`file` will correspond to `FileController`, and the menu item will link to `FileController#index` by default).
 
-Of course, there will be situations where the path may need to be explicitly specified. In this case, the `:controller`
-and `:action` options can be specified:
+Of course, there will be situations where the path may need to be explicitly specified. In this case, you can use a path finder:
 
-    Waiter::Menu.serve do |menu|
-      menu.file :controller => 'documents', :action => 'show'
+    Waiter::Menu::serve do
+      menu.file documents_path
     end
+ 
+Alternately, the `:controller` and `:action` options can be specified:
 
-In this case the File menu will correspond to `DocumentsController#show`, and will only light up for that action. If
-no specific action is given, the menu item will be lit up for all actions within the given controller.
+    Waiter::Menu.serve do
+      menu.file :controller => :documents, :action => :index
+    end
+    
+In both of the above examples, the File menu will correspond to `DocumentsController#index`, and will be shown as selected
+for any action within that controller.
 
 There may also be times where you need multiple controllers to light up the same menu item. This can be achieved by
 passing an array to the `:controllers` option:
 
-    Waiter::Menu.serve do |menu|
-      menu.file :controller => 'documents', :controllers => ['files', 'print', ... ]
+    Waiter::Menu.serve do
+      file :controllers => ['files', 'print', ... ]
     end
 
-This will create a menu that links to `DocumentsController#index`, which will be lit up the user hits any action within the `FilesController`, `PrintController`, as well as the `DocumentsController`.
+This will create a menu that links to `DocumentsController#index`, which will be lit up the user hits any action within
+the `FilesController`, `PrintController`, as well as the `DocumentsController`.
 
 
 ### Submenus
@@ -61,20 +69,18 @@ passed as a block to the root menu item.
 
 Submenus automatically assume the controller to use is the controller specified by its root menu item, so a
 controller does not need to be specified unless it differs. As well, the menu item name is assumed to be used
-for the action within that controller, so action does not need to be specified unless it differs from the name.
+for the controller for that item, so it does not need to be specified unless it differs from the name.
 An id can also be specified if necessary (with the `:id` option).
 
-    Waiter::Menu.serve do |menu|
-      menu.file, :controllers => ['print'] do |file|
-        file.new                            # Corresponds to FileController#new
-        file.open :action => :read          # Corresponds to FileController#read
-        file.save :action => :write         # Corresponds to FileController#write
-        file.print, :controller => 'print'  # Corresponds to PrintController#print
+    Waiter::Menu.serve do
+      file do
+        new                            # Corresponds to FileController#new
+        print print_file_path          # Corresponds to PrintController#print
+        list :action => :all           # Corresponds to ListController#all
       end
     end
 
-If an action isn't explicitly given, and the menu item name does not correspond to an actual action, the default
-action for the controller will be used instead.
+If a path hash is given without an `action` key, the index action will be inferred.
 
 
 ### Menu Options
@@ -82,14 +88,6 @@ action for the controller will be used instead.
 There are two options that you can use when building your menu. Options can be passed into build when defining
 a menu or specified once the menu is defined by accessing the menu.options hash.
 
-`string_prefix`: Allows for a prefix for I18n strings to be specified.
-
-    Waiter::Menu.serve(:string_prefix => 'menu_') do |menu|
-      menu.file
-    end
-
-    # will use I18n.t(:menu_file) instead of I18n.t(:file)
-
 `selected`: Allows the selected menu item to be overridden, so a specified menu item can be lit up regardless of
 what the current controller/action is. This can be useful if there is an action that falls under different menu
 items depending on application context, or if there is a controller that may correspond to multiple menu items.
@@ -123,7 +121,11 @@ the context is self.
 
     Waiter::Menu::Drawer.new(menu, context).draw
 
-If a different `Drawer` is desired, `Waiter::Menu::Drawer` can be subclassed and the methods `draw` and `draw_submenu` overridden to provide an alternate format.
+If a different `Drawer` is desired, `Waiter::Menu::Drawer` can be subclassed and the method `draw` overridden to provide an alternate format.
+
+Alternately, `Waiter::Menu` responds to `draw` directly:
+
+    menu.draw(context)
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,11 @@
 require "bundler/gem_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end

data/app/assets/stylesheets/waiter/menu.css.scss

@@ -0,0 +1,129 @@
+/*
+ * Menu bar
+ */
+.waiter-menu
+{
+  width: 100%;
+  display: block;
+  height: 40px;
+  border: 0px;
+  background: image-url('waiter/bg.gif') repeat-x left top;
+
+  div.top-item
+  {
+    float: left;
+    position: relative;
+    top: 10px;
+    height: 20px;
+    min-width: 80px;
+    border-right: 1px solid #e6e9ef;
+    border-left: 0;
+    margin: 0;
+    text-align: center;
+    /* Fix IE7 z-index bug - See http://brenelz.com/blog/squish-the-internet-explorer-z-index-bug/ */
+    z-index: 10501;
+    color: #e6e9ef;
+    font-family: "Arial";
+    font-weight: bold;
+    font-size: 14px;
+    padding: 5px 15px 5px 10px;
+    cursor: default;
+
+    a
+    {
+      color: #FFF;
+      display: block;
+      height: 20px;
+      min-width: 80px;
+      text-decoration: none;
+    }
+
+    &:hover, &.selected
+    {
+      color: #FFF;
+      background: image-url('waiter/selected-bg.gif') repeat-x left top;
+    }
+
+    $submenu-border-color: #888;
+    $submenu-item-border-color: #CCC;
+    $submenu-item-height: 20px;
+
+    ul.submenu
+    {
+      position: absolute;
+      top: 30px;
+      left: 0;
+      background-color: #ffffff;
+      display: none;
+      z-index: 10500;
+      margin: 0;
+      padding: 0;
+      border: 2px solid $submenu-border-color;
+
+      li
+      {
+        list-style-type: none;
+        min-height: $submenu-item-height;
+        line-height: $submenu-item-height;
+        vertical-align: middle;
+        background-color: #e6e9ef;
+        border-top: 1px solid $submenu-item-border-color;
+        min-width: 150px;
+        text-align: left;
+        white-space: nowrap;
+        color: #000000;
+        border-collapse: collapse;
+
+        font-family: "Arial";
+        font-weight: normal;
+        font-size: 12px;
+        white-space: nowrap;
+
+        a, a:hover
+        {
+          color: #000000;
+          font-weight: normal;
+          padding-left: 8px;
+          padding-right: 8px;
+          line-height: $submenu-item-height + 12px;
+          height: $submenu-item-height + 12px;
+        }
+
+        &:first-child
+        {
+          border-top: 0;
+        }
+
+        &:hover
+        {
+          background-color: #ff9900;
+        }
+
+        &.separator
+        {
+          min-height: 0;
+          max-height: 0;
+          padding: 0;
+          border: 0;
+        }
+      }
+
+      li.separator + li
+      {
+        border-top: 2px solid $submenu-border-color;
+      }
+
+      li.separator + li.separator
+      {
+        display: none;
+      }
+    }
+
+    &:hover ul.submenu
+    {
+      background-color: #333333;
+      /*border:1px solid #333333;*/
+      display: block;
+    }
+  }
+}

data/app/views/waiter/_item.haml

@@ -0,0 +1,8 @@
+.top-item{ class: item.selected? ? 'selected' : '' }
+  - if item.path
+    = link_to item.menu_title, item.path
+  - else
+    = item.menu_title
+
+  - if item.submenu?
+    = render 'waiter/submenu', parent: item, items: item.submenu.items(true)

data/app/views/waiter/_menu_bar.haml

@@ -0,0 +1,3 @@
+.waiter-menu{ id: menu.name }
+  - menu.items.each do |item|
+    = render 'waiter/item', item: item

data/app/views/waiter/_section.haml

@@ -0,0 +1,5 @@
+- section.items.each do |subitem|
+  = render 'waiter/sub_item', item: item, subitem: subitem
+
+- unless last
+  %li.separator

data/app/views/waiter/_sub_item.haml

@@ -0,0 +1,2 @@
+%li
+  = link_to subitem.item_title, subitem.path

data/app/views/waiter/_submenu.haml

@@ -0,0 +1,6 @@
+%ul.submenu
+  - items.each.with_index do |subitem, idx|
+    - if subitem.section?
+      = render 'waiter/section', item: parent, section: subitem, last: idx == items.count - 1
+    - else
+      = render 'waiter/sub_item', item: parent, subitem: subitem

data/lib/waiter/dsl.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/array/extract_options'
+
+module Waiter
+  module DSL
+    def section(options = {}, &block)
+      add_section(options, &block)
+    end
+
+    def method_missing(name, *args, &block)
+      return context.send(name, *args, &block) if context.respond_to?(name)
+
+      path = args.shift
+      options = args.extract_options!
+
+      if path.is_a?(Hash) && !(path.key?(:controller) || path.key?(:action))
+        options, path = path, nil
+      end
+
+      options[:controllers] ||= []
+      add(name, path, options, &block)
+      return nil
+    end
+  end
+end

data/lib/waiter/menu/drawer.rb

@@ -1,63 +1,21 @@
+require 'active_support/core_ext/module/delegation'
+
 module Waiter
   class Menu
     # Outputs a Menu into HTML
     class Drawer
-      # @context is a Controller binding, which allows the ActionView helpers to work in the correct context
-      delegate :link_to, :content_tag, :params, :to => :@context
+      attr_reader :menu, :context
+
+      delegate :render, :link_to, :content_tag, :params, :to => :context
 
       def initialize(menu, context)
+        # context is a Controller binding, which allows the ActionView helpers to work in the correct context
         @context = context
         @menu = menu
       end
 
       def draw
-        content_tag :div, :id => "menu" do
-          out = ActiveSupport::SafeBuffer.new
-
-          @menu.items.each do |(name, menu)|
-            menu[:controller] = name unless menu[:controller]
-
-            # Allow an :if option which will only display the menu if true
-            if !menu[:if] or menu[:if].call
-              # If there is a :selected option, use that instead of trying to determine the selected menu item
-              selected = menu_selected?(name, menu[:controller], menu[:action] || menu[:actions], menu.delete(:controllers))
-
-              out << content_tag(:span, :class => selected ? "selected" : nil) do
-                out2 = ActiveSupport::SafeBuffer.new
-                out2 << link_to(I18n.t(@menu.options[:string_prefix].to_s + name.to_s), { :controller => menu.delete(:controller).to_s.absolutify, :action => (menu.delete(:action) || menu.delete(:actions).andand.first) }.merge(menu))
-                out2 << draw_submenu(@menu.submenus[name]) if @menu.submenus[name]
-                out2
-              end
-            end
-          end
-
-          out << '<br class="clear" />'.html_safe
-          out
-        end
-      end
-
-      def draw_submenu(submenu)
-        content_tag :table, :class => "dropdown", :cellspacing => 0 do
-
-          out = ActiveSupport::SafeBuffer.new
-
-          submenu.items.each do |(name, menu)|
-            out << content_tag(:tr) do
-              content_tag :td do
-                controller = menu.delete(:controller) || submenu.options[:controller]
-                action =
-                    menu.delete(:action) || begin
-                      controller_class = "#{controller}_controller".classify.constantize
-                      controller_class.action_methods.include?(name.to_s) ? name : nil
-                    end rescue nil || :index
-
-                link_to I18n.t(submenu.options[:string_prefix].to_s + name.to_s), { :controller => controller.to_s.absolutify, :action => action }.merge(menu)
-              end
-            end
-          end
-
-          out
-        end
+        render partial: 'waiter/menu_bar', locals: { menu: menu }
       end
 
       protected
@@ -82,10 +40,4 @@ module Waiter
       end
     end
   end
-end
-
-class String
-  def absolutify
-    self.gsub(%r{^(?!/)}, "/")
-  end
 end

data/lib/waiter/menu/item.rb

@@ -0,0 +1,137 @@
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+
+module Waiter
+  class Menu
+    class Item
+      attr_reader :parent, :name, :path, :submenu
+      attr_accessor :options
+      delegate :context, to: :parent
+
+      def initialize(parent, name, path = {}, options = {}, &block)
+        @parent = parent
+        @name = name
+        @path = complete_path_for(path)
+        @options = options
+
+        collect_controllers
+
+        @options.reverse_merge!(parent.options || {})
+
+        if block_given?
+          @submenu = Menu.new([@parent.name, name].compact, @parent.context, @options.dup)
+          @submenu.parent = self
+          @submenu.update(&block)
+        end
+      end
+
+      def section?
+        false
+      end
+
+      def items
+        @submenu.try(:items) || []
+      end
+
+      def [](name)
+        return nil if items.empty?
+        items[name]
+      end
+
+      def submenu?
+        submenu.present?
+      end
+
+      def menu_title
+        translate(:title)
+      end
+
+      def item_title
+        translate(name)
+      end
+
+      def controller
+        @controller ||= find_controller
+      end
+
+      def controllers
+        options[:controllers]
+      end
+
+      def selected?
+        return name == options[:selected] if options[:selected]
+
+        current_controller = context.params[:controller]
+
+        if wildcard_controllers.any?
+          return true if wildcard_controllers.any? do |c|
+            r = Regexp.new(c.sub(%r{/\*$}, '(/*)?').gsub('*', '.*'))
+            r =~ current_controller
+          end
+        end
+
+        controllers.include?(current_controller)
+      end
+
+      def inspect
+        "#<#{self.class.name}:#{'0x%x' % (36971870 << 1)} name=#{name.inspect} options=#{options.inspect} parent=#{parent.inspect} submenu=#{submenu.inspect}>"
+      end
+
+    private
+
+      def translate(key)
+        scope = i18n_scope
+        scope.pop if scope.last == key
+        I18n.t(key, scope: scope, cascade: true)
+      end
+
+      def i18n_scope
+        [:menu, parent.name, name].flatten.compact
+      end
+
+      def complete_path_for(path)
+        return if path.nil? && parent.top?
+
+        case path
+          when String
+            path
+
+          when Hash, NilClass
+            path ||= {}
+            path[:action] ||= :index
+            path[:controller] ||= name
+            path[:controller] = path[:controller].to_s.gsub(%r{^(?!/)}, '/')
+            path
+        end
+      end
+
+      def find_controller
+        case path
+          when Hash
+            path[:controller].to_s.gsub(%r{^/}, '')
+
+          when String
+            request = parent.context.request
+            route = Rails.application.routes.recognize_path("#{request.protocol}#{request.host}#{path}")
+            route ? route[:controller].to_s : nil
+        end
+
+      rescue ActionController::RoutingError
+        nil
+      end
+
+      def collect_controllers
+        target = parent.top? ? self : parent
+        target.options[:controllers] ||= []
+        target.options[:controllers] << controller unless controller.blank?
+        target.options[:controllers].uniq!
+      end
+
+      def wildcard_controllers
+        @wildcard_controllers ||= controllers.select{ |c| c['*'] }
+      end
+    end
+  end
+end

data/lib/waiter/menu/item_list.rb

@@ -0,0 +1,19 @@
+module Waiter
+  class Menu
+    class ItemList < Array
+      def include?(other)
+        return map(&:name).include?(other) if other.is_a? Symbol
+        super
+      end
+
+      def [](index)
+        return detect{ |item| item.name == index } if index.is_a? Symbol
+        super
+      end
+
+      def names
+        map(&:name)
+      end
+    end
+  end
+end

data/lib/waiter/menu/section.rb

@@ -0,0 +1,21 @@
+require 'waiter/menu/item'
+
+module Waiter
+  class Menu
+    class Section < Item
+      def initialize(parent, options = {}, &block)
+        super(parent, nil, nil, options, &block)
+      end
+
+      def section?
+        true
+      end
+
+    private
+
+      def complete_path_for(*)
+        nil
+      end
+    end
+  end
+end

data/lib/waiter/menu.rb

@@ -1,26 +1,68 @@
+require 'waiter/dsl'
+require 'waiter/menu/item_list'
+require 'waiter/menu/item'
+require 'waiter/menu/section'
+require 'waiter/menu/drawer'
+
 module Waiter
   class Menu
-    attr_accessor :options, :submenus
+    attr_accessor :name, :context, :options, :submenu, :parent
+
+    include DSL
 
-    class << self
-      def serve(options = {})
-        yield Builder.new(obj = self.new(options))
-        obj
+    def self.serve(name, context = nil, options = {}, &block)
+      new(name, context, options).tap do |menu|
+        menu.update(&block)
       end
     end
 
-    def initialize(options = {})
-      @menu_items = []
-      @submenus = {}
+    def initialize(name, context, options = {})
+      @name = name
+      @context = context
+      @items = ItemList.new
       @options = options
     end
 
-    def add(name, args = {})
-      @menu_items << [name, args]
+    def update(&block)
+      instance_eval(&block)
+    end
+
+    def draw(context = nil)
+      Drawer.new(self, context).draw
+    end
+
+    def add(name, path = {}, options = {}, &block)
+      items << Item.new(self, name, path, options, &block)
+    end
+
+    def add_section(options = {}, &block)
+      section = Section.new(self, options, &block)
+      items << section if section.items.any?
+    end
+
+    def sections
+      items.select(&:section?) || []
+    end
+
+    def [](name)
+      items[name]
+    end
+
+    def items(sorted = false)
+      return @items unless sorted
+
+      items = @items.dup
+      items.sort_by!(&options[:sort].to_sym) if options.fetch(:sort, false)
+      items.reverse! if options.fetch(:reverse, false)
+      ItemList.new(items)
+    end
+
+    def top?
+      parent.nil?
     end
 
-    def items
-      @menu_items
+    def inspect
+      "#<#{self.class.name}:#{'0x%x' % (36971870 << 1)} name=#{name.inspect} options=#{options.inspect}>"
     end
   end
 end

data/lib/waiter/version.rb

@@ -1,3 +1,3 @@
 module Waiter
-  VERSION = "0.0.1"
+  VERSION = "2.0.0"
 end