drujensen-browsercms 3.2.0

data/app/helpers/cms/form_builder.rb

@@ -0,0 +1,178 @@
+#
+# Adds additional form fields to the Rails FormBuilder which can be used to create CMS forms.
+#
+class Cms::FormBuilder < ActionView::Helpers::FormBuilder
+
+
+  # Renders a CMS styled JavaScript/CSS styled select box, by itself with no label or other markup besides the js.
+  #
+  # Options:
+  #   * All standard select tag options plus:
+  #   * :default_value - The default item to have selected (defaults to the value of the underlying model)
+  #   * :width - The width for the select (defaults to 455px).
+  #
+  def drop_down(method, choices, options = {}, html_options = {})
+    select_class = "#{@object_name}_#{method}"
+    h_opts = add_tabindex!(@default_options.merge(html_options))
+    h_opts[:class] = select_class
+
+    opts = objectify_options(options)
+    set_default_value!(method, options)
+    cms_options = options.extract!(:default_value, :width)
+    render_cms_form_partial :fancy_drop_down,
+                            :object_name => @object_name, :method => method,
+                            :choices => choices, :options => opts,
+                            :cms_options => cms_options, :html_options => h_opts
+  end
+
+  def date_picker(method, options={})
+    text_field(method, {:size => 10, :class => "date_picker"}.merge(options))
+  end
+
+  def tag_list(options={})
+    field_name = options.delete(:name) || :tag_list
+    text_field(field_name, {:size => 50, :class => "tag-list"}.merge(options))
+  end
+
+  # These are the higher-level fields, 
+  # that get wrapped in divs with labels, instructions, etc.
+
+  %w[date_picker datetime_select text_area text_field file_field].each do |f|
+    src = <<-end_src
+      def cms_#{f}(method, options={})
+        add_tabindex!(options)
+        set_default_value!(method, options)
+        cms_options = options.extract!(:label, :instructions, :default_value, :fancy)
+        render_cms_form_partial :#{f},
+          :object_name => @object_name, :method => method,
+          :options => options, :cms_options => cms_options
+      end
+    end_src
+    class_eval src, __FILE__, __LINE__
+  end
+
+  def cms_drop_down(method, choices, options={}, html_options={})
+    add_tabindex!(html_options)
+    set_default_value!(method, options)
+    cms_options = options.extract!(:label, :instructions, :default_value)
+    render_cms_form_partial :drop_down,
+                            :object_name => @object_name, :method => method,
+                            :choices => choices, :options => options,
+                            :cms_options => cms_options, :html_options => html_options
+  end
+
+  def cms_tag_list(options={})
+    add_tabindex!(options)
+    set_default_value!(:tag_list, options)
+    cms_options = options.extract!(:label, :instructions, :default_value)
+    render_cms_form_partial :tag_list,
+                            :options => options, :cms_options => cms_options
+  end
+
+  #
+  # Renders a WYWIWYG editor without the 'type' selector.
+  #
+  def text_editor(method, options = {})
+    @template.send(
+            "text_editor",
+            @object_name,
+            method,
+            objectify_options(options))
+  end
+
+  # Renders a WYWIWYG editor with the 'type' selector. 
+  def cms_text_editor(method, options = {})
+    add_tabindex!(options)
+    set_default_value!(method, options)
+    cms_options = options.extract!(:label, :instructions, :default_value)
+    render_cms_form_partial :text_editor,
+                            :id => (options[:id] || "#{@object_name}_#{method}"),
+                            :editor_enabled => (cookies["editorEnabled"].blank? ? true : (cookies["editorEnabled"] == 'true' || cookies["editorEnabled"] == ['true'])),
+                            :object_name => @object_name, :method => method,
+                            :options => options, :cms_options => cms_options
+  end
+
+  # Renders instructions for a given field below the field itself. Instructions can be used to provide helpful
+  # guidance to content editors including formatting help or just explaining what a field is for.
+  #
+  # Will not render if instructions are blank/nil.
+  #
+  # * instructions - The text of the instructions to show (Defaults to blank)
+  def cms_instructions(instructions)
+    render_cms_form_partial :instructions, :instructions=>instructions
+  end
+
+  # Renders a label and checkbox suitable for allow editors to update a boolean field.
+  #
+  # Params:
+  #   * method - The name of the field this check_box will update.
+  #   * options - Hash of values including:
+  #       - :label
+  #       - :instructions
+  #       - :default_value
+  #       - Any other standard FormBuilder.check_box options that will be passed directly to the check_box method.
+  def cms_check_box(method, options={})
+    add_tabindex!(options)
+    set_default_value!(method, options)
+    cms_options = options.extract!(:label, :instructions, :default_value)
+    render_cms_form_partial "check_box", :method=>method, :options => options, :cms_options => cms_options
+  end
+
+  #
+  # Renders a template editor that allows developers to edit the view used to render a specific block. Render both
+  # a 'Handler' select box (erb, builder, etc) and a text_area for editing. Will not display the editor if the underlying
+  # object is marked as 'render_inline(false)'. This allows developers to edit the render.html.erb directly to update
+  # how the model displays.
+  #
+  # For example, Portlets will often specify a :template to allow runtime update of their view.
+  #
+  # Options:
+  #   :default_handler - Which handler will be the default when creating new instances. (Defaults to erb)
+  #   :instructions - Instructions that will be displayed below the text area. (Blank by default)
+  #   :label - The name for the label (Defaults to humanized version of field name)
+  #                                                                               
+  def cms_template_editor(method, options={})
+    if object.class.render_inline
+
+      # Set some defaults
+      options[:default_value] = @object.class.default_template
+      set_default_value!(method, options)
+      options[:default_handler] = "erb" unless options[:default_handler]
+
+      cms_options = options.extract!(:label, :instructions)
+      dropdown_options = options.extract!(:default_handler)
+      add_tabindex!(options)
+      render_cms_form_partial :template_editor, :method=>method, :dropdown_options=>dropdown_options, :options => options, :cms_options=>cms_options
+    end
+  end
+
+
+  private
+
+  def set_default_value!(method, options={})
+    if options.has_key?(:default_value) && @object.send(method).blank?
+      @object.send("#{method}=", options[:default_value])
+    end
+  end
+
+  def add_tabindex!(options)
+    if options.has_key?(:tabindex)
+      options.delete(:tabindex) if options[:tabindex].blank?
+    else
+      options[:tabindex] = @template.next_tabindex
+    end
+    options
+  end
+
+  def cookies
+    #Ugly, is there an easier way to get to the cookies?
+    @template.instance_variable_get("@_request").cookies || {}
+  end
+
+  def render_cms_form_partial(field_type_name, locals)
+    @template.render :partial => "cms/form_builder/cms_#{field_type_name}",
+                     :locals => {:f => self}.merge(locals)
+  end
+
+end
+

