browsercms 3.1.4 → 3.1.5

data/db/migrate/20120117144039_browsercms315.rb

@@ -0,0 +1,94 @@
+class Browsercms315 < ActiveRecord::Migration
+  def self.up
+    generate_ancestry_from_section_id
+    update_latest_version_cache
+
+    INDEXES.each do |index|
+      add_index *index
+    end
+  end
+
+  def self.down
+    # This migration is not reversible since it removes the original section_id column.
+  end
+
+  # Add some very commonly used indexes to improve the site performance as the # of pages/content grows (i.e. several thousand pages)
+  INDEXES = [
+      [:pages, :deleted],
+      [:pages, :path],
+      [:pages, :version],
+      [:page_versions, :page_id],
+      [:groups, :code],
+      [:groups, :group_type_id],
+      [:group_types, :cms_access],
+      [:group_sections, :section_id],
+      [:group_sections, :group_id],
+      [:users, :expires_at],
+      [:user_group_memberships, :group_id],
+      [:user_group_memberships, :user_id],
+      [:group_permissions, :group_id],
+      [:group_permissions, :permission_id],
+      [:group_permissions, [:group_id, :permission_id]],
+      [:section_nodes, :node_type],
+      [:section_nodes, :ancestry],
+      [:connectors, :page_id],
+      [:connectors, :page_version],
+      [:html_blocks, :deleted],
+      [:html_block_versions, :html_block_id],
+      [:html_block_versions, :version],
+      [:portlet_attributes, :portlet_id],
+      [:portlets, :name],
+      [:sections, :path],
+      [:redirects, :from_path],
+      [:connectors, :connectable_version],
+      [:connectors, :connectable_type],
+      [:content_types, :content_type_group_id],
+      [:content_types, :name],
+      [:file_block_versions, :file_block_id],
+      [:file_block_versions, :version],
+      [:file_blocks, :deleted],
+      [:file_blocks, :type],
+      [:attachment_versions, :attachment_id],
+      [:tasks, :page_id],
+      [:tasks, :completed_at],
+      [:tasks, :assigned_to_id],
+  ]
+
+  private
+
+  # v3.1.5 uses Ancestry to manage the parent child relationship between sections and their children.
+  # This converts the data from the old section_id to use the ancestry column.
+  def self.generate_ancestry_from_section_id
+    add_column :section_nodes, :ancestry, :string
+    add_column :section_nodes, :temp_parent_id, :integer
+
+    SectionNode.reset_column_information
+    root_section = Section.root.first
+    SectionNode.create!(:node => root_section) if root_section
+
+    all_nodes_but_root = SectionNode.find(:all, :conditions=>["section_id IS NOT NULL"])
+    all_nodes_but_root.each do |sn|
+      parent_node = SectionNode.find(:first, :conditions => ["node_id = ? and node_type = 'Section'", sn.section_id])
+      sn.temp_parent_id = parent_node.id
+      sn.save!
+    end
+    rename_column :section_nodes, :temp_parent_id, :parent_id # Ancestry works off the 'parent_id' column.
+
+    SectionNode.build_ancestry_from_parent_ids!
+    remove_column :section_nodes, :section_id
+    remove_column :section_nodes, :parent_id
+    SectionNode.reset_column_information
+  end
+
+  # Adds a 'latest_version' pointer to pages and links. Greatly reduces the number of queries the sitemap requires to determine if pages are in draft/published mode
+  def self.update_latest_version_cache
+    add_column :pages, :latest_version, :integer
+    add_column :links, :latest_version, :integer
+    Page.all.each do |p|
+      p.update_latest_version
+    end
+    Link.all.each do |link|
+      link.update_latest_version
+    end
+  end
+end

data/db/migrate/{20081114172307_load_seed_data.rb → 20121114172307_load_seeds.rb}

@@ -1,6 +1,13 @@
-class LoadSeedData < ActiveRecord::Migration
+# This is a new seed data file (new timestamp and name) so migrations will work in order.
+#   It should be able to peacefully coexist next to the previous load_seed_data
+class LoadSeeds < ActiveRecord::Migration
   extend Cms::DataLoader
   def self.up
+    if User.count > 0
+      puts "Database has already been seeded. So skip reloading."
+      return
+    end
+
     if %w[development test dev local].include?(Rails.env)
       pwd = "cmsadmin"
     else

data/lib/acts_as_list.rb

@@ -7,7 +7,7 @@ module ActsAsList
   # The class that has this specified needs to have a +position+ column defined as an integer on
   # the mapped database table.
   #
-  # Todo list example:
+  # To Do list example:
   #
   #   class TodoList < ActiveRecord::Base
   #     has_many :todo_items, :order => "position"

data/lib/browsercms.rb

