browsercms 3.5.7 → 4.0.0.alpha

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
+    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
+    extract_default
+    @builder.text_area(attribute_name, input_html_options).html_safe
+  end
+end

data/app/inputs/cms_text_field_input.rb

@@ -0,0 +1,29 @@
+# Adds additional attributes to text field.
+class CmsTextFieldInput < SimpleForm::Inputs::TextInput
+
+  include Cms::FormBuilder::DefaultInput
+
+  # @todo Generating a slug probably shouldn't be done as a side effect of a :name field.
+  def input
+
+    if should_autogenerate_slug?(attribute_name)
+      input_html_options[:class] << 'slug-source'
+    end
+
+    extract_default
+    html = @builder.text_field(attribute_name, input_html_options).html_safe
+
+    html
+  end
+
+
+  protected
+
+  def should_autogenerate_slug?(method)
+    content_requires_slug_field?(method) && (object.new_record? || (object.name.blank? && object.slug.blank?))
+  end
+
+  def content_requires_slug_field?(method)
+    method == :name && object.class.requires_slug?
+  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
+    @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
+    # 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/path_input.rb

@@ -0,0 +1,18 @@
+class PathInput < SimpleForm::Inputs::TextInput
+
+  def input
+    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

data/app/inputs/template_editor_input.rb

@@ -0,0 +1,24 @@
+class TemplateEditorInput < SimpleForm::Inputs::TextInput
+
+  include Cms::FormBuilder::DefaultInput
+
+  def label
+    super if render_template_input?
+  end
+
+  def input
+    if render_template_input?
+      options[:default] = object.class.default_template
+      options[:default_handler] = "erb" unless options[:default_handler]
+      view = @builder.select "#{attribute_name}_handler", ActionView::Template.template_handler_extensions, selected: options[:default_handler]
+      view << '<br />'.html_safe
+      extract_default
+      view << @builder.text_area(attribute_name, input_html_options).html_safe
+    end
+  end
+
+  private
+  def render_template_input?
+    object.class.render_inline
+  end
+end

data/app/inputs/text_editor_input.rb

@@ -0,0 +1,19 @@
+class TextEditorInput < SimpleForm::Inputs::TextInput
+
+  def input
+    tag_id = "#{object_name}_#{attribute_name}"
+    s = template.select_tag(:dhtml_selector,
+                                  template.options_for_select([["Rich Text", ""],["Simple Text", "disabled"]],
+                                  template.cookies[:editorEnabled] == 'true' ? "" : "disabled"),
+                                  :class => "#{object_name}_#{attribute_name}_dhtml_selector",
+                                  :tabindex => '-1',
+                                  :onchange => "toggleEditor('#{tag_id}', this)".html_safe)
+    s += template.content_tag(:div, super, class: 'editor')
+
+  end
+
+  # Mark textarea with class for WYSIWYG editor.
+  def input_html_classes
+    super.push('editor')
+  end
+end

data/app/models/cms/abstract_file_block.rb

@@ -1,16 +1,20 @@
 module Cms
   class AbstractFileBlock < ActiveRecord::Base
+    self.table_name = "cms_file_blocks"
 
+    def self.with_parent_id(parent_id)
+      if parent_id == 'all'
+        where(true) # Empty scope for chaining
+      else
+        self.includes({:attachments => :section_node})
+            .references(:section_node)
+            .where(["#{"cms_section_nodes"}.ancestry = ?",  Section.find(parent_id).ancestry_path])
 
-    self.table_name = Namespacing.prefix("file_blocks")
+      end
+    end
 
     validates_presence_of :name
 
-    scope :by_section, lambda { |section| {
-        :include => {:attachments => :section_node},
-        :conditions => ["#{SectionNode.table_name}.ancestry = ?", section.node.ancestry_path]}
-    }
-
     # Return the parent section for this block.
     # @return [Cms::Section]
     def parent

data/app/models/cms/attachment.rb

@@ -11,8 +11,6 @@ module Cms
     cattr_accessor :definitions, :instance_writer => false
     @@definitions = {}.with_indifferent_access
     cattr_reader :configuration
-    attr_accessor :attachable_class
-    attr_accessible :attachable_class
 
     before_validation :set_cardinality
     before_save :set_section, :sanitized_file_path_and_name
@@ -20,28 +18,20 @@ module Cms
 
     belongs_to :attachable, :polymorphic => true
 
-    include DefaultAccessible
-    attr_accessible :data, :attachable, :attachment_name
+    extend DefaultAccessible
 
     validates :attachment_name, :attachable_type, :presence => true
 