data/app/helpers/cms/form_tag_helper.rb

@@ -0,0 +1,32 @@
+module Cms
+  module FormTagHelper
+    
+    # A drop-down is just a specialized HTML select
+    
+    def drop_down_tag(name, option_tags = nil, options = {}) 
+      select_tag(name, option_tags, options)
+    end
+    
+    def drop_down(object, method, choices, options = {}, html_options = {})
+      select(object, method, choices, options, html_options)
+    end
+    
+    # A text editor is an HTML WYSIWYG editor.  The result of this
+    # will be a div with a select and a textarea in it.
+    
+    def text_editor_options(options={})
+      opts = options.dup
+      (opts[:class] ||= "") << " editor"
+      opts
+    end
+    
+    def text_editor_tag(name, content = nil, options = {})
+      text_area_tag(name, content, text_editor_options(options))
+    end
+    
+    def text_editor(object_name, method, options = {})
+      text_area(object_name, method, text_editor_options(options))
+    end
+        
+  end
+end

data/app/helpers/cms/menu_helper.rb

@@ -0,0 +1,169 @@
+module Cms
+  module MenuHelper
+    # Renders a menu. There are two options, neither are required:
+    # 
+    # ==== Options
+    # * <tt>:items</tt> - The items which should appear in the menu. This defaults to calling 
+    #   menu_items which generates items automatically based on the current page. But you can use 
+    #   this option to pass in a custom menu structure.
+    # * <tt>:partial</tt> - The partial used to render the menu. By default this is "partials/menu",
+    #   which can be customised through the CMS. The partial gets a local variable <tt>items</tt>.
+    #
+    # ==== Structure of items
+    #
+    # The items should be an array of hashes, in a tree. Each hash can have the following keys (name
+    # and url are required, others are optional):
+    # 
+    # * <tt>:name</tt> - The name which appears in the menu
+    # * <tt>:url</tt> - The URL to link to
+    # * <tt>:id</tt> - The id for the menu item
+    # * <tt>:selected</tt> - Boolean value to indicate whether the menu item is the current page
+    # * <tt>:target</tt> - The target attribute for the link
+    # * <tt>:children</tt> - An array of hashes containing the child menu items. This is where the
+    #   tree structure comes in.
+    #
+    # Edge Cases:
+    #   If both @page and :items are nil/empty, this will return an empty string. This might happen if used on an CMS
+    #   rendered page, where @page isn't set.
+    #
+    def render_menu(options = {})
+      options[:items] ||= menu_items(options)
+      return "" unless options[:items]
+
+      options[:partial] ||= "cms/menus/menu"
+      options[:id] ||= "menu"
+      options[:class] ||= "menu"
+      render :partial => options[:partial], :locals => { :items => options[:items], :css_id => options[:id], :css_class => options[:class] }
+    end
+    
+    # This will render generate an array-of-hashes tree structure based on the page, which can be
+    # passed to render_menu in order to generate a menu.
+    # 
+    # With no options passed, it will generate a structure that includes all the child sections of 
+    # the root and then it will include the path of decendent sections all the way to the current
+    # page.
+    # 
+    # Hidden pages will not be included, but if the first page in a Section is hidden, it will be
+    # used as the URL for that Section. This is commonly done to have a page for a Section and avoid
+    # having duplicates in the navigation.
+    # 
+    # You can change the behavior with the following options, all of these are optional:
+    #
+    # ==== Options
+    # * <tt>:page</tt> - What page should be used as the current page.  If this value is omitted, 
+    #   the value in @page will be used.
+    # * <tt>:path</tt> - This will be used to look up a section and that section will used to 
+    #   generate the menu structure. The current page will still be the value of the page option or
+    #   @page. Note that this is the path to a section, not a path to a page.
+    # * <tt>:from_top</tt> - How many below levels from the root the tree should start at.  
+    #   All sections at this level will be shown.  The default is 0, which means show all
+    #   nodes that are direct children of the root
+    # * <tt>:depth</tt> - How many levels deep should the tree go, relative to from_top.  
+    #   If no value is supplied, the tree will go all the way down to the current page.
+    #   If a value is supplied, the tree will be that many levels underneath from_top deep.
+    # * <tt>:limit</tt> - Limits the number of top-level elements that will be included in the list
+    # * <tt>:show_all_siblings</tt> - Passing true for this option will make all sibilings appear in
+    #   the tree. The default is false, in which case only the siblings of nodes within the open
+    #   path will appear.
+    # 
+    # ==== Examples
+    #
+    # Assume you have the structure the NFL, which is NFL > Conference > Division > Team,
+    # with teams being a Page, everything else a Section.  Also, assume we are on the
+    # Baltimore Ravens page. If you're not a footbal fan, see http://sports.yahoo.com/nfl/teams
+    #
+    #   menu_items
+    #   # => [
+    #     { :id => "section_2", :url => "/buf", :name => "AFC", :children => [
+    #       { :id => "section_3", :url => "/buf", :name => "East" },
+    #       { :id => "section_4", :url => "/bal", :name => "North", :children => [
+    #         { :id => "page_5", :selected => true, :url => "/bal", :name => "Baltimore Ravens" },
+    #         { :id => "page_6", :url => "/cin", :name => "Cincinnati Bengals" },
+    #         { :id => "page_7", :url => "/cle", :name => "Cleveland Browns" },
+    #         { :id => "page_8", :url => "/pit", :name => "Pittsburgh Steelers" }
+    #       ] },
+    #       { :id => "section_9", :url => "/hou", :name => "South" },
+    #       { :id => "section_10}", :url => "/den", :name => "West" }
+    #       ] },
+    #     { :id => "section_11", :url => "/dal", :name => "NFC" }
+    #   ]
+    #
+    #   menu_items(:depth => 2, :show_all_siblings => true)
+    #   # => [
+    #     { :id => "section_2", :url => "/buf", :name => "AFC", :children => [
+    #         { :id => "section_3", :url => "/buf", :name => "East" },
+    #         { :id => "section_4", :url => "/bal", :name => "North" },
+    #         { :id => "section_5", :url => "/hou", :name => "South" },
+    #         { :id => "section_6", :url => "/den", :name => "West" }
+    #       ] },
+    #     { :id => "section_7", :url => "/dal", :name => "NFC", :children => [
+    #         { :id => "section_8", :url => "/dal", :name => "East" },
+    #         { :id => "section_9", :url => "/chi", :name => "North" },
+    #         { :id => "section_10", :url => "/atl", :name => "South" },
+    #         { :id => "section_11", :url => "/ari", :name => "West" }
+    #       ] }
+    #   ]
+    def menu_items(options = {})
+      # Intialize parameters
+      selected_page = options[:page] || @page
+      return nil unless selected_page
+      
+      # Path to the section
+      if options.has_key?(:path)
+        section_for_path = Section.find_by_path(options[:path])
+        raise "Could not find section for path '#{options[:path]}'" unless section_for_path
+        ancestors = section_for_path.ancestors(:include_self => true)
+      else
+        ancestors = selected_page.ancestors
+      end
+      
+      if options.has_key?(:from_top)
+        ancestors = ancestors[options[:from_top].to_i..-1] || []
+      end
+      
+      depth = options.has_key?(:depth) ? options[:depth].to_i : 1.0/0
+      show_all_siblings = options[:show_all_siblings] || false
+      
+      # We are defining a recursive lambda that takes the top-level sections
+      fn = lambda do |section_nodes, current_depth|
+        section_nodes.map do |section_node|
+          node = section_node.node
+          
+          item = {}
+          item[:id] = "#{section_node.node_type.underscore}_#{section_node.node_id}"
+          
+          # If we are showing a section item, we want to use the path for the first page
+          page = section_node.section? ? node.first_page_or_link : node
+          if section_node.section? && page
+            item[:selected] = true if page.hidden? && selected_page == page
+          else
+            item[:selected] = true if selected_page == page
+          end
+         
+          item[:url] = page && page.path || '#'
+          item[:name] = node.name
+          item[:target] = "_blank" if page.respond_to?(:new_window?) && page.new_window?
+          
+          # Now if this is a section, we do the child nodes, 
+          # but only if the show_all_siblings parameter is true, 
+          # or if this section is one of the current page's ancestors
+          # and also if the current depth is less than the target depth
+          if section_node.section? &&
+             current_depth < depth &&
+             (show_all_siblings || ancestors.include?(node)) &&
+             !node.visible_child_nodes.empty?
+            item[:children] = fn.call(node.visible_child_nodes, current_depth + 1)
+          end
+          
+          item
+        end
+      end
+      
+      if ancestors.empty?
+        []
+      else
+        fn.call(ancestors.first.visible_child_nodes(:limit => options[:limit]), 1)
+      end
+    end
+  end
+end

