browsercms 3.1.5 → 3.3.0.beta

data/app/models/permission.rb

@@ -5,6 +5,6 @@ class Permission < ActiveRecord::Base
   validates_presence_of :name
   validates_uniqueness_of :name
   
-  named_scope :named, lambda{|name| {:conditions => {:name => name}}}
+  scope :named, lambda{|name| {:conditions => {:name => name}}}
   
 end

data/app/models/portlet.rb

@@ -18,13 +18,18 @@ class Portlet < ActiveRecord::Base
   ensure
     subclass.class_eval do
       
-      has_dynamic_attributes
+      has_dynamic_attributes(:class_name=>'PortletAttribute', :foreign_key=>'portlet_id')
       
       acts_as_content_block(
         :versioned => false, 
         :publishable => false,
         :renderable => {:instance_variable_name_for_view => "@portlet"})
-      
+
+      # Used to skip the 'after_save' callbacks that connect blocks to pages.
+      # Portlets aren't verisonable but are connectable, so this will prevent the saving of portlets.  
+      attr_accessor :skip_callbacks
+
+
       def self.template_path
         default_template_path
       end      
@@ -44,7 +49,7 @@ class Portlet < ActiveRecord::Base
   end
   
   def self.types
-    @types ||= ActiveSupport::Dependencies.load_paths.map do |d| 
+    @types ||= ActiveSupport::Dependencies.autoload_paths.map do |d|
       if d =~ /app\/portlets/
         Dir["#{d}/*_portlet.rb"].map do |p| 
           File.basename(p, ".rb").classify
@@ -122,7 +127,12 @@ class Portlet < ActiveRecord::Base
       {:label => "Type", :method => :type_name, :order => "type" },
       {:label => "Updated On", :method => :updated_on_string, :order => "updated_at"} ]
   end
-  
+
+  # Duck typing (like a ContentBlock) for determining if this block should have a usages link or not.
+  def self.connectable?
+    true
+  end
+
   #----- Portlet Action Related Methods ----------------------------------------
   def instance_name
     "#{self.class.name.demodulize.underscore}_#{id}"

data/app/models/section.rb

@@ -3,93 +3,51 @@ class Section < ActiveRecord::Base
   flush_cache_on_change
 
   #The node that links this section to its parent
-  has_one :section_node, :class_name => "SectionNode", :as => :node, :inverse_of => :node
+  has_one :node, :class_name => "SectionNode", :as => :node, :dependent => :destroy
 
-  include Addressable
-  include Addressable::NodeAccessors
+  #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'
 
-  # 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 :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'
 
   has_many :group_sections
   has_many :groups, :through => :group_sections
 
-  named_scope :root, :conditions => ['root = ?', true]
-  named_scope :system, :conditions => {:name => 'system'}
+  scope :root, :conditions => ['root = ?', true]
+  scope :system_section, :conditions => {:name => 'system'}
 
-  named_scope :hidden, :conditions => {:hidden => true}
-  named_scope :not_hidden, :conditions => {:hidden => false}
+  scope :hidden, :conditions => {:hidden => true}
+  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]} }
+  scope :named, lambda{|name| {:conditions => ['sections.name = ?', name]}}
+  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
 
-  attr_accessor :full_path
-
-  delegate :ancestry_path, :to => :node
-
-  def ancestry
-    self.node.ancestry
-  end
-
-  def before_validation
-    unless node
-      self.node = build_section_node
-    end
-  end
-
-  # 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
-
-  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
-
-  # Used by the sitemap to find children to iterate over.
-  def child_nodes
-    self.node.children
-  end
-
-  def pages
-    child_pages = self.node.children.collect do |section_node|
-      section_node.node if section_node.page?
-    end
-    child_pages.compact
-  end
+  before_destroy :deletable?
 
-  def self.sitemap
-    SectionNode.of_type(["Page", "Link", "Section"]).fetch_nodes.arrange(:order=>:position)
-  end
+  attr_accessor :full_path
 
   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? }
+    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
   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
+  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
   end
 
@@ -97,10 +55,27 @@ class Section < ActiveRecord::Base
     parent ? parent.id : nil
   end
 
+  def parent
+    node ? node.section : nil
+  end
+
   def parent_id=(sec_id)
     self.parent = Section.find(sec_id)
   end
 
