zen 0.3 → 0.4

data/lib/zen/package/menu.rb

@@ -81,8 +81,13 @@ module Zen
 
         g        = Ramaze::Gestalt.new
         children = []
+        attrs    = {}
 
-        g.li do
+        if respond_to?(:request) and url == request.env['SCRIPT_NAME']
+          attrs[:class] = 'current'
+        end
+
+        g.li(attrs) do
           g.a(title, :href => url, :title => title)
 
           unless @children.empty?

data/lib/zen/package/menus/lib/menus.rb

@@ -7,7 +7,7 @@ Zen::Package.add do |p|
   p.root       = __DIR__('menus')
   p.migrations = __DIR__('../migrations')
 
-  p.menu('menus.titles.index', '/admin/menus', :permission => :show_menu)
+  p.menu 'menus.titles.index', '/admin/menus', :permission => :show_menu
 
   p.permission :show_menu  , 'menus.permissions.show'
   p.permission :edit_menu  , 'menus.permissions.edit'
@@ -20,12 +20,14 @@ Zen::Package.add do |p|
   p.permission :delete_menu_item, 'menu_items.permissions.delete'
 end
 
-Zen::Language.load('menus')
-Zen::Language.load('menu_items')
-
 require __DIR__('menus/model/menu')
 require __DIR__('menus/model/menu_item')
 require __DIR__('menus/controller/menus')
 require __DIR__('menus/controller/menu_items')
 
 Zen::Controller::FrontendController.helper(:menu_frontend)
+
+Zen::Event.listen :post_start do
+  Zen::Language.load('menus')
+  Zen::Language.load('menu_items')
+end

data/lib/zen/package/menus/lib/menus/controller/menu_items.rb

@@ -2,28 +2,36 @@ module Menus
   #:nodoc:
   module Controller
     ##
-    # The MenuItems controller allows users to manage menu items of a menu
-    # group. In order to manage menu items you must first navigate to a menu
-    # group and click the link "Manage menu items" (see
-    # {Menus::Controller::Menus} for more information). Once you've reached this
-    # page you'll see an overview that looks like the image below.
+    # Managing menu items is divided into two separate parts: specifying the
+    # order and hierarchy and editing individual menu items such as their names
+    # and URLs. In order to manage a set of menu items you must navigate to the
+    # menu to which the items belong and then click on "Manage menu items". Once
+    # you've clicked this link you'll be presented with a page that looks
+    # somewhat like the one shown in the image below.
     #
-    # ![Menu Items](../../_static/menus/menu_items.png)
+    # ![Menu Items](../../images/menus/menu_items.png)
     #
-    # Editing or creating a menu item can be done by either clicking the name of
-    # a menu item or by clicking the "Add menu item" button. In both cases
-    # you'll end up with a form looking like the one in the following image:
+    # This overview allows you to sort and specify the hierarchy of menu items,
+    # editing individual items can be done by clicking on the name.
     #
-    # ![Edit Menu Item](../../_static/menus/edit_menu_item.png)
+    # Both sorting and creating the hierarchy is done by dragging the menu
+    # items. By dragging them up or down you can change the order, by dragging
+    # them to the left or right you can specify the parent element of a set of
+    # menu items. For example, in the image below the "User Guide" item has been
+    # set to be a child item of the "Home" item.
+    #
+    # ![Menu Item Hierarchy](../../images/menus/menu_item_hierarchy.png)
+    #
+    # If you want to edit an individual menu item you can do so by clicking on
+    # the name of the item, once done you'll be presented with the following
+    # form:
+    #
+    # ![Edit Menu Item](../../images/menus/edit_menu_item.png)
     #
     # In this form you can specify the following fields:
     #
     # * **Name**: the name of the menu item.
     # * **URL**: the URL of the menu item.
-    # * **Order**: a number that indicates the sort order when the menu is
-    #   built.
-    # * **Parent**: a parent menu item. This allows you to easily create sub
-    #   menus.
     # * **HTML class**: a space separated list of classes to apply to the HTML
     #   element.
     # * **HTML ID**: a single ID to apply to the HTML element.
@@ -38,36 +46,27 @@ module Menus
     # * edit_menu_item
     # * delete_menu_item
     #
