browsercms 3.0.6 → 3.1.0

data/app/controllers/cms/application_controller.rb

@@ -1,8 +1,7 @@
 class Cms::ApplicationController < ApplicationController
   include Cms::Authentication::Controller
   include Cms::ErrorHandling
-
-  helper :all # include all helpers, all the time
+  include Cms::DomainSupport
 
   helper Cms::ApplicationHelper
   helper Cms::FormTagHelper
@@ -11,6 +10,7 @@ class Cms::ApplicationController < ApplicationController
   include Cms::PageHelper
   helper Cms::PageHelper
   helper Cms::MenuHelper
+  helper Cms::RenderingHelper
   
   protected
     def escape_javascript(javascript)
@@ -49,16 +49,6 @@ class Cms::ApplicationController < ApplicationController
       before_filter(opts) do |controller|
         raise Cms::Errors::AccessDenied unless controller.send(:current_user).able_to?(*perms)
       end      
-    end  
-  
-    def cms_domain_prefix
-      "cms"
-    end
-  
-    def cms_site?
-      subdomains = request.subdomains
-      subdomains.shift if subdomains.first == "www"
-      subdomains.first == cms_domain_prefix
     end
   
     def url_with_cms_domain_prefix

data/app/controllers/cms/content_block_controller.rb

@@ -7,7 +7,7 @@ class Cms::ContentBlockController < Cms::BaseController
   before_filter :set_toolbar_tab
   
   helper_method :block_form, :new_block_path, :block_path, :blocks_path, :content_type
-  
+  helper Cms::RenderingHelper
   # Basic REST Crud Action
   
   def index

data/app/controllers/cms/content_controller.rb

@@ -1,8 +1,5 @@
 class Cms::ContentController < Cms::ApplicationController
-
-  rescue_from Exception, :with => :handle_server_error_on_page
-  rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied_on_page
-  rescue_from ActiveRecord::RecordNotFound, :with => :handle_not_found_on_page
+  include Cms::ContentRenderingSupport
 
   skip_before_filter :redirect_to_cms_site
   before_filter :redirect_non_cms_users_to_public_site, :only => [:show, :show_page_route]
@@ -12,6 +9,8 @@ class Cms::ContentController < Cms::ApplicationController
   before_filter :try_to_stream_file,                    :only => [:show]
   before_filter :check_access_to_page,                  :only => [:show, :show_page_route]
 
+
+  
   # ----- Actions --------------------------------------------------------------
   def show
     render_page_with_caching
@@ -21,23 +20,6 @@ class Cms::ContentController < Cms::ApplicationController
     render_page_with_caching
   end
 
-  # ----- Error Handlers -------------------------------------------------------
-  
-  def handle_not_found_on_page(exception)
-    logger.warn "Page Not Found"
-    handle_error_with_cms_page('/system/not_found', exception, :not_found)
-  end
-
-  def handle_access_denied_on_page(exception)
-    logger.warn "Access Denied"
-    handle_error_with_cms_page('/system/access_denied', exception, :forbidden)
-  end
-
-  def handle_server_error_on_page(exception)
-    logger.warn "Exception: #{exception.message}\n"
-    logger.warn "#{exception.backtrace.join("\n")}\n"
-    handle_error_with_cms_page('/system/server_error', exception, :internal_server_error)
-  end
 
   # Used by the rendering behavior
   def instance_variables_for_rendering
@@ -67,68 +49,6 @@ class Cms::ContentController < Cms::ApplicationController
     cache_page if perform_caching
   end
   
-  # This is the method all error handlers delegate to
-  def handle_error_with_cms_page(error_page_path, exception, status, options={})
-
-    # If we are in the CMS, we just want to show the exception
-    if perform_caching
-      return handle_server_error(exception) if cms_site?
-    else
-      return handle_server_error(exception) if current_user.able_to?(:edit_content, :publish_content)
-    end
-    
-    # We must be showing the page outside of the CMS
-    # So we will show the error page
-    if @page = Page.find_live_by_path(error_page_path)
-      logger.info "Rendering Error Page: #{@page.inspect}"
-      @mode = "view"
-      @show_page_toolbar = false
-      
-      # copy new instance variables to the template
-      %w[page mode show_page_toolbar].each do |v|
-        @template.instance_variable_set("@#{v}", instance_variable_get("@#{v}"))
-      end
-      
-      # clear out any content already captured 
-      # by previous attempts to render the page within this request
-      @template.instance_variables.select{|v| v =~ /@content_for_/ }.each do |v|
-        @template.instance_variable_set("#{v}", nil)
-      end
-      
-      prepare_connectables_for_render
-      render :layout => @page.layout, :template => 'cms/content/show', :status => status
-    else
-      handle_server_error(exception)
-    end      
-  end   
-  
-  # If any of the page's connectables (portlets, etc) are renderable, they may have a render method
-  # which does "controller" stuff, so we need to get that run before rendering the page.
-  def prepare_connectables_for_render
-
-    @_connectors = @page.connectors.for_page_version(@page.version)
-    @_connectables = @_connectors.map(&:connectable_with_deleted)
-    unless (logged_in? && current_user.able_to?(:administrate, :edit_content, :publish_content))
-      worst_exception = nil
-      @_connectables.each do |c|
-        begin
-          c.prepare_to_render(self) 
-        rescue
-          logger.debug "THROWN EXCEPTION by connectable #{c}: #{$!}"
-          case $!
-          when ActiveRecord::RecordNotFound
-            raise
-          when Cms::Errors::AccessDenied
-            worst_exception = $!
-          else
-            c.render_exception = $!
-          end
-        end
-      end
-      raise worst_exception if worst_exception
-    end 
-  end 
-
   # ----- Before Filters -------------------------------------------------------
   def construct_path
     @paths = params[:page_path] || params[:path] || []

