browsercms 3.3.4 → 3.4.0.rc1

data/lib/cms/acts/content_block.rb

@@ -1,11 +1,22 @@
 module Cms
   module Acts
     module ContentBlock
+
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
+
       module MacroMethods
+
+        # Adds Content Block behavior to this class
+        #
+        # @param [Hash] options
         def acts_as_content_block(options={})
+          defaults = {
+            # Set default values here.
+          }
+          options = defaults.merge(options)
+
           belongs_to_attachment(options[:belongs_to_attachment].is_a?(Hash) ? options[:belongs_to_attachment] : {}) if options[:belongs_to_attachment]
           is_archivable(options[:archiveable].is_a?(Hash) ? options[:archiveable] : {}) unless options[:archiveable] == false
           is_connectable(options[:connectable].is_a?(Hash) ? options[:connectable] : {}) unless options[:connectable] == false
@@ -15,14 +26,15 @@ module Cms
           is_searchable(options[:searchable].is_a?(Hash) ? options[:searchable] : {}) unless options[:searchable] == false
           uses_soft_delete(options[:soft_delete].is_a?(Hash) ? options[:soft_delete] : {}) unless options[:soft_delete] == false
           is_taggable(options[:taggable].is_a?(Hash) ? options[:taggable] : {}) if options[:taggable]
-          is_userstamped(options[:userstamped].is_a?(Hash) ? options[:userstamped] : {}) unless options[:userstamped] == false  
+          is_userstamped(options[:userstamped].is_a?(Hash) ? options[:userstamped] : {}) unless options[:userstamped] == false
           is_versioned(options[:versioned].is_a?(Hash) ? options[:versioned] : {}) unless options[:versioned] == false
-        
+
           include InstanceMethods
         end
+
         module InstanceMethods
           def to_s
-            "#{self.class.name.titleize} '#{name}'"
+            "#{self.class.name.demodulize.titleize} '#{name}'"
           end
         end
       end

data/lib/cms/addressable.rb

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

data/lib/cms/authentication/controller.rb

@@ -12,14 +12,14 @@
 #
 # 1. Guests - These represents users that are not logged in. What guests can see and do can be modified via the CMS UI. Guests
 #             are not considered to be 'logged in'.
-# 2. 'Current' User - The currently logged in user is stored in a thread local, and can be accessed anywhere via 'User.current'.
+# 2. 'Current' User - The currently logged in user is stored in a thread local, and can be accessed anywhere via 'Cms::User.current'.
 #             This allows model code to easily record which user is making changes to records, for versioning, etc.
 #
 # 3. 'Admin' Access Denied Page - If users try to access a protected controller, they are redirected to the CMS administration Login page
 #             which may be different than the 'front end' user login page. (Cms::Controller handles that differently)
 #
 #
-# To Dos: It appears as though we are storing the 'current' user in two places, @current_user and User.current. This is probably not DRY, but
+# To Dos: It appears as though we are storing the 'current' user in two places, @current_user and Cms::User.current. This is probably not DRY, but
 #   more testing would be needed.
 #
 module Cms
@@ -27,7 +27,7 @@ module Cms
     module Controller
       protected
         # Returns true or false if the user is logged in.
-        # Preloads User.current with the user model if they're logged in.
+        # Preloads Cms::User.current with the user model if they're logged in.
         def logged_in?
           !current_user.nil? && !current_user.guest?
         end
@@ -38,7 +38,7 @@ module Cms
         def current_user
           # Note: We have disabled basic_http_auth
           @current_user ||= begin
-            User.current = (login_from_session || login_from_cookie || User.guest)  
+            Cms::User.current = (login_from_session || login_from_cookie || Cms::User.guest)  
           end
         end
 
@@ -46,7 +46,7 @@ module Cms
         def current_user=(new_user)
           session[:user_id] = new_user ? new_user.id : nil
           @current_user = new_user || false
-          User.current = @current_user
+          Cms::User.current = @current_user
         end
 
         # Check if the user is authorized
@@ -96,7 +96,7 @@ module Cms
           respond_to do |format|
             format.html do
               store_location
