browsercms-artirix 4.0.0.rc1.art4

data/app/helpers/cms/rendering_helper.rb

@@ -0,0 +1,112 @@
+##
+# Provides specific helper methods to render content blocks and connectors.
+# Split off from Cms::ApplicationController so it can be included in Cms::Acts::ContentPage
+#
+module Cms
+  module RenderingHelper
+
+    def page_content_iframe(path)
+      content_tag "iframe", "" , src: path, id: 'page_content', frameborder: 0, width: '100%', height: '80%'
+      #<iframe id="page_content" src="<%= url_for engine_aware_path(@block, :inline) %>" frameborder="0" width="100%" height="80%"></iframe>
+
+    end
+    # Renders the content for the given field from the current content block.
+    # Designed to be used in Block Templates instead of direct output of fields.
+    #   Example:
+    #     <pre><%= show :content %></pre>
+    #   Instead of:
+    #     <pre><%= @content_block.content.html_safe %></pre>
+    #
+    # Why bother?: This abstracts the actual variable name (makes future upgrades more robust),
+    #   as well as let us mark up the content with html_safe,
+    #   plus conditionally make fields editable.
+    #
+    # @param [Symbol] method
+    # @param [Hash] options
+    def show(method, options={})
+      if (!is_current_user_able_to_edit_this_content?(@content_block)) # Need to check the current user can edit the page attached to this block too
+        value = @content_block.send(method)
+        value.respond_to?(:html_safe) ? value.html_safe : value
+      else
+        content_tag 'div',
+                    id: random_unique_identifier(),
+                    class: 'content-block',
+                    contenteditable: true,
+                    data: {
+                      content_name: @content_block.content_name,
+                      id: @content_block.id,
+                      attribute: method,
+                      page_id: @page.id
+
+                    } do
+          content = @content_block.send(method)
+          content.to_s.html_safe
+        end
+      end
+
+    end
+
+    # Renders a table of attachments for a given content block.
+    # This is intended as a basic view of the content, and probably won't be suitable for blocks that need to be added directly to pages.
+    #
+    def attachment_viewer(content)
+      render :partial => 'cms/attachments/attachment_table', :locals => {:block => content, :can_delete => false}
+    end
+
+    # Determines if the current user can edit and is currently editing this content.
+    def is_current_user_able_to_edit_this_content?(content)
+      content && logged_in? && edit_mode? && current_user.able_to_edit?(content)
+    end
+
+    # @deprecated
+    alias :is_editing_page? :is_current_user_able_to_edit_this_content?
+
+    def render_connector_and_connectable(connector, connectable)
+      if is_current_user_able_to_edit_this_content?(connector.page)
+        render(:partial => 'cms/pages/edit_content', :locals => {:connector => connector, :connectable => connectable})
+      else
+        render_connectable(connectable)
+      end
+    end
+
+    def render_connectable(content_block)
+      if content_block
+        if content_block.class.renderable?
+          Rails.logger.debug "Rendering connectable #{content_block.class} ##{content_block.id} #{"v#{content_block.version}" if content_block.respond_to?(:version)}"
+          content_block.perform_render(controller)
+        else
+          Rails.logger.warn "Connectable #{content_block.class} ##{content_block.id} is not renderable"
+        end
+      else
+        Rails.logger.warn "Connectable is null"
+      end
+    rescue Exception => e
+      Cms::ErrorHandling::NotifierService.notify e
+      Rails.logger.error "Error occurred while rendering #{content_block.class}##{content_block.id}: #{e.message}\n#{e.backtrace.join("\n")}"
+      "ERROR: #{e.message}"
+    end
+
+    # Some content doesn't have inline editing, so we need to conditionally show move up/down/remove buttons on the page
+    def content_supports_inline_editing?(connector)
+      content = connector.connectable
+      content.supports_inline_editing?
+    end
+    ##
+    # Renders the toolbar for the CMS. All page templates need to include this or they won't be editable.
+    # Typically rendered as an iframe to avoid CSS/JS conflicts.
+    #
+    # @param [Symbol] tab Which tab of the dashboard to highlight. Defaults to :dashboard.
+    #
+    def render_cms_toolbar(tab=:dashboard)
+      render :partial => 'layouts/cms_toolbar', :locals => {:tab => tab}
+    end
+
+    private
+
+    # Each block needs a unique id on the page so CKeditor can attach to it. Doesn't matter what it is though.
+    # This ensure that if the same block is add twice, it will still work.
+    def random_unique_identifier
+      SecureRandom.urlsafe_base64
+    end
+  end
+end

