browsercms 3.1.4 → 3.1.5

data/app/controllers/cms/content_block_controller.rb

@@ -121,8 +121,8 @@ class Cms::ContentBlockController < Cms::BaseController
     def load_blocks
       options = {}
       if params[:section_id] && params[:section_id] != 'all'
-        options[:include] = { :attachment => { :section_node => :section }} 
-        options[:conditions] = ["sections.id = ?", params[:section_id]]
+        options[:include] = { :attachment =>  :section_node }
+        options[:conditions] = ["section_nodes.ancestry = ?", Section.find(params[:section_id]).ancestry_path]
       end
       options[:page] = params[:page]    
       options[:order] = model_class.default_order if model_class.respond_to?(:default_order)

data/app/controllers/cms/section_nodes_controller.rb

@@ -3,7 +3,12 @@ class Cms::SectionNodesController < Cms::BaseController
   
   def index
     @toolbar_tab = :sitemap
-    @section = Section.root.first
+    @modifiable_sections = current_user.modifiable_sections
+    @public_sections = Group.guest.sections.all # Load once here so that every section doesn't need to.
+
+    @sitemap = Section.sitemap
+    @root_section_node = @sitemap.keys.first
+    @section = @root_section_node.node
   end
   def move_before
     move(:before)

data/app/controllers/cms/sections_controller.rb

@@ -16,7 +16,7 @@ class Cms::SectionsController < Cms::BaseController
   end
   
   def new
-    @section = @parent.sections.build
+    @section = @parent.build_section
     @section.groups = @parent.groups
   end
   

data/app/helpers/cms/application_helper.rb

@@ -23,7 +23,7 @@ module Cms
     def searchable_sections(selected = nil)
       root = Section.root.first
       options = [['All sections', 'all'], [root.name, root.id]]
-      root.all_children_with_name.each { |s|  options << [s.full_path, s.id] }
+      root.master_section_list.each { |s|  options << [s.full_path, s.id] }
       options_for_select(options, selected.to_i)
     end
 

data/app/helpers/cms/content_block_helper.rb

@@ -0,0 +1,27 @@
+module Cms
+  module ContentBlockHelper
+
+
+    # Prints the <tr> for each block. Adds classes based on:
+    # * Name/id of the block
+    # * If a block is published/draft
+    # * If the user can edit/publish it
+    def block_row_tag(block)
+      cname = class_name_for(block)
+      can_modify = current_user.able_to_modify?(block)
+
+      options = {
+          :id => "#{cname}_#{block.id}",
+          :class => cname
+      }
+      options[:class] += block.class.publishable? && !block.published? ? ' draft' : ' published'
+      options[:class] += ' non-editable' unless can_modify && current_user.able_to?(:edit_content)
+      options[:class] += ' non-publishable' unless can_modify && current_user.able_to?(:publish_content)
+      tag "tr", options, true
+    end
+
+    def class_name_for(block)
+      block.class.name.underscore
+    end
+  end
+end

data/app/helpers/cms/section_nodes_helper.rb

@@ -1,13 +1,51 @@
 module Cms
   module SectionNodesHelper
-    def section_icons(node)
-      
-      if (node.root? || node.parent.root? || node.parent.parent.root?)
-        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle large") : image_tag("cms/sitemap/gray_expand.png", :class => "folder_toggle large")
+
+    def access_status(section_node, public_sections)
+      access_icon = :unlocked
+      unless public_sections.include?(section_node)
+        access_icon = :locked
+      end
+      access_icon
+    end
+
+    def section_icons(section_node, children=[])
+      folder_style = ""
+      expander_image = "expand.png"
+      if top_level_section?(section_node)
+        folder_style = " large"
+        expander_image = "gray_expand.png"
+      end
+      if children.empty?
+        image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle#{folder_style}")
       else
-        node.child_nodes.empty? ? image_tag("cms/sitemap/no_contents.png", :class => "no_folder_toggle") : image_tag("cms/sitemap/expand.png", :class => "folder_toggle")
+        image_tag("cms/sitemap/#{expander_image}", :class => "folder_toggle#{folder_style}")
       end
     end
 