@@ -2,6 +2,8 @@ require 'cms/extensions'
 require 'cms/init'
 require 'cms/routes'
 require 'cms/caching'
+require 'cms/addressable'
+require 'cms/error_pages'
 
 #Load libraries that are included with CMS
 require 'acts_as_list'

data/lib/cms/addressable.rb

@@ -0,0 +1,83 @@
+# Represents any object which exists in a Sitemap.
+#
+# Can have parents (using SectionNodes) and children.
+module Addressable
+
+  # 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
+  # @return [Array<Addressable]
+  #
+  def ancestors(options={})
+    ancestor_nodes = node.ancestors
+    ancestors = ancestor_nodes.collect { |node| node.node }
+    ancestors << self if options[:include_self]
+    ancestors
+  end
+
+  def parent
+    @parent if @parent
+    node ? node.section : nil
+  end
+
+  def cache_parent(section)
+    @parent = section
+  end
+
+  def parent=(sec)
+    if node
+      node.move_to_end(sec)
+    else
+      build_section_node(:node => self, :section => sec)
+    end
+  end
+
+  # Computes the name of the partial used to render this object in the sitemap.
+  def partial_for
+    self.class.name.underscore
+  end
+
+  # Pages/Links/Attachments use their parent to determine access
+  module LeafNode
+    def access_status
+      parent.status
+    end
+  end
+
+  module NodeAccessors
+    def node
+      section_node
+    end
+
+    def node=(n)
+      self.section_node = n
+    end
+  end
+  # 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
+    include LeafNode
+    include NodeAccessors
+
+    def build_node(opts)
+      build_section_node(opts)
+    end
+
+    def section_id
+      section ? section.id : nil
+    end
+
+    def section_id=(sec_id)
+      self.section = Section.find(sec_id)
+    end
+
+    def section
+      parent
+    end
+
+    def section=(sec)
+      self.parent = sec
+
+    end
+  end
+end

data/lib/cms/behaviors/attaching.rb

@@ -1,34 +1,36 @@
 module Cms
   module Behaviors
     module Attaching
-      SANITIZATION_REGEXES = [ [/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, ''] ]
-      
+      SANITIZATION_REGEXES = [[/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, '']]
+
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
-      module MacroMethods      
+
+      module MacroMethods
         def belongs_to_attachment?
           !!@belongs_to_attachment
         end
+
         def belongs_to_attachment(options={})
           @belongs_to_attachment = true
           include InstanceMethods
-          before_validation :process_attachment  
+          before_validation :process_attachment
           before_save :update_attachment_if_changed
           after_save :clear_attachment_ivars
-          belongs_to :attachment, :dependent => :destroy 
-          
+          belongs_to :attachment, :dependent => :destroy
+
           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  
+                else
                   record.errors.add(:attachment_file, err_value)
                 end
-              end      
+              end
             end
-          end       
+          end
         end
       end
       module InstanceMethods
@@ -92,20 +94,30 @@ module Cms
             unless attachment_section_id.blank?
               errors.add(:attachment_file, "You must upload a file")
               return false
-            end              
+            end
           else
-            build_attachment if attachment.nil?  
-            attachment.temp_file = attachment_file 
-            set_attachment_file_path
+            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
-            set_attachment_section
-            if attachment.section_id.blank?
+            handle_setting_attachment_section
+            unless attachment.section
               errors.add(:attachment_file, "Section is required for attachment")
               return false
             end
+
+          end
+        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
         end
 
@@ -113,18 +125,26 @@ module Cms
           @attachment_file = nil
           @attachment_file_path = nil
           @attachment_section_id = nil
-          @attachment_section = nil            
+          @attachment_section = nil
+        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
         end
 
-        # Override this method if you would like to override the way the section is set
-        def set_attachment_section
+        # 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 = Section.root.first
           end
         end
 
-        # Override this method if you would like to override the way file_path is set
-        def set_attachment_file_path
+        def use_default_attachment_path
           if !attachment_file.blank?
             attachment.file_path = "/attachments/#{File.basename(attachment_file.original_filename).to_s.downcase}"
           end
@@ -168,16 +188,16 @@ module Cms
             (published? && live_version?) ? attachment_file_path : "/cms/attachments/#{attachment_id}?version=#{attachment_version}"
           else
             nil
-          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
-        end          
-        
+        end
+
       end
     end
   end

data/lib/cms/behaviors/connecting.rb

@@ -39,7 +39,8 @@ module Cms
       module InstanceMethods
 
         def connected_pages
-          Page.connected_to(self)
+          return @connected_pages if @connected_pages
+          @connected_pages = Page.connected_to(self)
         end
 
         def connected_page_count

data/lib/cms/behaviors/publishing.rb

@@ -106,15 +106,24 @@ module Cms
         end    
             
         def status
