browsercms-artirix 4.0.0.rc1.art4

data/app/helpers/cms/content_block_helper.rb

@@ -0,0 +1,55 @@
+module Cms
+  module ContentBlockHelper
+
+    # From 3.3.x (Performance)
+    # Delete once we confirm that content_block_tr_tag below works.
+
+    # Prints the <tr> for each block. Adds classes based on:
+    # * Name/id of the block
+    # * If a block is published/draft
+    # * If the user can edit/publish it
+    def block_row_tag(block)
+      cname = class_name_for(block)
+      can_modify = current_user.able_to_modify?(block)
+
+      options = {
+          :id => "#{cname}_#{block.id}",
+          :class => cname
+      }
+      options[:class] += block.class.publishable? && !block.published? ? ' draft' : ' published'
+      options[:class] += ' non-editable' unless can_modify && current_user.able_to?(:edit_content)
+      options[:class] += ' non-publishable' unless can_modify && current_user.able_to?(:publish_content)
+      tag "tr", options, true
+    end
+
+    # From 3.4.x (Namespaced and using Data elements to clean up JS in pages)
+    
+    # For each row in content block table, we need to output all the paths for the actions in a way that JS can read them.
+    # We use 'data-' elements here to avoid duplication of path calculations.
+    def content_block_tr_tag(block)
+      cname = class_name_for(block)
+      can_modify = current_user.able_to_modify?(block)
+
+      options = {}
+      data = options[:data] = {}
+      data[:status] = block.class.publishable? && !block.published? ? 'draft' : 'published'
+
+      options[:id] = "#{cname}_#{block.id}"
+      options[:class] = [cname]
+      options[:class] << 'non-editable' unless can_modify && current_user.able_to?(:edit_content)
+      options[:class] << 'non-publishable' unless can_modify && current_user.able_to?(:publish_content)
+      options['data-new_path'] = url_for(new_engine_aware_path(block))
+      options['data-view_path'] = url_for(engine_aware_path(block, nil))
+      options['data-edit_path'] = url_for(edit_engine_aware_path(block))
+      options['data-preview_path'] = block.path if block.class.addressable?
+      options['data-versions_path'] = engine(block).polymorphic_path(block, action: :versions) if block.class.versioned?
+      options['data-delete_path'] = url_for(engine_aware_path(block))
+      options['data-publish_path'] = engine(block).polymorphic_path([:publish, block]) if block.class.publishable?
+      tag "tr", options, true
+    end
+
+    def class_name_for(block)
+      block.class.name.underscore
+    end
+  end
+end

data/app/helpers/cms/content_types_helper.rb

@@ -0,0 +1,4 @@
+module Cms
+  module ContentTypesHelper
+  end
+end

data/app/helpers/cms/form_tag_helper.rb

@@ -0,0 +1,36 @@
+module Cms
+  module FormTagHelper
+
+    # Generates a form (i.e. Rails form_for) for creating/updating content blocks. Exposes additional methods to
+    # to create inputs. Implements a superset of SimpleForm behavior (i.e. simple_form_for).
+    #
+    # This also includes deprecated methods from pre-4.0 form building (like f.cms_text_field) for backwards compatiable
+    # support.
+    def content_block_form_for(object, *args, &block)
+      options = args.extract_options!
+      simple_form_for(engine_aware_path(object), *(args << options.merge(builder: Cms::FormBuilder::ContentBlockFormBuilder, wrapper: 'browsercms')), &block)
+    end
+
+    # Simple wrapper for Rails form_for that will use the CMS CustomFormBuilder.
+    # Can be used by portlets or other random public facing views to render content.
+    def cms_form_for(*args, &block)
+      options = args.extract_options!
+      options.merge!(:builder => Cms::FormBuilder::ContentBlockFormBuilder)
+      form_for(*(args + [options]), &block)
+    end
+
+    def forecasting_a_new_section?(form_object)
+      Cms::Section.with_path(form_object.object.class.path).first.nil?
+    end
+
+
+    def slug_source_if(boolean)
+      if boolean
+        {input_html: {class: 'slug-source'}}
+      else
+        {}
+      end
+    end
+
+  end
+end

data/app/helpers/cms/menu_helper.rb

@@ -0,0 +1,167 @@
+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.gsub("::","_").underscore}_#{section_node.node_id}"
+
+          # If we are showing a section item, we want to use the path for the first page
+          page_or_link = section_node.section? ? node.first_page_or_link : node
+          if section_node.section? && page_or_link
+            item[:selected] = true if page_or_link.respond_to?(:hidden?) && page_or_link.hidden? && selected_page == page_or_link
+          else
+            item[:selected] = true if selected_page == page_or_link
+          end
+          item[:url] = page_or_link.try(:path) || '#'
+          item[:name] = node.name
+          item[:target] = "_blank" if page_or_link.respond_to?(:new_window?) && page_or_link.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/mobile_helper.rb

