browsercms 3.4.2 → 3.5.0.rc1

data/lib/cms/behaviors/connecting.rb

@@ -17,10 +17,9 @@ module Cms
           extend ClassMethods
           include InstanceMethods
 
-          attr_accessor :connect_to_page_id
-          attr_accessor :connect_to_container
-          attr_accessor :connected_page
-        
+          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

data/lib/cms/behaviors/dynamic_attributes.rb

@@ -122,7 +122,7 @@ module Cms
           !!@has_dynamic_attributes
         end
 
-          # Will make the current class have dynamic attributes.
+        # Will make the current class have dynamic attributes.
         def has_dynamic_attributes(options={})
           @has_dynamic_attributes = true
           include InstanceMethods
@@ -137,45 +137,47 @@ module Cms
           options[:value_field] ||= 'value'
           options[:fields].collect! { |f| f.to_s } unless options[:fields].nil?
 
-            # Init option storage if necessary
+          # Init option storage if necessary
           cattr_accessor :dynamic_options
           self.dynamic_options ||= Hash.new
 
-            # Return if already processed.
+          # Return if already processed.
           return if self.dynamic_options.keys.include? options[:class_name]
 
-            # Attempt to load related class. If not create it
+          # 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
-              set_table_name options[:table_name]
+            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
+          # Store options
           self.dynamic_options[options[:class_name]] = options
 
-            # Modify attribute class
+          # 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
+          # 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
+            # The following is only setup once
             unless private_method_defined? :method_missing_without_dynamic_attributes
 
               # Carry out delayed actions before save
@@ -211,10 +213,10 @@ module Cms
           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.
+        # 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
@@ -235,9 +237,10 @@ module Cms
 
           multi_parameter_attributes = []
 
-          unless options[:without_protection]
-            attributes = sanitize_for_mass_assignment(attributes, role)
-          end
+          # 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?("(")
@@ -252,129 +255,129 @@ module Cms
         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
+      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
-          @save_dynamic_attr = []
         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)
+      # 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
-          read_attribute_without_dynamic_attributes(attr_name)
+          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)
+      # 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
-          write_attribute_without_dynamic_attributes(attr_name, value)
         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
+      # 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
-            raise e
           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 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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

data/lib/cms/behaviors/flush_cache_on_change.rb

@@ -23,9 +23,7 @@ module Cms
       end
       module InstanceMethods
         def flush_cache
-          if Cms.caching_enabled?
-            Cms.flush_cache
-          end
+          Cms::Cache.flush
         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/pagination.rb

@@ -2,10 +2,13 @@
 module Cms
   module Behaviors
     module Pagination
+
+      DEFAULT_PER_PAGE =  15
+
       def self.included(model_class)
         model_class.extend(ClassMethods)
         class << model_class
-          define_method(:default_per_page) { 15 }
+          define_method(:default_per_page) { DEFAULT_PER_PAGE }
         end
       end
       class InvalidPage < ArgumentError

data/lib/cms/behaviors/publishing.rb

@@ -22,7 +22,8 @@ module Cms
           include InstanceMethods
         
           attr_accessor :publish_on_save
-        
+          attr_accessible :publish_on_save
+
           after_save :publish_for_non_versioned
         
           scope :published, :conditions => {:published => true}
@@ -71,13 +72,18 @@ module Cms
         # Force the publishing of this block.
         #
         # Warning: The behavior of calling the following on an existing block:
-        #   block.save_on_publish
+        #   block.save_on_publish = true
         #   block.save!
         #
         # Is different than calling:
         #   block.publish!
         #
-        # And it probably shouldn't be. Try to merge the 'else' with the 'Versioning#create_or_update' method to eliminate duplication 
+        # And it probably shouldn't be. Try to merge the 'else' with the 'Versioning#create_or_update' method to eliminate duplication.
+        #
+        # In addition, after_publish is NOT called if you do:
+        #   block.save_on_publish = true
+        #   block.save!
+        # which will cause problems if blocks are updated via the method (like with the UI)
         def publish!
           if new_record?
             self.publish_on_save = true

data/lib/cms/behaviors/searching.rb

@@ -14,9 +14,8 @@ module Cms
           extend ClassMethods
         
           #This is in a method to allow classes to override it
-          scope :search, lambda{|search_params| 
-            term = search_params.is_a?(Hash) ? search_params[:term] : search_params  
-            order = search_params.is_a?(Hash) && search_params[:order] ? search_params[:order] : default_order_for_search
+          scope :search, lambda{|search_params|
+            term = search_params.is_a?(Hash) ? search_params[:term] : search_params
             conditions = []
             unless term.blank?
               searchable_columns.each do |c|
@@ -31,8 +30,7 @@ module Cms
             end
             scope = {}
             scope[:conditions] = conditions if conditions
-            scope[:order] = order if order
-            scope                      
+            scope
           }
         end
       end
@@ -40,9 +38,6 @@ module Cms
         def searchable_columns
           @searchable_columns
         end
-        def default_order_for_search
-          "#{table_name}.#{searchable_columns.first}"
-        end
       end
     end
   end

data/lib/cms/behaviors/soft_deleting.rb

@@ -24,6 +24,7 @@ module Cms
 
           extend ClassMethods
           include InstanceMethods
+          attr_accessible :deleted
 
           # By default, all queries for blocks should filter out deleted rows.
           begin