zen 0.3 → 0.4

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

@@ -49,58 +49,74 @@ module Ramaze
       end
 
       ##
-      # Builds a hierarchy of navigation items and all their sub items. The
-      # generated structure looks like the following:
+      # Builds the menu item tree that can be used by the user to edit the sort
+      # order, create the menu item tree and edit individual menu items.
       #
-      #     Root
-      #      |
-      #      |_ Sub
-      #      | |
-      #      | |_ Sub sub
-      #      |
-      #      |_ Sub 1
+      # @since  11-02-2012
+      # @param  [Array] tree The menu item tree to process. This array should be
+      #  in the format as returned by {Menus::Model::Menu#menu_items_tree}.
+      # @return [String]
       #
-      # @since  0.2a
-      # @param  [Fixnum] menu_id The ID of the current menu group.
-      # @return [Hash]
-      #
-      def menu_item_tree(menu_id)
-        menu_items = ::Menus::Model::MenuItem.filter(
-          :menu_id   => menu_id,
-          :parent_id => nil
-        )
+      def menu_items_tree(tree)
+        gestalt = Ramaze::Gestalt.new
+        params  = {:id => 'menu_items'}
 
-        @menu_items_hash = {nil => '--'}
-
-        menu_items.each do |item|
-          @menu_items_hash[item.id] = item.name
+        unless user_authorized?(:edit_menu_item)
+          params[:'data-editable'] = false
+        end
 
-          item.descendants.each do |i|
-            descendant_items(i, 2)
+        gestalt.ul(params) do
+          tree.each do |item|
+            menu_item(item, gestalt)
           end
         end
 
-        return @menu_items_hash
+        return gestalt.to_s
       end
 
+      private
+
       ##
-      # Helper method for retrieving descendant navigation items.
+      # Builds the HTML for a single menu item and recursively calls itself for
+      # any sub menu items.
       #
-      # @since  0.2a
-      # @param  [Menus::Model::MenuItem] item A MenuItem instance
-      # @param  [Fixnum] spaces The amount of unbreakable spaces to use.
+      # @since 11-02-2012
+      # @param [Hash] item A single menu item to process.
+      # @param [Ramaze::Gestalt] gestalt An instance of Ramaze::Gestalt to use
+      #  for building the HTML.
       #
-      def descendant_items(item, spaces)
-        return if @menu_items_hash.key?(item.id)
+      def menu_item(item, gestalt)
+        gestalt.li(:id => "menu_item_#{item[:node].id}") do
+          gestalt.div(:class => 'menu_item') do
 
-        nbsps = ''
-        spaces.times { nbsps += " " }
-        @menu_items_hash[item.id] = nbsps + item.name
-        descendants               = item.descendants
+            if user_authorized?(:delete_menu_item)
+              gestalt.input(
+                :type  => 'checkbox',
+                :name  => 'menu_item_ids[]',
+                :value => item[:node].id
+              )
+            end
+
+            if user_authorized?(:edit_menu_item)
+              edit_link(
+                Menus::Controller::MenuItems.r(
+                  :edit,
+                  item[:node].menu_id,
+                  item[:node].id
+                ),
+                item[:node].name
+              )
+            else
+              item[:node].name
+            end
+          end
 
-        if !descendants.empty?
-          descendants.each do |i|
-            self.descendant_items(i, spaces + 2)
+          unless item[:children].empty?
+            gestalt.ul do
+              item[:children].each do |child|
+                menu_item(child, gestalt)
+              end
+            end
           end
         end
       end

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

@@ -40,13 +40,6 @@ module Ramaze
         }.merge(options)
 
         menu  = Menus::Model::Menu.find_by_pk_or_slug(menu)
-        items = Menus::Model::MenuItem \
-          .filter(:parent_id => nil, :menu_id => menu.id) \
-          .limit(options[:limit]) \
-          .order(:sort_order.send(options[:order])) \
-          .eager(:parent) \
-          .all
-
         g     = Ramaze::Gestalt.new
         attrs = {}
         tree  = {}
@@ -61,8 +54,8 @@ module Ramaze
 
         # Build the HTML
         g.ul(attrs) do
-          items.each do |item|
-            if item.parent_id.nil?
+          menu.menu_items_tree(options[:order], options[:limit]).each do |item|
+            if item[:node].parent_id.nil?
               render_menu_item(item, g, options)
             end
           end
@@ -77,14 +70,15 @@ module Ramaze
       # Generates the HTML for a single menu item.
       #
       # @since  0.3