data/app/helpers/cms/page_helper.rb

@@ -0,0 +1,104 @@
+module Cms
+  module PageHelper
+    def page_title(*args)
+      if args.first
+        @controller.instance_variable_get("@template").instance_variable_set("@page_title", args.first)
+      else
+        @controller.instance_variable_get("@template").instance_variable_get("@page_title")
+      end
+    end    
+    
+    def current_page
+      @page
+    end
+    
+    def container(name)
+      content = instance_variable_get("@content_for_#{name}")
+      if logged_in? && @page && @mode == "edit" && current_user.able_to_edit?(@page)
+        render :partial => 'cms/pages/edit_container', :locals => {:name => name, :content => content}
+      else
+        content
+      end
+    end
+    
+    # Determine if a given container has any blocks within it. Useful for determine if markup should be conditionally included
+    # when a block is present, but not shown if no block was added. For example:
+    #
+    # <% unless container_has_block? :sidebar %>
+    #   <div id="sidebar">
+    #   <%= container :sidebar %>
+    #   </div>
+    # <% end %>
+    #
+    # @param [Symbol] name The name of the container to check
+    # @param [Proc] block
+    # @return [Boolean] True if the container has one or more blocks, or if we are in edit mode. False otherwise. 
+    def container_has_block?(name, &block)
+      has_block = (@mode == "edit") || current_page.connectable_count_for_container(name) > 0
+      logger.info "mode = #{@mode}, has_block = #{has_block}"
+      if block_given?
+        concat(capture(&block)) if has_block
+      else
+        has_block
+      end
+    end
+    
+    def cms_toolbar
+      instance_variable_get("@content_for_layout")
+    end
+
+
+    # Renders breadcrumbs based on the current_page. This will generate an unordered list representing the
+    # current page and all it's ancestors including the root name of of the site. The UL can be styled via CSS for
+    # layout purposes. Each breadcrumb except the last will be linked to the page in question.
+    #
+    # If the current_page is nil, it will return an empty string.
+    #
+    # ==== Params:
+    #   options = A hash of options which determine how the breadcrumbs will be laid out.
+    #
+    # ==== Options:
+    # * <tt>:from_top</tt> - How many below levels from the root the tree should start at.
+    #   All sections at this level will be shown.  The default is 0, which means show all
+    #   nodes that are direct children of the root.
+    # * <tt>:show_parent</tt> - Determines if the name of the page itself show be shown as a breadcrumb link. Defaults to false, meaning
+    #   that the parent section of the current page will be the 'last' breadcrumb link. (Note: This probably better renamed as 'show_page').
+    #
+    def render_breadcrumbs(options={})
+      return "" unless current_page
+
+      start = options[:from_top] || 0
+      show_parent = options[:show_parent].nil? ? false : options[:show_parent]
+      ancestors = current_page.ancestors
+      items = []
+      ancestors[start..ancestors.size].each_with_index do |sec,i|
+        items << content_tag(:li, 
+          link_to(h(sec.name), sec.actual_path), 
+          (i == 0 ? {:class => "first"} : {}))
+      end
+      if !show_parent && current_page.section.path == current_page.path
+        items[items.size-1] = content_tag(:li, h(current_page.section.name))
+      else
+        items << content_tag(:li, h(current_page.page_title))
+      end
+      content_tag(:ul, "\n  #{items.join("\n  ")}\n", :class => "breadcrumbs")
+    end
+    
+    def render_portlet(name)
+      portlets = Portlet.all(:conditions => ["name = ?", name.to_s])
+      if portlets.size > 1
+        @mode == "edit" ? "ERROR: Multiple Portlets with name '#{name}'" : nil
+      elsif portlets.empty?
+        @mode == "edit" ? "ERROR: No Portlet with name '#{name}'" : nil
+      else
+        render_connectable(portlets.first)
+      end
+    end
+
+    # Determines if the current_user is able to do specific permissions.
+    def able_to?(*perms, &block)
+      yield if current_user.able_to?(*perms)
+    end
+
+  end
+end