-    # ## Events
-    #
-    # All events in this controller receive an instance of
-    # {Menus::Model::MenuItem}. Just like other packages the event
-    # ``delete_menu_item`` receives an instance that has already been destroyed.
-    #
-    # @example Automatically prefix URLs with http
-    #  Zen::Event.listen(:new_menu_item) do |item|
-    #    unless item.url =~ /^http/
-    #      item.url = 'http://' + item.url
-    #      item.save
-    #    end
-    #  end
-    #
     # @since  0.2a
     # @map    /admin/menu-items
-    # @event  before_new_menu_item
-    # @event  after_new_menu_item
-    # @event  before_edit_menu_item
-    # @event  after_edit_menu_item
-    # @event  before_delete_menu_item
-    # @event  after_delete_menu_item
     #
     class MenuItems <  Zen::Controller::AdminController
       map    '/admin/menu-items'
       helper :menu
       title  'menu_items.titles.%s'
 
+      autosave Model::MenuItem, Model::MenuItem::COLUMNS, :edit_menu_item
+
       csrf_protection :save, :delete
 
+      serve :css, ['/admin/menus/css/menus'],
+        :name    => 'menus',
+        :methods => [:index]
+
+      serve :javascript,
+        ['/admin/menus/js/lib/nested_sortables', '/admin/menus/js/menu_items'],
+        :name    => 'menus',
+        :methods => [:index]
+
       ##
       # Shows an overview of all the menu items for a menu group.
       #
@@ -86,17 +85,7 @@ module Menus
         )
 
         @menu_id    = menu_id
-        @menu_items = search do |query|
-          ::Menus::Model::MenuItem.search(query) \
-            .filter(:menu_id => menu_id) \
-            .order(:id.asc)
-        end
-
-        @menu_items ||= ::Menus::Model::MenuItem \
-          .filter(:menu_id => menu_id) \
-          .order(:id.asc)
-
-        @menu_items = paginate(@menu_items)
+        @menu_items = Model::Menu[menu_id].menu_items_tree
       end
 
       ##
@@ -117,13 +106,10 @@ module Menus
           lang('menu_items.titles.new')
         )
 
-        @menu_id = menu_id
+        @menu_id   = menu_id
+        @menu_item = Model::MenuItem.new
 
-        if flash[:form_data]
-          @menu_item = flash[:form_data]
-        else
-          @menu_item = ::Menus::Model::MenuItem.new
-        end
+        @menu_item.set(flash[:form_data]) if flash[:form_data]
 
         render_view(:form)
       end
@@ -147,13 +133,10 @@ module Menus
           lang('menu_items.titles.edit')
         )
 
-        @menu_id = menu_id
+        @menu_id   = menu_id
+        @menu_item = validate_menu_item(id, menu_id)
 
-        if flash[:form_data]
-          @menu_item = flash[:form_data]
-        else
-          @menu_item = validate_menu_item(id, menu_id)
-        end
+        @menu_item.set(flash[:form_data]) if flash[:form_data]
 
         render_view(:form)
       end
@@ -165,86 +148,71 @@ module Menus
       # @since      0.2a
       # @permission edit_menu_item (when editing an item)
       # @permission new_menu_item (when creating an item)
-      # @event      before_edit_menu_item
-      # @event      after_edit_menu_item
-      # @event      before_new_menu_item
-      # @event      after_new_menu_item
       #
       def save
-        post = request.subset(
-          :id,
-          :parent_id,
-          :name,
-          :url,
-          :sort_order,
-          :html_class,
-          :html_id,
-          :menu_id
-        )
-
-        if post['parent_id'].empty? or post['parent_id'] == post['id']
-          post['parent_id'] = nil
-        end
+        post = post_fields(*Model::MenuItem::COLUMNS)
+        id   = request.params['id']
 
-        # Determine if we're saving changes made to an existing menu item or
-        # if we're going to create a new one.
-        if post.key?('id') and !post['id'].empty?
+        if id and !id.empty?
           authorize_user!(:edit_menu_item)
 
-          menu_item    = validate_menu_item(post['id'], post['menu_id'])
-          save_action  = :save
-          before_event = :before_edit_menu_item
-          after_event  = :after_edit_menu_item
+          menu_item   = validate_menu_item(id, post['menu_id'])
+          save_action = :save
         else
           authorize_user!(:new_menu_item)
 