+    # Renders the ul for a given node (Page/Section/Link/etc)
+    # Default look:
+    #   - First level pages/sections use 'big' icons
+    #   - All non-first level items should be hidden.
+    def sitemap_ul_tag(node)
+      opts = {
+        :id => "section_node_#{node.section_node.id}",
+        :class => "section_node"
+      }
+      opts[:class] += " rootlet" if in_first_level?(node)
+      opts[:style] = "display: none" unless in_first_level?(node)
+      tag("ul", opts, true)
+    end
+
+    def in_first_level?(node)
+      node.section_node.depth == 1
+    end
+
+    private
+
+    def top_level_section?(node)
+      node.depth <= 2
+    end
+
   end
 end

data/app/models/abstract_file_block.rb

@@ -4,7 +4,10 @@ class AbstractFileBlock < ActiveRecord::Base
       
   validates_presence_of :name  
   
-  named_scope :by_section, lambda { |section| { :include => {:attachment => :section_node }, :conditions => ["section_nodes.section_id = ?", section.id] } } 
+  named_scope :by_section, lambda { |section| {
+      :include => {:attachment => :section_node },
+      :conditions => ["section_nodes.ancestry = ?", section.node.ancestry_path] }
+  }
   
   def path
     attachment_file_path
@@ -14,4 +17,16 @@ class AbstractFileBlock < ActiveRecord::Base
     true
   end
 
+  def set_attachment_path
+    if @attachment_file_path && @attachment_file_path != attachment.file_path
+      attachment.file_path = @attachment_file_path
+    end
+  end
+
+  def set_attachment_section
+    if @attachment_section_id && @attachment_section_id != attachment.section
+      attachment.section_id = @attachment_section_id
+    end
+  end
+
 end

data/app/models/attachment.rb

@@ -20,48 +20,27 @@ class Attachment < ActiveRecord::Base
   before_validation :extract_file_type_from_temp_file
   before_validation :extract_file_size_from_temp_file
   before_validation :set_file_location
-  before_save :process_section
 
   after_save :write_temp_file_to_storage_location
   after_save :clear_ivars  
   
   #----- Associations ----------------------------------------------------------
 
+  include Addressable
+  include Addressable::DeprecatedPageAccessors
   has_one :section_node, :as => :node
+  alias :node :section_node
 
   #----- Validations -----------------------------------------------------------
 
-  validates_presence_of :temp_file, 
-    :message => "You must upload a file", :on => :create
+  validates_presence_of :temp_file, :message => "You must upload a file", :on => :create
   validates_presence_of :file_path
   validates_uniqueness_of :file_path
-  validates_presence_of :section_id
-    
-  #----- Virtual Attributes ----------------------------------------------------
-  
-  def section_id
-    @section_id ||= section_node ? section_node.section_id : nil
-  end
-
-  def section_id=(section_id)
-    if @section_id != section_id 
-      dirty!
-      @section_id = section_id
-    end
-  end
-
-  def section
-    @section ||= section_node ? section_node.section : nil
-  end
 
   def section=(section)
-    if @section != section
-      dirty!
-      @section_id = section ? section.id : nil
-      @section = section
-    end
+    dirty! if self.section != section
+    super(section)
   end
-  
   #----- Callbacks Methods -----------------------------------------------------
   
   def make_dirty_if_temp_file
@@ -103,14 +82,17 @@ class Attachment < ActiveRecord::Base
     end
   end
 
-  def process_section
-    #logger.info "processing section, section_id => #{section_id}, section_node => #{section_node.inspect}"
-    if section_node && !section_node.new_record? && section_node.section_id != section_id
-      section_node.move_to_end(Section.find(section_id))
-    else
-      build_section_node(:node => self, :section_id => section_id)
-    end    
-  end
+  #def process_section
+  #  if section_node
+  #    section_node.move_to_end(parent)
+  #  #end
+  #  #logger.info "processing section, section_id => #{section_id}, section_node => #{section_node.inspect}"
+  #  #if section_node && !section_node.new_record? && section_node.section_id != section_id
+  #  #  section_node.move_to_end(Section.find(section_id))
+  #  else
+  #    build_section_node(:node => self, :parent => parent)
+  #  end
+  #end
     
   def write_temp_file_to_storage_location
     unless temp_file.blank?