-    include Cms::Addressable
-    include Cms::Addressable::DeprecatedPageAccessors
-    has_one :section_node, :as => :node, :class_name => 'Cms::SectionNode'
-    alias :node :section_node
+    is_addressable
+    include Cms::Concerns::Addressable::DeprecatedPageAccessors
 
     is_archivable; is_publishable; uses_soft_delete; is_userstamped; is_versioned
 
-    #TODO change this to a simple method
-    #def named(mid)
-    # find_all_by_name mid
-    # end
-    # ...or even get rid of it
     scope :named, lambda { |name|
       {:conditions => {:attachment_name => name.to_s}}
     }
 
-    scope :multiple, :conditions => {:cardinality => MULTIPLE}
+    scope :multiple, -> {where(:cardinality => MULTIPLE)}
 
     FILE_BLOCKS = "Cms::AbstractFileBlock"
     validates_presence_of :data_file_path, :if => Proc.new { |a| a.attachable_type == FILE_BLOCKS }
@@ -49,6 +39,9 @@ module Cms
 
     class << self
 
+      def permitted_params
+        super + [:attachable_class, :data]
+      end
       # Makes file paths more URL friendly
       def sanitize_file_path(file_path)
         SANITIZATION_REGEXES.inject(file_path.to_s) do |s, (regex, replace)|
@@ -104,7 +97,8 @@ module Cms
                           :whiny => configuration.whiny,
                           :storage => rail_config(:storage),
                           :s3_credentials => rail_config(:s3_credentials),
-                          :bucket => rail_config(:s3_bucket)
+                          :bucket => rail_config(:s3_bucket),
+                          :s3_host_alias => rail_config(:s3_host_alias)
 
       end
 
@@ -117,11 +111,10 @@ module Cms
       # @param [Class] block_class The class of a block which has an attachment.
       # @param [String] name_of_attachment The name of the attachment association (i.e. if was 'has_attachment :photos' then pass 'photo')
       # @param [Symbol] key The key for the value to be fetched (i.e. :styles)
-      #
       def configuration_value(block_class, name_of_attachment, key)
         class_definitions = definitions[block_class]
         if class_definitions == nil
-          raise "Couldn't find any definitions for '#{block_class}'."
+          raise "Couldn't find any definitions for '#{block_class}'. Available definitions are #{definitions.inspect}."
         end
         attachment_definition = class_definitions[name_of_attachment]
         if attachment_definition == nil
@@ -132,6 +125,14 @@ module Cms
 
     end
 
+    def attachable_class
+      attachable_type
+    end
+
+    # @todo There isn't any good reason I know of why this needs to be a distinct field. Needed to add it to get it working for 4.0 though.
+    def attachable_class=(klass)
+      self.attachable_type = klass
+    end
 
     def section=(section)
       dirty! if self.section != section
@@ -143,7 +144,8 @@ module Cms
     end
 
     def content_block_class
-      attachable_class || attachable.try(:class).try(:name) || attachable_type
+      attachable.try(:class).try(:name) || attachable_type
+      #attachable_class || attachable.try(:class).try(:name) || attachable_type
     end
 
     def icon
@@ -260,14 +262,5 @@ module Cms
       end
 
     end
-
-    # Forces this record to be changed, even if nothing has changed
-    # This is necessary if just the section.id has changed, for example
-    # test if this is necessary now that the attributes are in the
-    # model itself.
-    def dirty!
-      # Seems like a hack, is there a better way?
-      self.updated_at = Time.now
-    end
   end
 end

data/app/models/cms/category.rb

@@ -4,18 +4,28 @@ module Cms
     belongs_to :parent, :class_name => 'Cms::Category'
     has_many :children, :class_name => 'Cms::Category', :foreign_key => "parent_id"
     is_searchable
+    has_content_type :module => :categorization
 
-    include DefaultAccessible
-
-    attr_accessible :category_type
+    extend DefaultAccessible
+    include Concerns::IgnoresPublishing
 
     validates_presence_of :category_type_id, :name
     validates_uniqueness_of :name, :scope => :category_type_id
 
