browsercms 3.1.5 → 3.3.0.beta

data/lib/cms/behaviors/rendering.rb

@@ -36,7 +36,15 @@ module Cms
       
           extend ClassMethods
           include InstanceMethods
-      
+
+          # I'm not pleased with the need to include all of the these rails helpers onto every 'renderable' content item
+          # It's likely to lead to unfortunate side effects.
+          # Need to determine how this can be simplified.
+
+          # Required to make the calls to add Rails Core controllers work
+          include ActiveSupport::Configurable
+
+          # Include all the core rails helpers
           include ActionController::Helpers
           include ActionController::RequestForgeryProtection
 
@@ -89,11 +97,11 @@ module Cms
 
         # This gives the view a reference to this object
         instance_variable_set(self.class.instance_variable_name_for_view, self)
-    
+
         # This is like a controller action
         # We will call it if you have defined a render method
         # but if you haven't we won't
-        render if respond_to?(:render)
+        render if should_render_self?
       end
     
       def perform_render(controller)
@@ -113,26 +121,34 @@ module Cms
         end
 
         # Create, Instantiate and Initialize the view
-        view_class  = Class.new(ActionView::Base)      
-        action_view = view_class.new(@controller.view_paths, {}, @controller)
-    
+        action_view = Cms::ViewContext.new(@controller, assigns_for_view)
+#        view_class  = Class.new(ActionView::Base)
+#        action_view = view_class.new(@controller.view_paths, {}, @controller)
+
+#        logger.warn("View Class: #{view_class}")
+#        logger.warn("View : #{action_view}")
+
         # Make helpers and instance vars available
-        view_class.send(:include, @controller.class.master_helper_module)
-        if $:.detect{|d| File.exists?(File.join(d, self.class.helper_path))}
-          view_class.send(:include, self.class.helper_class)
-        end
-        
+#       view_class.send(:include, @controller.class._helpers)
+
+        # Add helpers for the portlet or content block
+#        if $:.detect{|d| File.exists?(File.join(d, self.class.helper_path))}
+#          view_class.send(:include, self.class.helper_class)
+#        end
+#
         # We want content_for to be called on the controller's view, not this inner view
-        def action_view.content_for(name, content=nil, &block)
-          @controller.instance_variable_get("@template").content_for(name, content, &block)
-        end
+#        def action_view.content_for(name, content=nil, &block)
+#          @controller.instance_variable_get("@template").content_for(name, content, &block)
+#        end
         
         # Copy instance variables from this renderable object to it's view
-        action_view.assigns = assigns_for_view
-          
+#        action_view.assigns = assigns_for_view
+
+        # Determine if this content should render from a file system template or inline (i.e. database based template)
         if respond_to?(:inline_options) && self.inline_options && self.inline_options.has_key?(:inline)
-          options = {:locals => {}}.merge(self.inline_options)
-          ActionView::InlineTemplate.new(options[:inline], options[:type]).render(action_view, options[:locals])
+          options = self.inline_options
+          locals = {}
+          action_view.render(options, locals)
         else
           action_view.render(:file => self.class.template_path)
         end
@@ -142,6 +158,13 @@ module Cms
         @render_exception = exception
       end
 
+      # Determines if a block should have its 'render' method called when it's rendered within a page.
+      def should_render_self?
+        # Reason to exist: This was added to work around the fact that Rails 3 AbstractController::Helpers defines its own
+        # render method, which was conflicted with block's render methods.
+        public_methods(false).include?(:render)
+      end
+      
       protected
         def copy_instance_variables_from_controller!
           if @controller.respond_to?(:instance_variables_for_rendering)

data/lib/cms/behaviors/searching.rb

@@ -14,7 +14,7 @@ module Cms
           extend ClassMethods
         
           #This is in a method to allow classes to override it
