browsercms-artirix 4.0.0.rc1.art4

data/lib/cms/behaviors/attaching.rb

@@ -0,0 +1,363 @@
+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 < ActiveRecord::Base
+    #   acts_as_content_block
+    #   has_attachment :cover
+    # end
+    #
+    #
+    # To add a set of multiple attachments:
+    #
+    # class Book
+    #   acts_as_content_block
+    #
+    #   has_attachment :cover
+    #   has_many_attachments :drafts
+    # end
+    #
+    #  Adds the following methods to Book:
+    #  - Book#cover @return [Cms::Attachment]
+    #  - Book#drafts @return [Array<Cms::Attachment>]
+    #
+    module Attaching
+
+      def self.included(base)
+        base.extend MacroMethods
+      end
+
+      module MacroMethods
+
+        # 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
+
+          # Allows a block to be associated with a list of uploaded attachments (done via AJAX)
+          attr_accessor :attachment_id_list, :attachments_changed
+
+          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? }
+
+          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
+
+      #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 validates_attachment_presence(name, options = {})
+          message = options[:message] || "Must provide at least one #{name}"
+          validate(options) do |record|
+            return if record.deleted?
+            unless record.attachments.any? { |a| a.attachment_name == name.to_s }
+              record.errors.add(:attachment, message)
+            end
+          end
+        end
+
+        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
+
+        # Define the #set_attachment_path method if you would like to override the way file_path is set.
+        # A path input will be rendered for content types having #set_attachment_path.
+        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
+
+        # Finds all instances of this Attaching content that exist in a given section.
+        # @param [Cms::Section] section
+        # @return [ActiveRecord::Relation] A relation that will return Attaching instances.
+        def by_section(section)
+          where(["#{SectionNode.table_name}.ancestry = ?", section.node.ancestry_path])
+            .includes(:attachments => :section_node)
+            .references(:section_nodes)
+        end
+
+        # 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
+
+          define_method name do
+            attachment_named(name)
+          end
+          define_method "#{name}?" do
+            (attachment_named(name) != nil)
+          end
+        end
+
+        # 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
+
+        # 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).load
+          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
+
+        # Return all definitions for a given class.
+        def definitions_for(name)
+          Cms::Attachment.definitions[self.name][name]
+        end
+      end
+
+      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
+          if attachments_changed == "true" || attachments_were_updated?
+            changed_attributes['attachments'] = "Uploaded new files"
+          end
+        end
+
+        def attachments_were_updated?
+          attachments.each do |a|
+            if a.changed?
+              return true
+            end
+          end
+          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
+
+        def after_publish
+          attachments.each &:publish
+        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 unassigned_attachments
+          return [] if attachment_id_list.blank?
+          Cms::Attachment.find attachment_id_list.split(',').map(&:to_i)
+        end
+
+        def all_attachments
+          attachments << unassigned_attachments
+        end
+
+        def attachable_type
+          self.class.name
+        end
+
+        # 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
+
+        # 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
+
+        # 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
+
+        # 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
+          end
+        end
+
+        # @return [Array<Cms::Attachment>]
+        def multiple_attachments
+          attachments.select { |a| a.cardinality == Attachment::MULTIPLE }
+        end
+
+        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
+          logger.warn "save_associated_attachments #{attachments}"
+          attachments.each do |a|
+            a.save if a.changed?
+          end
+        end
+
+
+        # 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
+
+        # 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
+
+        # 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.attachable_type }
+        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
+end

data/lib/cms/behaviors/categorizing.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Behaviors
+    module Categorizing
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def belongs_to_category?
+          !!@belongs_to_category
+        end
+        def belongs_to_category
+          @belongs_to_category = true
+          extend ClassMethods
+          include InstanceMethods
+          
+          belongs_to :category, :class_name => 'Cms::Category'
+          
+          scope :in_category, lambda{|cat| {:conditions => ["category_id = ?", cat.id]}}
+          
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def category_name
+          category && category.name
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/connecting.rb

