activeadmin 0.5.1 → 0.6.0

data/lib/active_admin/locales/vi.yml

@@ -3,7 +3,7 @@ vi:
     dashboard: Dashboard
     dashboard_welcome:
       welcome: "Chào mừng bạn đến với Active Admin. Đây là trang Dashboard mặc định."
-      call_to_action: "Để thêm phần phần cho trang Dashboar hãy chỉnh sửa 'app/admin/dashboards.rb'"
+      call_to_action: "Để thêm phần phần cho trang Dashboar hãy chỉnh sửa 'app/admin/dashboard.rb'"
     view: "Xem"
     edit: "Chỉnh sửa"
     delete: "Xóa"

data/lib/active_admin/locales/zh-CN.yml

@@ -3,7 +3,7 @@
     dashboard: "控制面板"
     dashboard_welcome:
       welcome: "欢迎使用Active Admin. 这是默认的控制面板页."
-      call_to_action: "若要添加新的面板内容, 请修改 'app/admin/dashboards.rb'"
+      call_to_action: "若要添加新的面板内容, 请修改 'app/admin/dashboard.rb'"
     view: "查看"
     edit: "编辑"
     delete: "删除"

data/lib/active_admin/locales/zh-TW.yml

@@ -3,7 +3,7 @@
     dashboard: 儀表板
     dashboard_welcome:
       welcome: "歡迎來到 Active Admin 這是預設的儀表板頁面。"
-      call_to_action: "要新增儀表板內容，請查看 'app/admin/dashboards.rb'"
+      call_to_action: "要新增儀表板內容，請查看 'app/admin/dashboard.rb'"
     view: "檢視"
     edit: "編輯"
     delete: "刪除"

data/lib/active_admin/menu.rb

@@ -5,8 +5,8 @@ module ActiveAdmin
   # To build a new menu:
   #
   #   menu = Menu.new do |m|
-  #     m.add MenuItem.new(:label => "Dashboard", :url => "/")
-  #     m.add MenuItem.new(:label => "Admin", :url => "/admin")
+  #     m.add label: 'Dashboard', url: '/'
+  #     m.add label: 'Users',     url: '/users'
   #   end
   #
   # If you're interested in configuring a menu item, take a look at the
@@ -14,54 +14,92 @@ module ActiveAdmin
   #
   class Menu
 
-    attr_accessor :children
-
     def initialize
-      @children = Menu::ItemCollection.new
-
+      super # MenuNode
       yield(self) if block_given?
     end
 
-    # Add a new MenuItem to the menu
-    #
-    # Example:
-    #   menu = Menu.new
-    #   dash = MenuItem.new :label => "Dashboard"
-    #   menu.add dash
-    #
-    # Accepts as many menu items as you wish to add:
-    #
-    #   menu = Menu.new
-    #   dash = MenuItem.new :label => "Dashboard"
-    #   admin = MenuItem.new :label => "Admin"
-    #   menu.add dash, admin
-    #
-    # @param [MenuItem] menu_items Add as many menu items as you pass in
-    def add(*menu_items)
-      menu_items.each do |menu_item|
-        menu_item.parent = nil
-        @children << menu_item
+    module MenuNode
+      def initialize
+        @children = {}
       end
-    end
 
-    def [](id)
-      @children.find_by_id(id)
-    end
+      def [](id)
+        @children[normalize_id(id)]
+      end
+      def []=(id, child)
+        @children[normalize_id(id)] = child
+      end
 
-    # @return Sorted [Array] of [MenuItem]
-    def items
-      @children.sort
-    end
+      # Recursively builds any given menu items. There are two syntaxes supported,
+      # as shown in the below examples. Both create an identical menu structure.
+      #
+      # Example 1:
+      #   menu = Menu.new
+      #   menu.add label: 'Dashboard' do |dash|
+      #     dash.add label: 'My Child Dashboard'
+      #   end
+      #
+      # Example 2:
+      #   menu = Menu.new
+      #   menu.add label:  'Dashboard'
+      #   menu.add parent: 'Dashboard', label: 'My Child Dashboard'
+      #
+      def add(options)
+        item = if parent = options.delete(:parent)
+          (self[parent] || add(:label => parent)).add options
+        else
+          _add options.merge :parent => self
+        end
 