data/app/controllers/cms/dashboard_controller.rb

@@ -1,7 +1,7 @@
 class Cms::DashboardController < Cms::BaseController
       
   def index
-    @unpublished_pages = Page.unpublished.all(:order => "updated_at desc")
+    @unpublished_pages = Page.unpublished.all(:order => "pages.updated_at desc")
     @unpublished_pages = @unpublished_pages.select { |page| current_user.able_to_publish?(page) }
     @incomplete_tasks = current_user.tasks.incomplete.all(
       :include => :page, 

data/app/controllers/cms/pages_controller.rb

@@ -7,6 +7,8 @@ class Cms::PagesController < Cms::BaseController
   before_filter :hide_toolbar, :only => [:new, :create]
   before_filter :strip_publish_params, :only => [:create, :update]
 
+  helper Cms::RenderingHelper
+  
   def new
     @page = Page.new(:section => @section, :cacheable => true)
     if @section.child_nodes.count < 1

data/app/controllers/tests/pretend_controller.rb

@@ -0,0 +1,32 @@
+# This class exists to provide a test for including page behavior in controllers.
+# I didn't know of a way to add functional tests for controllers/routes that aren't in
+# the apps directory.
+#
+# This should be moved to the test directory if possible.
+class Tests::PretendController < ApplicationController
+  include Cms::Acts::ContentPage
+  
+  requires_permission_for_section "/members", :only=>[:restricted]
+
+  RESTRICTED_H1 = "Restricted"
+
+  def restricted
+    render :text =>"<h1>#{RESTRICTED_H1}</h1> You can see this restricted page."
+  end
+
+  def open
+    render :text =>"<h1>Open Page</h1> You can see this public page."   
+  end
+
+  def error
+    raise StandardError     
+  end
+
+  def not_found
+    raise ActiveRecord::RecordNotFound.new("This thing was missing!")
+  end
+
+  def open_with_layout
+    render :layout=>"templates/subpage"
+  end
+end

data/app/helpers/application_helper.rb

@@ -1,3 +1,5 @@
 # Any code for core CMS should go in /cms/application_helper.rb rather than here.
+#
+# Really, don't anything in here as all BrowserCMS projects will have a generated file that obscures this one.
 module ApplicationHelper
 end

data/app/helpers/cms/application_helper.rb

@@ -42,31 +42,6 @@ module Cms
       text
     end
 
-    def render_connector_and_connectable(connector, connectable)
-      if logged_in? && @mode == "edit" && current_user.able_to_edit?(connector.page)
-        render :partial => 'cms/pages/edit_connector', 
-          :locals => { :connector => connector, :connectable => connectable}
-      else
-        render_connectable(connectable)
-      end
-    end
-    
-    def render_connectable(content_block)
-      if content_block
-        if content_block.class.renderable?
-          logger.info "..... Rendering connectable #{content_block.class} ##{content_block.id} #{"v#{content_block.version}" if content_block.respond_to?(:version)}"
-          content_block.perform_render(@controller)
-        else
-          logger.warn "Connectable #{content_block.class} ##{content_block.id} is not renderable"
-        end
-      else
-        logger.warn "Connectable is null"
-      end    
-    rescue Exception => e
-      logger.error "Error occurred while rendering #{content_block.class}##{content_block.id}: #{e.message}\n#{e.backtrace.join("\n")}"
-      "ERROR: #{e.message}"
-    end
-    
     def action_icon_src(name)
       "cms/icons/actions/#{name}.png"
     end
@@ -79,10 +54,6 @@ module Cms
       image_tag "cms/icons/status/#{status.to_s.underscore}.gif", {:alt => status.to_s.titleize}.merge(options)
     end
     
-    def render_cms_toolbar(tab=:dashboard)
-      render :partial => 'layouts/cms_toolbar', :locals => {:tab => tab}    
-    end
-    
     def link_to_usages(block)
       count = block.connected_pages.count
       if count > 0
@@ -110,9 +81,6 @@ module Cms
       link_to_function name, "$('#{selector}').attr('checked', false)"
     end
     
-    def able_to?(*perms, &block)
-      yield if current_user.able_to?(*perms)
-    end
     
     def span_tag(content)
       content_tag :span, content

data/app/helpers/cms/form_builder.rb

@@ -1,24 +1,34 @@
+#
+# Adds additional form fields to the Rails FormBuilder which can be used to create CMS forms.
+#
 class Cms::FormBuilder < ActionView::Helpers::FormBuilder
-  
-  # These are the new fields we are adding
-  
-  # A JavaScript/CSS styled select
+
+
+  # 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 = {})
-    @template.drop_down(@object_name, method, choices, objectify_options(options), add_tabindex!(@default_options.merge(html_options)))
-  end
+    select_class = "#{@object_name}_#{method}"
+    h_opts = add_tabindex!(@default_options.merge(html_options))
+    h_opts[:class] = select_class
 
-  def text_editor(method, options = {})
-    @template.send(
-      "text_editor",
-      @object_name,
-      method,
-      objectify_options(options))
+    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))
@@ -26,13 +36,13 @@ class Cms::FormBuilder < ActionView::Helpers::FormBuilder
 
   # 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)
+        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
@@ -40,62 +50,129 @@ class Cms::FormBuilder < ActionView::Helpers::FormBuilder
     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)    
+    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  
-    
+                            :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)    
+    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
+    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)    
+    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
+    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
 
-  private
+  # 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
 
-    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
+  # 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
-  
-    def cookies
-      #Ugly, is there an easier way to get to the cookies?
-      @template.instance_variable_get("@_request").cookies || {}
+  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
-  
-    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
+
+  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