data/app/models/file_block.rb

@@ -1,18 +1,6 @@
 class FileBlock < AbstractFileBlock
 
   acts_as_content_block :belongs_to_attachment => true, :taggable => true
-
-  def set_attachment_file_path
-    if @attachment_file_path && @attachment_file_path != attachment.file_path
-      attachment.file_path = @attachment_file_path
-    end
-  end
-
-  def set_attachment_section
-    if @attachment_section_id && @attachment_section_id != attachment.section_id
-      attachment.section_id = @attachment_section_id 
-    end
-  end
   
   def self.display_name
     "File"

data/app/models/image_block.rb

@@ -3,18 +3,6 @@ class ImageBlock < AbstractFileBlock
   acts_as_content_block :versioned => { :version_foreign_key => :file_block_id },
     :belongs_to_attachment => true, :taggable => true
 
-  def set_attachment_file_path
-    if @attachment_file_path && @attachment_file_path != attachment.file_path
-      attachment.file_path = @attachment_file_path
-    end
-  end
-
-  def set_attachment_section
-    if @attachment_section_id && @attachment_section_id != attachment.section_id
-      attachment.section_id = @attachment_section_id 
-    end
-  end
-
   def self.display_name
     "Image"
   end  

data/app/models/link.rb

@@ -3,29 +3,12 @@ class Link < ActiveRecord::Base
   
   named_scope :named, lambda{|name| {:conditions => ['links.name = ?', name]}}
   
-  has_one :section_node, :as => :node, :dependent => :destroy
-  
+  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node
+
   validates_presence_of :name
 
-  def section_id
-    section ? section.id : nil
-  end
-  
-  def section
-    section_node ? section_node.section : nil
-  end
-  
-  def section_id=(sec_id)
-    self.section = Section.find(sec_id)
-  end
-  
-  def section=(sec)
-    if section_node
-      section_node.move_to_end(sec)
-    else
-      build_section_node(:node => self, :section => sec)
-    end      
-  end
+  include Addressable
+  include Addressable::DeprecatedPageAccessors
 
   #needed by menu_helper
   def path

data/app/models/page.rb

@@ -1,5 +1,5 @@
 class Page < ActiveRecord::Base
-  
+
   is_archivable
   flush_cache_on_change
   is_hideable
@@ -42,8 +42,12 @@ class Page < ActiveRecord::Base
     end 
   }  
   
-  has_one :section_node, :as => :node, :dependent => :destroy
-  
+  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node
+
+
+  include Addressable
+  include Addressable::DeprecatedPageAccessors
+
   has_many :tasks
   
   before_validation :append_leading_slash_to_path
@@ -168,26 +172,6 @@ class Page < ActiveRecord::Base
     "?"
   end
   
-  def section_id
-    section ? section.id : nil
-  end
-  
-  def section
-    section_node ? section_node.section : nil
-  end
-  
-  def section_id=(sec_id)
-    self.section = Section.find(sec_id)
-  end
-  
-  def section=(sec)
-    if section_node
-      section_node.move_to_end(sec)
-    else
-      build_section_node(:node => self, :section => sec)
-    end      
-  end
-  
   def public?
     section ? section.public? : false
   end
@@ -223,16 +207,25 @@ class Page < ActiveRecord::Base
     template_file_name && PageTemplate.display_name(template_file_name)
   end
 
-  def ancestors
-    section_node.ancestors
-  end
-  
+  # Determines if a page is a descendant of a given Section.
+  #
+  # @param [String | Section] section_or_section_name
   def in_section?(section_or_section_name)