@@ -0,0 +1,29 @@
+module Cms
+  module MobileHelper
+
+    def full_site_url
+      options = {
+          :host => Rails.configuration.cms.site_domain,
+          path: current_page.path,
+          params: {:prefer_full_site => true}
+      }
+      ActionDispatch::Http::URL.url_for(options)
+    end
+
+    def mobile_site_url
+      options = {
+          :host => Rails.configuration.cms.site_domain,
+          path: current_page.path,
+          params: {:prefer_mobile_site => true}
+      }
+      ActionDispatch::Http::URL.url_for(options)
+    end
+
+    # Determines if the mobile template exists for a given page.
+    # Used by view to show/hide the mobile toggle.
+    def mobile_template_exists?(page)
+      controller.template_exists?(page.layout_name, "layouts/mobile")
+    end
+  end
+
+end

data/app/helpers/cms/nav_menu_helper.rb

@@ -0,0 +1,23 @@
+module Cms
+  module NavMenuHelper
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :new_button_path, :target_section
+    end
+
+    # In most cases, the 'New' button should go to create a new page.
+    def new_button_path
+      cms.new_section_page_path(target_section)
+    end
+
+    # Used to determine which section a New Page should go in, based on the current context.
+    def target_section
+      if @page && @page.parent
+        @page.parent
+      else
+        Cms::Section.first
+      end
+    end
+  end
+end

data/app/helpers/cms/page_helper.rb

@@ -0,0 +1,169 @@
+module Cms
+
+  # Deprecated in 4.0. Remove in 4.1
+  module DeprecatedBehavior
+
+    # Add the code to render the CMS toolbar.
+    # @deprecated This method is no longer required for BrowserCMS templates.
+    def cms_toolbar
+      ActiveSupport::Deprecation.warn "The cms_toolbar helper is deprecated and no longer necessary. You can safely remove <%= cms_toolbar %> from templates.", caller
+      return ""
+    end
+
+    def deprecated_set_page_title_usage(args)
+      ActiveSupport::Deprecation.warn "Calling page_title('#{args.first}') is deprecated and will be remove in 4.1. Call use_page_title('#{args.first}') instead.", caller
+      use_page_title args.first
+    end
+  end
+
+  module PageHelper
+    include Cms::DeprecatedBehavior
+
+    # Keep this taller until we reverse the iframes (so menus will work)
+    PAGE_TOOLBAR_HEIGHT = 159
+    TOOLBAR_HEIGHT = 100
+
+    # Return the JS file to load the configured default WYSIWYG editor
+    #
+    # Ideally, this could be improved if sprockets allows for dynamically determining which js library to use.
+    # @return [String] Names of the JS file needed to load the editor.
+    def cms_content_editor
+      "bcms/#{Cms.content_editor}"
+    end
+
+    # Outputs the title for this page. Used by both internal CMS pages, as well as page templates. Call use_page_title to
+    # change this value.
+    #
+    # @param [String] If provided, this is the name of the page to set. (This usage is deprecated in 4.0 and will be removed in 4.1)
+    # @return [String] The title of the page.
+    def page_title(*args)
+      if args.first
+        deprecated_set_page_title_usage(args)
+      else
+        if @page_title
+          @page_title
+        elsif current_page
+          current_page.page_title
+        else
+          "Untitled"
+        end
+      end
+    end
+
+    # Returns the Page title in an In Context editable area.
+    #
+    # Use for h1/h2 elements. Use page_title for title elements.
+    def page_header()
+      if (is_current_user_able_to_edit_this_content?(current_page))
+        options = {id: 'page_title', contenteditable: true, data: {attribute: "title", content_name: "page", id: current_page.id, page_id: current_page.id}}
+        content_tag "div", page_title, options
+      else
+        page_title
+      end
+    end
+
+    # Allows Views to set what will be displayed as the <title> element for Page Templates (and Cms admin pages.)
+    #
+    def use_page_title(title)
+      # Implementation note: This method is named use_page_title rather than page_title= because ruby will create a
+      # local variable if you call <%= page_title = "A New Page Name" %>
+      @page_title = title
+    end
+
+    def current_page
+      @page
+    end
+
+    # Outputs the content of a particular container. If the user is in 'edit' mode the container and block controls will
+    # be rendered.
+    #
+    # @return [String] The HTML content for the container.
+    def container(name)
+      content = content_for(name)
+      if is_current_user_able_to_edit_this_content?(@page)
+        render :partial => 'cms/pages/simple_container', :locals => {:name => name, :content => content, :container => name}
+      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 = (edit_mode?) || 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
+
+    # 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(sec.name, sec.actual_path), (i == 0 ? {:class => "first"} : {}))
+      end
+      if !show_parent && current_page.landing_page?
+        items[items.size-1] = content_tag(:li, current_page.parent.name)
+      else
+        items << content_tag(:li, current_page.page_title)
+      end
+      content_tag(:ul, "\n  #{items.join("\n  ")}\n".html_safe, :class => "breadcrumbs")
+    end
+
+    def render_portlet(name)
+      portlets = Portlet.all(:conditions => ["name = ?", name.to_s])
+      if portlets.size > 1
+        edit_mode? ? "ERROR: Multiple Portlets with name '#{name}'" : nil
+      elsif portlets.empty?
+        edit_mode? ? "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)
+      block.call if current_user.able_to?(*perms)
+      return ''
+    end
+
+    # Determines whether this page is in edit mode or not.
+    def edit_mode?()
+      @mode == "edit"
+    end
+  end
+end