-    class ItemCollection < Array
+        yield(item) if block_given?
 
-      def find_by_id(id)
-        id = MenuItem.generate_item_id(id)
-        find{ |i| i.id == id }
+        item
       end
 
+      # Whether any children match the given item.
+      def include?(item)
+        @children.values.include? item
+      end
+
+      # Used in the UI to visually distinguish which menu item is selected.
+      def current?(item)
+        self == item || include?(item)
+      end
+
+      # Returns sorted array of menu items that should be displayed in this context.
+      # Sorts by priority first, then alphabetically by label if needed.
+      def items(context = nil)
+        @children.values.select{ |i| i.display?(context) }.sort do |a,b|
+          result = a.priority       <=> b.priority
+          result = a.label(context) <=> b.label(context) if result == 0
+          result
+        end
+      end
+
+      attr_reader :children
+      private
+      attr_writer :children
+
+      # The method that actually adds new menu items. Called by the public method.
+      # If this ID is already taken, transfer the children of the existing item to the new item.
+      def _add(options)
+        item = ActiveAdmin::MenuItem.new(options)
+        item.send :children=, self[item.id].children if self[item.id]
+        self[item.id] = item
+      end
+
+      def normalize_id(id)
+        case id
+        when String, Symbol
+          id.to_s.downcase.gsub ' ', '_'
+        else
+          raise TypeError, "#{id.class} isn't supported as a Menu ID"
+        end
+      end
     end
 
-  end
+    include MenuNode
 
+  end
 end

data/lib/active_admin/menu_collection.rb

@@ -0,0 +1,96 @@
+module ActiveAdmin
+
+  DEFAULT_MENU = :default
+
+  # A MenuCollection stores multiple menus for any given namespace. Namespaces delegate
+  # the addition of menu items to this class.
+  class MenuCollection
+
+    NoMenuError = Class.new(KeyError)
+
+    def initialize
+      @menus = {}
+      @build_callbacks = []
+      @built = false
+    end
+
+    # Add a new menu item to a menu in the collection
+    def add(menu_name, menu_item_options = {})
+      menu = find_or_create(menu_name)
+
+      menu.add menu_item_options
+    end
+
+    def clear!
+      @menus = {}
+      @built = false
+    end
+
+    def exists?(menu_name)
+      @menus.keys.include? menu_name
+    end
+
+    def fetch(menu_name)
+      build_menus!
+
+      @menus[menu_name] or
+        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in availble menus: #{@menus.keys.join(", ")}"
+    end
+
+    # Add callbacks that will be run when the menu is going to be built. This
+    # helps use with reloading and allows configurations to add items to menus.
+    #
+    # @param [Proc] block A block which will be ran when the menu is built. The
+    #                   will have the menu collection yielded.
+    def on_build(&block)
+      @build_callbacks << block
+    end
+
+    # Add callbacks that will be run before the menu is built
+    def before_build(&block)
+      @build_callbacks.unshift(block)
+    end
+
+    def menu(menu_name)
+      menu = find_or_create(menu_name)
+
+      yield(menu) if block_given?
+
+      menu
+    end
+
+    private
+
+    def built?
+      @built
+    end
+
+    def build_menus!
+      return if built?
+
+      build_default_menu
+      run_on_build_callbacks
+
+      @built = true
+    end
+
+    def run_on_build_callbacks
+      @build_callbacks.each do |callback|
+        callback.call(self)
+      end
+    end
+
+    def build_default_menu
+      find_or_create DEFAULT_MENU
+    end
+
+    def find_or_create(menu_name)
+      menu_name ||= DEFAULT_MENU
+      @menus[menu_name] ||= ActiveAdmin::Menu.new
+    end
+
+
+
+  end
+
+end

data/lib/active_admin/menu_item.rb

@@ -1,106 +1,96 @@
-module ActiveAdmin
+require 'active_admin/view_helpers/method_or_proc_helper'
 
+module ActiveAdmin
   class MenuItem
+    include Menu::MenuNode
+    include MethodOrProcHelper
 
-    attr_accessor :id, :label, :url, :priority, :parent, :display_if_block, :children
+    attr_reader :html_options, :parent, :priority
 