-          named_scope :search, lambda{|search_params| 
+          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
             conditions = []

data/lib/cms/behaviors/soft_deleting.rb

@@ -4,35 +4,67 @@ module Cms
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
-      module MacroMethods      
+
+      module MacroMethods
         def uses_soft_delete?
           !!@uses_soft_delete
         end
+
+        def handle_missing_table_error_during_startup(e)
+          puts e.inspect
+          Rails.logger.info e.inspect
+        end
+
         def uses_soft_delete(options={})
           @uses_soft_delete = true
-        
-          named_scope :not_deleted, :conditions => ["#{table_name}.deleted = ?", false]
+
+          scope :not_deleted, :conditions => ["#{table_name}.deleted = ?", false]
           class << self
-            alias_method :find_with_deleted, :find
-            alias_method :count_with_deleted, :count
             alias_method :delete_all!, :delete_all
           end
-          alias_method :destroy_without_callbacks!, :destroy_without_callbacks
-        
+
           extend ClassMethods
           include InstanceMethods
+
+          # By default, all queries for blocks should filter out deleted rows.
+          begin
+            default_scope where(:deleted => false)
+          # This may fail during gem loading, if no DB exists. Log it and move on.
+          rescue StandardError => e
+            handle_missing_table_error_during_startup(e)
+          end
         end
       end
+
+      # TODO: Refactor this class to remove need for overriding count, delete_all, etc.
+      # Should not be necessary due to introduction of 'default_scope'.
+      #
+      # 2. TODO: Allow a record to define its own default_scope that doesn't 'override' this one.
+      # See http://github.com/fernandoluizao/acts_as_active for an implementation of this
       module ClassMethods
-        def find(*args)
-          not_deleted.find_with_deleted(*args)
+
+        # Returns all records, including those which are marked as deleted.
+        #
+        # Basically 'find' exactly how ActiveRecord originally implements it.
+        #
+        # @param args Same params as ActiveRecord.find
+        def find_with_deleted(* args)
+          self.with_exclusive_scope { find(* args) }
         end
-        def count(*args)
-          not_deleted.count_with_deleted(*args)
+
+        # Returns a count of all records of this type, including those marked as deleted.
+        #
+        # Behaves like ActiveRecord.count is originally implemented.
+        #
+        # @param args Same params as ActiveRecord.count
+        def count_with_deleted(* args)
+          self.with_exclusive_scope { count(* args) }
         end
+
         def delete_all(conditions=nil)
           update_all(["deleted = ?", true], conditions)
         end
+
         def exists?(id_or_conditions)
           if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
             conditions = {:conditions => id_or_conditions}
@@ -40,37 +72,34 @@ module Cms
             conditions = {:conditions => {:id => id_or_conditions}}
           end
           count(conditions) > 0
-        end      
+        end
       end
       module InstanceMethods
-        #Overrides original destroy method
-        def destroy_without_callbacks
-          if self.class.publishable?
-            update_attributes(:deleted => true, :publish_on_save => true)
-          else
-            update_attributes(:deleted => true)
+
+        # Destroying a soft deletable model should mark the record as deleted, and not actually remove it from the database.
+        #
+        # Overrides original destroy method
+        def destroy
+          run_callbacks :destroy do
+            if self.class.publishable?
+              update_attributes(:deleted => true, :publish_on_save => true)
+            else
+              update_attributes(:deleted => true)
+            end
           end
         end
 
         def mark_as_deleted!
-          destroy_without_callbacks
-        end
-
-        def destroy_with_callbacks!
-          return false if callback(:before_destroy) == false
-          result = destroy_without_callbacks!
-          @destroyed = true
-          callback(:after_destroy)
-          result
+          destroy
         end
 
         def destroy!
-          transaction { destroy_with_callbacks! }
+          transaction { super.destroy }
         end
 
         def destroyed?
           @destroyed
-        end        
+        end
       end
     end
   end

data/lib/cms/behaviors/taggable.rb

@@ -15,7 +15,7 @@ module Cms
           has_many :taggings, :as => :taggable
           has_many :tags, :through => :taggings, :order => "tags.name"                    
           
-          named_scope :tagged_with, lambda{|t| {:include => {:taggings => :tag}, :conditions => ["tags.name = ?", t]} }          
+          scope :tagged_with, lambda{|t| {:include => {:taggings => :tag}, :conditions => ["tags.name = ?", t]} }          
                     
           after_save :save_tags          
                     

data/lib/cms/behaviors/userstamping.rb

@@ -18,18 +18,19 @@ module Cms
         
           before_save :set_userstamps
         
-          named_scope :created_by, lambda{|user| {:conditions => {:created_by => user}}}        
-          named_scope :updated_by, lambda{|user| {:conditions => {:updated_by => user}}}        
+          scope :created_by, lambda{|user| {:conditions => {:created_by => user}}}
+          scope :updated_by, lambda{|user| {:conditions => {:updated_by => user}}}        
         end
       end
       module ClassMethods
       end
       module InstanceMethods
         def set_userstamps
+          current_user = User.current ? User.current : nil
           if new_record?
-            self.created_by = User.current 
+            self.created_by = current_user
           end
-          self.updated_by = User.current
+          self.updated_by = current_user
         end
       end
     end

data/lib/cms/behaviors/versioning.rb

@@ -1,5 +1,25 @@
 module Cms
   module Behaviors
+
+    # This behavior adds Versioning to an ActiveRecord object. It seriously monkeys with how objects are saved or updated.
+    #
+    # This implementation is pretty tied to Rails 3 ActiveRecord. Here's how I understand it works:
+    # ActiveRecord alias chain- Here is the order that methods get called.
+    #
+    # save
+    #   save_with_transactions
+    #   save_with_dirty
+    #   save_with_validations
+    #   AR::Base#save (save_without_validations)
+    #   AR::Base#create_or_update_with_callbacks
+    #
+    #
+    #  AR::Base - Defines a 'save' method with no params
+    #  AR::Validations - alias save to a save_with_validations (which takes params)
+    #  ActiveRecord Object has:
+    #  - save_with_validations(options)
+    #  - save_without_validation() - (Original save)
+    #
     module Versioning
       def self.included(model_class)
         model_class.extend(MacroMethods)
@@ -19,9 +39,11 @@ module Cms
           extend ClassMethods
           include InstanceMethods
 
-          has_many :versions, :class_name => version_class_name, :foreign_key => version_foreign_key
+          has_many :versions, :class_name  => version_class_name, :foreign_key => version_foreign_key
 
-          before_validation_on_create :initialize_version
+          before_validation :initialize_version
+          before_save :build_new_version
+          attr_accessor :skip_callbacks
 
           attr_accessor :revert_to_version
 
@@ -71,34 +93,21 @@ module Cms
 
         def versioned_columns
           @versioned_columns ||= (version_class.new.attributes.keys -
-              (%w[id lock_version position version_comment created_at updated_at created_by_id updated_by_id type] + [version_foreign_key]))
+                  (%w[  id lock_version position version_comment created_at updated_at created_by_id updated_by_id type  ] + [version_foreign_key]))
         end
       end
       module InstanceMethods
         def initialize_version