data/app/helpers/cms/section_nodes_helper.rb

@@ -0,0 +1,112 @@
+module Cms
+  module SectionNodesHelper
+
+    def draggable_class?(modifiable_sections, section_node, parent)
+      if !section_node.root? && current_user_can_modify(modifiable_sections, section_node, parent)
+        'draggable'
+      else
+        ''
+      end
+    end
+
+    def add_page_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_page_path(section)
+    end
+
+    def add_link_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_link_path(section)
+    end
+
+    def add_section_path_data(section_node, parent_section_node)
+      section = figure_out_target_section(parent_section_node, section_node)
+      new_section_path(section_id: section)
+    end
+
+    # When sitemap initially renders, we only want to show first level.
+    def initial_visibility_class(section_node)
+      section_node.depth >= 1 ? 'hide' : ''
+    end
+
+    # Returns a css class for determine sitemap depth.
+    def sitemap_depth_class(section_node)
+      one_based_depth = section_node.depth + 1
+      "level-#{one_based_depth}"
+    end
+
+    # Generate HTML for 'hidden' icon for hidden content.
+    # @param [Object] content
+    # @return [String] HTML (HTML safe)
+    def hidden_icon_tag(content)
+      if content.respond_to?(:hidden?) && content.hidden?
+        '<span aria-hidden="true" class="permission-icon icon-eye-blocked"></span>'.html_safe
+      else
+        ''
+      end
+    end
+
+    def guest_accessible_icon_tag(parent, content)
+      if content.accessible_to_guests? @public_sections, parent
+        ''
+      else
+        '<span aria-hidden="true" class="permission-icon icon-locked"></span>'.html_safe
+      end
+    end
+
+    # Generate the HTML for a given section node.
+    def icon_tag(section_node, children)
+      name = if section_node.ancestors.size == 0
+               'earth'
+             elsif section_node.home?
+               'house'
+             elsif section_node.link?
+               'link'
+             elsif section_node.page?
+               'file'
+             elsif section_node.section? && children.empty?
+               'folder-open'
+             elsif section_node.section?
+               'folder'
+             else
+               'list' # All other content types.
+             end
+      content_tag("span", "", {'aria-hidden' => true, class: "type-icon icon-#{name}"})
+    end
+
+    # Marks a section to determine if it can be opened/closed in the sitemap.
+    def closable_data(section_node, children)
+      if section_node.root?
+        false
+      elsif !children.empty?
+        true
+      else
+        false
+      end
+    end
+
+    def current_user_can_modify(modifiable_sections, section_node, parent_section_node)
+      if section_node.section?
+        modifiable_sections.include?(section_node.node)
+      else
+        modifiable_sections.include?(parent_section_node.node)
+      end
+    end
+
+    # Determines if a row is leaf or folder based on whether there are any subchildren.
+    def row_type_tag(section_node)
+      section_node.section? ? 'folder' : 'leaf'
+    end
+
+    private
+
+    # Need to determine if we should be adding content to a node or its parent.
+    def figure_out_target_section(parent_section_node, section_node)
+      if section_node.section?
+        section_node.node
+      else
+        parent_section_node.node
+      end
+    end
+  end
+end