-    # Build a new menu item
+    # Builds a new menu item
     #
     # @param [Hash] options The options for the menu
     #
-    # @option options [String, Proc] :label
-    #         The label to display for this menu item. It can either be a String or a 
-    #         Proc. If the option is Proc, it is called each time the label is requested.
+    # @option options [String, Symbol, Proc] :label
+    #         The label to display for this menu item.
+    #         Default: Titleized Resource Name
     #
     # @option options [String] :id
-    #         A custom id to reference this menu item with. If empty an id is automatically 
-    #         generated for you.
+    #         A custom id to reference this menu item with.
+    #         Default: underscored_resource_name
     #
-    # @option options [String, Symbol] :url
-    #         A string or symbol representing the url for this item. If it's a symbol, the
-    #         view will automatically call the method for you.
+    # @option options [String, Symbol, Proc] :url
+    #         The URL this item will link to.
     #
     # @option options [Integer] :priority
-    #         MenuItems are sorted by priority then by label. The lower the priority, the 
-    #         earlier in the menu the item will be displayed.
+    #         The lower the priority, the earlier in the menu the item will be displayed.
     #         Default: 10
     #
-    # @option options [Proc] :if
-    #         A block for the view to call to decide if this menu item should be displayed.
-    #         The block should return true of false
+    # @option options [Symbol, Proc] :if
+    #         This decides whether the menu item will be displayed. Evaluated on each request.
+    #
+    # @option options [Hash] :html_options
+    #         A hash of options to pass to `link_to` when rendering the item
+    #
+    # @option [ActiveAdmin::MenuItem] :parent
+    #         This menu item's parent. It will be displayed nested below its parent.
+    #
+    # NOTE: for :label, :url, and :if
+    # These options are evaluated in the view context at render time. Symbols are called
+    # as methods on `self`, and Procs are exec'd within `self`.
+    # Here are some examples of what you can do:
+    #
+    #   menu if:  :admin?
+    #   menu url: :new_book_path
+    #   menu url: :awesome_helper_you_defined
+    #   menu label: ->{ User.some_method }
+    #   menu label: ->{ I18n.t 'menus.user' }
     #
-    # @option options [Proc] :parent
-    #         The parent label to display for this menu item. Menu item will be nested
-    #         under that label. It can either be a String or a Proc. If the option is Proc,
-    #         it is called each time the label is requested.
     def initialize(options = {})
-      @label    = options[:label]
-      @id       = MenuItem.generate_item_id(options[:id] || label)
-      @url      = options[:url]
-      @priority = options[:priority] || 10
-      @children = Menu::ItemCollection.new
-      @parent   = options[:parent]
-
-      @display_if_block = options[:if]
+      super() # MenuNode
+      @label          = options[:label]
+      @dirty_id       = options[:id]           || options[:label]
+      @url            = options[:url]          || '#'
+      @priority       = options[:priority]     || 10
+      @html_options   = options[:html_options] || {}
+      @should_display = options[:if]           || proc{true}
+      @parent         = options[:parent]
 
       yield(self) if block_given? # Builder style syntax
     end
 
-    def self.generate_item_id(id)
-      id.to_s.downcase.gsub(" ", "_")
+    def id
+      @id ||= normalize_id @dirty_id
     end
 
-    def label
-      case @label
-      when Proc
-        @label.call
-      else
-        @label.to_s
-      end
+    def label(context = nil)
+      render_in_context context, @label
     end
 
-    def add(*menu_items)
-      menu_items.each do |menu_item|
-        menu_item.parent = self
-        @children << menu_item
-      end
+    def url(context = nil)
+      render_in_context context, @url
     end
 
-    def children
-      @children.sort
+    # Don't display if the :if option passed says so
+    # Don't display if the link isn't real, we have children, and none of the children are being displayed.
+    def display?(context = nil)
+      return false unless render_in_context(context, @should_display)
+      return false if     !real_url?(context) && @children.any? && !items(context).any?
+      true
     end
 
-    def parent?
-      !parent.nil?
-    end
-
-    def dom_id
-      id.gsub( " ", '_' ).gsub( /[^a-z0-9_]/, '' )
-    end
-
-    # Returns an array of the ancestory of this menu item
-    # The first item is the immediate parent fo the item
+    # Returns an array of the ancestory of this menu item.
+    # The first item is the immediate parent of the item.
     def ancestors