-      # @param  [Menus::Model::MenuItem] item The menu item to render.
+      # @param  [Hash] node A single node containing a :node and :children key.
       # @param  [Ramaze::Gestalt] g An instance of ``Ramaze::Gestalt`` to use
       #  for building the HTML.
       # @param  [Hash] options A hash of options, see the options hash for
       #  {Ramaze::Helper::MenuFrontend#render_menu} for more information.
       #
-      def render_menu_item(item, g, options = {})
+      def render_menu_item(node, g, options = {})
         attrs = {}
+        item  = node[:node]
 
         if !item.html_class.nil? and !item.html_class.empty?
           attrs[:class] = item.html_class
@@ -99,9 +93,9 @@ module Ramaze
 
           # Render any sub menu items
           if options[:sub] == true
-            children = item.children
+            children = node[:children]
 
-            if !children.empty?
+            unless children.empty?
               g.ul(:class => :children) do
                 children.each { |child| render_menu_item(child, g, options) }
               end

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

@@ -4,15 +4,56 @@ module Menus
     ##
     # Model used for managing groups of menu items.
     #
-    # @since  0.2a
+    # @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
+    # @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 Menu < Sequel::Model
       include Zen::Model::Helper
 
-      plugin :sluggable, :source => :name, :freeze => false
+      ##
+      # Array containing all the columns that can be set by the user.
+      #
+      # @since 17-02-2012
+      #
+      COLUMNS = [:name, :slug, :description, :html_class, :html_id]
 
       one_to_many :menu_items, :class => 'Menus::Model::MenuItem'
 
+      plugin :sluggable, :source => :name, :freeze => false
+
+      plugin :association_dependencies, :menu_items => :delete
+
+      plugin :events,
+        :before_create  => :before_new_menu,
+        :after_create   => :after_new_menu,
+        :before_update  => :before_edit_menu,
+        :after_update   => :after_edit_menu,
+        :before_destroy => :before_delete_menu,
+        :after_destroy  => :after_delete_menu
+
       ##
       # Searches for a set of menus.
       #
@@ -28,6 +69,81 @@ module Menus
         )
       end
 
+      ##
+      # Creates an array containing a hierarchy of menu items based on the
+      # values of the "id" and "parent_id" columns. The advantage of this method
+      # over the "tree" plugin that comes with Sequel is that it's capable of
+      # building this structure using only a single query, the downside is that
+      # it probably uses a bit more memory.
+      #
+      # The return value is an array of hashes. Each hash has the following
+      # format:
+      #
+      #     {:node => #<Menus::Model::MenuItem>, :children => [...]}
+      #
+      # The :node key contains the menu item, the :children key contains an
+      # array which in turn contains all the sub nodes (and so on).
+      #
+      # On average this method is about 2.5 times faster than using the tree
+      # plugin's ``#children()`` method, see https://gist.github.com/1713481 for
+      # a small benchmark.
+      #
+      # @example
+      #  def loop_nodes(node)
+      #    puts node[:node].id
+      #
+      #    node[:children].each do |child|
+      #      loop_nodes(child)
+      #    end
+      #  end
+      #
+      #  loop_nodes(Menus::Model::Menu[1].menu_items_tree)
+      #
+      # @since  30-01-2012
+      # @param  [Symbol] order The sort order to apply to menu items, set to
+      #  :asc by default.
+      # @param  [Fixnum|NilClass] limit The maximum amount of menu items to
+      #  retrieve. Set to unlimited by default.
+      # @return [Hash]
+      #
+      def menu_items_tree(order = :asc, limit = nil)
+        nodes   = []
+        indexes = {}
+        rows    =  MenuItem.filter(:menu_id => id).limit(limit).all
+
+        rows.sort! do |left, right|
+          (left.parent_id || 0) <=> (right.parent_id || 0)
+        end
+
+        # Create the basic structure for each node and index said node.
+        rows.each do |item|
+          node  = {:node => item, :children => []}
+          nodes << node
+
+          indexes[item.id] = nodes.rindex(node)
+        end
+
+        # Sort the nodes by their parent ID in descending order.
+        nodes.sort! do |left, right|
+          (left[:node].parent_id || 0) <=> (right[:node].parent_id || 0)
+        end
+
+        # Process the list of nodes in reverse order so that the child items can
+        # be assigned properly.
+        nodes.reverse.each do |node|
+          # If there's a matching parent node the current node should be
+          # assigned to that node and removed from the list. If there's no
+          # parent item then the node is un-modified.
+          if indexes[node[:node].parent_id]
+            index = indexes[node[:node].parent_id]
+
+            nodes[index][:children] << nodes.delete(node) if nodes[index]
+          end
+        end
+
+        return sort_menu_items(nodes, order)
+      end
+
       ##
       # Specifies all validates rules used when creating or updating a menu.
       #
