bf4-browsercms 3.1.0

data/lib/cms/behaviors/searching.rb

@@ -0,0 +1,49 @@
+module Cms
+  module Behaviors
+    module Searching
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def searchable?
+          !!@is_searchable
+        end
+        def is_searchable(options={})
+          @is_searchable = true
+          @searchable_columns = options[:searchable_columns] ? options[:searchable_columns].map(&:to_sym) : [:name]
+          extend ClassMethods
+        
+          #This is in a method to allow classes to override it
+          named_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] : default_order_for_search
+            conditions = []
+            unless term.blank?
+              searchable_columns.each do |c|
+                if conditions.empty?
+                  conditions = ["#{table_name}.#{c} like ?"]
+                else
+                  conditions.first << "or #{table_name}.#{c} like ?"
+                end
+                conditions << "%#{term}%"
+              end
+              conditions[0] = "(#{conditions[0]})"
+            end
+            scope = {}
+            scope[:conditions] = conditions if conditions
+            scope[:order] = order if order
+            scope                      
+          }
+        end
+      end
+      module ClassMethods
+        def searchable_columns
+          @searchable_columns
+        end
+        def default_order_for_search
+          "#{table_name}.#{searchable_columns.first}"
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/soft_deleting.rb

@@ -0,0 +1,77 @@
+module Cms
+  module Behaviors
+    module SoftDeleting
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def uses_soft_delete?
+          !!@uses_soft_delete
+        end
+        def uses_soft_delete(options={})
+          @uses_soft_delete = true
+        
+          named_scope :not_deleted, :conditions => ["#{table_name}.deleted = ?", false]
+          class << self
+            alias_method :find_with_deleted, :find
+            alias_method :count_with_deleted, :count
+            alias_method :delete_all!, :delete_all
+          end
+          alias_method :destroy_without_callbacks!, :destroy_without_callbacks
+        
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      module ClassMethods
+        def find(*args)
+          not_deleted.find_with_deleted(*args)
+        end
+        def count(*args)
+          not_deleted.count_with_deleted(*args)
+        end
+        def delete_all(conditions=nil)
+          update_all(["deleted = ?", true], conditions)
+        end
+        def exists?(id_or_conditions)
+          if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
+            conditions = {:conditions => id_or_conditions}
+          else
+            conditions = {:conditions => {:id => id_or_conditions}}
+          end
+          count(conditions) > 0
+        end      
+      end
+      module InstanceMethods
+        #Overrides original destroy method
+        def destroy_without_callbacks
+          if self.class.publishable?
+            update_attributes(:deleted => true, :publish_on_save => true)
+          else
+            update_attributes(:deleted => true)
+          end
+        end
+
+        def mark_as_deleted!
+          destroy_without_callbacks
+        end
+
+        def destroy_with_callbacks!
+          return false if callback(:before_destroy) == false
+          result = destroy_without_callbacks!
+          @destroyed = true
+          callback(:after_destroy)
+          result
+        end
+
+        def destroy!
+          transaction { destroy_with_callbacks! }
+        end
+
+        def destroyed?
+          @destroyed
+        end        
+      end
+    end
+  end
+end

data/lib/cms/behaviors/taggable.rb

@@ -0,0 +1,57 @@
+module Cms
+  module Behaviors
+    module Taggable
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def taggable?
+          !!@is_taggable
+        end
+        def is_taggable(options={})
+          @is_taggable = true
+          @tag_separator = options[:separator] || " "
+          
+          has_many :taggings, :as => :taggable
+          has_many :tags, :through => :taggings, :order => "tags.name"                    
+          
+          named_scope :tagged_with, lambda{|t| {:include => {:taggings => :tag}, :conditions => ["tags.name = ?", t]} }          
+                    
+          after_save :save_tags          
+                    
+          extend ClassMethods
+          include InstanceMethods
+        end
+      end
+      module ClassMethods
+        def tag_cloud
+          Tagging.cloud(base_class.name)
+        end
+        def tag_separator
+          @tag_separator
+        end
+      end
+      module InstanceMethods
+        def tag_list
+          @tag_list ||= tags.reload.map(&:name).join(self.class.tag_separator)
+        end
+        def tag_list=(tag_names)
+          changed_attributes["tag_list"] = tag_list unless @tag_list == tag_names
+          @tag_list = tag_names
+        end
+        def save_tags
+          tag_list_tags = tag_list.to_s.split(self.class.tag_separator).map{|t| Tag.find_or_create_by_name(t.strip) }
+          taggings.each do |tg|
+            if tag_list_tags.include?(tg.tag)
+              tag_list_tags.delete(tg.tag)
+            else
+              tg.destroy
+            end
+          end
+          tag_list_tags.each{|t| taggings.create(:tag => t, :taggable => self) }
+          self.tag_list = nil
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/userstamping.rb