-    sec = section_or_section_name.is_a?(String) ? 
-      Section.first(:conditions => {:name => section_or_section_name}) : 
-      section_or_section_name
-    fn = lambda{|s| s ? (s == sec || fn.call(s.parent)) : false}
-    fn.call(section)
+    found = false
+    ancestors.each do |a|
+      if section_or_section_name.is_a?(String)
+        if a.name == section_or_section_name
+          found = true
+          break
+        end
+      else
+        if a == section_or_section_name
+          found = true
+          break
+        end
+      end
+    end
+    found
   end
     
   #Returns true if the block attached to each connector in the given container are published
@@ -256,12 +249,16 @@ class Page < ActiveRecord::Base
     (a[1..a.size].map{|a| a.name} + [name]).join(" / ")
   end
   
-  # This will return the "top level section" for a page, which is the section directly
+  # This will return the "top level section" for this page, which is the section directly
   # below the root (a.k.a My Site) that this page is in.  If this page is in root,
   # then this will return root.
+  #
+  # @return [Section] The first non-root ancestor if available, root otherwise.
   def top_level_section
+    # Cache the results of this since many projects will call it repeatly on current_page in menus.
+    return @top_level_section if @top_level_section
     a = ancestors
-    (a.size > 0 && ancestors[1]) ? ancestors[1] : Section.root.first
+    @top_level_section = (a.size > 0 && a[1]) ? a[1] : Section.root.first
   end
   
   def current_task

data/app/models/section.rb

@@ -3,14 +3,15 @@ class Section < ActiveRecord::Base
   flush_cache_on_change
 
   #The node that links this section to its parent
-  has_one :node, :class_name => "SectionNode", :as => :node, :dependent => :destroy
+  has_one :section_node, :class_name => "SectionNode", :as => :node, :inverse_of => :node
 
-  #The nodes that link this section to its children
-  has_many :child_nodes, :class_name => "SectionNode"
-  has_many :child_sections, :class_name => "SectionNode", :conditions => ["node_type = ?", "Section"], :order => 'section_nodes.position'
+  include Addressable
+  include Addressable::NodeAccessors
 
-  has_many :pages, :through => :child_nodes, :source => :node, :source_type => 'Page', :order => 'section_nodes.position'
-  has_many :sections, :through => :child_nodes, :source => :node, :source_type => 'Section', :order => 'section_nodes.position'
+  # Cannot use dependent => :destroy to do this. Ancestry's callbacks trigger before the before_destroy callback.
+  #   So sections would always get deleted since deletable? would return true
+  after_destroy :destroy_node
+  before_destroy :deletable?
 
   has_many :group_sections
   has_many :groups, :through => :group_sections
@@ -21,59 +22,83 @@ class Section < ActiveRecord::Base
   named_scope :hidden, :conditions => {:hidden => true}
   named_scope :not_hidden, :conditions => {:hidden => false}
 
-  named_scope :named, lambda{|name| {:conditions => ['sections.name = ?', name]}}
-  named_scope :with_path, lambda{|path| {:conditions => ['sections.path = ?', path]}}
+  named_scope :named, lambda { |name| {:conditions => ['sections.name = ?', name]} }
+  named_scope :with_path, lambda { |path| {:conditions => ['sections.path = ?', path]} }
 
   validates_presence_of :name, :path
-  #validates_presence_of :parent_id, :if => Proc.new {root.count > 0}, :message => "section is required"
 
   # Disabling '/' in section name for interoperability with FCKEditor file browser
   validates_format_of :name, :with => /\A[^\/]*\Z/, :message => "cannot contain '/'"
 
   validate :path_not_reserved
 
-  before_destroy :deletable?
-
   attr_accessor :full_path
 
-  def visible_child_nodes(options={})
-    children = child_nodes.of_type(["Section", "Page", "Link"]).all(:order => 'section_nodes.position')
-    visible_children = children.select{|sn| sn.visible?}
-    options[:limit] ? visible_children[0...options[:limit]] : visible_children
+  delegate :ancestry_path, :to => :node
+
+  def ancestry
+    self.node.ancestry
   end
 
