browsercms 3.1.5 → 3.3.0.beta

data/app/models/content_type.rb

@@ -5,9 +5,9 @@ class ContentType < ActiveRecord::Base
   validates_presence_of :content_type_group
   before_validation :set_content_type_group
   
-  named_scope :named, lambda{|name| {:conditions => ['content_types.name = ?', name]}}
+  scope :named, lambda{|name| {:conditions => ['content_types.name = ?', name]}}
   
-  named_scope :connectable, 
+  scope :connectable,
     :include => :content_type_group,
     :conditions => ['content_type_groups.name != ?', 'Categorization'],
     :order => 'content_types.priority, content_types.name'
@@ -19,7 +19,7 @@ class ContentType < ActiveRecord::Base
   # Given a 'key' like 'html_blocks' or 'portlet'
   # Raises exception if nothing was found.
   def self.find_by_key(key)
-    class_name = key.tableize.classify
+    class_name = key.singularize.tableize.classify
     content_type = find_by_name(class_name)
     if content_type.nil?
       if class_name.constantize.ancestors.include?(Portlet)

data/app/models/dynamic_view.rb

@@ -3,7 +3,7 @@ class DynamicView < ActiveRecord::Base
   after_save :write_file_to_disk
   after_destroy :remove_file_from_disk
 