-          self.version = 1
-        end
-
-        def after_save
-          update_latest_version
+          self.version = 1 if new_record?
         end
 
-        # Used in migrations and as a callback.
-        def update_latest_version
-          #Rails 3 could use update_column here instead
-          if respond_to? :latest_version
-            sql = "UPDATE #{self.class.table_name} SET latest_version = #{draft.version} where id = #{self.id}"
-            connection.execute sql
-            self.latest_version = draft.version # So we don't need to #reload this object. Probably marks it as dirty though, which could have weird side effects.
-          end
-        end
 
-        def build_new_version
+        def build_new_version_and_add_to_versions_list_for_saving
           # First get the values from the draft
           attrs = draft_attributes
 
           # Now overwrite all values
-          (self.class.versioned_columns - %w(version)).each do |col|
+          (self.class.versioned_columns - %w(  version  )).each do |col|
             attrs[col] = send(col)
           end
 
@@ -111,7 +120,7 @@ module Cms
         end
 
         def draft_attributes
-          # When there is no draft, we'll just copy the attibutes from this object
+          # When there is no draft, we'll just copy the attributes from this object
           # Otherwise we need to use the draft
           d = new_record? ? self : draft
           self.class.versioned_columns.inject({}) { |attrs, col| attrs[col] = d.send(col); attrs }
@@ -121,76 +130,153 @@ module Cms
           if new_record?
             "Created"
           else
-            "Changed #{(changes.keys - %w[version created_by_id updated_by_id]).sort.join(', ')}"
+            "Changed #{(changes.keys - %w[  version created_by_id updated_by_id  ]).sort.join(', ')}"
           end
         end
 
-        def save(perform_validations=true)
-          transaction do
-            #logger.info "..... Calling valid?"
-            return false unless !perform_validations || valid?
-
-            if different_from_last_draft?
-              #logger.info "..... Changes => #{changes.inspect}"
-            else
-              #logger.info "..... No Changes"
-              return true
-            end
+        def publish_if_needed
+          logger.debug { "#{self.class}#publish_if_needed. publish? = '#{!!@publish_on_save}'"}
 
-            #logger.info "..... Calling before_save"
-            return false if callback(:before_save) == false
+          if @publish_on_save
+            publish
+            @publish_on_save = nil
+          end
+        end
 