-              redirect_to cms_login_path
+              redirect_to cms.login_path
             end
           end
         end
@@ -129,13 +129,13 @@ module Cms
 
         # Called from #current_user.  First attempt to login by the user id stored in the session.
         def login_from_session
-          self.current_user = User.find_by_id(session[:user_id]) if session[:user_id]
+          self.current_user = Cms::User.find_by_id(session[:user_id]) if session[:user_id]
         end
 
         # Called from #current_user.  Now, attempt to login by basic authentication information.
         def login_from_basic_auth
           authenticate_with_http_basic do |login, password|
-            self.current_user = User.authenticate(login, password)
+            self.current_user = Cms::User.authenticate(login, password)
           end
         end
     
@@ -146,7 +146,7 @@ module Cms
         # Called from #current_user.  Finaly, attempt to login by an expiring token in the cookie.
         # for the paranoid: we _should_ be storing user_token = hash(cookie_token, request IP)
         def login_from_cookie
-          user = cookies[:auth_token] && User.find_by_remember_token(cookies[:auth_token])
+          user = cookies[:auth_token] && Cms::User.find_by_remember_token(cookies[:auth_token])
           if user && user.remember_token?
             self.current_user = user
             handle_remember_cookie! false # freshen cookie token (keeping date)
@@ -159,8 +159,8 @@ module Cms
         # However, **all session state variables should be unset here**.
         def logout_keeping_session!
           # Kill server-side auth cookie
-          User.current.forget_me if User.current.is_a? User
-          User.current = false     # not logged in, and don't do it for me
+          Cms::User.current.forget_me if Cms::User.current.is_a? User
+          Cms::User.current = false     # not logged in, and don't do it for me
           kill_remember_cookie!     # Kill client-side auth cookie
           session[:user_id] = nil   # keeps the session but kill our variable
           # explicitly kill any other session variables you set
@@ -183,18 +183,18 @@ module Cms
         # Cookies shouldn't be allowed to persist past their freshness date,
         # and they should be changed at each login
         def valid_remember_cookie?
-          return nil unless User.current
-          (User.current.remember_token?) && 
-            (cookies[:auth_token] == User.current.remember_token)
+          return nil unless Cms::User.current
+          (Cms::User.current.remember_token?) && 
+            (cookies[:auth_token] == Cms::User.current.remember_token)
         end
     
         # Refresh the cookie auth token if it exists, create it otherwise
         def handle_remember_cookie! new_cookie_flag
-          return unless User.current
+          return unless Cms::User.current
           case
-          when valid_remember_cookie? then User.current.refresh_token # keeping same expiry date
-          when new_cookie_flag        then User.current.remember_me 
-          else                             User.current.forget_me
+          when valid_remember_cookie? then Cms::User.current.refresh_token # keeping same expiry date
+          when new_cookie_flag        then Cms::User.current.remember_me 
+          else                             Cms::User.current.forget_me
           end
           send_remember_cookie!
         end
@@ -205,8 +205,8 @@ module Cms
     
         def send_remember_cookie!
           cookies[:auth_token] = {
-            :value   => User.current.remember_token,
-            :expires => User.current.remember_token_expires_at }
+            :value   => Cms::User.current.remember_token,
+            :expires => Cms::User.current.remember_token_expires_at }
         end
 
     end

data/lib/cms/authoring.rb

@@ -0,0 +1,9 @@
+module Cms::Authoring
+
+  # Represents the common permissions that are common for CMS operations.
+  PERMISSIONS = [:edit_content, :administrate, :publish_content]
+
+  # A full fledged editor can do these things.
+  EDITOR_PERMISSIONS = [:edit_content, :publish_content]
+
+end

data/lib/cms/behaviors/attaching.rb

@@ -2,6 +2,7 @@ module Cms
   module Behaviors
     module Attaching
       SANITIZATION_REGEXES = [[/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, '']]
+      #' this tic cleans up emacs ruby mode
 
       def self.included(model_class)
         model_class.extend(MacroMethods)