-          menu_item    = ::Menus::Model::MenuItem.new
-          save_action  = :new
-          before_event = :before_new_menu_item
-          after_event  = :after_new_menu_item
+          menu_item   = ::Menus::Model::MenuItem.new
+          save_action = :new
         end
 
-        post.delete('id')
-
-        # Set our notifications
         success = lang("menu_items.success.#{save_action}")
         error   = lang("menu_items.errors.#{save_action}")
 
-        # Time to save the data
         begin
-          post.each { |k, v| menu_item.send("#{k}=", v) }
-          Zen::Event.call(before_event, menu_item)
-
+          menu_item.set(post)
           menu_item.save
         rescue => e
-          Ramaze::Log.error(e.inspect)
+          Ramaze::Log.error(e)
           message(:error, error)
 
-          flash[:form_data]   = menu_item
+          flash[:form_data]   = post
           flash[:form_errors] = menu_item.errors
 
           redirect_referrer
         end
 
-        Zen::Event.call(after_event, menu_item)
-
         message(:success, success)
         redirect(MenuItems.r(:edit, menu_item.menu_id, menu_item.id))
       end
 
+      ##
+      # Updates the sort order and parent IDs for the given menu items.
+      #
+      # @since      11-02-2012
+      # @permission edit_menu_item
+      #
+      def tree
+        authorize_user!(:edit_menu_item)
+
+        request.POST['menu_items'].each do |item|
+          Model::MenuItem[item[1]['id']].update(
+            :sort_order => item[0],
+            :parent_id  => item[1]['parent_id']
+          )
+        end
+      end
+
       ##
       # Delete all specified menu items based on the values in the POST array
       # "menu_item_ids".
       #
       # @since      0.2a
       # @permission delete_menu_item
-      # @event      before_delete_menu_item
-      # @event      after_delete_menu_item
       #
       def delete
         authorize_user!(:delete_menu_item)
 
-        post = request.subset(:menu_item_ids)
+        post = post_fields(:menu_item_ids)
 
         if !post['menu_item_ids'] or post['menu_item_ids'].empty?
           message(:error, lang('menu_items.errors.no_delete'))
@@ -255,18 +223,15 @@ module Menus
           menu = ::Menus::Model::MenuItem[id]
 
           next if menu.nil?
-          Zen::Event.call(:before_delete_menu_item, menu)
 
           begin
             menu.destroy
           rescue => e
-            Ramaze::Log.error(e.inspect)
+            Ramaze::Log.error(e)
             message(:error, lang('menu_items.errors.delete') % id)
 
             redirect_referrer
           end
-
-          Zen::Event.call(:after_delete_menu_item, menu)
         end
 
         message(:success, lang('menu_items.success.delete'))

data/lib/zen/package/menus/lib/menus/controller/menus.rb

@@ -29,7 +29,7 @@ module Menus
     # this is the case). An example of such an overview can be seen in the image
     # below.
     #
-    # ![Menus Overview](../../_static/menus/menus.png)
+    # ![Menus Overview](../../images/menus/menus.png)
     #
     # This overview allows you to edit, create or remove menu groups as well as
     # managing the menu items of a group. Editing a group can be done by
@@ -37,7 +37,7 @@ module Menus
     # the button "Add menu". In both cases you'll end up with the form shown in
     # the image below.
     #
-    # ![Edit Menu](../../_static/menus/edit_menu.png)
+    # ![Edit Menu](../../images/menus/edit_menu.png)
     #
     # In this form you can use the following fields:
     #
@@ -61,44 +61,16 @@ module Menus
     # * edit_menu
     # * delete_menu
     #
-    # ## Events
-    #
-    # All events in this controller receive an instance of {Menus::Model::Menu}.
-    # Just like other packages the event ``delete_menu`` receives an instance
-    # that has already been destroyed.
-    #
-    # @example Automatically add a menu item
-    #  Zen::Event.listen(:new_menu) do |menu|
-    #    menu.add_menu_item(:name => 'Home', :url => '/', :html_id => 'home')
-    #  end
-    #
-    # @example Remove duplicate menu items when editing a menu
-    #  Zen::Event.listen(:edit_menu) do |menu|
-    #    urls = []
-    #
-    #    menu.items.each do |item|
-    #      if urls.include?(item.url)
-    #        item.destroy
-    #      else
-    #        urls << item.url
-    #      end
-    #    end
-    #  end
-    #
     # @since  0.2a
     # @map    /admin/menus