@@ -0,0 +1,37 @@
+module Cms
+  module Behaviors
+    module Userstamping
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def userstamped?
+          !!@is_userstamped
+        end
+        def is_userstamped(options={})
+          @is_userstamped = true
+          extend ClassMethods
+          include InstanceMethods
+        
+          belongs_to :created_by, :class_name => "User"
+          belongs_to :updated_by, :class_name => "User"
+        
+          before_save :set_userstamps
+        
+          named_scope :created_by, lambda{|user| {:conditions => {:created_by => user}}}        
+          named_scope :updated_by, lambda{|user| {:conditions => {:updated_by => user}}}        
+        end
+      end
+      module ClassMethods
+      end
+      module InstanceMethods
+        def set_userstamps
+          if new_record?
+            self.created_by = User.current 
+          end
+          self.updated_by = User.current
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/versioning.rb

@@ -0,0 +1,273 @@
+module Cms
+  module Behaviors
+    module Versioning
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def versioned?
+          !!@is_versioned
+        end
+        def is_versioned(options={})
+          @is_versioned = true
+
+          @version_foreign_key = (options[:version_foreign_key] || "#{name.underscore}_id").to_s
+          @version_table_name = (options[:version_table_name] || "#{table_name.singularize}_versions").to_s
+
+          extend ClassMethods
+          include InstanceMethods
+
+          has_many :versions, :class_name  => version_class_name, :foreign_key => version_foreign_key
+
+          before_validation_on_create :initialize_version
+
+          attr_accessor :revert_to_version
+
+          #Define the version class
+          const_set("Version", Class.new(ActiveRecord::Base)).class_eval do 
+            class << self; attr_accessor :versioned_class end
+
+            def versioned_class
+              self.class.versioned_class
+            end
+            def versioned_object_id
+              send("#{versioned_class.name.underscore}_id")
+            end
+            def versioned_object
+              send(versioned_class.name.underscore.to_sym)
+            end                 
+          end
+
+          version_class.versioned_class = self
+
+          version_class.belongs_to(name.underscore.to_sym, :foreign_key => version_foreign_key)
+
+          version_class.is_userstamped if userstamped?
+
+        end
+      end
+      module ClassMethods        
+        def version_class
+          const_get "Version"
+        end
+
+        def version_class_name
+          "#{name}::Version"
+        end        
+
+        def version_foreign_key
+          @version_foreign_key
+        end
+
+        def version_table_name        
+          @version_table_name
+        end
+
+        def versioned_columns
+          @versioned_columns ||= (version_class.new.attributes.keys - 
+            (%w[id lock_version position version_comment created_at updated_at created_by_id updated_by_id type] + [version_foreign_key]))
+        end                   
+      end
+      module InstanceMethods
+        def initialize_version
+          self.version = 1
+        end
+
+        def build_new_version
+          # First get the values from the draft
+          attrs = draft_attributes
+
+          # Now overwrite all values
+          (self.class.versioned_columns - %w(version)).each do |col|
+            attrs[col] = send(col)
+          end
+
+          attrs[:version_comment] = @version_comment || default_version_comment
+          @version_comment = nil            
+          new_version = versions.build(attrs)
+          new_version.version = new_record? ? 1 : (draft.version.to_i + 1)
+          after_build_new_version(new_version) if respond_to?(:after_build_new_version)
+          new_version
+        end
+
+        def draft_attributes
+          # When there is no draft, we'll just copy the attibutes from this object
+          # Otherwise we need to use the draft
+          d = new_record? ? self : draft
+          self.class.versioned_columns.inject({}){|attrs, col| attrs[col] = d.send(col); attrs }
+        end 
+
+        def default_version_comment
+          if new_record?
+            "Created"
+          else
+            "Changed #{(changes.keys - %w[version created_by_id updated_by_id]).sort.join(', ')}"
+          end
+        end
+
+        def save(perform_validations=true)
+          transaction do
+            #logger.info "..... Calling valid?"
+            return false unless !perform_validations || valid?            
+            
+            if different_from_last_draft?
+              #logger.info "..... Changes => #{changes.inspect}"
+            else
+              #logger.info "..... No Changes"
+              return true
+            end
+            
+            #logger.info "..... Calling before_save"
+            return false if callback(:before_save) == false
+
+            if new_record?
+              #logger.info "..... Calling before_create"
+              return false if callback(:before_create) == false
+            else      
+              #logger.info "..... Calling before_update"
+              return false if callback(:before_update) == false
+            end
+
+            #logger.info "..... Calling build_new_version"
+            new_version = build_new_version
+            #logger.info "..... Is new version valid? #{new_version.valid?}"
+            if new_record?
+              self.version = 1
+              #logger.info "..... Calling create_without_callbacks"
+              if result = create_without_callbacks
+                #logger.info "..... Calling after_create"
+                if callback(:after_create) != false
+                  #logger.info "..... Calling after_save"
+                  callback(:after_save)
+                end
+                
+                if @publish_on_save
+                  publish
+                  @publish_on_save = nil
+                end                
+                changed_attributes.clear                                   
+              end
+              result
+            elsif new_version
+              #logger.info "..... Calling save"
+              if result = new_version.save
+                #logger.info "..... Calling after_save"
+                if callback(:after_update) != false
+                  #logger.info "..... Calling after_update"
+                  callback(:after_save)
+                end
+                
+                if @publish_on_save
+                  publish
+                  @publish_on_save = nil
+                end 
+                changed_attributes.clear
+              end
+              result
+            end
+            true
+          end
+        end
+
+        def save!(perform_validations=true)
+          save(perform_validations) || raise(ActiveRecord::RecordNotSaved.new(errors.full_messages))
+        end
+
+        def draft
+          versions.first(:order => "version desc")    
+        end
+        
+        def draft_version?
+          version == draft.version
+        end
+        
+        def live_version
+          find_version(self.class.find(id).version)
+        end
+
+        def live_version?
+          version == self.class.find(id).version
+        end
+
+        def current_version
+          find_version(self.version)
+        end
+        
+        def find_version(number)
+          versions.first(:conditions => { :version => number })
+        end
+
+        def as_of_draft_version
+          as_of_version(draft.version)
+        end
+
+        def as_of_version(version)
+          v = find_version(version)
+          raise ActiveRecord::RecordNotFound.new("version #{version.inspect} does not exist for <#{self.class}:#{id}>") unless v
+          obj = self.class.new
+
+          (self.class.versioned_columns + [:version, :created_at, :created_by_id, :updated_at, :updated_by_id]).each do |a|
+            obj.send("#{a}=", v.send(a))
+          end
+          obj.id = id
+          obj.lock_version = lock_version
+
+          # Need to do this so associations can be loaded
+          obj.instance_variable_set("@new_record", false)
+
+          # Callback to allow us to load other data when an older version is loaded
+          obj.after_as_of_version if obj.respond_to?(:after_as_of_version)
+
+          # Last but not least, clear the changed attributes
+          if changed_attrs = obj.send(:changed_attributes)
+            changed_attrs.clear
+          end
+
+          obj      
+        end
+
+        def revert
+          draft_version = draft.version
+          revert_to(draft_version - 1) unless draft_version == 1
+        end
+
+        def revert_to_without_save(version)
+          raise "Version parameter missing" if version.blank?
+          self.revert_to_version = find_version(version)
+          raise "Could not find version #{version}" unless revert_to_version
+          (self.class.versioned_columns - ["version"]).each do |a|
+            send("#{a}=", revert_to_version.send(a))
+          end  
+          self.version_comment = "Reverted to version #{version}"
+          self            
+        end    
+
+        def revert_to(version)
+          revert_to_without_save(version)
+          save
+        end    
+
+        def version_comment
+          @version_comment
+        end
+
+        def version_comment=(version_comment)
+          @version_comment = version_comment
+          send(:changed_attributes)["version_comment"] = @version_comment
+        end
+
+        def different_from_last_draft?
+          return true if self.changed?
+          last_draft = self.draft
+          return true unless last_draft
+          (self.class.versioned_columns - %w(version)).each do |col|
+            return true if self.send(col) != last_draft.send(col)
+          end
+          return false
+        end
+
+      end
+    end
+
+  end
+end