browsercms-artirix 4.0.0.rc1.art4

data/lib/cms/behaviors/dynamic_attributes.rb

@@ -0,0 +1,384 @@
+module Cms
+  module Behaviors
+    # The DynamicAttributes behavior allows a model to store values for any attributes.
+    # A model that uses DynamicAttributes should have corresponding "_attributes" table
+    # where it stores the values for the dynamic attributes.
+    # This is based on the {Flex Attributes Rails Plugin}[http://rubyforge.org/projects/flex-attributes].
+    #
+    #   class User < ActiveRecord::Base
+    #     has_dynamic_attributes
+    #   end
+    #   eric = User.find_by_login 'eric'
+    #   puts "My AOL instant message name is: #{eric.aim}"
+    #   eric.phone = '555-123-4567'
+    #   eric.save
+    #
+    # The above example should work even though "aim" and "phone" are not
+    # attributes on the User model.
+    #
+    # The following options are available on for has_dynamic_attributes to modify
+    # the behavior. Reasonable defaults are provided:
+    #
+    # class_name::
+    #   The class for the related model. This defaults to the
+    #   model name prepended to "Attribute". So for a "User" model the class
+    #   name would be "UserAttribute". The class can actually exist (in that
+    #   case the model file will be loaded through Rails dependency system) or
+    #   if it does not exist a basic model will be dynamically defined for you.
+    #   This allows you to implement custom methods on the related class by
+    #   simply defining the class manually.
+    # table_name::
+    #   The table for the related model. This defaults to the
+    #   attribute model's table name.
+    # relationship_name::
+    #   This is the name of the actual has_many
+    #   relationship. Most of the type this relationship will only be used
+    #   indirectly but it is there if the user wants more raw access. This
+    #   defaults to the class name underscored then pluralized finally turned
+    #   into a symbol.
+    # foreign_key::
+    #   The key in the attribute table to relate back to the
+    #   model. This defaults to the model name underscored prepended to "_id"
+    # name_field::
+    #   The field which stores the name of the attribute in the related object
+    # value_field::
+    #   The field that stores the value in the related object
+    # fields::
+    #   A list of fields that are valid dynamic attributes. By default
+    #   this is "nil" which means that all field are valid. Use this option if
+    #   you want some fields to go to one dynamic attribute model while other
+    #   fields will go to another. As an alternative you can override the
+    #   #dynamic_attributes method which will return a list of all valid dynamic
+    #   attributes. This is useful if you want to read the list of attributes
+    #   from another source to keep your code DRY. This method is given a
+    #   single argument which is the class for the related model. The following
+    #   provide an example:
+    #
+    #  class User < ActiveRecord::Base
+    #    has_dynamic_attributes :class_name => 'UserContactInfo'
+    #    has_dynamic_attributes :class_name => 'Preferences'
+    #
+    #    def dynamic_attributes(model)
+    #      case model
+    #        when UserContactInfo
+    #          %w(email phone aim yahoo msn)
+    #        when Preference
+    #          %w(project_search project_order user_search user_order)
+    #        else Array.new
+    #      end
+    #    end
+    #  end
+    #
+    #  eric = User.find_by_login 'eric'
+    #  eric.email = 'eric@example.com' # Will save to UserContactInfo model
+    #  eric.project_order = 'name'     # Will save to Preference
+    #  eric.save # Carries out save so now values are in database
+    #
+    # Note the else clause in our case statement. Since an empty array is
+    # returned for all other models (perhaps added later) then we can be
+    # certain that only the above dynamic attributes are allowed.
+    #
+    # If both a :fields option and #dynamic_attributes method is defined the
+    # :fields option take precidence. This allows you to easily define the
+    # field list inline for one model while implementing #dynamic_attributes
+    # for another model and not having #dynamic_attributes need to determine
+    # what model it is answering for. In both cases the list of dynamic
+    # attributes can be a list of string or symbols
+    #
+    # A final alternative to :fields and #dynamic_attributes is the
+    # #is_dynamic_attribute? method. This method is given two arguments. The
+    # first is the attribute being retrieved/saved the second is the Model we
+    # are testing for. If you override this method then the #dynamic_attributes
+    # method or the :fields option will have no affect. Use of this method
+    # is ideal when you want to retrict the attributes but do so in a
+    # algorithmic way. The following is an example:
+    #   class User < ActiveRecord::Base
+    #     has_dynamic_attributes :class_name => 'UserContactInfo'
+    #     has_dynamic_attributes :class_name => 'Preferences'
+    #
+    #     def is_dynamic_attribute?(attr, model)
+    #       case attr.to_s
+    #         when /^contact_/ then true
+    #         when /^preference_/ then true
+    #         else
+    #           false
+    #       end
+    #     end
+    #   end
+    #
+    #   eric = User.find_by_login 'eric'
+    #   eric.contact_phone = '555-123-4567'
+    #   eric.contact_email = 'eric@example.com'
+    #   eric.preference_project_order = 'name'
+    #   eric.some_attribute = 'blah'  # If some_attribute is not defined on
+    #                                 # the model then method not found is thrown
+    module DynamicAttributes
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def has_dynamic_attributes?
+          !!@has_dynamic_attributes
+        end
+
+        # Will make the current class have dynamic attributes.
+        def has_dynamic_attributes(options={})
+          @has_dynamic_attributes = true
+          include InstanceMethods
+
+          # Provide default options
+          options[:class_name] ||= "#{self.model_name}Attribute"
+          options[:table_name] ||= options[:class_name].tableize
+          options[:relationship_name] ||= options[:class_name].tableize.to_sym
+          options[:foreign_key] ||= self.model_name.foreign_key
+          options[:base_foreign_key] ||= self.name.underscore.foreign_key
+          options[:name_field] ||= 'name'
+          options[:value_field] ||= 'value'
+          options[:fields].collect! { |f| f.to_s } unless options[:fields].nil?
+
+          # Init option storage if necessary
+          cattr_accessor :dynamic_options
+          self.dynamic_options ||= Hash.new
+
+          # Return if already processed.
+          return if self.dynamic_options.keys.include? options[:class_name]
+
+          # Attempt to load related class. If not create it
+          begin
+            options[:class_name].constantize
+          rescue
+            Object.const_set(options[:class_name], Class.new(ActiveRecord::Base)).class_eval do
+              self.table_name = options[:table_name]
+              #self.mass_assignment_sanitizer = Cms::IgnoreSanitizer.new
+
+              def self.reloadable? #:nodoc:
+                false
+              end
+            end
+          end
+
+          # Store options
+          self.dynamic_options[options[:class_name]] = options
+
+          # Modify attribute class
+          attribute_class = options[:class_name].constantize
+          base_class = self.name.underscore.to_sym
+          attribute_class.class_eval do
+            belongs_to base_class, :foreign_key => options[:base_foreign_key]
+            alias_method :base, base_class # For generic access
+           #attr_accessible :name, :value, "#{base_class.to_s}_id".to_sym
+          end
+
+          # Modify main class
+          class_eval do
+            has_many options[:relationship_name],
+                     :class_name => options[:class_name],
+                     :foreign_key => options[:foreign_key],
+                     :dependent => :destroy
+
+            # The following is only setup once
+            unless private_method_defined? :method_missing_without_dynamic_attributes
+
+              # Carry out delayed actions before save
+              after_validation :save_modified_dynamic_attributes
+
+              # Make attributes seem real
+              alias_method :method_missing_without_dynamic_attributes, :method_missing
+              alias_method :method_missing, :method_missing_with_dynamic_attributes
+
+              private
+
+              alias_method :read_attribute_without_dynamic_attributes, :read_attribute
+              alias_method :read_attribute, :read_attribute_with_dynamic_attributes
+              alias_method :write_attribute_without_dynamic_attributes, :write_attribute
+              alias_method :write_attribute, :write_attribute_with_dynamic_attributes
+
+            end
+          end
+
+
+        end
+      end
+      module InstanceMethods
+        # Will determine if the given attribute is a dynamic attribute on the
+        # given model. Override this in your class to provide custom logic if
+        # the #dynamic_attributes method or the :fields option are not flexible
+        # enough. If you override this method :fields and #dynamic_attributes will
+        # not apply at all unless you implement them yourself.
+        def is_dynamic_attribute?(attr, model)
+          attr = attr.to_s
+          return dynamic_options[model.name][:fields].include?(attr) unless dynamic_options[model.name][:fields].nil?
+          return dynamic_attributes(model).collect { |f| f.to_s }.include?(attr) unless dynamic_attributes(model).nil?
+          true
+        end
+
+        # Return a list of valid dynamic attributes for the given model. Return
+        # nil if any field is allowed. If you want to say no field is allowed
+        # then return an empty array. If you just have a static list the :fields
+        # option is most likely easier.
+        def dynamic_attributes(model)
+          ; nil
+        end
+
+
+        # Overrides the assign_attributes= defined in ActiveRecord::Base(active_record/base.rb)
+        #
+        # The only difference is that this doesn't check to see if the
+        # model responds_to the method before sending it
+        #
+        # Not happy with this copy/paste duplication, but its merely an update to the previous Rails 2/3 behavior
+        # Must remain PUBLIC so other rails methods can call it (like ActiveRecord::Persistence#update_attributes)
+        def assign_attributes(new_attributes, options = {})
+          return unless new_attributes
+
+          attributes = new_attributes.stringify_keys
+          role = options[:as] || :default
+
+          multi_parameter_attributes = []
+
+          # Disabling mass assignment protection for attributes, might be a terrible idea, but dynamic_attributes are really wonky.
+          #unless options[:without_protection]
+          #  attributes = sanitize_for_mass_assignment(attributes, role)
+          #end
+
+          attributes.each do |k, v|
+            if k.include?("(")
+              multi_parameter_attributes << [k, v]
+            else
+              # Dynamic Attributes will take ALL setters (unlike ActiveRecord)
+              send("#{k}=", v)
+            end
+          end
+
+          assign_multiparameter_attributes(multi_parameter_attributes)
+        end
+      end
+
+      private
+
+      # Called after validation on update so that dynamic attributes behave
+      # like normal attributes in the fact that the database is not touched
+      # until save is called.
+      def save_modified_dynamic_attributes
+        return if new_record?
+        return if @save_dynamic_attr.nil?
+        @save_dynamic_attr.each do |s|
+          model, attr_name = s
+          related_attr = dynamic_related_attr model, attr_name
+          unless related_attr.nil?
+            if related_attr.value.nil?
+              dynamic_related(model).delete related_attr
+            else
+              related_attr.save
+            end
+          end
+        end
+        @save_dynamic_attr = []
+      end
+
+      # Overrides ActiveRecord::Base#read_attribute
+      def read_attribute_with_dynamic_attributes(attr_name)
+        attr_name = attr_name.to_s
+        exec_if_related attr_name do |model|
+          return nil if !@remove_dynamic_attr.nil? && @remove_dynamic_attr.any? do |r|
+            r[0] == model && r[1] == attr_name
+          end
+          value_field = dynamic_options[model.name][:value_field]
+          related_attr = dynamic_related_attr model, attr_name
+          return nil if related_attr.nil?
+          return related_attr.send(value_field)
+        end
+        read_attribute_without_dynamic_attributes(attr_name)
+      end
+
+      # Overrides ActiveRecord::Base#write_attribute
+      def write_attribute_with_dynamic_attributes(attr_name, value)
+        attr_name = attr_name.to_s
+        exec_if_related attr_name do |model|
+          value_field = dynamic_options[model.name][:value_field]
+          @save_dynamic_attr ||= []
+          @save_dynamic_attr << [model, attr_name]
+          related_attr = dynamic_related_attr(model, attr_name)
+          if related_attr.nil?
+            # Used to check for nil? but this caused validation
+            # problems that are harder to solve. blank? is probably
+            # not correct but it works well for now.
+            unless value.blank?
+              name_field = dynamic_options[model.name][:name_field]
+              foreign_key = dynamic_options[model.name][:foreign_key]
+              dynamic_related(model).build name_field => attr_name,
+                                           value_field => value, foreign_key => self.id
+            end
+            return value
+          else
+            value_field = (value_field.to_s + '=').to_sym
+            return related_attr.send(value_field, value)
+          end
+        end
+        write_attribute_without_dynamic_attributes(attr_name, value)
+      end
+
+      # Implements dynamic-attributes as if real getter/setter methods
+      # were defined.
+      def method_missing_with_dynamic_attributes(method_id, *args, &block)
+        begin
+          method_missing_without_dynamic_attributes method_id, *args, &block
+        rescue NoMethodError => e
+          attr_name = method_id.to_s.sub(/\=$/, '')
+          exec_if_related attr_name do |model|
+            if method_id.to_s =~ /\=$/
+              return write_attribute_with_dynamic_attributes(attr_name, args[0])
+            else
+              return read_attribute_with_dynamic_attributes(attr_name)
+            end
+          end
+          raise e
+        end
+      end
+
+      # Retrieve the related dynamic attribute object
+      def dynamic_related_attr(model, attr)
+        name_field = dynamic_options[model.name][:name_field]
+        dynamic_related(model).to_a.find { |r| r.send(name_field) == attr }
+      end
+
+      # Retrieve the collection of related dynamic attributes
+      def dynamic_related(model)
+        relationship = dynamic_options[model.name][:relationship_name]
+        send relationship
+      end
+
+      # Yield only if attr_name is a dynamic_attribute
+      def exec_if_related(attr_name)
+        return false if self.class.column_names.include? attr_name
+        each_dynamic_relation do |model|
+          if is_dynamic_attribute?(attr_name, model)
+            yield model
+          end
+        end
+      end
+
+      # Yields for each dynamic relation.
+      def each_dynamic_relation
+        dynamic_options.keys.each { |kls| yield kls.constantize }
+      end
+
+      # Returns the options for the dynamic attributes
+      def dynamic_options
+        nonversioned_class(self.class).dynamic_options
+      end
+
+      # Will return the parent model if kls is a versioned class
+      def nonversioned_class(kls)
+        if kls.name =~ /\:\:Version$/
+          base_class = kls.name
+          base_class.sub!(/\:\:Version$/, '')
+          return base_class.constantize
+        end
+        kls
+      end
+
+    end
+  end
+end