-      return [] unless parent?
-      [parent, parent.ancestors].flatten
+      parent ? [parent, parent.ancestors].flatten : []
     end
 
-    # Returns the child item with the name passed in
-    #    @blog_menu["Create New"] => <#MenuItem @name="Create New" >
-    def [](id)
-      @children.find_by_id(id)
-    end
-
-    def <=>(other)
-      result = priority <=> other.priority
-      result = label <=> other.label if result == 0
-      result
-    end
+    private
 
-    # Returns the display if block. If the block was not explicitly defined
-    # a default block always returning true will be returned.
-    def display_if_block
-      @display_if_block || lambda { |_| true }
+    # URL is not nil, empty, or '#'
+    def real_url?(context = nil)
+      url = url context
+      url.present? && url != '#'
     end
 
   end

data/lib/active_admin/namespace.rb

@@ -1,6 +1,5 @@
 require 'active_admin/helpers/settings'
 require 'active_admin/resource_collection'
-require 'active_admin/menu_builder'
 
 module ActiveAdmin
 
@@ -33,7 +32,7 @@ module ActiveAdmin
 
     RegisterEvent = 'active_admin.namespace.register'.freeze
 
-    attr_reader :application, :resources, :name, :menu
+    attr_reader :application, :resources, :name, :menus
 
     def initialize(application, name)
       @application = application
@@ -41,6 +40,7 @@ module ActiveAdmin
       @resources = ResourceCollection.new
       register_module unless root?
       generate_dashboard_controller
+      build_menu_collection
     end
 
     # Register a resource into this namespace. The preffered method to access this is to 
@@ -114,16 +114,78 @@ module ActiveAdmin
       application.send(name)
     end
 
-    def menu
-      @menu ||= MenuBuilder.build_for_namespace(self)
+    def fetch_menu(name)
+      @menus.fetch(name)
     end
 
     def reset_menu!
-      @menu = nil
+      @menus.clear!
+    end
+
+    # Add a callback to be ran when we build the menu
+    #
+    # @param [Symbol] name The name of the menu. Default: :default
+    # @param [Proc] block The block to be ran when the menu is built
+    #
+    # @returns [void]
+    def build_menu(name = DEFAULT_MENU, &block)
+      @menus.before_build do |menus|
+        menus.menu name do |menu|
+          block.call(menu)
+        end
+      end
+    end
+
+    # Add the default logout button to the menu, using the ActiveAdmin configuration settings
+    #
+    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
+    # @param [Fixnum] priority Override the default priority of 100 to position the logout button where you want
+    # @param [Hash] html_options An options hash to pass along to link_to
+    #
+    # @returns [void]
+    def add_logout_button_to_menu(menu, priority=100, html_options={})
+      if logout_link_path
+        logout_method = logout_link_method || :get
+        menu.add :id           => 'logout',
+                 :priority     => priority,
+                 :label        => proc{ I18n.t('active_admin.logout') },
+                 :html_options => html_options.reverse_merge(:method => logout_method),
+                 :url          => proc{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
+                 :if           => proc{ current_active_admin_user? }
+      end
     end
 
     protected
 
+    def build_menu_collection
+      @menus = MenuCollection.new
+
+      @menus.on_build do |menus|
+        # Support for deprecated dashboards...
+        Dashboards.add_to_menu(self, menus.menu(DEFAULT_MENU))
+
+        # Build the default utility navigation
+        build_default_utility_nav
+
+        resources.each do |resource|
+          resource.add_to_menu(@menus)
+        end
+      end
+    end
+
+    # Builds the default utility navigation in top right header with current user & logout button
+    def build_default_utility_nav
+      return if @menus.exists? :utility_navigation
+      @menus.menu :utility_navigation do |menu|
+        menu.add  :label  => proc{ display_name current_active_admin_user },
+                  :url    => '#',
+                  :id     => 'current_user',
+                  :if     => proc{ current_active_admin_user? }
+                  
+        add_logout_button_to_menu menu
+      end
+    end
+
     # Either returns an existing Resource instance or builds a new
     # one for the resource and options
     def find_or_build_resource(resource_class, options)