browsercms 3.0.0

data/lib/cms/authentication/model.rb

@@ -0,0 +1,116 @@
+module Cms
+  module Authentication
+    module Model
+      def self.included(model_class)
+        model_class.extend ClassMethods
+        model_class.class_eval do
+          include InstanceMethods
+        
+          # Virtual attribute for the unencrypted password
+          attr_accessor :password
+          validates_presence_of     :password,                   :if => :password_required?
+          validates_presence_of     :password_confirmation,      :if => :password_required?
+          validates_confirmation_of :password,                   :if => :password_required?
+          #validates_length_of       :password, :within => 6..40, :if => :password_required?
+          before_save :encrypt_password
+        end      
+      end
+
+      module ClassMethods
+        def authenticate(login, password)
+          u = find_by_login(login) # need to get the salt
+          u && u.authenticated?(password) && !u.expired? ? u : nil
+        end
+
+        #Method to make it easy to change a user's password from the console, not used in the app
+        def change_password(login, new_password)
+          find_by_login(login).change_password(new_password)
+        end
+
+        def make_token
+          secure_digest(Time.now, (1..10).map{ rand.to_s })
+        end
+
+        def password_digest(password, salt)
+          key = '8771d0d9bef6f1091b723d2e701a17c811d69b26'
+          digest = key
+          10.times do
+            digest = secure_digest(digest, salt, password, key)
+          end
+          digest
+        end      
+      
+        def secure_digest(*args)
+          Digest::SHA1.hexdigest(args.flatten.join('--'))
+        end      
+      
+      end
+    
+      module InstanceMethods
+        #Method to make it easy to change a user's password from the console, not used in the app
+        def change_password(new_password)
+          update_attributes(:password => new_password, :password_confirmation => new_password)
+        end      
+      
+        # Encrypts the password with the user salt
+        def encrypt(password)
+          self.class.password_digest(password, salt)
+        end
+      
+        def authenticated?(password)
+          crypted_password == encrypt(password)
+        end
+      
+        # before filter 
+        def encrypt_password
+          return if password.blank?
+          self.salt = self.class.make_token if new_record?
+          self.crypted_password = encrypt(password)
+        end
+      
+        def password_required?
+          crypted_password.blank? || !password.blank?
+        end      
+      
+        def remember_token?
+          (!remember_token.blank?) && 
+            remember_token_expires_at && (Time.now.utc < remember_token_expires_at.utc)
+        end
+
+        # These create and unset the fields required for remembering users between browser closes
+        def remember_me
+          remember_me_for 2.weeks
+        end
+
+        def remember_me_for(time)
+          remember_me_until time.from_now.utc
+        end
+
+        def remember_me_until(time)
+          self.remember_token_expires_at = time
+          self.remember_token            = self.class.make_token
+          save
+        end
+
+        # refresh token (keeping same expires_at) if it exists
+        def refresh_token
+          if remember_token?
+            self.remember_token = self.class.make_token 
+            save      
+          end
+        end
+
+        # 
+        # Deletes the server-side record of the authentication token.  The
+        # client-side (browser cookie) and server-side (this remember_token) must
+        # always be deleted together.
+        #
+        def forget_me
+          self.remember_token_expires_at = nil
+          self.remember_token            = nil
+          save
+        end      
+      end
+    end
+  end
+end

data/lib/cms/behaviors.rb

@@ -0,0 +1,33 @@
+# Behaviors are used in CMS to add features to a model. 
+# They are very similar to the various "acts_as_*" or "*_fu" plugins/gems 
+# that have been created for Rails.  
+#
+# Generally, each behavior has three modules in it.  They are:
+# * MacroMethods
+# * ClassMethods
+# * InstanceMethods
+#
+# When the CMS starts up, all of the Behaviors are included into ActiveRecord::Base.
+# The MacroMethods module of each Behavior is also included into ActiveRecord::Base.
+# The MacroMethods module contains Class methods that you can call within your model
+# in order to enable that Behavior for that Class.  For example, if you want to have
+# an Article module that is taggable, you would do this:
+#
+#     class Article < ActiveRecord::Base
+#       is_taggable
+#     end
+#
+# So in this case, you are calling the `is_taggable` macro method, which enables the 
+# taggable behavior for the Article model.  It enables the behavior by extending the
+# ClassMethods module and including the InstanceMethods module into the Article class.
+# Each Behavior typically has one macro method which takes an options Hash, which of course
+# varies from Behavior to Behavior.  The macro method will also sometimes call other
+# macro methods, like before_fitler, named_scope, etc. to modify the model.
+# Consult the documentation for each module for specific details as to what
+# the Behavior does.
+module Cms::Behaviors; end
+
+Dir["#{File.dirname(__FILE__)}/behaviors/*.rb"].each do |b| 
+  require File.join("cms", "behaviors", File.basename(b, ".rb"))
+  ActiveRecord::Base.send(:include, "Cms::Behaviors::#{File.basename(b, ".rb").camelize}".constantize)
+end