-            if new_record?
-              #logger.info "..... Calling before_create"
-              return false if callback(:before_create) == false
-            else
-              #logger.info "..... Calling before_update"
-              return false if callback(:before_update) == false
-            end
 
-            #logger.info "..... Calling build_new_version"
-            new_version = build_new_version
-            #logger.info "..... Is new version valid? #{new_version.valid?}"
-            if new_record?
-              self.version = 1
-              #logger.info "..... Calling create_without_callbacks"
-              if result = create_without_callbacks
-                #logger.info "..... Calling after_create"
-                if callback(:after_create) != false
-                  #logger.info "..... Calling after_save"
-                  callback(:after_save)
-                end
-
-                if @publish_on_save
-                  publish
-                  @publish_on_save = nil
-                end
-                changed_attributes.clear
-              end
-              result
-            elsif new_version
-              #logger.info "..... Calling save"
-              if result = new_version.save
-                #logger.info "..... Calling after_save"
-                if callback(:after_update) != false
-                  #logger.info "..... Calling after_update"
-                  callback(:after_save)
-                end
-
-                if @publish_on_save
-                  publish
-                  @publish_on_save = nil
-                end
-                changed_attributes.clear
-              end
-              result
+        #  
+        #ActiveRecord 3.0.0 call chain
+        # ActiveRecord 3 now uses basic inheritence rather than alias_method_chain.  The order in which ActiveRecord::Base
+        # includes methods (at the bottom of activerecord) repeatedly overrides save/save! with chains of 'super'
+        #
+        # Callstack order as observed
+        # 1. ActiveRecord::Base#save - The original method called by client
+        #
+        #  AR::Transactions#save
+        #  AR::Dirty#save
+        #  AR::Validations#save
+        #  ActiveRecord::Persistence#save
+        #  ActiveRecord::Persistence#create_or_update
+        #  AR::Callbacks#create_or_update (runs :save callbacks)
+        #
+        #
+        #
+        # This aliases the original ActiveRecord::Base.save method, in order to change
+        # how calling save works. It should do the following things:
+        #
+        # 1. If the record is unchanged, no save is performed, but true is returned. (Skipping after_save callbacks)
+        # 2. If its an update, a new version is created and that is saved.
+        # 3. If new record, its version is set to 1, and its published if needed.
+        def create_or_update
+          logger.debug {"#{self.class}#create_or_update called. Published = #{!!publish_on_save}"}
+          self.skip_callbacks = false
+          unless different_from_last_draft?
+            logger.debug {"No difference between this version and last. Skipping save"}
+            self.skip_callbacks = true
+            return true
+          end
+          logger.debug {"Saving #{self.class} #{self.attributes}"}
+          if new_record?
+            self.version = 1
+            # This should call ActiveRecord::Callbacks#create_or_update, which will correctly trigger the :save callback_chain
+            saved_correctly = super
+            changed_attributes.clear
+          else
+            logger.debug {"#{self.class}#update"}
+            # Because we are 'skipping' the normal ActiveRecord update here, we must manually call the save callback chain.
+            run_callbacks :save do
+              saved_correctly = @new_version.save
             end
-            true
           end
+          publish_if_needed
+          return saved_correctly
         end
 