data/app/helpers/cms/sites/authentication_helper.rb

@@ -0,0 +1,25 @@
+module Cms
+  module Sites
+
+    # Override Devise Helpers to point to main_app rather than engine.
+    # Used for public site authentication.
+    module AuthenticationHelper
+
+      def new_session_path(resource_name)
+        main_app.new_cms_user_session_path
+      end
+
+      def session_path(resource_name)
+        main_app.cms_user_session_path
+      end
+
+      def password_path(resource_name)
+        main_app.cms_user_password_path
+      end
+
+      def new_password_path(resource_name)
+        main_app.forgot_password_path
+      end
+    end
+  end
+end

data/app/helpers/cms/sites/devise_shim_helper.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Sites
+
+    # A shim that can be added to Portlet helpers to provide Devise behavior.
+    module DeviseShimHelper
+
+      # Shim to ensure main_app. is available for this helper.
+      def main_app
+        Rails.application.class.routes.url_helpers
+      end
+
+      include DeviseHelper
+
+      # Use public routes (/login) for paths
+      include Cms::Sites::AuthenticationHelper
+
+
+      def resource
+        :cms_user
+      end
+
+      def resource_name
+        :cms_user
+      end
+
+      def devise_mapping
+        @devise_mapping ||= Devise.mappings[:cms_user]
+      end
+    end
+  end
+end

data/app/helpers/cms/template_support.rb

@@ -0,0 +1,18 @@
+# This is a module, not a helper, that is meant to be included
+# into controllers that want to use page templates for their layout
+module Cms
+  module TemplateSupport
+    def self.included(controller)
+      controller.class_eval do
+        include Cms::Authentication::Controller
+        include Cms::ErrorHandling
+        
+        helper Cms::PageHelper
+        helper Cms::MenuHelper
+        helper Cms::RenderingHelper
+
+      end
+    end
+  end
+  
+end

data/app/helpers/cms/ui_elements_helper.rb