data/lib/cms/behaviors/archiving.rb

@@ -0,0 +1,43 @@
+module Cms
+  module Behaviors
+    module Archiving
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def archivable?
+          !!@is_archivable
+        end
+        def is_archivable(options={})
+          @is_archivable = true
+          include InstanceMethods
+
+          named_scope :archived, :conditions => {:archived => true}
+          named_scope :not_archived, :conditions => {:archived => false}        
+        end
+      end
+      module InstanceMethods
+        def archive
+          self.archived = true
+          self.version_comment = "Archived"
+          self.save
+        end
+        def archive!
+          self.archived = true
+          self.version_comment = "Archived"          
+          self.save!
+        end
+        def unarchive
+          self.archived = false
+          self.version_comment = "Unarchived"          
+          self.save
+        end
+        def unarchive!
+          self.archived = false
+          self.version_comment = "Unarchived"          
+          self.save!
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/attaching.rb

@@ -0,0 +1,184 @@
+module Cms
+  module Behaviors
+    module Attaching
+      SANITIZATION_REGEXES = [ [/\s/, '_'], [/[&+()]/, '-'], [/[=?!'"{}\[\]#<>%]/, ''] ]
+      
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      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_save :update_attachment_if_changed
+          after_save :clear_attachment_ivars
+          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  
+                  record.errors.add(:attachment_file, err_value)
+                end
+              end      
+            end
+          end       
+        end
+      end
+      module InstanceMethods
+
+        def attachment_file
+          @attachment_file ||= attachment ? attachment.temp_file : nil
+        end
+
+        def attachment_file=(file)
+          if @attachment_file != file
+            dirty!
+            @attachment_file = file
+          end
+        end
+
+        def attachment_file_name
+          @attachment_file_name ||= attachment ? attachment.file_name : nil
+        end
+
+        def attachment_file_path
+          @attachment_file_path ||= attachment ? attachment.file_path : nil
+        end
+
+        def attachment_file_path=(file_path)
+          fp = sanitize_file_path(file_path)
+          if @attachment_file_path != fp
+            dirty!
+            @attachment_file_path = fp
+          end
+        end
+
+        def attachment_section_id
+          @attachment_section_id ||= attachment ? attachment.section_id : nil
+        end
+
+        def attachment_section_id=(section_id)
+          if @attachment_section_id != section_id
+            dirty!
+            @attachment_section_id = section_id
+          end
+        end
+
+        def attachment_section
+          @attachment_section ||= attachment ? attachment.section : nil
+        end
+
+        def attachment_section=(section)
+          if @attachment_section != section
+            dirty!
+            @attachment_section_id = section ? section.id : nil
+            @attachment_section = section
+          end
+        end
+
+        def process_attachment
+          if attachment.nil? && attachment_file.blank?
+            unless attachment_file_path.blank?
+              errors.add(:attachment_file, "You must upload a file")
+              return false
+            end
+            unless attachment_section_id.blank?
+              errors.add(:attachment_file, "You must upload a file")
+              return false
+            end              
+          else
+            build_attachment if attachment.nil?  
+            attachment.temp_file = attachment_file 
+            set_attachment_file_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?
+              errors.add(:attachment_file, "Section is required for attachment")
+              return false
+            end
+          end
+        end
+
+        def clear_attachment_ivars
+          @attachment_file = nil
+          @attachment_file_path = nil
+          @attachment_section_id = nil
+          @attachment_section = nil            
+        end
+
+        # Override this method if you would like to override the way the section is set
+        def set_attachment_section
+          if new_record? && !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
+          if new_record? && !attachment_file.blank?
+            attachment.file_path = "/attachments/#{File.basename(attachment_file.original_filename).to_s.downcase}"
+          end
+        end
+
+        def sanitize_file_path(file_path)
+          SANITIZATION_REGEXES.inject(file_path.to_s) do |s, (regex, replace)|
+            s.gsub(regex, replace)
+          end
+        end
+
+        def update_attachment_if_changed
+          if attachment
+            attachment.archived = archived if self.class.archivable?
+            if respond_to?(:revert_to_version) && revert_to_version
+              attachment.revert_to(revert_to_version.attachment_version)
+            elsif new_record? || attachment.changed? || attachment.temp_file
+              attachment.save
+            end
+            self.attachment_version = attachment.draft.version
+          end
+        end
+
+        def after_publish
+          attachment.publish
+        end
+
+        #Size in kilobytes
+        def file_size
+          attachment ? "%0.2f" % (attachment.file_size / 1024.0) : "?"
+        end
+
+        def after_as_of_version
+          if attachment_id && attachment_version
+            self.attachment = Attachment.find(attachment_id).as_of_version(attachment_version)
+          end
+        end
+
+        def attachment_link
+          if attachment
+            (published? && live_version?) ? attachment_file_path : "/cms/attachments/#{attachment_id}?version=#{attachment_version}"
+          else
+            nil
+          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/categorizing.rb

@@ -0,0 +1,31 @@
+module Cms
+  module Behaviors
+    module Categorizing
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def belongs_to_category?
+          !!@belongs_to_category
+        end
+        def belongs_to_category
+          @belongs_to_category = true
+          extend ClassMethods
+          include InstanceMethods
+          
+          belongs_to :category
+          
+          named_scope :in_category, lambda{|cat| {:conditions => ["category_id = ?", cat.id]}}
+          
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def category_name
+          category && category.name
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/connecting.rb

@@ -0,0 +1,99 @@
+module Cms
+  module Behaviors
+    module Connecting
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def connectable?
+          !!@is_connectable
+        end
+        def is_connectable(options={})
+          @is_connectable = true
+          extend ClassMethods
+          include InstanceMethods
+
+          attr_accessor :connect_to_page_id
+          attr_accessor :connect_to_container
+          attr_accessor :connected_page
+        
+          has_many :connectors, :as => :connectable    
+
+          attr_accessor :updated_by_page
+
+          after_create :connect_to_page
+          after_save :update_connected_pages
+        end
+      end
+      module ClassMethods
+        def content_block_type
+          to_s.underscore
+        end
+        def display_name
+          to_s.titleize
+        end
+        def display_name_plural
+          display_name.pluralize
+        end                
+      end
+      module InstanceMethods
+
+        def connected_pages
+          Page.connected_to(self)
+        end
+
+        def connected_page_count
+          Page.connected_to(self).count
+        end
+
+        def content_block_type
+          self.class.content_block_type
+        end
+
+        def display_name
+          self.class.display_name
+        end
+
+        def display_name_plural
+          self.class.display_name_plural
+        end
+      
+        def connect_to_page
+          unless connect_to_page_id.blank? || connect_to_container.blank?
+            #Note that we are setting connected_page so that page can look at that 
+            #to determine if the page should be published            
+            self.connected_page = Page.find(connect_to_page_id)
+            connected_page.create_connector(self, connect_to_container)
+          end
+          true
+        end        
+      
+        def update_connected_pages
+          # If this is versioned, then we need make new versions of all the pages this is connected to
+          if self.class.versioned? 
+            #logger.info "..... Updating connected pages for #{self.class} #{id} v#{version}"
+
+            #Get all the pages the previous version of this connectable was connected to
+            draft_version = draft.version            
+            Page.connected_to(:connectable => self, :version => (draft_version - 1)).all.each do |p|
+              # This is needed in the case of updating page,
+              # which updates this object, so as not to create a loop
+              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}")
+
+                #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
+                p.connectors.for_page_version(p.draft.version).for_connectable(self).each do |con|
+                  con.update_attribute(:connectable_version, draft_version)
+                end
+              end
+            end
+          end
+          true
+        end        
+      end
+    end
+  end
+end