-    # @event  before_new_menu
-    # @event  after_new_menu
-    # @event  before_edit_menu
-    # @event  after_edit_menu
-    # @event  before_delete_menu
-    # @event  after_delete_menu
     #
     class Menus < Zen::Controller::AdminController
       map    '/admin/menus'
       helper :menu
       title  'menus.titles.%s'
 
+      autosave Model::Menu, Model::Menu::COLUMNS, :edit_menu
+
       csrf_protection :save, :delete
 
       ##
@@ -137,7 +109,8 @@ module Menus
           @page_title
         )
 
-        @menu = ::Menus::Model::Menu.new
+        @menu = Model::Menu.new
+        @menu.set(flash[:form_data]) if flash[:form_data]
 
         render_view(:form)
       end
@@ -159,11 +132,8 @@ module Menus
           @page_title
         )
 
-        if flash[:form_data]
-          @menu = flash[:form_data]
-        else
-          @menu = validate_menu(id)
-        end
+        @menu = validate_menu(id)
+        @menu.set(flash[:form_data]) if flash[:form_data]
 
         render_view(:form)
       end
@@ -172,63 +142,41 @@ module Menus
       # Saves any changes made to an existing menu or creates a new menu.
       #
       # @since      0.2a
-      # @event      before_edit_menu
-      # @event      after_edit_menu
-      # @event      before_new_menu
-      # @event      after_new_menu
       # @permission edit_menu (when editing an existing menu)
       # @permission new_menu (when creating a new menu)
       #
       def save
-        post = request.subset(
-          :name,
-          :slug,
-          :description,
-          :html_class,
-          :html_id,
-          :id
-        )
+        post = post_fields(*Model::Menu::COLUMNS)
+        id   = request.params['id']
 
-        # Determine if we're creating a new group or modifying an existing one.
-        if post.key?('id') and !post['id'].empty?
+        if id and !id.empty?
           authorize_user!(:edit_menu)
 
-          menu         = validate_menu(post['id'])
-          save_action  = :save
-          before_event = :before_edit_menu
-          after_event  = :after_edit_menu
+          menu        = validate_menu(id)
+          save_action = :save
         else
           authorize_user!(:new_menu)
 
-          menu         = ::Menus::Model::Menu.new
-          save_action  = :new
-          before_event = :before_new_menu
-          after_event  = :after_new_menu
+          menu        = ::Menus::Model::Menu.new
+          save_action = :new
         end
 
-        post.delete('id')
-
         success = lang("menus.success.#{save_action}")
         error   = lang("menus.errors.#{save_action}")
 
-        # Let's see if we can insert/update the data
         begin
-          post.each { |k, v| menu.send("#{k}=", v) }
-          Zen::Event.call(before_event, menu)
-
+          menu.set(post)
           menu.save
         rescue => e
-          Ramaze::Log.error(e.inspect)
+          Ramaze::Log.error(e)
           message(:error, error)
 
-          flash[:form_data]   = menu
+          flash[:form_data]   = post
           flash[:form_errors] = menu.errors
 
           redirect_referrer
         end
 
-        Zen::Event.call(after_event, menu)
-
         message(:success, success)
         redirect(Menus.r(:edit, menu.id))
       end
@@ -239,8 +187,6 @@ module Menus
       # "menu_ids".
       #
       # @since      0.2a
-      # @event      before_delete_menu
-      # @event      after_delete_menu
       # @permission delete_menu
       #
       def delete
@@ -258,18 +204,15 @@ module Menus
           menu = ::Menus::Model::Menu[id]
 
           next if menu.nil?
-          Zen::Event.call(:before_delete_menu, menu)
 
           begin
             menu.destroy
           rescue => e
-            Ramaze::Log.error(e.inspect)
+            Ramaze::Log.error(e)
             message(:error, lang('menus.errors.delete') % id)
 
             redirect_referrer
           end
-
-          Zen::Event.call(:after_delete_menu, menu)
         end
 
         message(:success, lang('menus.success.delete'))