@@ -0,0 +1,141 @@
+module Cms
+  module Behaviors
+    module Connecting
+
+      def self.default_naming_for(klass)
+        klass.name.demodulize.titleize
+      end
+
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def connectable?
+          !!@is_connectable
+        end
+
+        def is_connectable(options={})
+          @is_connectable = true
+          extend ClassMethods
+          include InstanceMethods
+
+          attr_accessor :connect_to_page_id, :connect_to_container, :connected_page
+          #attr_accessible :connect_to_page_id, :connect_to_container,:connected_page
+
+          has_many :connectors, :as => :connectable, :class_name => 'Cms::Connector'
+
+          attr_accessor :updated_by_page
+
+          after_create :connect_to_page
+          after_save :update_connected_pages, :unless => :skip_callbacks
+
+
+        end
+      end
+      module ClassMethods
+
+        def content_block_type
+          ::ActiveModel::Naming.singular(self)
+        end
+
+        def display_name
+          Connecting.default_naming_for(self)
+        end
+
+        def display_name_plural
+          display_name.pluralize
+        end
+      end
+      module InstanceMethods
+
+        # Returns a machine readable key that identifies the type of content this is.
+        # Should match the key passed to ContentType.find_by_key
+        def content_name
+          class_name = self.class.name
+          if class_name.starts_with?("Cms::")
+            class_name.demodulize.underscore
+          else
+            class_name.underscore
+          end
+        end
+
+        def connected_pages
+          return @connected_pages if @connected_pages
+          @connected_pages = Page.connected_to(self)
+        end
+
+        def connected_page_count
+          Page.currently_connected_to(self).count
+        end
+
+        def content_block_type
+          self.class.content_block_type
+        end
+
+        def display_name
+          self.class.display_name
+        end
+
+        def display_name_plural
+          self.class.display_name_plural
+        end
+
+        def connect_to_page
+          unless connect_to_page_id.blank? || connect_to_container.blank?
+            #Note that we are setting connected_page so that page can look at that 
+            #to determine if the page should be published            
+            self.connected_page = Page.find(connect_to_page_id)
+            connected_page.create_connector(self, connect_to_container)
+          end
+          true
+        end
+
+        # By default, all content types will support inline editing. Subclasses can override this.
+        def supports_inline_editing?
+          true
+        end
+
+        #
+        # After blocks are updated, all pages they are connected to should also be updated,
+        # connecting the page to the new version of the block, as well as putting the pages into
+        # draft status if necessary.
+        #
+        def update_connected_pages
+          # If this is versioned, then we need make new versions of all the pages this is connected to
+          if self.class.versioned?
+            #logger.info "..... Updating connected pages for #{self.class} #{id} v#{version}"
+
+            #Get all the pages the previous version of this connectable was connected to
+            draft_version = draft.version
+            connected_pages = Page.connected_to(:connectable => self, :version => (draft_version - 1)).to_a
+#            puts "Found #{connected_pages}"
+            connected_pages.each do |p|
+              # This is needed in the case of updating page,
+              # which updates this object, so as not to create a loop
+              if p != updated_by_page
+                #This just creates a new version of the page
+                action = deleted? ? "Deleted" : "Edited"
+                p.update_attributes(:version_comment => "#{self.class.name.demodulize} ##{id} was #{action}", :publish_on_save => false)
+
+                #The previous step will copy over a connector pointing to the previous version of this connectable
+                #We need to change that to point at the new version of this connectable
+                connectors_for_page = p.connectors
+                #                puts "cfp #{connectors_for_page}"
+                page_draft_version = p.draft.version
+                cnn = connectors_for_page.for_page_version(page_draft_version)
+                #                puts "Connectors for page version #{page_draft_version} are #{cnn.all}"
+                connectors = cnn.for_connectable(self)
+                #                puts "Found connectors #{connectors.all}"
+                connectors.each do |con|
+                  con.update_attribute(:connectable_version, draft_version)
+                end
+              end
+            end
+          end
+          true
+        end
+      end
+    end
+  end
+end