-  def all_children_with_name
-    child_sections.map do |s|
-      if s.node
-        s.node.full_path = root? ? s.node.name : "#{name} / #{s.node.name}"
-        [s.node] << s.node.all_children_with_name
-      end
-    end.flatten.compact
+  def before_validation
+    unless node
+      self.node = build_section_node
+    end
   end
 
-  def parent_id
-    parent ? parent.id : nil
+  # Returns a list of all children which are sections.
+  # @return [Array<Section>]
+  def sections
+    child_nodes.of_type("Section").fetch_nodes.in_order.collect do |section_node|
+      section_node.node
+    end
   end
 
-  def parent
-    node ? node.section : nil
+  alias :child_sections :sections
+
+  # Since #sections isn't an association anymore, callers can use this rather than #sections.build
+  def build_section
+    Section.new(:parent=>self)
   end
 
-  def parent_id=(sec_id)
-    self.parent = Section.find(sec_id)
+  # Used by the sitemap to find children to iterate over.
+  def child_nodes
+    self.node.children
   end
 
-  def parent=(sec)
-    if node
-      node.move_to_end(sec)
-    else
-      build_node(:node => self, :section => sec)
+  def pages
+    child_pages = self.node.children.collect do |section_node|
+      section_node.node if section_node.page?
     end
+    child_pages.compact
+  end
+
+  def self.sitemap
+    SectionNode.of_type(["Page", "Link", "Section"]).fetch_nodes.arrange(:order=>:position)
   end
 
-  def ancestors(options={})
-    ancs = node ? node.ancestors : []
-    options[:include_self] ? ancs + [self] : ancs
+  def visible_child_nodes(options={})
+    children = child_nodes.of_type(["Section", "Page", "Link"]).fetch_nodes.in_order.all
+    visible_children = children.select { |sn| sn.visible? }
+    options[:limit] ? visible_children[0...options[:limit]] : visible_children
+  end
+
+
+  # Returns a complete list of all sections that are desecendants of this sections, in order, as a single flat list.
+  # Used by Section selectors where users have to pick a single section from a complete list of all sections.
+  def master_section_list
+    sections.map do |section|
+      section.full_path = root? ? section.name : "#{name} / #{section.name}"
+      [section] << section.master_section_list
+    end.flatten.compact
+  end
+
+  def parent_id
+    parent ? parent.id : nil
+  end
+
+  def parent_id=(sec_id)
+    self.parent = Section.find(sec_id)
   end
 
   def with_ancestors(options = {})
@@ -94,33 +119,46 @@ class Section < ActiveRecord::Base
   end
 
   def empty?
-    child_nodes.reject{|n| n.orphaned?}.empty?
+    child_nodes.empty?
   end
 
+  # Callback to determine if this section can be deleted.
   def deletable?
     !root? && empty?
   end
 
+  # Callback to clean up related nodes
+  def destroy_node
+    node.destroy
+  end
+
   def editable_by_group?(group)
     group.editable_by_section(self)
   end
 
   def status
-    public? ? :unlocked : :locked
+    @status ||= public? ? :unlocked : :locked
   end
 
+  # Used by the file browser to look up a section by the combined names as a path.
+  #   i.e. /A/B/
+  # @return [Section] nil if not found
   def self.find_by_name_path(name_path)
-    section = Section.root.first
-    children = name_path.split("/")[1..-1] || []
-    children.each do |name|
-      section = section.sections.first(:conditions => {:name => name})
+    current_section = Section.root.first
+    path_names = name_path.split("/")[1..-1] || []
+
+    # This implementation is very slow as it has to loop over the entire tree in memory to match each name element.
+    path_names.each do |name|
+      current_section.sections.each do |s|
+        current_section = s if s.name == name
+      end
     end
-    section
+    current_section
   end
 
   #The first page that is a decendent of this section
   def first_page_or_link
-    section_node = child_nodes.of_type(['Link', 'Page']).first(:order => "section_nodes.position")
+    section_node = child_nodes.of_type(['Link', 'Page']).fetch_nodes.in_order.first
     return section_node.node if section_node
     sections.each do |s|
       node = s.first_page_or_link