-  named_scope :with_file_name, lambda{|file_name|
+  scope :with_file_name, lambda{|file_name|
     conditions = {:name => nil, :format => nil, :handler => nil}
     if file_name && (parts = file_name.split(".")).size == 3
       conditions[:name] = parts[0]

data/app/models/email_message.rb

@@ -1,6 +1,6 @@
 class EmailMessage < ActiveRecord::Base
   
-  named_scope :undelivered, :conditions => "delivered_at is null"
+  scope :undelivered, :conditions => "delivered_at is null"
   
   validates_presence_of :recipients
   
@@ -24,7 +24,7 @@ class EmailMessage < ActiveRecord::Base
   
   def deliver!
     return false if delivered?
-    EmailMessageMailer.deliver_email_message(self)
+    EmailMessageMailer.email_message(self).deliver
     update_attributes(:delivered_at => Time.now)
   end
   

data/app/models/file_block.rb

@@ -1,6 +1,18 @@
 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/group.rb

@@ -19,11 +19,11 @@ class Group < ActiveRecord::Base
     
   validates_presence_of :name
   
-  named_scope :named, lambda{|n| {:conditions => {:name => n}}}
-  named_scope :with_code, lambda{|c| {:conditions => {:code => c}}}
+  scope :named, lambda{|n| {:conditions => {:name => n}}}
+  scope :with_code, lambda{|c| {:conditions => {:code => c}}}
     
-  named_scope :public, :include => :group_type, :conditions => ["group_types.cms_access = ?", false]
-  named_scope :cms_access, :include => :group_type, :conditions => ["group_types.cms_access = ?", true]
+  scope :public_groups, :include => :group_type, :conditions => ["group_types.cms_access = ?", false]
+  scope :cms_access, :include => :group_type, :conditions => ["group_types.cms_access = ?", true]
   
   def guest?
     group_type && group_type.guest?

data/app/models/group_type.rb

@@ -3,10 +3,10 @@ class GroupType < ActiveRecord::Base
   has_many :group_type_permissions
   has_many :permissions, :through => :group_type_permissions
 
-  named_scope :guest, :conditions => ["group_types.guest = ?", true]
-  named_scope :non_guest, :conditions => ["group_types.guest = ?", false]
+  scope :guest, :conditions => ["group_types.guest = ?", true]
+  scope :non_guest, :conditions => ["group_types.guest = ?", false]
   
-  named_scope :cms_access, :conditions => ["group_types.cms_access = ?", true]
-  named_scope :non_cms_access, :conditions => ["group_types.cms_access = ?", false]
+  scope :cms_access, :conditions => ["group_types.cms_access = ?", true]
+  scope :non_cms_access, :conditions => ["group_types.cms_access = ?", false]
   
 end

data/app/models/html_block.rb

@@ -5,7 +5,7 @@ class HtmlBlock < ActiveRecord::Base
   validates_presence_of :name
   
   # Override of search scope from searching behavior to deal with include_body 
-  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] : "html_blocks.name"
     include_body = search_params.is_a?(Hash) ? search_params[:include_body] : false

data/app/models/image_block.rb

@@ -3,6 +3,18 @@ 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

@@ -1,14 +1,31 @@
 class Link < ActiveRecord::Base
   acts_as_content_block :connectable => false
   
-  named_scope :named, lambda{|name| {:conditions => ['links.name = ?', name]}}
+  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
 
-  include Addressable
-  include Addressable::DeprecatedPageAccessors
+  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
 
   #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
@@ -11,8 +11,8 @@ class Page < ActiveRecord::Base
   has_many :connectors, :order => "connectors.container, connectors.position"
   has_many :page_routes
   
-  named_scope :named, lambda{|name| {:conditions => ['pages.name = ?', name]}}
-  named_scope :with_path, lambda{|path| {:conditions => ['pages.path = ?', path]}}
+  scope :named, lambda{|name| {:conditions => ['pages.name = ?', name]}}
+  scope :with_path, lambda{|path| {:conditions => ['pages.path = ?', path]}}
   
   # This scope will accept a connectable object or a Hash.  The Hash is expect to have
   # a value for the key :connectable, which is the connectable object, and possibly
@@ -20,7 +20,7 @@ class Page < ActiveRecord::Base
   # it will use the value in :version if present, otherwise it will use the version 
   # of the object.  In either case of a connectable object or a Hash, if the object
   # is not versioned, no version will be used
-  named_scope :connected_to, lambda { |b| 
+  scope :connected_to, lambda { |b|
     if b.is_a?(Hash)
       obj = b[:connectable]
       if obj.class.versioned?
@@ -32,7 +32,7 @@ class Page < ActiveRecord::Base
       obj = b
       ver = obj.class.versioned? ? obj.version : nil
     end
-    
+
     if ver
       { :include => :connectors, 
         :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ? and connectors.connectable_version = ?', obj.id, obj.class.base_class.name, ver] }
@@ -41,20 +41,33 @@ class Page < ActiveRecord::Base
         :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ?', obj.id, obj.class.base_class.name] }    
     end 
   }  
-  
-  has_one :section_node, :as => :node, :dependent => :destroy, :inverse_of => :node
-
-
-  include Addressable
-  include Addressable::DeprecatedPageAccessors
 
+  # currently_connected_to tightens the scope of connected_to by restricting to the 
+  # results to matches on current versions of pages only.  This renders obj versions
+  # useless, as the older objects will very likely have older versions of pages and
+  # thus return no results.
+  scope :currently_connected_to, lambda { |obj|
+    ver = obj.class.versioned? ? obj.version : nil
+    if ver
+      { :include => :connectors, 
+        :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ? and connectors.connectable_version = ? and connectors.page_version = pages.version', obj.id, obj.class.base_class.name, ver] }
+    else
+      { :include => :connectors, 
+        :conditions => ['connectors.connectable_id = ? and connectors.connectable_type = ? and connectors.page_version = pages.version', obj.id, obj.class.base_class.name] }    
+    end
+  }
+  
+  has_one :section_node, :as => :node, :dependent => :destroy
+  
   has_many :tasks
   
-  before_validation :append_leading_slash_to_path
+  before_validation :append_leading_slash_to_path, :remove_trailing_slash_from_path
   before_destroy :delete_connectors
   
   validates_presence_of :name, :path
-  validates_uniqueness_of :path
+
+  # Paths must be unique among undeleted records
+  validates_uniqueness_of :path, :scope=>:deleted
   validate :path_not_reserved
           
   def after_build_new_version(new_version)
@@ -75,15 +88,22 @@ class Page < ActiveRecord::Base
       end
     end
   end
-  
+
+  # Each time a page is updated, we need to copy all connectors associated with it forward, and save
+  # them.
   def copy_connectors(options={})
-    connectors.for_page_version(options[:from_version_number]).all(:order => "connectors.container, connectors.position").each do |c|
+    logger.debug {"Copying connectors from Page #{id} v#{options[:from_version_number]} to v#{options[:to_version_number]}." }
+
+    c_found = connectors.for_page_version(options[:from_version_number]).all(:order => "connectors.container, connectors.position")
+    logger.debug {"Found connectors #{c_found}" }
+    c_found.each do |c|
       # The connector won't have a connectable if it has been deleted
       # Also need to see if the draft has been deleted,
       # in which case we are in the process of deleting it
       if c.should_be_copied?
+        logger.debug { "Connector id=>#{c.id} should be copied." }
         connectable = c.connectable_type.constantize.versioned? ? c.connectable.as_of_version(c.connectable_version) : c.connectable
-      
+
         version = connectable.class.versioned? ? connectable.version : nil
 
         #If we are copying connectors from a previous version, that means we are reverting this page,
@@ -96,20 +116,26 @@ class Page < ActiveRecord::Base
           connectable.revert_to(c.connectable_version)
           version = connectable.class.versioned? ? connectable.draft.version : nil
         end      
-      
-        new_connector = connectors.build(
+
+        logger.debug "When copying block #{connectable.inspect} version is '#{version}'"
+
+        new_connector = connectors.create(
           :page_version => options[:to_version_number], 
           :connectable => connectable, 
-          :connectable_version => version,         
+          :connectable_version => version,
           :container => c.container, 
           :position => c.position
         )
+        logger.debug {"Built new connector #{new_connector}."}
       end
     end
     true
   end  
-  
-  def create_connector(connectable, container)
+
+  # Adds a Content block to this page.
+  #
+  #
+  def create_connector(connectable, container=:main)
     transaction do
       raise "Connectable is nil" unless connectable
       raise "Container is required" if container.blank?
@@ -126,6 +152,7 @@ class Page < ActiveRecord::Base
         :container => container)      
     end
   end
+  alias_method :add_content, :create_connector
 
   def move_connector(connector, direction)
     transaction do
@@ -156,7 +183,8 @@ class Page < ActiveRecord::Base
       end
     end
   end          
-          
+
+  # Pages that get deleted should be 'disconnected' from any blocks they were associated with.
   def delete_connectors
     connectors.for_page_version(version).all.each{|c| c.destroy }
   end
@@ -172,6 +200,26 @@ 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
@@ -187,6 +235,12 @@ class Page < ActiveRecord::Base
       self.path = "/#{path}"
     end
   end
+
+  # remove trailing slash, unless the path is only a slash.  uses capture and
+  # substition because ruby regex engine does not support lookbehind
+  def remove_trailing_slash_from_path
+    self.path.sub!(/(.+)\/+$/, '\1') 
+  end
   
   def path_not_reserved
     if Cms.reserved_paths.include?(path)
@@ -207,25 +261,16 @@ class Page < ActiveRecord::Base
     template_file_name && PageTemplate.display_name(template_file_name)
   end
 
-  # Determines if a page is a descendant of a given Section.
-  #
-  # @param [String | Section] section_or_section_name
+  def ancestors
+    section_node.ancestors
+  end
+  
   def in_section?(section_or_section_name)
-    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
+    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)
   end
     
   #Returns true if the block attached to each connector in the given container are published
@@ -249,16 +294,12 @@ class Page < ActiveRecord::Base
     (a[1..a.size].map{|a| a.name} + [name]).join(" / ")
   end
   
-  # This will return the "top level section" for this page, which is the section directly
+  # This will return the "top level section" for a 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
-    @top_level_section = (a.size > 0 && a[1]) ? a[1] : Section.root.first
+    (a.size > 0 && ancestors[1]) ? ancestors[1] : Section.root.first
   end
   
   def current_task

data/app/models/page_route.rb

@@ -1,3 +1,19 @@
+# Allows Rails routes to be matched to CMS pages, allowing arbitrary code that can be executed before the page is rendered.
+#
+# The primary goal of this is to provide human readable (and cachable) URLs for content_blocks. For example,
+# a single 'Article' page can have a portlet that knows how to look up and display an Article by id. By default, this
+# would look like this:
+#   GET /article?id=120
+#
+# Unless the Article page is marked a 'cache enabled = false' this will cause problems. Plus that URL is ugly.
+# With PageRoutes, you can have multiple URLs all map to the article page, like so:
+#   GET /article/2010/12/30/article-1
+#   GET /article/2011/1/18/article-2
+# In both these cases, these URLs can be matched to a Rails Route which is linked to a page:
+# GET /article/:year/:month/:day/:slug -> Articles Page
+#
+# Saving a new PageRoute will reload the Rails routes.
+#
 class PageRoute < ActiveRecord::Base
   belongs_to :page
   has_many :conditions, :class_name => "PageRouteCondition"
@@ -8,22 +24,32 @@ class PageRoute < ActiveRecord::Base
 
   after_save :reload_routes
 
+  # Force Rails to reload the routes. Allows modules to call this without concern that the Rails classes are going to change again.
+  def self.reload_routes
+    Rails.application.reload_routes!
+  end
+
   def reload_routes
-    ActionController::Routing::Routes.load!
+    PageRoute.reload_routes
   end
 
   def add_condition(name, value)
     conditions.build(:name => name.to_s, :value => value.to_s)
   end  
-  
+
+  # @deprecated Use add_constraint instead (matches Rails 3 syntax)
   def add_requirement(name, value)
     requirements.build(:name => name.to_s, :value => value.to_s)
   end
-  
+
+  alias_method :add_constraint, :add_requirement
+
+  # @deprecated Rails 3 no longer uses a 'conditions' element in its syntax for routing.
   def conditions_map
     conditions.inject({}){|acc, e| acc[e.name.to_sym] = e.value.to_sym; acc}
   end
-  
+
+
   def requirements_map
     requirements.inject({}){|acc, e| acc[e.name.to_sym] = Regexp.new(e.value); acc}
   end
@@ -31,8 +57,33 @@ class PageRoute < ActiveRecord::Base
   def route_name
     name ? name.to_slug.gsub('-','_') : nil
   end
-  
+
+  alias_method :as, :route_name
+
+  def to
+    "cms/content#show_page_route"
+  end
+
+  # Returns which methods this route can be via. Defaults to [:get, :post] if not specified.
+  def via
+    found = conditions.collect(){|condition| if condition.name.to_sym == :method; condition.value.to_sym end}
+    methods = found.compact
+    if methods.empty?
+      methods << :get << :post
+    end
+    methods
+  end
+
+  # Builds a hash which can be passed to the :constraints value in a route, like:
+  #
+  # match 'some/:pattern', :constraints => page_route.constraints()
+  def constraints
+    requirements_map
+  end
+
   # This is used in defining the route in the ActionController::Routing
+  # Used in Rails 2 version of routing (No longer valid for rails 3)
+  # @deprecated
   def options_map
     m = {:controller => "cms/content", :action => "show_page_route"}
     
@@ -43,7 +94,11 @@ class PageRoute < ActiveRecord::Base
     
     m
   end
-  
+
+  def page_route_id
+    self.id.to_s
+  end
+
   # This is called by an instance of the content controller 
   # in the process of rendering a page.  This will eval the code
   # stored in this page route in the context of the controller.