+  def parent=(sec)
+    if node
+      node.move_to_end(sec)
+    else
+      build_node(:node => self, :section => sec)
+    end
+  end
+
+  def ancestors(options={})
+    ancs = node ? node.ancestors : []
+    options[:include_self] ? ancs + [self] : ancs
+  end
+
   def with_ancestors(options = {})
     options.merge! :include_self => true
     self.ancestors(options)
@@ -119,46 +94,33 @@ class Section < ActiveRecord::Base
   end
 
   def empty?
-    child_nodes.empty?
+    child_nodes.reject{|n| n.orphaned?}.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
-    @status ||= public? ? :unlocked : :locked
+    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)
-    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
+    section = Section.root.first
+    children = name_path.split("/")[1..-1] || []
+    children.each do |name|
+      section = section.sections.first(:conditions => {:name => name})
     end
-    current_section
+    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']).fetch_nodes.in_order.first
+    section_node = child_nodes.of_type(['Link', 'Page']).first(:order => "section_nodes.position")
     return section_node.node if section_node
     sections.each do |s|
       node = s.first_page_or_link

data/app/models/section_node.rb

@@ -1,31 +1,10 @@
 class SectionNode < ActiveRecord::Base
-  has_ancestry
+  belongs_to :section
+  belongs_to :node, :polymorphic => :true
 
-  # This is the parent section for this node
-  # For backwards compatiblity
-  def parent_section
-    self.parent ? self.parent.node : nil
-  end
-
-  alias :section :parent_section
-
-  # For backwards compatiblity
-  def section=(new_section)
-    self.parent = new_section.node
-  end
+  acts_as_list :scope => :section
 
-  # The item this node links to
-  belongs_to :node, :polymorphic => :true, :inverse_of => :section_node
-
-  acts_as_list
-  # For acts_as_list. Specifies that position should be unique within a section.
-  def scope_condition
-    ancestry ? "ancestry = '#{ancestry}'" : 'ancestry IS NULL'
-  end
-
-  named_scope :of_type, lambda{|types| {:conditions => ["section_nodes.node_type IN (?)", types]}}
-  named_scope :in_order, :order => "position asc"
-  named_scope :fetch_nodes, :include => :node
+  scope :of_type, lambda{|types| {:conditions => ["section_nodes.node_type IN (?)", types]}}
 
   def visible?
     return false unless node
@@ -48,29 +27,27 @@ class SectionNode < ActiveRecord::Base
   def page?
     node_type == 'Page'
   end
-
-  # @param [Section] section
-  # @param [Integer] position
-  def move_to(section, position)
+  
+  def move_to(sec, pos)
     #logger.info "Moving Section Node ##{id} to Section ##{sec.id} Position #{pos}"
     transaction do
-      if self.parent != section.node
+      if section != sec
         remove_from_list
-        self.parent = section.node
+        self.section = sec
         save
       end
       
-      if position < 0
-        position = 0
+      if pos < 0
+        pos = 0
       else
         #This helps prevent the position from getting out of whack
         #If you pass in a really high number for position, 
         #this just corrects it to the right number
-        node_count = SectionNode.count(:conditions => {:ancestry => ancestry})
-        position = node_count if position > node_count
+        node_count = SectionNode.count(:conditions => {:section_id => section_id})
+        pos = node_count if pos > node_count
       end
       
-      insert_at_position(position)
+      insert_at_position(pos)
     end
   end
   
@@ -100,9 +77,17 @@ class SectionNode < ActiveRecord::Base
     #1.0/0 == Infinity
     move_to(sec, 1.0/0)
   end
-
-
-  def ancestry_path
-    path_ids.join "/"
+  
+  def ancestors()
+    ancestors = []
+    fn = lambda do |sn|
+      ancestors << sn.section
+      if sn.section && !sn.section.root?
+        fn.call(sn.section.node)
+      end
+    end
+    fn.call(self)
+    ancestors.reverse
   end
+  
 end

data/app/models/site.rb

@@ -7,7 +7,7 @@ class Site < ActiveRecord::Base
   before_save :unset_default
   after_save :set_default
   
-  named_scope :default, :conditions => {:the_default => true}
+  scope :default, :conditions => {:the_default => true}
     
   def self.find_by_domain(domain)
     d = domain.clone

data/app/models/tag.rb

@@ -6,7 +6,7 @@ class Tag < ActiveRecord::Base
   
   attr_accessor :size
   is_searchable  
