browsercms 3.5.7 → 4.0.0.alpha

data/app/helpers/cms/content_block_helper.rb

@@ -32,18 +32,19 @@ module Cms
 
       options = {}
       data = options[:data] = {}
-      data[:status] = block.class.publishable? && !block.published? ? ' draft' : ' published'
+      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_block_path(block))
-      options['data-view_path'] = url_for(block_path(block))
-      options['data-edit_path'] = url_for(block_path(block, :edit))
-      options['data-versions_path'] = url_for(block_path(block, :versions)) if block.class.versioned?
-      options['data-delete_path'] = url_for(block_path(block))
-      options['data-publish_path'] = url_for(block_path(block, :publish)) if block.class.publishable?
+      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
 

data/app/helpers/cms/form_tag_helper.rb

@@ -1,32 +1,28 @@
 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)
+
+    # 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)), &block)
     end
-    
-    def drop_down(object, method, choices, options = {}, html_options = {})
-      select(object, method, choices, options, html_options)
+
+
+    def forecasting_a_new_section?(form_object)
+      Cms::Section.with_path(form_object.object.class.path).first.nil?
     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
+
+    def slug_source_if(boolean)
+      if boolean
+        {input_html: {class: 'slug-source'}}
+      else
+        {}
+      end
     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

@@ -131,7 +131,7 @@ module Cms
           
           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
@@ -139,7 +139,6 @@ module Cms
           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?
@@ -154,7 +153,6 @@ module Cms
              !node.visible_child_nodes.empty?
             item[:children] = fn.call(node.visible_child_nodes, current_depth + 1)
           end
-          
           item
         end
       end

data/app/helpers/cms/mobile_helper.rb

@@ -2,11 +2,21 @@ module Cms
   module MobileHelper
 
     def full_site_url
-      main_app.url_for(:host => Rails.configuration.cms.site_domain, :prefer_full_site => true)
+      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
-      main_app.url_for(:host => Rails.configuration.cms.site_domain, :prefer_mobile_site => true)
+      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.

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

@@ -1,5 +1,27 @@
 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
     #
@@ -13,20 +35,45 @@ module Cms
       end
     end
 
-    # Outputs the title for this page. Used by both internal CMS pages, as well as page templates. If not explicitily set,
-    #   returns the title of the page.
+    # 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] The name this page should be set to.
+    # @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
-        # Removed unneeded indirection/fixed issue where @template is frozen in r1.9.1
-        @page_title = 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 ? @page_title : current_page.page_title
+        page_title
       end
-    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
@@ -37,12 +84,13 @@ module Cms
     # @return [String] The HTML content for the container.
     def container(name)
       content = 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}
+      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    
+    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:
     #
@@ -56,7 +104,7 @@ module Cms
     # @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
+      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
@@ -65,16 +113,6 @@ module Cms
       end
     end
 
-    # Add the code to render the CMS toolbar.
-    def cms_toolbar
-      toolbar = <<HTML
-<iframe src="#{cms.toolbar_path(:page_id => @page.id, :page_version => @page.version, :mode => @mode, :page_toolbar => @show_page_toolbar ? 1 : 0) }" width="100%" height="#{@show_page_toolbar ? 159 : 100 }px" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" name="cms_toolbar"></iframe>
-HTML
-      toolbar.html_safe if @show_toolbar
-    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.
@@ -98,24 +136,24 @@ HTML
       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"} : {}))
+      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.section.path == current_page.path
-        items[items.size-1] = content_tag(:li, current_page.section.name)
+      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
-        @mode == "edit" ? "ERROR: Multiple Portlets with name '#{name}'" : nil
+        edit_mode? ? "ERROR: Multiple Portlets with name '#{name}'" : nil
       elsif portlets.empty?
-        @mode == "edit" ? "ERROR: No Portlet with name '#{name}'" : nil
+        edit_mode? ? "ERROR: No Portlet with name '#{name}'" : nil
       else
         render_connectable(portlets.first)
       end
@@ -127,5 +165,9 @@ HTML
       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

@@ -20,54 +20,12 @@ module Cms
     #
     # @param [Cms::ContentType] content_type
     # @param [String] column_to_sort The name of the column to sort on.
-    def cms_sortable_column_path(content_type, column_to_sort)
+    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))
-      cms_connectable_path(content_type.model_class, filtered_params)
-    end
-
-    # @deprecated Use cms_connectable_path instead.
-    def cms_index_path_for(resource, options={})
-      polymorphic_path(build_path_for(resource), options)
-    end
-
-    # @deprecated Remove all usages of this in favor of cms_index_path_for ()
-    def cms_index_url_for(resource, options={})
-      send("#{resource_collection_name(resource).underscore.pluralize.gsub('/', '_')}_url", options)
-    end
-
-    def cms_new_path_for(resource, options={})
-      new_polymorphic_path(build_path_for(resource), options)
-    end
-
-    # @deprecated Remove all usages of this in favor of cms_new_path_for ()
-    def cms_new_url_for(resource, options={})
-      send("new_#{resource_collection_name(resource).underscore.gsub('/', '_')}_url", options)
-    end
-
-    # @param [Class, String] connectable The model class (i.e. HtmlBlock) or plural collection name (html_blocks) to link to
-    # @param [Hash] options Passed to polymorphic_path
-    #
-    # @return [String] path suitable to give to link_to
-    def cms_connectable_path(connectable, options={})
-      if Portlet === connectable
-        cms.portlet_path(connectable)
-      else
-        polymorphic_path(build_path_for(connectable), options)
-      end
-    end
-
-    # @todo Really needs to be renamed to match conventions for Engines.
-    # In CMS::Engine, should be edit_connectable_path
-    # From app, should be cms.edit_connectable_path
-    def edit_cms_connectable_path(connectable, options={})
-      if Portlet === connectable
-        edit_portlet_path(connectable, options)
-      else
-        edit_polymorphic_path(build_path_for(connectable), options)
-      end
+      polymorphic_path(engine_aware_path(content_type.model_class), filtered_params)
     end
 
     def link_to_usages(block)
@@ -80,7 +38,7 @@ module Cms
                  p = []
                  p << engine_for(block)
                  p << :usages
-                 p.concat path_elements_for(block)
+                 p << block
                  p
                end
         link_to count, path, :id => block.id, :block_type => block.content_block_type
@@ -89,40 +47,58 @@ module Cms
       end
     end
 
-    # Returns the Engine Proxy that this resource is from.
-    def engine_for(resource)
-      EngineHelper.decorate(resource)
-      send(resource.engine_name)
+
+    # 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
 
-    def path_elements_for(resource)
-      EngineHelper.decorate(resource)
-      resource.path_elements
+    # @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
 
-    private
+    # 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
 
-    # Returns the name of the collection that this resource belongs to
-    # the resource can be a ContentType, ActiveRecord::Base instance
-    # or just a string or symbol
-    def resource_collection_name(resource)
-      if resource.respond_to?(:resource_collection_name)
-        return resource.resource_collection_name
-      end
-      case resource
-        when ContentType then
-          resource.route_name
-        when ActiveRecord::Base then
-          resource.class.model_name.demodulize
-        else
-          resource.to_s
-      end
-    end
-
   end
 end