data/lib/cms/behaviors/flush_cache_on_change.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Behaviors
+    module FlushCacheOnChange
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+        model_class.class_eval do
+          def flush_cache_on_change?
+            false
+          end
+        end
+      end
+      module MacroMethods      
+        def flush_cache_on_change?
+          !!@flush_cache_on_change
+        end
+        def flush_cache_on_change(options={})
+          include InstanceMethods
+          @flush_cache_on_change = true
+          
+          after_save :flush_cache
+          after_destroy :flush_cache
+        end
+      end
+      module InstanceMethods
+        def flush_cache
+          Cms::Cache.flush
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/hiding.rb

@@ -0,0 +1,46 @@
+module Cms
+  module Behaviors
+    module Hiding
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def hideable?
+          !!@is_hideable
+        end
+        def is_hideable(options={})
+          @is_hideable = true
+          extend ClassMethods
+          include InstanceMethods
+        
+          scope :hidden, ->{where(:hidden => true)}
+          scope :not_hidden, ->{where(:hidden => false)}
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def hide
+          self.hidden = true
+          self.version_comment = "Hidden"         
+          self.save
+        end
+        def hide!
+          self.hidden = true
+          self.version_comment = "Hidden"
+          self.save!
+        end
+        def unhide
+          self.hidden = false
+          self.version_comment = "Unhidden"          
+          self.save
+        end
+        def unhide!
+          self.hidden = false
+          self.version_comment = "Unhidden"          
+          self.save!
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/namespacing.rb