@@ -40,6 +156,46 @@ module Menus
         validates_format(/^[a-zA-Z\-_0-9\s]*$/, :html_class)
         validates_format(/^[a-zA-Z\-_0-9]*$/  , :html_id)
       end
+
+      ##
+      # Hook that is executed before creating or saving an object.
+      #
+      # @since 03-01-2012
+      #
+      def before_save
+        sanitize_fields([:name, :slug, :description, :html_class, :html_id])
+
+        super
+      end
+
+      private
+
+      ##
+      # Sorts a set of sub nodes as returned by
+      # {Menus::Model::Menu#menu_item_tree}.
+      #
+      # @since  01-02-2012
+      # @param  [Array]  nodes An array of nodes to sort.
+      # @param  [Symbol] order The sort order to apply.
+      # @return [Array]
+      #
+      def sort_menu_items(nodes, order = :asc)
+        return nodes if nodes.empty?
+
+        nodes.sort! do |left, right|
+          if order == :asc
+            left[:node].sort_order <=> right[:node].sort_order
+          else
+            right[:node].sort_order <=> left[:node].sort_order
+          end
+        end
+
+        nodes.each do |node|
+          node[:children] = sort_menu_items(node[:children])
+        end
+
+        return nodes
+      end
     end # Menu
   end # Model
 end # Menus

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

@@ -4,13 +4,44 @@ module Menus
     ##
     # Model used for managing individual menu items in a group.
     #
-    # @since  0.2a
+    # @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
+    # @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 MenuItem < Sequel::Model
       include Zen::Model::Helper
 
+      ##
+      # Array containing the columns that can be set by the user.
+      #
+      # @since 17-02-2012
+      #
+      COLUMNS = [
+        :parent_id, :name, :url, :sort_order, :html_class, :html_id, :menu_id
+      ]
+
       plugin :tree, :order => :sort_order
 
+      plugin :events,
+        :before_create  => :before_new_menu_item,
+        :after_create   => :after_new_menu_item,
+        :before_update  => :before_edit_menu_item,
+        :after_update   => :after_edit_menu_item,
+        :before_destroy => :before_delete_menu_item,
+        :after_destroy  => :after_delete_menu_item
+
       many_to_one :menu  , :class => 'Menus::Model::Menu'
       many_to_one :parent, :class => self
 
@@ -29,6 +60,18 @@ module Menus
         )
       end
 
+      ##
+      # Sets the ID of the parent navigation item but *only* if it's not empty
+      # and not the same as the current ID.
+      #
+      # @since  0.3
+      # @param  [Fixnum] parent_id The ID of the parent navigation item.
+      #
+      def parent_id=(parent_id)
+        return if parent_id == id
+        return super(parent_id)
+      end
+
       ##
       # Specifies all validation rules that will be used when creating or
       # updating a menu item.
@@ -36,7 +79,7 @@ module Menus
       # @since  0.2a
       #
       def validate
-        validates_presence([:name, :url])
+        validates_presence([:name, :url, :menu_id])
         validates_max_length(255, [:name, :url, :html_class, :html_id])
         validates_integer([:sort_order, :parent_id])
         validates_format(/^[a-zA-Z\-_0-9\s]*$/, :html_class)
@@ -44,17 +87,37 @@ module Menus
       end
 
       ##
-      # Sets the ID of the parent navigation item but *only* if it's not empty
-      # and not the same as the current ID.
+      # Hook that is called before creating a new object.
       #
-      # @since  0.3
-      # @param  [Fixnum] parent_id The ID of the parent navigation item.
+      # @since 28-02-2012
       #
-      def parent_id=(parent_id)
-        if !(parent_id.respond_to?(:empty?) and !parent_id.empty?) \
-        and parent_id != self.id
-          super(parent_id)
+      def before_create
+        # Set the sort order based on the order of the last item.
+        if self.sort_order.nil?
+          last = Zen.database[MenuItem.table_name] \
+            .select(:sort_order + 1 => :sort_order) \
+            .filter(:menu_id => self.menu_id) \
+            .order(:sort_order.desc) \
+            .limit(1) \
+            .first
+
+          unless last.nil?
+            self.sort_order = last[:sort_order]
+          end
         end
+
+        super
+      end
+
+      ##
+      # Hook that is executed before creating or saving an object.
+      #
+      # @since 03-01-2012
+      #
+      def before_save
+        sanitize_fields([:name, :url, :html_class, :html_id])
+
+        super
       end
     end # MenuItem
   end # Model