-    scope :named, lambda { |name| {:conditions => ["#{table_name}.name = ?", name]} }
-    scope :of_type, lambda { |type_name| {:include => :category_type, :conditions => ["#{CategoryType.table_name}.name = ?", type_name], :order => "#{Category.table_name}.name"} }
-    scope :top_level, :conditions => ["#{Category.table_name}.parent_id is null"]
-    scope :list, :include => :category_type
+    class << self
+      def named(name)
+        where(["#{table_name}.name = ?", name])
+      end
+
+      def of_type(type_name)
+        where(["#{CategoryType.table_name}.name = ?", type_name])
+        .order("#{Category.table_name}.name")
+        .includes(:category_type)
+        .references(:category_type)
+      end
+    end
+    scope :top_level, -> { where(["#{Category.table_name}.parent_id is null"]) }
+    scope :list, -> { includes(:category_type) }
 
     def ancestors
       fn = lambda do |cat, parents|

data/app/models/cms/category_type.rb

@@ -1,13 +1,17 @@
 module Cms
   class CategoryType < ActiveRecord::Base
-    attr_accessible :name
 
     has_many :categories, :class_name => 'Cms::Category'
     validates_presence_of :name
     validates_uniqueness_of :name
     is_searchable
+    has_content_type :module => :categorization
 
-    scope :named, lambda { |name| {:conditions => ["#{table_name}.name = ?", name]} }
+    include Concerns::IgnoresPublishing
+
+    def self.named(name)
+      where(name: name)
+    end
 
     # Return a map when the key is category type id as a string
     # and the value is an array of arrays, each entry having
@@ -25,9 +29,9 @@ module Cms
       list = []
       fn = lambda do |cat|
         list << cat
-        cat.children.all(:order => order).each { |c| fn.call(c) }
+        cat.children.order(order).each { |c| fn.call(c) }
       end
-      categories.top_level.all(:order => order).each { |cat| fn.call(cat) }
+      categories.top_level.order(order).each { |cat| fn.call(cat) }
       list
     end
 

data/app/models/cms/connector.rb

@@ -4,30 +4,42 @@ module Cms
     belongs_to :page, :class_name => 'Cms::Page'
     belongs_to :connectable, :polymorphic => true
 
-    include DefaultAccessible
-    attr_accessible :connectable, :page_version, :connectable_version, :container # Need to be explicit due to seed data loading
+    extend DefaultAccessible
+    #attr_accessible :connectable, :page_version, :connectable_version, :container # Need to be explicit due to seed data loading
 
     acts_as_list :scope => "#{Connector.table_name}.page_id = \#{page_id} and #{Cms::Connector.table_name}.page_version = \#{page_version} and #{Cms::Connector.table_name}.container = '\#{container}'"
     alias :move_up :move_higher
     alias :move_down :move_lower
 
-    scope :for_page_version, lambda { |pv| {:conditions => {:page_version => pv}} }
-    scope :for_connectable_version, lambda { |cv| {:conditions => {:connectable_version => cv}} }
-    scope :for_connectable, lambda { |c|
-#    puts "Finding for_connectable for #{c.id} and #{c.class.base_class.name}"
-      {:conditions => {:connectable_id => c.id, :connectable_type => c.class.base_class.name}}
-    }
-    scope :in_container, lambda { |container| {:conditions => {:container => container}} }
-    scope :at_position, lambda { |position| {:conditions => {:position => position}} }
-    scope :like, lambda { |connector|
-      {:conditions => {
-          :connectable_id => connector.connectable_id,
-          :connectable_type => connector.connectable_type,
-          :connectable_version => connector.connectable_version,
-          :container => connector.container,
-          :position => connector.position
-      }}
-    }
+    class << self
+      def for_page_version(pv)
+        where(:page_version => pv)
+      end
+
+      def for_connectable_version(cv)
+        where(:connectable_version => cv)
+      end
+
+      def for_connectable(c)
+        where(:connectable_id => c.id, :connectable_type => c.class.base_class.name)
+      end
+
+      def in_container(container)
+        where(:container => container)
+      end
+
+      def at_position(position)
+        where(:position => position)
+      end
+
+      def like(connector)
+        where(:connectable_id => connector.connectable_id,
+              :connectable_type => connector.connectable_type,
+              :connectable_version => connector.connectable_version,
+              :container => connector.container,
+              :position => connector.position)
+      end
+    end
 
     validates_presence_of :page_id, :page_version, :connectable_id, :connectable_type, :container
 
@@ -41,7 +53,7 @@ module Cms
 
     def connectable_with_deleted
       c = if connectable_type.constantize.respond_to?(:find_with_deleted)
-            connectable_type.constantize.find_with_deleted(connectable_id)
+            connectable_type.constantize.find_with_deleted(id: connectable_id)
           else
             connectable_type.constantize.find(connectable_id)
           end