+        # Build a new version of this record and associate it with this record.
+        #
+        # Called as a before_create in order to correctly allow any other associations to be saved correctly.
+        # Called explicitly during update, where it will just define the new_version to be saved.
+        def build_new_version
+          @new_version = build_new_version_and_add_to_versions_list_for_saving
+          logger.debug {"New version of #{self.class}::Version is #{@new_version.attributes}"}
+        end
+
+        # Implementation from BrowserCMS 3.1 (Rails 2 API). Left for reference while tests are being fixed for Rails 3 upgrade.
+        #
+        #
+        # This overrides the 'save' method from activerecord
+        # Things happening here:
+        # 1. If the record is unchanged, no save is performed, but true is returned (Make a separete call back)
+        # 2. If its an update, a new version is created and that is saved.
+        # 3. If new record, its version is set to 1, and its published if needed.
+        #
+        # Note: According to AR::Callbacks, save is its own transactions, so should be no need for separate TX.
+#        def save(perform_validations=true)
+#          transaction do
+#            #logger.info "..... Calling valid?"
+#            return false unless !perform_validations || valid?
+#
+#            if different_from_last_draft?
+#              #logger.info "..... Changes => #{changes.inspect}"
+#            else
+#              #logger.info "..... No Changes"
+#              return true
+#            end
+#
+#            #logger.info "..... Calling before_save"
+#            return false if callback(:before_save) == false
+#
+#            if new_record?
+#              #logger.info "..... Calling before_create"
+#              return false if callback(:before_create) == false
+#            else
+#              #logger.info "..... Calling before_update"
+#              return false if callback(:before_update) == false
+#            end
+#
+#            #logger.info "..... Calling build_new_version"
+#            new_version = build_new_version
+#            #logger.info "..... Is new version valid? #{new_version.valid?}"
+#            if new_record?
+#              self.version = 1
+#              #logger.info "..... Calling create_without_callbacks"
+#              if result = create_without_callbacks
+#                #logger.info "..... Calling after_create"
+#                if callback(:after_create) != false
+#                  #logger.info "..... Calling after_save"
+#                  callback(:after_save)
+#                end
+#
+#                if @publish_on_save
+#                  publish
+#                  @publish_on_save = nil
+#                end
+#                changed_attributes.clear
+#              end
+#              result
+#            elsif new_version
+#              #logger.info "..... Calling save"
+#              if result = new_version.save
+#                #logger.info "..... Calling after_save"
+#                if callback(:after_update) != false
+#                  #logger.info "..... Calling after_update"
+#                  callback(:after_save)
+#                end
+#
+#                if @publish_on_save
+#                  publish
+#                  @publish_on_save = nil
+#                end
+#                changed_attributes.clear
+#              end
+#              result
+#            end
+#            true
+#          end
+#        end
+
         def save!(perform_validations=true)
-          save(perform_validations) || raise(ActiveRecord::RecordNotSaved.new(errors.full_messages))
+          save(:validate=>perform_validations) || raise(ActiveRecord::RecordNotSaved.new(errors.full_messages))
         end
 
         def draft
@@ -218,13 +304,37 @@ module Cms
         end
 
         def as_of_draft_version
-          build_object_from_version(draft)
+          as_of_version(draft.version)
         end
 
+        # Find a Content Block as of a specific version.
+        #
+        # @param [Integer] version The specific version of the block to look up
+        # @return [ContentBlock] The block as of the state it existed at 'version'.
         def as_of_version(version)
           v = find_version(version)
           raise ActiveRecord::RecordNotFound.new("version #{version.inspect} does not exist for <#{self.class}:#{id}>") unless v
-          build_object_from_version(v)
+          obj = self.class.new
+
+          (self.class.versioned_columns + [:version, :created_at, :created_by_id, :updated_at, :updated_by_id]).each do |a|
+            obj.send("#{a}=", v.send(a))
+          end
+          obj.id = id
+          obj.lock_version = lock_version
+
+          # Need to do this so associations can be loaded
+          obj.instance_variable_set("@persisted", true)
+          obj.instance_variable_set("@new_record", false)
+
+          # Callback to allow us to load other data when an older version is loaded
+          obj.after_as_of_version if obj.respond_to?(:after_as_of_version)
+
+          # Last but not least, clear the changed attributes
+          if changed_attrs = obj.send(:changed_attributes)
+            changed_attrs.clear
+          end
+
+          obj
         end
 
         def revert
@@ -261,41 +371,12 @@ module Cms
           return true if self.changed?
           last_draft = self.draft
           return true unless last_draft
-          (self.class.versioned_columns - %w(version)).each do |col|
+          (self.class.versioned_columns - %w(  version  )).each do |col|
             return true if self.send(col) != last_draft.send(col)
           end
           return false
         end
 
-        private
-
-        # Given a ::Version object of a given type, create an original object from its attributes.
-        #
-        # @param [Class#name::Version] version (i.e. HtmlBlock::Version)
-        # @return [Class#name] i.e. HtmlBlock
-        def build_object_from_version(version_of_object)
-          obj = self.class.new
-
-          (self.class.versioned_columns + [:version, :created_at, :created_by_id, :updated_at, :updated_by_id]).each do |a|
-            obj.send("#{a}=", version_of_object.send(a))
-          end
-          obj.id = id
-          obj.lock_version = lock_version
-
-          # Need to do this so associations can be loaded
-          obj.instance_variable_set("@new_record", false)
-
-          # Callback to allow us to load other data when an older version is loaded
-          obj.after_as_of_version if obj.respond_to?(:after_as_of_version)
-
-          # Last but not least, clear the changed attributes
-          if changed_attrs = obj.send(:changed_attributes)
-            changed_attrs.clear
-          end
-
-          obj
-        end
-
       end
     end