data/app/helpers/cms/path_helper.rb

@@ -0,0 +1,113 @@
+module Cms
+
+  # @todo All methods really need to be renamed to match conventions for Engines.
+  # In CMS::Engine, shouldn't have cms_ in method name.
+  # From app, should be cms.xyz_path
+  module PathHelper
+
+    # @return A link if content is addressable, name otherwise.
+    # Link_to_if would call content.path even if it doesn't respond to '
+    def link_to_addressable_content(name, content)
+      if content.respond_to? :path
+        link_to name, content.path
+      else
+        name
+      end
+    end
+    # Returns the relative path to the given attachment.
+    # Content editors will see exact specific version path, while other users will see the 'public' url for the path.
+    def attachment_path_for(attachment)
+      return "" unless attachment
+      if current_user.able_to?(:edit_content)
+        attachment.attachment_version_path
+      else
+        attachment.url
+      end
+    end
+
+    # Returns a path to sort a table of Content Blocks by a given parameter. Retains other relevant parameters (like search criteria).
+    #
+    # @param [Cms::ContentType] content_type
+    # @param [String] column_to_sort The name of the column to sort on.
+    def sortable_column_path(content_type, column_to_sort)
+      filtered_params = params.clone
+      filtered_params.delete(:action)
+      filtered_params.delete(:controller)
+      filtered_params.merge!(:order => determine_order(filtered_params[:order], column_to_sort))
+      polymorphic_path(engine_aware_path(content_type.model_class), filtered_params)
+    end
+
+    def link_to_usages(block)
+      count = block.connected_pages.count
+      if count > 0
+        # Would love a cleaner solution to this problem, see http://stackoverflow.com/questions/702728
+        path = if Portlet === block
+                 usages_portlet_path(block)
+               else
+                 p = []
+                 p << engine_for(block)
+                 p << :usages
+                 p << block
+                 p
+               end
+        link_to count, path, :id => block.id, :block_type => block.content_block_type
+      else
+        count
+      end
+    end
+
+
+    # Returns the route proxy (aka engine) for a given resource, which can then have named paths called on it.
+    #  I.e. engine(@block).polymorphic_path([@block, :preview])
+    # 
+    # @param [ActiveRecord::Base] resource
+    # @return [ActionDispatch::Routing::RoutesProxy]
+    def engine(resource)
+      name = EngineAwarePathBuilder.new(resource).engine_name
+      send(name)
+    end
+
+    # @deprecated
+    alias :engine_for :engine
+
+    # Return the path for a given resource. Determines the relevant engine, and the result can be passed to polymporhic_path
+    #
+    # @param [Object] model_or_class_or_content_type A content block, class or content type.
+    # @param [String] action (Optional) i.e. :edit
+    # @return [Array] An array of argument suitable to be passed to url_for or link_to helpers. This will be something like:
+    #     [main_app, :dummy_products, @block, :edit]
+    #  or [cms, :html_blocks, @block]
+    #
+    # This will work whether the block is:
+    #   1. A block in a project (namespaced to the project) (i.e. Dummy::Product)
+    #   2. A core CMS block (i.e. Cms::Portlet)
+    #   3. A block in a module (i.e. BcmsNews::NewsArticle)
+    # e.g.
+    #   engine_aware_path(Dummy::Product.find(1)) => /dummy/products/1
+    #   engine_aware_path(Cms::HtmlBlock.find(1)) => /cms/html_blocks/1
+    #   engine_aware_path(BcmsNews::NewsArticle.find(1)) => /bcms_news/news_articles/1
+    #
+    def engine_aware_path(model_or_class_or_content_type, action = false)
+      elements = build_path_for(model_or_class_or_content_type)
+      elements << action if action
+      elements
+    end
+
+    # Wrappers edit_polymorphic_path to be engine aware.
+    def edit_engine_aware_path(model_or_class_or_content_type, options={})
+      edit_polymorphic_path(build_path_for(model_or_class_or_content_type), options)
+    end
+
+    # Wrappers new_polymorphic_path to be engine aware.
+    def new_engine_aware_path(subject, options={})
+      new_polymorphic_path(build_path_for(subject), options)
+    end
+
+    private
+
+    def build_path_for(model_or_class_or_content_type)
+      Cms::EngineAwarePathBuilder.new(model_or_class_or_content_type).build(self)
+    end
+
+  end
+end