@@ -0,0 +1,168 @@
+module Cms
+
+  # Defines functions for creating buttons and links using the CMS styling.
+  # I.e. Menus, Save, Publish buttons and links.
+  module UiElementsHelper
+
+    def cancel_button(location, label="Cancel")
+      klass = ['btn']
+      klass << 'btn-small' if location == :top
+      link_to label, :back, class: klass
+    end
+
+    def button_menu(location)
+      container_class = location == :top ? 'span6 top-buttons' : 'form-actions clearfix'
+      container_element = location == :top ? 'span' : 'div'
+      content_tag container_element, class: container_class do
+        yield if block_given?
+      end
+    end
+
+    def page_title_with_buttons(form, partial_name="buttons")
+      render(partial: partial_name, locals: {f: form, location: :top}, layout: 'page_title')
+    end
+
+    def bottom_buttons(form, partial_name="buttons")
+      render(partial: partial_name, locals: {f: form, location: :bottom}, layout: 'row')
+    end
+
+    # @deprecated Everything below.
+
+    # Renders a Save And Publish button if:
+    # 1. Current User has publish rights
+    # 2. Block is publishable
+    def save_and_publish_button(block, content_type)
+      if current_user.able_to?(:publish_content) && block.publishable?
+        html = %Q{<button type="submit" name="#{content_type.content_block_type.singularize}[publish_on_save]" value="true" class="submit btn btn-primary" tabindex="#{next_tabindex}"><span>Save And Publish</span></button>}
+        html.html_safe
+      end
+    end
+
+    # For simple publish buttons
+    def publish_button(type)
+      html = %Q{<button type="submit" name="#{type}[publish_on_save]" value="true" class="submit btn btn-primary"><span>Save And Publish</span></button>'}
+      html.html_safe
+    end
+
+    # Renders a Publish button for the menu based on whether:
+    #   1. The current user can publish
+    #   2. The content item can or needs to be published.
+    def publish_menu_button(content_item)
+      options = {class: ["btn", "btn-primary", "http_put"], id: "publish_button"}
+      path = "#"
+      if current_user.able_to?(:publish_content) && !content_item.new_record? && content_item.respond_to?(:live?) && !content_item.live?
+        path = engine(@block).polymorphic_path([:publish, @block])
+      else
+        options[:class] << "disabled"
+      end
+      link_to "Publish", path, options
+    end
+
+    def edit_content_menu_button(content_item)
+      path = "#"
+      unless content_item.new_record?
+        path = edit_engine_aware_path(content_item)
+      end
+      link_to "Edit Content", path, class: "btn btn-primary", id: "edit_button"
+    end
+
+    def view_content_menu_button(content_item)
+      path = "#"
+      unless content_item.new_record?
+        path = engine_aware_path(content_item, nil)
+      end
+      link_to "View Content", path, class: "btn btn-primary", id: "view_button"
+    end
+
+
+    # Generic bootstrap based menu button
+    # @param [Hash] options
+    # @option options [Boolean] :enabled
+    # @option options [Array<String>] :class An array of additional classes to apply
+    def menu_button(label, path, options={})
+      defaults = {
+          enabled: true,
+          pull: 'left'
+      }
+      options = defaults.merge!(options)
+      options[:class] = %w{btn btn-primary}
+      if (options[:pull] == 'left' || options[:pull]== 'right')
+        options[:class] << "pull-#{options.delete(:pull)}"
+      end
+
+      options[:class] << 'disabled' unless options[:enabled]
+      options.delete(:enabled)
+      options[:class] << 'http_put' if options[:method] == :put
+      options[:class] << 'http_delete' if options[:method] == :delete
+      options[:class] << 'confirm_with_title' if options[:method] == :delete
+
+      options.delete(:method)
+      copy_title(options, options)
+      link_to(label, path, options)
+    end
+
+    def versions_menu_button(content_item)
+      options = {class: ["btn", "btn-primary"], id: "revisions_button"}
+      path = "#"
+      if !content_item.new_record? && content_item.class.versioned?
+        path = engine(content_item).polymorphic_path([:versions, content_item])
+      else
+        options[:class] << "disabled"
+      end
+      link_to "List Versions", path, options
+    end
+
+    # Render a CMS styled 'Delete' button. This button will appear on tool bars, typically set apart visually from other buttons.
+    # Has a 'confirm?' popup attached to it as well.
+    # Assumes that javascript code to handle the 'confirm' has already been included in the page.
+    #
+    def delete_menu_button(content_item=nil, opts={class: []})
+      classes = ["btn", "http_delete", "confirm_with_title"]
+      if current_user.able_to_publish?(content_item)
+        classes << 'btn-primary'
+      else
+        classes << 'disabled'
+      end
+
+      link_to_path = "#"
+      options = {:id => 'delete_button', :class => classes}
+      options[:class].concat(opts[:class]) if opts[:class]
+
+      if content_item == nil || content_item.new_record?
+        classes << 'disabled'
+      else
+        options[:title] = "Are you sure you want to delete '#{content_item.name}'?"
+        link_to_path = engine_aware_path(content_item, nil)
+      end
+      if opts[:title]
+        options[:title] = opts[:title]
+      end
+      link_to "Delete", link_to_path, options
+    end
+
+    def select_content_type_tag(type, &block)
+      options = {:rel => "select-#{type.param_key}"}
+      if (defined?(content_type) && content_type == type)
+        options[:class] = "on"
+      end
+      content_tag_for(:li, type, nil, options, &block)
+    end
+
+    # Used by Twitter Bootstrap dropdown menus used to divide groups of menu items.
+    # @param [Integer] index
+    def divider_tag(index = 1)
+      content_tag(:li, "&nbsp;", {class: "divider"}) if index != 0
+    end
+
+    def nav_link_to(name, link, options={})
+      content_tag(:li, link_to(name, link, options))
+    end
+
+    private
+
+    def copy_title(from, to)
+      to[:title] = from[:title] if (!from[:title].blank? && from[:title].class == String)
+    end
+
+  end
+end

data/app/helpers/forgot_password_portlet_helper.rb

@@ -0,0 +1,9 @@
+module ForgotPasswordPortletHelper
+
+  # Acts like this is Cms::Sites::PasswordsController
+  def controller_name
+    'passwords'
+  end
+
+  include Cms::Sites::DeviseShimHelper
+end

data/app/helpers/login_portlet_helper.rb

@@ -0,0 +1,10 @@
+module LoginPortletHelper
+
+
+  # Acts like this is Cms::Sites::SessionsController
+  def controller_name
+    'sessions'
+  end
+
+  include Cms::Sites::DeviseShimHelper
+end

data/app/inputs/attachments_input.rb

@@ -0,0 +1,14 @@
+class AttachmentsInput < SimpleForm::Inputs::Base
+
+  def input(_wrapper_options = nil)
+    definitions = Cms::Attachment.definitions_for(object.class.name, :multiple)
+    if definitions.empty?
+      template.render(partial: 'cms/attachments/no_attachments_defined', locals: {object: object})
+    else
+      names = definitions.keys.sort
+      names.unshift "Select a type to upload a file" if names.size > 1
+      template.render(partial: 'cms/attachments/attachment_manager', locals: {:asset_definitions => definitions, :asset_types => names, f: @builder, object: object})
+    end
+  end
+
+end

data/app/inputs/cms_text_area_input.rb

@@ -0,0 +1,10 @@
+# Adds additional options to the TextArea
+# @option [String] :default A default value
+class CmsTextAreaInput < SimpleForm::Inputs::TextInput
+
+  include Cms::FormBuilder::DefaultInput
+  def input(_wrapper_options = nil)
+    extract_default
+    @builder.text_area(attribute_name, input_html_options).html_safe
+  end
+end

data/app/inputs/date_picker_input.rb

@@ -0,0 +1,8 @@
+# Displays a text field with a JQuery DatePicker widget.
+#   1. Allows for empty dates (i.e. no date)
+class DatePickerInput < SimpleForm::Inputs::TextInput
+
+  def input(_wrapper_options = nil)
+    @builder.text_field(attribute_name, input_html_options).html_safe
+  end
+end

data/app/inputs/file_picker_input.rb

@@ -0,0 +1,75 @@
+# Returns a file upload input tag for a given block, along with label and instructions.
+#
+# @param [Symbol] method The name of the model this form upload is associated with
+# @param [Hash] options
+# @option options [String] :label (method) If no label is specified, the human readable name for method will be used.
+# @option options [String] :hint (blank) Helpful tips for the person entering the field, appears blank if nothing is specified.
+class FilePickerInput < SimpleForm::Inputs::Base
+
+  def input(_wrapper_options = nil)
+    # New blocks will not have their attachments created yet.
+    object.ensure_attachment_exists if object.respond_to?(:ensure_attachment_exists)
+
+    # Need to explictly use correct id (i.e. image_block_file) rather than the autogenerated one (i.e. image_block_attachments_attributes_0_attachment_name)
+    # Otherwise <label for=""/> won't be right.
+    tag = ActionView::Helpers::Tags::Base.new(object_name, attribute_name, template, options)
+    tag_id = tag.send(:tag_id)
+
+    html = ""
+    if render_section_picker?
+      sections = sections_with_full_paths
+      sections.each do |s|
+        html << template.content_tag(:span, "", {:class => "section_id_map", style: 'display: hidden', :data => {:id => s.id, :path => s.prependable_path}})
+      end
+    end
+    @builder.simple_fields_for :attachments do |a|
+      if matching_attachment?(a)
+        html << a.hidden_field("attachment_name", value: attribute_name.to_s)
+        html << a.file_field(:data, input_html_options.merge('data-purpose' => "cms_file_field", id: tag_id))
+        html << a.hint(options.delete(:hint)) if has_hint?
+        if render_section_picker?
+          html << a.input(:section_id, collection: sections, label_method: :full_path, include_blank: false, label: "Section", wrapper_html: {class: "inline-section-picker"}, input_html: {'data-purpose' => "section_selector"})
+        end
+        if render_path_input?
+          klass = object.new_record? ? "suggest_file_path" : "keep_existing_path"
+          html << a.input(:data_file_path, label: "Path", wrapper_html: {class: "inline-path"}, input_html: {class: klass})
+        end
+      end
+      html << a.input(:id, as: :hidden, wrapper: false)
+    end
+    html.html_safe
+
+  end
+
+  protected
+
+  # @override Find errors on attachments rather than the provide attribute name.
+  def errors_on_attribute
+    object.errors[:attachment]
+  end
+
+  # Because #attachments holds ALL attachments by all names, need to verify we only render one form control for each one.
+  def matching_attachment?(a)
+    a.object.attachment_name == attribute_name.to_s
+  end
+
+  def render_path_input?
+    object.respond_to?(:set_attachment_path)
+  end
+
+  def render_section_picker?
+    object.respond_to?(:set_attachment_section)
+  end
+
+
+  def sections_with_full_paths
+    root = Cms::Section.root.first
+    root.full_path = root.name
+    sections = []
+    sections << root
+    sections += root.master_section_list
+    sections.each { |s| s.full_path = "/" + s.full_path unless s == root }
+    sections
+  end
+
+end

data/app/inputs/name_input.rb

@@ -0,0 +1,42 @@
+# A text field that is used for the Name fields of content.
+#
+# @example <%= f.name as: :name %>
+#
+# Add the following behaviors above and beyond
+#   1. Will generate a slug if the class requires it. (Requires a as: :path field to work)
+#   2. If no label is specified, it shows a larger than normal input which spans the full row.
+#   3. Labels are turned off by default.
+class NameInput < SimpleForm::Inputs::TextInput
+
+  def initialize(*args)
+    super(*args)
+    options[:label] = false if options[:label].nil?
+    options[:placeholder] = "Name" if options[:placeholder].nil?
+  end
+
+  def input(_wrapper_options = nil)
+    add_slug_source_for_content_that_needs_it
+
+    unless options[:label]
+      input_html_options[:class] << 'input-block-level input-xxlarge'
+    end
+
+    @builder.text_field(attribute_name, input_html_options).html_safe
+  end
+
+  protected
+
+  def add_slug_source_for_content_that_needs_it
+    if should_autogenerate_slug?
+      input_html_options[:class] << 'slug-source'
+    end
+  end
+
+  def should_autogenerate_slug?
+    content_requires_slug_field? && (object.new_record? || (object.name.blank? && object.slug.blank?))
+  end
+
+  def content_requires_slug_field?
+    object.class.requires_slug?
+  end
+end

data/app/inputs/path_input.rb

@@ -0,0 +1,18 @@
+class PathInput < SimpleForm::Inputs::TextInput
+
+  def input(_wrapper_options = nil)
+    if forecasting_a_new_section?
+      options[:hint] = "Forecast: Saving this first #{object.class.display_name} will create a new section at #{object.class.path}."
+    end
+    html = template.content_tag(:span, object.class.base_path, data:{type: 'base-path'})
+    html << @builder.text_field(:slug, class: ['input-xxlarge', 'slug-dest'])
+    html
+  end
+
+  protected
+
+  def forecasting_a_new_section?
+    Cms::Section.with_path(object.class.path).first.nil?
+  end
+
+end

data/app/inputs/tag_list_input.rb

@@ -0,0 +1,3 @@
+class TagListInput < SimpleForm::Inputs::StringInput
+
+end