-  named_scope :named, lambda{|tag| {:conditions => ["tags.name = ? ", tag]} }
+  scope :named, lambda{|tag| {:conditions => ["tags.name = ? ", tag]} }
   
   # Returns an array of tags with a count attribute
   def self.counts(options={})

data/app/models/task.rb

@@ -7,11 +7,11 @@ class Task < ActiveRecord::Base
   after_create :mark_other_tasks_for_the_same_page_as_complete
   after_create :send_email
   
-  named_scope :complete, :conditions => ["completed_at is not null"]
-  named_scope :incomplete, :conditions => ["completed_at is null"]
+  scope :complete, :conditions => ["completed_at is not null"]
+  scope :incomplete, :conditions => ["completed_at is null"]
   
-  named_scope :for_page, lambda{|p| {:conditions => ["page_id = ?", p]}}
-  named_scope :other_than, lambda{|t| {:conditions => ["id != ?", t.id]}}
+  scope :for_page, lambda{|p| {:conditions => ["page_id = ?", p]}}
+  scope :other_than, lambda{|t| {:conditions => ["id != ?", t.id]}}
   
   validates_presence_of :assigned_by_id, :message => "is required"
   validates_presence_of :assigned_to_id, :message => "is required"
@@ -42,10 +42,11 @@ class Task < ActiveRecord::Base
     elsif assigned_to.email.blank?
       logger.warn "Can't send email for task because assigned to user #{assigned_to.login}:#{assigned_to.id} has no email address"
     else
-      if SITE_DOMAIN =~ /^www/
-        host = SITE_DOMAIN.sub(/^www\./, "#{cms_domain_prefix}.")
+      domain = SITE_DOMAIN
+      if domain =~ /^www/
+        host = domain.sub(/^www\./, "#{cms_domain_prefix}.")
       else
-        host = "#{cms_domain_prefix}.#{SITE_DOMAIN}"
+        host = "#{cms_domain_prefix}.#{domain}"
       end
       email = EmailMessage.create(
                                   :sender => assigned_by.email,

data/app/models/user.rb

@@ -18,8 +18,8 @@ class User < ActiveRecord::Base
   has_many :groups, :through => :user_group_memberships
   has_many :tasks, :foreign_key => "assigned_to_id"
 
-  named_scope :active, :conditions => ["expires_at IS NULL OR expires_at > ?", Time.now.utc]    
-  named_scope :able_to_edit_or_publish_content, 
+  scope :active, :conditions => ["expires_at IS NULL OR expires_at > ?", Time.now.utc]
+  scope :able_to_edit_or_publish_content,
     :include => {:groups => :permissions}, 
     :conditions => ["permissions.name = ? OR permissions.name = ?", "edit_content", "publish_content"]
 
@@ -106,11 +106,6 @@ class User < ActiveRecord::Base
     @modifiable_sections ||= Section.find(:all, :include => {:groups => [:group_type, :users]}, :conditions => ["users.id = ? and group_types.cms_access = ?", id, true])
   end
 
-  #def unmodifiable_sections
-  #
-  #  #@modifiable_sections ||= Section.find(:all, :include => {:groups => [:group_type, :users]}, :conditions => ["users.id = ? and group_types.cms_access = ?", id, true])
-  #end
-
   # Expects a list of names of Permissions
   # true if the user has any of the permissions
   def able_to?(*required_permissions)

data/app/portlets/forgot_password_portlet.rb

@@ -4,11 +4,15 @@ class ForgotPasswordPortlet < Portlet
   enable_template_editor true
 
   def render
+    logger.warn "Handling Class #{request.class}"
+    logger.warn "Handling FORGOT as #{request.method}"
+    logger.warn "Am I a POST? #{request.post?}"
     flash[:forgot_password] = {}
 
-    return unless request.method == :post
+    return unless request.post?
     user = User.find_by_email(params[:email])
-    
+
+    logger.warn "Send email "
     unless user
       flash[:forgot_password][:error] = "We were unable to verify your account. Please make sure your email address is accurate."
       return

data/app/portlets/reset_password_portlet.rb

@@ -15,7 +15,7 @@ class ResetPasswordPortlet < Portlet
       return
     end
 
-    if request.method == :post
+    if request.post?
       @user.password = params[:password]
       @user.password_confirmation = params[:password_confirmation]