-          live? ? :published : :draft
-        end        
+          return @status if @status
+          @status = live? ? :published : :draft
+        end
 
         def status_name
           status.to_s.titleize
         end
 
         def live?
-          self.class.versioned? ? live_version.version == draft.version && published? : true
+          if self.class.versioned?
+            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

data/lib/cms/behaviors/versioning.rb

@@ -4,10 +4,12 @@ module Cms
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
-      module MacroMethods      
+
+      module MacroMethods
         def versioned?
           !!@is_versioned
         end
+
         def is_versioned(options={})
           @is_versioned = true
 
@@ -17,25 +19,29 @@ 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
 
           attr_accessor :revert_to_version
 
           #Define the version class
-          const_set("Version", Class.new(ActiveRecord::Base)).class_eval do 
-            class << self; attr_accessor :versioned_class end
+          const_set("Version", Class.new(ActiveRecord::Base)).class_eval do
+            class << self;
+              attr_accessor :versioned_class
+            end
 
             def versioned_class
               self.class.versioned_class
             end
+
             def versioned_object_id
               send("#{versioned_class.name.underscore}_id")
             end
+
             def versioned_object
               send(versioned_class.name.underscore.to_sym)
-            end                 
+            end
           end unless self.const_defined?("Version")
 
           version_class.versioned_class = self
@@ -46,33 +52,47 @@ module Cms
 
         end
       end
-      module ClassMethods        
+      module ClassMethods
         def version_class
           const_get "Version"
         end
 
         def version_class_name
           "#{name}::Version"
-        end        
+        end
 
         def version_foreign_key
           @version_foreign_key
         end
 
-        def version_table_name        
+        def version_table_name
           @version_table_name
         end
 
         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]))
-        end                   
+          @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]))
+        end
       end
       module InstanceMethods
         def initialize_version
           self.version = 1
         end
 
+        def after_save
+          update_latest_version
+        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
           # First get the values from the draft
           attrs = draft_attributes
@@ -83,7 +103,7 @@ module Cms
           end
 
           attrs[:version_comment] = @version_comment || default_version_comment
-          @version_comment = nil            
+          @version_comment = nil
           new_version = versions.build(attrs)
           new_version.version = new_record? ? 1 : (draft.version.to_i + 1)
           after_build_new_version(new_version) if respond_to?(:after_build_new_version)
@@ -94,8 +114,8 @@ module Cms
           # When there is no draft, we'll just copy the attibutes 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 }
-        end 
+          self.class.versioned_columns.inject({}) { |attrs, col| attrs[col] = d.send(col); attrs }
+        end
 
         def default_version_comment
           if new_record?
@@ -108,22 +128,22 @@ module Cms
         def save(perform_validations=true)
           transaction do
             #logger.info "..... Calling valid?"
-            return false unless !perform_validations || 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      
+            else
               #logger.info "..... Calling before_update"
               return false if callback(:before_update) == false
             end
@@ -140,12 +160,12 @@ module Cms
                   #logger.info "..... Calling after_save"
                   callback(:after_save)
                 end
-                
+
                 if @publish_on_save
                   publish
                   @publish_on_save = nil
-                end                
-                changed_attributes.clear                                   
+                end
+                changed_attributes.clear
               end
               result
             elsif new_version
@@ -156,11 +176,11 @@ module Cms
                   #logger.info "..... Calling after_update"
                   callback(:after_save)
                 end
-                
+
                 if @publish_on_save
                   publish
                   @publish_on_save = nil
-                end 
+                end
                 changed_attributes.clear
               end
               result
@@ -174,13 +194,13 @@ module Cms
         end
 
         def draft
-          versions.first(:order => "version desc")    
+          versions.first(:order => "version desc")
         end
-        
+
         def draft_version?
           version == draft.version
         end
-        
+
         def live_version
           find_version(self.class.find(id).version)
         end
@@ -192,38 +212,19 @@ module Cms
         def current_version
           find_version(self.version)
         end
-        
+
         def find_version(number)
-          versions.first(:conditions => { :version => number })
+          versions.first(:conditions => {:version => number})
         end
 
         def as_of_draft_version
-          as_of_version(draft.version)
+          build_object_from_version(draft)
         end
 
         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
-          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("@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      
+          build_object_from_version(v)
         end
 
         def revert
@@ -237,15 +238,15 @@ module Cms
           raise "Could not find version #{version}" unless revert_to_version
           (self.class.versioned_columns - ["version"]).each do |a|
             send("#{a}=", revert_to_version.send(a))
-          end  
+          end
           self.version_comment = "Reverted to version #{version}"
-          self            
-        end    
+          self
+        end
 
         def revert_to(version)
           revert_to_without_save(version)
           save
-        end    
+        end
 
         def version_comment
           @version_comment
@@ -266,6 +267,35 @@ module Cms
           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