@@ -0,0 +1,15 @@
+module Cms
+
+  # @deprecated To be removed in BrowserCMS 4.1 or later.
+  def self.table_prefix=(prefix)
+    message = "Calling Cms.table_prefix('#{prefix}') is no longer necessary and can be removed from your project. See https://github.com/browsermedia/browsercms/issues/639"
+    ActiveSupport::Deprecation.warn(message, caller(1))
+  end
+
+  module Behaviors
+    module Namespacing
+
+
+    end
+  end
+end

data/lib/cms/behaviors/naming.rb

@@ -0,0 +1,16 @@
+module Cms
+  module Behaviors
+    # Assumes the 'extended' class is an instance of ActiveModel
+    module Naming
+
+      # Returns the name of this content block as it will appear in paths.
+      #
+      # Examples:
+      #   HtmlBlock -> html_blocks
+      #   Thing -> things
+      def path_name
+        model_name.element.pluralize
+      end
+    end
+  end
+end

data/lib/cms/behaviors/publishing.rb

@@ -0,0 +1,205 @@
+module Cms
+  module Behaviors
+
+    # Allows content to be marked as publishable or not. In practice, this has a direct dependency on
+    # Versioning, so it may not make sense to be separated out this way.
+    module Publishing
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+        model_class.class_eval do
+          def publishable?
+            false
+          end
+        end
+      end
+
+      module MacroMethods
+        def publishable?
+          !!@is_publishable
+        end
+
+        def is_publishable(options={})
+          @is_publishable = true
+          extend ClassMethods
+          include InstanceMethods
+
+          #attr_accessible :publish_on_save, :as
+          after_save :publish_for_non_versioned
+
+          scope :published, -> { where(:published => true) }
+          scope :unpublished, -> {
+            if self.versioned?
+              q = "#{connection.quote_table_name(version_table_name)}.#{connection.quote_column_name('version')} > " +
+                  "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name('version')}"
+              select("distinct #{connection.quote_table_name(table_name)}.*").where(q).joins(:versions)
+            else
+              where(:published => false)
+            end
+          }
+
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+
+        # Can specify whether to save this block as a draft using a terser syntax.
+        # These two calls behave identically
+        #   - Cms::HtmlBlock.create(name: "Shorter", as: :draft)
+        #   - Cms::HtmlBlock.create(name: "Longer",  publish_on_save: false)
+        # @param [Symbol] status :draft to not publish on the next save. All other values are ignored.
+        def as=(status)
+          if status == :draft
+            self.publish_on_save = false
+          end
+        end
+
+        # Whether or not this object will be published the next time '.save' is called.
+        # @return [Boolean] True unless explicitly set otherwise.
+        def publish_on_save
+          if @publish_on_save.nil?
+            @publish_on_save = true
+          end
+          @publish_on_save
+        end
+
+        # Set whether or not this object will be published next time '.save' is called.
+        # This status resets to true after calling '.save'
+        def publish_on_save=(publish)
+          @publish_on_save = publish
+        end
+
+        def publishable?
+          if self.class.connectable?
+            new_record? ? connect_to_page_id.blank? : connected_page_count < 1
+          else
+            true
+          end
+        end
+
+        def publish_for_non_versioned
+          unless self.class.versioned?
+            if @publish_on_save
+              publish
+              @publish_on_save = nil
+            end
+          end
+        end
+
+        def publish_if_needed
+          if publish_on_save
+            publish
+          else
+            self.publish_on_save = true
+          end
+        end
+
+        # Publishes the latest previously saved version of content as published. This will not create a new version,
+        # and will not persist changes made to a record.
+        #
+        # @return [Boolean] true if there was a draft record that was published, false otherwise.
+        def publish
+          publish!
+        rescue Exception => e
+          Cms::ErrorHandling::NotifierService.notify e
+          logger.warn("Could not publish, #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
+          false
+        end
+
+        # Saves a draft copy of this content item. This will create a new record in the _versions table for this item, but
+        # will not update the existing published record.
+        def save_draft
+          self.publish_on_save = false
+          save
+        end
+
+        # Publishes the latest draft version of a block. See .publish for more documentation. Can throw errors if publishing failed for unexpected reasons.
+        # Note: Having separate .publish! and .publish methods is probably no longer necessary. In practice, only .publish is probably needed.
+        # @return [Boolean] true if the block had a draft that was published, false otherwise.
+        def publish!
+          did_publish = false
+          if new_record?
+            ActiveSupport::Deprecation.warn "Calling .publish! on a new record no longer saves the record. Call '.save' to persist and publish the record.", caller
+          else
+            # Do this for publishing existing blocks.
+            transaction do
+              if self.class.versioned?
+                d = draft
+
+                # We only need to publish if this isn't already published
+                # or the draft version is greater than the live version
+                if !self.published? || d.version > self.version
+
+                  d.update_attributes(:published => true)
+
+                  # copy values from the draft to the main record
+                  quoted_attributes = d.send(:arel_attributes_with_values_for_update, self.class.versioned_columns)
+
+                  #the values from the draft MAY have a relation of the versioned module
+                  #as opposed to the actual class itself
+                  #eg Page::Version, and not Page
+                  #so remap to the actual arel_table´
+                  #I haven't figured out why this is, but I know it happens when you call save! on Page
+                  #during seeding of data
+                  if self.class.arel_table.name != quoted_attributes.keys[0].relation.name
+                    quoted_attributes = quoted_attributes.inject({}) { |hash, pair| hash[self.class.arel_table[pair[0].name]] = pair[1]; hash }
+                  end
+
+                  # Doing the SQL ourselves to avoid callbacks
+                  self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(quoted_attributes)
+                  did_publish = true
+                end
+              else
+                self.class.connection.update(
+                    "UPDATE #{self.class.quoted_table_name} " +
+                        "SET published = #{self.class.connection.quote(true, self.class.columns_hash["published"])} " +
+                        "WHERE #{self.class.connection.quote_column_name(self.class.primary_key)} = #{self.class.quote_value(id)}",
+                    "#{self.class.name.demodulize} Publish"
+                )
+                did_publish = true
+              end
+              after_publish if respond_to?(:after_publish)
+            end
+            self.published = true
+          end
+          did_publish
+        end
+
+        def status
+          return @status if @status
+          @status = live? ? :published : :draft
+        end
+
+        def status_name
+          status.to_s.titleize
+        end
+
+        # Determines if this resource is in draft mode or not. Opposite of #live?
+        #
+        # @return [Boolean] true if the latest version of the resource is a draft.
+        def draft?
+          !live?
+        end
+
+        # Determines if this resource is in published or not.
+        #
+        # @return [Boolean] true if the latest version of the resource is published.
+        def live?
+          if self.class.versioned?
+            unless persisted?
+              return false
+            end
+            if respond_to?(:latest_version) && self.latest_version
+              version == latest_version && published?
+            else
+              live_version.version == draft.version && published?
+            end
+          else
+            true
+          end
+        end
+
+      end
+    end
+  end
+end