@@ -18,7 +19,7 @@ module Cms
           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, :class_name => 'Cms::Attachment'
 
           validates_each :attachment_file do |record, attr, value|
             if record.attachment && !record.attachment.valid?
@@ -141,7 +142,7 @@ module Cms
         # 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
+            attachment.section = Cms::Section.root.first
           end
         end
 
@@ -158,7 +159,7 @@ module Cms
         end
 
         def update_attachment_if_changed
-          logger.debug {"UPDATE ATTACHMENT if changed" }
+          logger.debug { "UPDATE ATTACHMENT if changed" }
           if attachment
             attachment.archived = archived if self.class.archivable?
             if respond_to?(:revert_to_version) && revert_to_version
@@ -182,7 +183,7 @@ module Cms
 
         def after_as_of_version
           if attachment_id && attachment_version
-            self.attachment = Attachment.find(attachment_id).as_of_version(attachment_version)
+            self.attachment = Cms::Attachment.find(attachment_id).as_of_version(attachment_version)
           end
         end
 

data/lib/cms/behaviors/categorizing.rb

@@ -13,7 +13,7 @@ module Cms
           extend ClassMethods
           include InstanceMethods
           
-          belongs_to :category
+          belongs_to :category, :class_name => 'Cms::Category'
           
           scope :in_category, lambda{|cat| {:conditions => ["category_id = ?", cat.id]}}
           

data/lib/cms/behaviors/connecting.rb

@@ -1,6 +1,10 @@
 module Cms
   module Behaviors
     module Connecting
+
+      def self.default_naming_for(klass)
+        klass.name.demodulize.titleize
+      end
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
@@ -17,7 +21,7 @@ module Cms
           attr_accessor :connect_to_container
           attr_accessor :connected_page
         
-          has_many :connectors, :as => :connectable    
+          has_many :connectors, :as => :connectable, :class_name => 'Cms::Connector'
 
           attr_accessor :updated_by_page
 
@@ -28,11 +32,12 @@ module Cms
         end
       end
       module ClassMethods
+
         def content_block_type
-          to_s.underscore
+          ActiveModel::Naming.singular(self)
         end
         def display_name
-          to_s.titleize
+          Connecting.default_naming_for(self)
         end
         def display_name_plural
           display_name.pluralize
@@ -91,7 +96,7 @@ module Cms
               if p != updated_by_page
                 #This just creates a new version of the page
                 action = deleted? ? "Deleted" : "Edited"
-                p.update_attributes(:version_comment => "#{self.class.name} ##{id} was #{action}")
+                p.update_attributes(:version_comment => "#{self.class.name.demodulize} ##{id} was #{action}")
 
                 #The previous step will copy over a connector pointing to the previous version of this connectable
                 #We need to change that to point at the new version of this connectable

data/lib/cms/behaviors/dynamic_attributes.rb

@@ -116,12 +116,13 @@ module Cms
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
+
       module MacroMethods
         def has_dynamic_attributes?
           !!@has_dynamic_attributes
         end
-        
-        # Will make the current class have dynamic attributes.
+
+          # Will make the current class have dynamic attributes.
         def has_dynamic_attributes(options={})
           @has_dynamic_attributes = true
           include InstanceMethods
@@ -134,31 +135,32 @@ module Cms
           options[:base_foreign_key] ||= self.name.underscore.foreign_key
           options[:name_field] ||= 'name'
           options[:value_field] ||= 'value'
-          options[:fields].collect! {|f| f.to_s} unless options[:fields].nil?
+          options[:fields].collect! { |f| f.to_s } unless options[:fields].nil?
 
-          # Init option storage if necessary
+            # Init option storage if necessary
           cattr_accessor :dynamic_options
           self.dynamic_options ||= Hash.new
 
-          # Return if already processed.
+            # Return if already processed.
           return if self.dynamic_options.keys.include? options[:class_name]
 
-          # Attempt to load related class. If not create it
+            # Attempt to load related class. If not create it
           begin
             options[:class_name].constantize
           rescue
             Object.const_set(options[:class_name],
-              Class.new(ActiveRecord::Base)).class_eval do
+                             Class.new(ActiveRecord::Base)).class_eval do
+              set_table_name options[:table_name]
               def self.reloadable? #:nodoc:
                 false
               end
             end
           end
 
