browsercms 3.4.2 → 3.5.0.rc1

data/doc/release_notes.md

@@ -1,3 +1,62 @@
+v3.5.0
+======
+
+This release includes a number of new features, including:
+
+* Improved Attachments
+* Mobile Friendly templates
+* Rail 3.2 compatibility
+* Improved Heroku support
+
+See the upgrade instructions here for existing projects: https://github.com/browsermedia/browsercms/wiki/Upgrading-to-3.5.x-from-3.4.x
+
+Improved Attachments
+--------------------
+
+Attachments have been completely reworked to use Paperclip (https://github.com/thoughtbot/paperclip).
+
+* Each block can now have multiple attachments using different styles.
+* Attachments can be defined as one to one (has_attachment :image) or be stored as a collection (has_many_attachments :photos).
+* Upgrade migrations are provide to migrate file and data for older projects to the new attachment structure.
+* New generators have been provided to create content blocks with the new attachment styles.
+
+See this Attachments API guide for more details: https://github.com/browsermedia/browsercms/wiki/Attachments-API
+
+Mobile
+------
+
+The CMS can now be configured to serve mobile optimized content, using a mobile subdomain and smart redirecting based on User Agents.
+
+* Mobile Templates: Each template can have a 'mobile' version, which will be used when users request a mobile version of that page.
+* Fallback Templates: Any page which lacks a mobile ready template will use the 'full' desktop template when displayed as mobile.
+* Mobile Subdomain:  Any requests to the mobile subdomain automatically serve mobile pages. m. is the assumed subdomain.
+* Agent Redirection: Users on mobile devices can be automatically redirected to the mobile subdomain. (Handled via Apache User Agent detection.)
+* Mobile Site Opt Out: Users on mobile device can opt to be redirected to the desktop site if they want. (Handled via a cookie)
+* Mobile caching: The mobile and full sites have their own separate page cache, mean both can be served quickly by Apache.
+* View as Mobile: Editors can preview the mobile templates while editing pages in the admin, if a page has a mobile template. Once in 'mobile' mode, all pages should be viewed as mobile until they disable it.
+
+These features are originally from the bcms_mobile module, which has been inlined into the CMS core. See the [Mobile Setup Guide](https://github.com/browsermedia/browsercms/wiki/Setting-up-mobile-sites) for more information.
+
+Improved Heroku Support
+-----------------------
+
+To better support deploying BrowserCMS to Heroku, we have put together a new guide: https://github.com/browsermedia/browsercms/wiki/Deploying-to-Heroku which covers what steps are required, as well as some considerations. For example, using Heroku requires storing files on an external service, so we refactored the core CMS and worked on a new Amazon S3 module (bcms_aws_s3) that will integrate with it.
+
+As a side note, the CMS should work with Postgresql as well, based on our testing with Heroku (which uses Postgres by default).
+
+Notable Fixes
+-------------
+
+* [#493] Add Mobile capability
+* [#494] Speed up Cucumber Scenarios
+* [#492] Upgrade to be Rails 3.2.x compatible
+* [#509] Pagination works for custom blocks now
+* [#508] Remove fancy file upload (probably unused and wasn't working anyway)
+* [#519] Better support for Amazon/AWS S3
+* [#521] Remove SITE_DOMAIN constant in favor of more conventional rails configuration methods
+
+See the [detailed changelog](https://github.com/browsermedia/browsercms/compare/v3.4.0...v3.5.0.rc1) for more info.
+
 v3.4.2
 ======
 
@@ -8,6 +67,13 @@ Maintenance Release
 * [#470] Fix issue where loading throws errors on some OS's (Ubuntu)
 
 
+v3.4.1
+======
+
+Maintenance Release
+
+* [#490] Fix issue where Javascript errors occured when in Page edit mode
+
 v3.4.0
 ======
 
@@ -63,6 +129,14 @@ Other Notable Fixes
 
 See the [detailed changelog](https://github.com/browsermedia/browsercms/compare/v3.3.3...v3.4.0) for a complete list of changes, as well as the [Closed Tickets for 3.4.0](https://github.com/browsermedia/browsercms/issues?milestone=1&state=closed) for a complete list of closed items.
 
+v3.3.4
+======
+
+Maintenance release
+
+* [#503] - Searching and sort content blocks works
+* [#472] - Sorting content blocks works
+
 v3.3.3
 ======
 

data/lib/browsercms.rb

@@ -15,6 +15,9 @@ require 'cms/domain_support'
 require 'cms/authoring'
 require 'cms/date_picker'
 require 'cms/content_rendering_support'
+require 'cms/mobile_aware'
+require 'cms/attachments/configuration'
+require 'cms/default_accessible'
 
 # This shouldn't be necessary, except for the need to get into the loadpath for testing.
 require 'command_line'

data/lib/cms/acts/content_block.rb

@@ -11,13 +11,20 @@ module Cms
         # Adds Content Block behavior to this class
         #
         # @param [Hash] options
+        # @option options [Boolean] :allow_attachments (true) Determines whether this content block can be marked as having attachments.
         def acts_as_content_block(options={})
           defaults = {
-            # Set default values here.
+              # Set default values here.
+              :allow_attachments => true
           }
           options = defaults.merge(options)
 
-          belongs_to_attachment(options[:belongs_to_attachment].is_a?(Hash) ? options[:belongs_to_attachment] : {}) if options[:belongs_to_attachment]
+          if options[:belongs_to_attachment].present?
+            raise ArgumentError.new ":belongs_to_attachment option is no longer supported. Please use :has_attachments option"
+          end
+
+          include Cms::DefaultAccessible
+          allow_attachments if options[:allow_attachments]
           is_archivable(options[:archiveable].is_a?(Hash) ? options[:archiveable] : {}) unless options[:archiveable] == false
           is_connectable(options[:connectable].is_a?(Hash) ? options[:connectable] : {}) unless options[:connectable] == false
           flush_cache_on_change(options[:flush_cache_on_change].is_a?(Hash) ? options[:flush_cache_on_change] : {}) unless options[:flush_cache_on_change] == false
@@ -30,6 +37,7 @@ module Cms
           is_versioned(options[:versioned].is_a?(Hash) ? options[:versioned] : {}) unless options[:versioned] == false
 
           include InstanceMethods
+          extend Cms::Behaviors::Naming
         end
 
         module InstanceMethods

data/lib/cms/addressable.rb

@@ -4,6 +4,10 @@
 module Cms
   module Addressable
 
+    def self.included(model_class)
+      model_class.attr_accessible :parent
+    end
+
     # Returns a list of all Addressable objects that are ancestors to this record.
     # @param [Hash] options
     # @option [Symbol] :include_self If this object should be included in the Array
@@ -57,6 +61,10 @@ module Cms
     # These exist for backwards compatibility to avoid having to change tests.
     # I want to get rid of these in favor of parent and parent_id
     module DeprecatedPageAccessors
+
+      def self.included(model_class)
+        model_class.attr_accessible :section_id, :section
+      end
       include LeafNode
       include NodeAccessors
 

data/lib/cms/attachments/attachment_serving.rb

@@ -0,0 +1,59 @@
+module Cms
+  module Attachments
+
+    # Can be added to Controllers to handle serving files.
+    module Serving
+
+      # Send the file if:
+      #   1. It exists:
+      #   2. The user has permissions to see it.
+      #
+      # The strategy used to send the file can be configured based on the config.cms.attachments.storage parameter.
+      # Default is:
+      #   storage = :filesystem -> Cms::Attachments::FilesystemStrategy
+      def send_attachment(attachment)
+        if attachment
+          raise Cms::Errors::AccessDenied unless current_user.able_to_view?(attachment)
+          strategy_class = send_attachments_with
+          strategy_class.send_attachment(attachment, self)
+        end
+      end
+
+      def send_attachments_with
+        Cms::Attachments::Serving.send_attachments_with
+      end
+
+      # @return [#send_attachments] The strategy that will be used to serve files.
+      def self.send_attachments_with
+        storage = Rails.configuration.cms.attachments.storage
+        "Cms::Attachments::#{storage.to_s.classify}Strategy".constantize
+      end
+
+    end
+
+    class FilesystemStrategy
+
+      def self.attachments_storage_location
+        Rails.configuration.cms.attachments.storage_directory
+      end
+
+      def self.send_attachment(attachment, controller)
+        style = controller.params[:style]
+        style = "original" unless style
+        path_to_file = attachment.path(style)
+        if File.exists?(path_to_file)
+          Rails.logger.debug "Sending file #{path_to_file}"
+          controller.send_file(path_to_file,
+                               :filename => attachment.file_name,
+                               :type => attachment.file_type,
+                               :disposition => "inline"
+          )
+        else
+          msg = "Couldn't find file #{path_to_file}'"
+          Rails.logger.error msg
+          raise ActiveRecord::RecordNotFound.new(msg)
+        end
+      end
+    end
+  end
+end

data/lib/cms/attachments/configuration.rb

@@ -0,0 +1,88 @@
+require 'paperclip'
+require 'cms/attachments/attachment_serving'
+
+module Cms
+  # Cms::Attachments::Configuration exposes an interface to setup paperclip for BrowserCMS.
+  #
+  # Provides defaults that are suitable for the CMS and that probably make sense for most installations.
+  #
+  #This module also declares Paperclip interpolations that are used
+  #to construct the default url and path.
+  #
+  # For example, the default path:
+  #
+  # ":attachments_root/:id_partition/:style/:fingerprint"
+  #
+  # expands to something like:
+  #
+  #  #{Rails.root}/tmp/uploads/2011/1/30/thumb/thcu098rc87dgd
+  #
+  # but can be changed by using paperclip interpolations, either
+  # the ones already defined by Paperlip itself, the Cms::Assets
+  # module, or user defined.
+  module Attachments
+    mattr_accessor :configuration
+
+    def self.configure
+      configuration = self.configuration
+      yield configuration if block_given?
+      @@configuration = configuration
+      Attachment.configure_paperclip
+    end
+
+    def self.configuration
+      @@configuration || Configuration.new
+    end
+
+    # Allows each Attachment to have a customized configuration, even though there is a single Attachment class.
+    # Designed to allow 'typical' Paperclip configuration to be specified per attachment.
+    class Configuration
+      attr_accessor :url, :path, :styles, :processors, :default_url, :default_style, :storage, :whiny
+      attr_accessor :s3_credentials, :bucket
+      attr_accessor :file_permissions
+
+      attr_reader :use_timestamp
+
+      # Set default configurations for Attachments.
+      def initialize
+        self.url = ":attachment_file_path"
+        self.path = ":attachments_root/:id_partition/:style/:fingerprint"
+        self.styles = {}
+        self.processors = [:thumbnail]
+        self.default_url = "/:attachment/:style/missing.png"
+        self.default_style = :original
+        self.storage = :filesystem
+        self.whiny = false
+
+        @use_timestamp = false
+      end
+    end
+
+
+    # This is the typical url for attachments
+    # Some attachments will have a custom path (data_file_path) specified by users
+    # while others will just be 'defaults'. This dynamically returns path at runtime based
+    # on the instance of the specific instance.
+    Paperclip.interpolates :attachment_file_path do |asset, style|
+      path = asset.instance.data_file_path
+      unless path
+        path = "/attachments/#{asset.instance.id}/#{asset.instance.data_file_name}"
+      end
+      if style && style != :original
+        "#{path}?style=#{style}"
+      else
+        path
+      end
+    end
+
+    Paperclip.interpolates :attachments_root do |_, _|
+      strategy = Cms::Attachments::Serving.send_attachments_with
+      strategy.attachments_storage_location
+    end
+
+    Paperclip.interpolates :full_filename do |asset, _|
+      "#{asset.instance.content_block_class}_#{asset.instance.data_file_name}"
+    end
+
+  end
+end

data/lib/cms/behaviors/attaching.rb

@@ -1,207 +1,376 @@
 module Cms
+  # @todo Comments need to be cleaned up to get rid of 'uses_paperclip'
   module Behaviors
+    # Allows one or more files to be attached to content blocks.
+    #
+    # class Book
+    #   acts_as_content_block
+    #   uses_paperclip
+    # end
+    #
+    # It would probably be nice to do something like:
+    #
+    # class Book
+    #   acts_as_content_block :uses_paperclip => true
+    # end
+    #
+    # has_attached_asset and has_many_attached_assets are very similar.
+    # They both define a couple of methods in the content block:
+    #
+    # class Book
+    #   uses_paperclip
+    #
+    #   has_attached_asset :cover
+    #   has_many_attached_assets :drafts
+    # end
+    #
+    #  book = Book.new
+    #  book.cover = nil #is basically calling: book.assets.named(:cover).first
+    #  book.drafts = [] #is calling book.assets.named(:drafts)
+    #
+    #  Book#cover and Book#drafts both return Asset objects as opposed to what
+    #  happens with stand alone Paperclip:
+    #
+    #  class Book
+    #     has_attached_file :invoice #straight Paperclip
+    #  end
+    #
+    #  Book.new.invoice # returns an instance of Paperclip::Attachment
+    #
+    #  However, Asset instances respond to most of the same methods
+    #  Paperclip::Attachments do (at least the most usefull ones and the ones
+    #  that make sense for this implementation). Please see asset.rb for more on
+    #  this.
+    #
+    #  At the moment, calling has_attached_asset does not enforce that only
+    #  one asset is created, it only defines a method that returns the first one
+    #  ActiveRecord finds. It would be possible to do if that makes sense.
+    #
+    #  In terms of validations, I'm aiming to expose the same 3 class methods
+    #  Paperclip exposes, apart from those needed by BCMS itself (like enforcing
+    #  unique attachment paths) but this is not ready yet:
+    #
+    #  validates_asset_size
+    #  validates_asset_presence
+    #  validates_asset_content_type
+    #
     module Attaching
-      SANITIZATION_REGEXES = [[/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, '']]
-      #' this tic cleans up emacs ruby mode
 
-      def self.included(model_class)
-        model_class.extend(MacroMethods)
+      def self.included(base)
+        base.extend MacroMethods
       end
 
       module MacroMethods
-        def belongs_to_attachment?
-          !!@belongs_to_attachment
-        end
 
-        def belongs_to_attachment(options={})
-          @belongs_to_attachment = true
+        # Adds additional behavior to a model which allows it to have attachments.
+        # Typically, clients will not need to call this directly. Enabling attachments is normally done via:
+        #
+        #   acts_as_content_block :allow_attachments => false
+        #
+        ## By default, blocks can have attachments.
+        def allow_attachments
+          extend ClassMethods
+          extend Validations
           include InstanceMethods
-          before_validation :process_attachment
-          before_save :update_attachment_if_changed
-          after_save :clear_attachment_ivars
-          belongs_to :attachment, :dependent => :destroy, :class_name => 'Cms::Attachment'
-
-          validates_each :attachment_file do |record, attr, value|
-            if record.attachment && !record.attachment.valid?
-              record.attachment.errors.each do |err_field, err_value|
-                if err_field.to_sym == :file_path
-                  record.errors.add(:attachment_file_path, err_value)
-                else
-                  record.errors.add(:attachment_file, err_value)
-                end
-              end
-            end
-          end
+
+          # Allows a block to be associated with a list of uploaded attachments (done via AJAX)
+          attr_accessor :attachment_id_list
+
+          Cms::Attachment.definitions[self.name] = {}
+          has_many :attachments, :as => :attachable, :dependent => :destroy, :class_name => 'Cms::Attachment', :autosave => false
+
+          accepts_nested_attributes_for :attachments,
+                                        :allow_destroy => true,
+                                        # New attachments must have an uploaded file
+                                        :reject_if => lambda { |a| a[:data].blank? && a[:id].blank? }
+          attr_accessible :attachments_attributes, :attachment_id_list
+
+          validates_associated :attachments
+          before_validation :initialize_attachments, :check_for_updated_attachments
+          after_validation :filter_generic_attachment_errors
+
+          before_create :associate_new_attachments
+          before_save :ensure_status_matches_attachable
+
+          after_save :save_associated_attachments
+
         end
       end
-      module InstanceMethods
 
-        def attachment_file
-          @attachment_file ||= attachment ? attachment.temp_file : nil
+      #NOTE: Assets should be validated when created individually.
+      module Validations
+        def validates_attachment_size(name, options = {})
+
+          min = options[:greater_than] || (options[:in] && options[:in].first) || 0
+          max = options[:less_than] || (options[:in] && options[:in].last) || (1.0/0)
+          range = (min..max)
+          message = options[:message] || "#{name.to_s.capitalize} file size must be between :min and :max bytes."
+          message = message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+
+          #options[:unless] = Proc.new {|r| r.a.asset_name != name.to_s}
+
+          validate(options) do |record|
+            record.attachments.each do |attachment|
+              next unless attachment.attachment_name == name.to_s
+              record.errors.add_to_base(message) unless range.include?(attachment.data_file_size)
+            end
+          end
         end
 
-        def attachment_file=(file)
-          if @attachment_file != file
-            dirty!
-            @attachment_file = file
+        def validates_attachment_presence(name, options = {})
+          message = options[:message] || "Must provide at least one #{name}"
+          validate(options) do |record|
+            record.errors.add(:attachment, message) unless record.attachments.any? { |a| a.attachment_name == name.to_s }
           end
         end
 
-        def attachment_file_name
-          @attachment_file_name ||= attachment ? attachment.file_name : nil
+        def validates_attachment_content_type(name, options = {})
+          validation_options = options.dup
+          allowed_types = [validation_options[:content_type]].flatten
+          validate(validation_options) do |record|
+            attachments.each do |a|
+              if !allowed_types.any? { |t| t === a.data_content_type } && !(a.data_content_type.nil? || a.data_content_type.blank?)
+                record.add_to_base(options[:message] || "is not one of #{allowed_types.join(', ')}")
+              end
+            end
+
+          end
         end
 
-        def attachment_file_path
-          @attachment_file_path ||= attachment ? attachment.file_path : nil
+        # Define at :set_attachment_path if you would like to override the way file_path is set
+        def handle_setting_attachment_path
+          if self.respond_to? :set_attachment_path
+            set_attachment_path
+          else
+            use_default_attachment_path
+          end
         end
+      end
+
+      module ClassMethods
+
+
+        # Defines an single attachement with a given name.
+        #
+        # @param [Symbol] name The name of the attachment
+        # @param [Hash] options Accepts most Paperclip options for Paperclip::ClassMethods.has_attached_file
+        # @see http://rubydoc.info/gems/paperclip/Paperclip/ClassMethods:has_attached_file
+        def has_attachment(name, options = {})
+          options[:type] = :single
+          options[:index] = Cms::Attachment.definitions[self.name].size
+          Cms::Attachment.definitions[self.name][name] = options
 
-        def attachment_file_path=(file_path)
-          fp = sanitize_file_path(file_path)
-          if @attachment_file_path != fp
-            dirty!
-            @attachment_file_path = fp
+          define_method name do
+            attachment_named(name)
+          end
+          define_method "#{name}?" do
+            (attachment_named(name) != nil)
           end
         end
 
-        def attachment_section_id
-          @attachment_section_id ||= attachment ? attachment.section_id : nil
+        # Allows multiple attachments under a specific name.
+        #
+        # @param [Symbol] name The name of the attachments.
+        # @param [Hash] options Accepts most Paperclip options for Paperclip::ClassMethods.has_attached_file
+        # @see http://rubydoc.info/gems/paperclip/Paperclip/ClassMethods:has_attached_file
+        def has_many_attachments(name, options = {})
+          options[:type] = :multiple
+          Cms::Attachment.definitions[self.name][name] = options
+
+          define_method name do
+            attachments.named name
+          end
+
+          define_method "#{name}?" do
+            !attachments.named(name).empty?
+          end
         end
 
-        def attachment_section_id=(section_id)
-          if @attachment_section_id != section_id
-            dirty!
-            @attachment_section_id = section_id
+        # Find all attachments as of the given version for the specified block. Excludes attachments that were
+        # deleted as of a version.
+        #
+        # @param [Integer] version_number
+        # @param [Attaching] attachable The object with attachments
+        # @return [Array<Cms::Attachment>]
+        def attachments_as_of_version(version_number, attachable)
+          found_versions = Cms::Attachment::Version.where(:attachable_id => attachable.id).
+              where(:attachable_type => attachable.attachable_type).
+              where(:attachable_version => version_number).
+              order(:version).all
+          found_attachments = []
+
+          found_versions.each do |av|
+            record = av.build_object_from_version
+            found_attachments << record
           end
+          found_attachments.delete_if { |value| value.deleted? }
+          found_attachments
         end
 
-        def attachment_section
-          @attachment_section ||= attachment ? attachment.section : nil
+        # Return all definitions for a given class.
+        def definitions_for(name)
+          Cms::Attachment.definitions[self.name][name]
         end
+      end
 
-        def attachment_section=(section)
-          if @attachment_section != section
-            dirty!
-            @attachment_section_id = section ? section.id : nil
-            @attachment_section = section
+      module InstanceMethods
+
+        # This ensures that if a change is made to an attachment, that this model is also marked as changed.
+        # Otherwise, if the change isn't detected, this record won't save a new version (since updates are rejected if no changes were made)
+        def check_for_updated_attachments
+          attachments.each do |a|
+            if a.changed?
+              changed_attributes['attachments'] = "Uploaded new files"
+            end
           end
         end
 
-        def process_attachment
-          Rails.logger.warn "Processing attachment (#{attachment_file})"
-          if attachment.nil? && attachment_file.blank?
-            unless attachment_file_path.blank?
-              errors.add(:attachment_file, "You must upload a file")
-              return false
-            end
-            unless attachment_section_id.blank?
-              errors.add(:attachment_file, "You must upload a file")
-              return false
-            end
-          else
-            build_attachment if attachment.nil?
-            attachment.temp_file = attachment_file
-            handle_setting_attachment_path
-            if attachment.file_path.blank?
-              errors.add(:attachment_file_path, "File Name is required for attachment")
-              return false
-            end
-            handle_setting_attachment_section
-            unless attachment.section
-              errors.add(:attachment_file, "Section is required for attachment")
-              return false
-            end
+        # Returns a list of all attachments this content type has defined.
+        # @return [Array<String>] Names
+        def attachment_names
+          Cms::Attachment.definitions[self.class.name].keys
+        end
 
-          end
+        def after_publish
+          attachments.each &:publish
         end
 
-        # Define at :set_attachment_path if you would like to override the way file_path is set
-        def handle_setting_attachment_path
-          if self.respond_to? :set_attachment_path
-            set_attachment_path
-          else
-            use_default_attachment_path
-          end
+        # Locates the attachment with a given name
+        # @param [Symbol] name The name of the attachment
+        def attachment_named(name)
+          attachments.select { |item| item.attachment_name.to_sym == name }.first
         end
 
-        def clear_attachment_ivars
-          @attachment_file = nil
-          @attachment_file_path = nil
-          @attachment_section_id = nil
-          @attachment_section = nil
+        def unassigned_attachments
+          return [] if attachment_id_list.blank?
+          Cms::Attachment.find attachment_id_list.split(',').map(&:to_i)
         end
 
-        # Implement a :set_attachment_section method  if you would like to override the way the section is set
-        def handle_setting_attachment_section
-          if self.respond_to? :set_attachment_section
-            set_attachment_section
-          else
-            use_default_attachment_section
-          end
+        def all_attachments
+          attachments << unassigned_attachments
+        end
+
+        def attachable_type
+          self.class.name
         end
 
-        # Default behavior for assigning a section, if a block does not define its own.
-        def use_default_attachment_section
-          if !attachment_file.blank?
-            attachment.section = Cms::Section.root.first
+        # Versioning Callback - This will result in a new version of attachments being created every time the attachable is updated.
+        #   Allows a complete version history to be reconstructed.
+        # @param [Versionable] new_version
+        def after_build_new_version(new_version)
+          attachments.each do |a|
+            a.attachable_version = new_version.version
           end
         end
 
-        def use_default_attachment_path
-          if !attachment_file.blank?
-            attachment.file_path = "/attachments/#{File.basename(attachment_file.original_filename).to_s.downcase}"
+        # Version Callback - Reconstruct this object exactly as it was as of a particularly version
+        # Called after the object is 'reset' to the specific version in question.
+        def after_as_of_version()
+          @attachments_as_of = self.class.attachments_as_of_version(version, self)
+
+
+          # Override #attachments to return the original attachments for the current version.
+          metaclass = class << self;
+            self;
+          end
+          metaclass.send :define_method, :attachments do
+            @attachments_as_of
           end
         end
 
-        def sanitize_file_path(file_path)
-          SANITIZATION_REGEXES.inject(file_path.to_s) do |s, (regex, replace)|
-            s.gsub(regex, replace)
+        # Callback - Ensure attachments get reverted whenver a block does.
+        def after_revert(version)
+          version_number = version.version
+          attachments.each do |a|
+            a.revert_to(version_number, {:attachable_version => self.version+1})
           end
         end
 
-        def update_attachment_if_changed
-          logger.debug { "UPDATE ATTACHMENT if changed" }
-          if attachment
-            attachment.archived = archived if self.class.archivable?
-            if respond_to?(:revert_to_version) && revert_to_version
-              attachment.revert_to(revert_to_version.attachment_version)
-            elsif new_record? || attachment.changed? || attachment.temp_file
-              saved_attach = attachment.save
-              logger.warn "Attachment was saved = #{saved_attach}"
+        # Ensures that attachments exist for form, since it uses attachments.each to iterate over them.
+        #   Design Qualm: I don't like that this method has to exist, since its basically obscuring the fact that
+        #   individual attachments don't exist when an object is created.
+        def ensure_attachment_exists
+          attachment_names.each do |n|
+            unless attachment_named(n.to_sym)
+              # Can't use attachments.build because sometimes its an array
+              attachments << Attachment.new(:attachment_name => n, :attachable => self)
             end
-            self.attachment_version = attachment.draft.version
           end
         end
 
-        def after_publish
-          attachment.publish if attachment
+        # @return [Array<Cms::Attachment>]
+        def multiple_attachments
+          attachments.select { |a| a.cardinality == Attachment::MULTIPLE }
         end
 
-        #Size in kilobytes
-        def file_size
-          attachment ? "%0.2f" % (attachment.file_size / 1024.0) : "?"
+        private
+
+        # Saves associated attachments if they were updated. (Used in place of :autosave=>true, since the CMS Versioning API seems to break that)
+        #
+        # ActiveRecord Callback
+        def save_associated_attachments
+          attachments.each do |a|
+            a.save if a.changed?
+          end
         end
 
-        def after_as_of_version
-          if attachment_id && attachment_version
-            self.attachment = Cms::Attachment.find(attachment_id).as_of_version(attachment_version)
+
+        # Filter - Ensures that the status of all attachments matches the this block
+        def ensure_status_matches_attachable
+          if self.class.archivable?
+            attachments.each do |a|
+              a.archived = self.archived
+            end
+          end
+
+          if self.class.publishable?
+            attachments.each do |a|
+              a.publish_on_save = self.publish_on_save
+            end
           end
         end
 
-        def attachment_link
-          if attachment
-            (published? && live_version?) ? attachment_file_path : "/cms/attachments/#{attachment_id}?version=#{attachment_version}"
-          else
-            nil
+        # Handles assigning attachments that were created via use of
+        # the cms_asset manager.
+        #
+        # Since Attachments are created via AJAX, we need to go back and associate those with this Attaching object.
+        def associate_new_attachments
+          unless attachment_id_list.blank?
+            ids = attachment_id_list.split(',').map(&:to_i)
+            ids.each do |i|
+              begin
+                attachment = Cms::Attachment.find(i)
+              rescue ActiveRecord::RecordNotFound
+              end
+
+              # Previously saved attachments shouldn't have an attachable_version or attachable_id yet.
+              if attachment
+                attachment.attachable_version = self.version
+                attachments << attachment
+              end
+
+            end
           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
-        def dirty!
-          # Seems like a hack, is there a better way?
-          self.updated_at = Time.now
+        # We don't want errors like: Attachments is invalid showing up, since they are duplicates
+        def filter_generic_attachment_errors
+          filter_errors_named([:attachments])
         end
 
+        def initialize_attachments
+          attachments.each { |a| a.attachable_class = self.class.name }
+        end
+
+
+        private
+        def filter_errors_named(filter_list)
+          filtered_errors = self.errors.reject { |err| filter_list.include?(err.first) }
+
+          # reset the errors collection and repopulate it with the filtered errors.
+          self.errors.clear
+          filtered_errors.each { |err| self.errors.add(*err) }
+        end
       end
     end
   end