-          # Store options
+            # Store options
           self.dynamic_options[options[:class_name]] = options
 
-          # Modify attribute class
+            # Modify attribute class
           attribute_class = options[:class_name].constantize
           base_class = self.name.underscore.to_sym
           attribute_class.class_eval do
@@ -166,20 +168,18 @@ module Cms
             alias_method :base, base_class # For generic access
           end
 
-          # Modify main class
+            # Modify main class
           class_eval do
             has_many options[:relationship_name],
-              :class_name => options[:class_name],
-              :table_name => options[:table_name],
-              :foreign_key => options[:foreign_key],
-              :dependent => :destroy
+                     :class_name => options[:class_name],
+                     :foreign_key => options[:foreign_key],
+                     :dependent => :destroy
 
-            # The following is only setup once
+              # The following is only setup once
             unless private_method_defined? :method_missing_without_dynamic_attributes
 
               # Carry out delayed actions before save
               after_validation :save_modified_dynamic_attributes
-#              after_validation_on_update :save_modified_dynamic_attributes
 
               # Make attributes seem real
               alias_method :method_missing_without_dynamic_attributes, :method_missing
@@ -194,6 +194,8 @@ module Cms
 
             end
           end
+
+
         end
       end
       module InstanceMethods
@@ -204,24 +206,57 @@ module Cms
         # not apply at all unless you implement them yourself.
         def is_dynamic_attribute?(attr, model)
           attr = attr.to_s
-          return dynamic_options[model.name][:fields].include?(attr) unless
-            dynamic_options[model.name][:fields].nil?
-          return dynamic_attributes(model).collect {|f| f.to_s}.include?(attr) unless
-            dynamic_attributes(model).nil?
+          return dynamic_options[model.name][:fields].include?(attr) unless dynamic_options[model.name][:fields].nil?
+          return dynamic_attributes(model).collect { |f| f.to_s }.include?(attr) unless dynamic_attributes(model).nil?
           true
         end
 
-        # Return a list of valid dynamic attributes for the given model. Return
-        # nil if any field is allowed. If you want to say no field is allowed
-        # then return an empty array. If you just have a static list the :fields
-        # option is most likely easier.
-        def dynamic_attributes(model); nil end
+          # Return a list of valid dynamic attributes for the given model. Return
+          # nil if any field is allowed. If you want to say no field is allowed
+          # then return an empty array. If you just have a static list the :fields
+          # option is most likely easier.
+        def dynamic_attributes(model)
+          ; nil
+        end
+
+
+        # Overrides the assign_attributes= defined in ActiveRecord::Base(active_record/base.rb)
+        #
+        # The only difference is that this doesn't check to see if the
+        # model responds_to the method before sending it
+        #
+        # Not happy with this copy/paste duplication, but its merely an update to the previous Rails 2/3 behavior
+        # Must remain PUBLIC so other rails methods can call it (like ActiveRecord::Persistence#update_attributes)
+        def assign_attributes(new_attributes, options = {})
+          return unless new_attributes
+
+          attributes = new_attributes.stringify_keys
+          role = options[:as] || :default
+
+          multi_parameter_attributes = []
+
+          unless options[:without_protection]
+            attributes = sanitize_for_mass_assignment(attributes, role)
+          end
+
+          attributes.each do |k, v|
+            if k.include?("(")
+              multi_parameter_attributes << [k, v]
+            else
+              # Dynamic Attributes will take ALL setters (unlike ActiveRecord)
+              send("#{k}=", v)
+            end
+          end
+
+          assign_multiparameter_attributes(multi_parameter_attributes)
+        end
+      end
 
         private
 
-        # Called after validation on update so that dynamic attributes behave
-        # like normal attributes in the fact that the database is not touched
-        # until save is called.
+          # Called after validation on update so that dynamic attributes behave
+          # like normal attributes in the fact that the database is not touched
+          # until save is called.
         def save_modified_dynamic_attributes
           return if new_record?
           return if @save_dynamic_attr.nil?
@@ -239,7 +274,7 @@ module Cms
           @save_dynamic_attr = []
         end
 
-        # Overrides ActiveRecord::Base#read_attribute
+          # Overrides ActiveRecord::Base#read_attribute
         def read_attribute_with_dynamic_attributes(attr_name)
           attr_name = attr_name.to_s
           exec_if_related attr_name do |model|
@@ -254,7 +289,7 @@ module Cms
           read_attribute_without_dynamic_attributes(attr_name)
         end
 
-        # Overrides ActiveRecord::Base#write_attribute
+          # Overrides ActiveRecord::Base#write_attribute
         def write_attribute_with_dynamic_attributes(attr_name, value)
           attr_name = attr_name.to_s
           exec_if_related attr_name do |model|
@@ -270,7 +305,7 @@ module Cms
                 name_field = dynamic_options[model.name][:name_field]
                 foreign_key = dynamic_options[model.name][:foreign_key]
                 dynamic_related(model).build name_field => attr_name,
-                  value_field => value, foreign_key => self.id
+                                             value_field => value, foreign_key => self.id
               end
               return value
             else
@@ -281,8 +316,8 @@ module Cms
           write_attribute_without_dynamic_attributes(attr_name, value)
         end
 
-        # Implements dynamic-attributes as if real getter/setter methods
-        # were defined.
+          # Implements dynamic-attributes as if real getter/setter methods
+          # were defined.
         def method_missing_with_dynamic_attributes(method_id, *args, &block)
           begin
             method_missing_without_dynamic_attributes method_id, *args, &block
@@ -299,19 +334,19 @@ module Cms
           end
         end
 
-        # Retrieve the related dynamic attribute object
+          # Retrieve the related dynamic attribute object
         def dynamic_related_attr(model, attr)
-            name_field = dynamic_options[model.name][:name_field]
-            dynamic_related(model).to_a.find {|r| r.send(name_field) == attr}
+          name_field = dynamic_options[model.name][:name_field]
+          dynamic_related(model).to_a.find { |r| r.send(name_field) == attr }
         end
 
-        # Retrieve the collection of related dynamic attributes
+          # Retrieve the collection of related dynamic attributes
         def dynamic_related(model)
           relationship = dynamic_options[model.name][:relationship_name]
           send relationship
         end
 
-        # Yield only if attr_name is a dynamic_attribute
+          # Yield only if attr_name is a dynamic_attribute
         def exec_if_related(attr_name)
           return false if self.class.column_names.include? attr_name
           each_dynamic_relation do |model|
@@ -321,17 +356,17 @@ module Cms
           end
         end
 
-        # Yields for each dynamic relation.
+          # Yields for each dynamic relation.
         def each_dynamic_relation
-          dynamic_options.keys.each {|kls| yield kls.constantize}
+          dynamic_options.keys.each { |kls| yield kls.constantize }
         end
 
-        # Returns the options for the dynamic attributes
+          # Returns the options for the dynamic attributes
         def dynamic_options
           nonversioned_class(self.class).dynamic_options
         end
 
-        # Will return the parent model if kls is a versioned class
+          # Will return the parent model if kls is a versioned class
         def nonversioned_class(kls)
           if kls.name =~ /\:\:Version$/
             base_class = kls.name
@@ -340,31 +375,7 @@ module Cms
           end
           kls
         end
-        
-        # Overrides the attributes= defined in ActiveRecord::Base
-        #
-        # The only difference is that this doesn't check to see if the
-        # model responds_to the method before sending it
-        # This is needed for Rails 2.2
-        def attributes=(new_attributes, guard_protected_attributes = true)
-          return if new_attributes.nil?
-          attributes = new_attributes.dup
-          attributes.stringify_keys!
 
-          multi_parameter_attributes = []
-          attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
-
-          attributes.each do |k, v|
-            if k.include?("(")
-              multi_parameter_attributes << [ k, v ]
-            else
-              send(:"#{k}=", v)
-            end
-          end
-
-          assign_multiparameter_attributes(multi_parameter_attributes)
-        end                         
-      end
     end
   end
 end