browsercms 3.5.7 → 4.0.0.alpha

data/lib/cms/behaviors/rendering.rb

@@ -37,7 +37,6 @@ module Cms
           @instance_variable_name_for_view = options[:instance_variable_name_for_view]
 
           extend ClassMethods
-          extend EngineHelper
           include InstanceMethods
 
           # I'm not pleased with the need to include all of the these rails helpers onto every 'renderable' content item
@@ -82,11 +81,7 @@ module Cms
       # of the renderable, so if you have an Article that is renderable, 
       # the template will be "articles/render"
       def template_path
-        path = "#{name.underscore.pluralize}/render"
-        if main_app_model?
-          path = "cms/#{path}"
-        end
-        path
+        "#{name.underscore.pluralize}/render"
       end
 
       # Instance variables that will not be copied from the renderable to the view
@@ -96,6 +91,19 @@ module Cms
 
     end
     module InstanceMethods
+
+      # Returns the Mercury editor type for a given attribute
+      # @param [Symbol] method (i.e. :name, :content, etc)
+      # @return [Hash]
+      def editor_info(method)
+        column = self.class.columns_hash[method.to_s]
+        if column.type == :text
+          {:element => 'div', :region => 'full'}
+        else
+          {:element => 'span', :region => 'simple'}
+        end
+      end
+
       def prepare_to_render(controller)
         # Give this renderable a reference to the controller
         @controller = controller
@@ -123,7 +131,7 @@ module Cms
 
         if self.respond_to?(:deleted) && self.deleted
           logger.error "Attempting to render deleted object: #{self.inspect}"
-          msg = (@mode == 'edit' ? %Q[<div class="error">This #{self.class.name} has been deleted.  Please remove this container from the page</div>] : '')
+          msg = (edit_mode? ? %Q[<div class="error">This #{self.class.name} has been deleted.  Please remove this container from the page</div>] : '')
           return msg
         end
 

data/lib/cms/behaviors/searching.rb

@@ -26,11 +26,12 @@ module Cms
                 end
                 conditions << "%#{term}%"
               end
-              conditions[0] = "(#{conditions[0]})"
+              #conditions[0] = "(#{conditions[0]})"
             end
-            scope = {}
-            scope[:conditions] = conditions if conditions
-            scope
+            where(conditions)
+            #scope = {}
+            #scope[:conditions] = conditions if conditions
+            #scope
           }
         end
       end

data/lib/cms/behaviors/soft_deleting.rb

@@ -17,18 +17,18 @@ module Cms
         def uses_soft_delete(options={})
           @uses_soft_delete = true
 
-          scope :not_deleted, :conditions => ["#{table_name}.deleted = ?", false]
+          scope :not_deleted, -> {where (["#{table_name}.deleted = ?", false])}
           class << self
             alias_method :delete_all!, :delete_all
           end
 
           extend ClassMethods
           include InstanceMethods
-          attr_accessible :deleted
+         #attr_accessible :deleted
 
           # By default, all queries for blocks should filter out deleted rows.
           begin
-            default_scope where(:deleted => false)
+            default_scope {where(:deleted => false)}
           # This may fail during gem loading, if no DB or the table does not exist. Log it and move on.
           rescue StandardError => e
             handle_missing_table_error_during_startup("Can't set a default_scope for soft_deleting", e)
@@ -43,13 +43,10 @@ module Cms
       # See http://github.com/fernandoluizao/acts_as_active for an implementation of this
       module ClassMethods
 
-        # Returns all records, including those which are marked as deleted.
-        #
-        # Basically 'find' exactly how ActiveRecord originally implements it.
-        #
-        # @param args Same params as ActiveRecord.find
-        def find_with_deleted(* args)
-          self.with_exclusive_scope { find(* args) }
+        # Returns a content block even if it is marked as deleted.
+        # @param [Hash] options Hash suitable to be passed to '#where'
+        def find_with_deleted(options)
+          self.unscoped.where(options).first
         end
 
         # Returns a count of all records of this type, including those marked as deleted.
@@ -58,20 +55,20 @@ module Cms
         #
         # @param args Same params as ActiveRecord.count
         def count_with_deleted(* args)
-          self.with_exclusive_scope { count(* args) }
+          self.unscoped.count(* args)
         end
 
         def delete_all(conditions=nil)
-          update_all(["deleted = ?", true], conditions)
+          where(conditions).update_all(["deleted = ?", true])
         end
 
         def exists?(id_or_conditions)
-          if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
-            conditions = {:conditions => id_or_conditions}
+          query = if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
+            where id_or_conditions
           else
-            conditions = {:conditions => {:id => id_or_conditions}}
+            where(:id => id_or_conditions)
           end
-          count(conditions) > 0
+          query.count > 0
         end
       end
       module InstanceMethods

data/lib/cms/behaviors/taggable.rb

@@ -4,31 +4,36 @@ module Cms
       def self.included(model_class)
         model_class.extend(MacroMethods)
       end
-      module MacroMethods      
+
+      module MacroMethods
         def taggable?
           !!@is_taggable
         end
+
         def is_taggable(options={})
           @is_taggable = true
           @tag_separator = options[:separator] || " "
-          
+
           has_many :taggings, :as => :taggable, :class_name => 'Cms::Tagging'
-          has_many :tags, :through => :taggings, :order => "#{Cms::Tag.table_name}.name", :class_name => 'Cms::Tag'          
-          
-          scope :tagged_with, lambda{|t| {:include => {:taggings => :tag}, :conditions => ["#{Cms::Tag.table_name}.name = ?", t]} }
+          has_many :tags, -> { order("#{Cms::Tag.table_name}.name") }, :class_name => 'Cms::Tag', :through => :taggings
+
+
+          after_save :save_tags
 
-          after_save :save_tags          
-                    
           extend ClassMethods
           include InstanceMethods
 
-          attr_accessible :tag_list
         end
       end
       module ClassMethods
+        def tagged_with(t)
+          where(["#{Cms::Tag.table_name}.name = ?", t]).includes(:taggings => :tag).references(:tags)
+        end
+
         def tag_cloud
           Cms::Tagging.cloud(base_class.name)
         end
+
         def tag_separator
           @tag_separator
         end
@@ -37,12 +42,14 @@ module Cms
         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| Cms::Tag.find_or_create_by_name(t.strip) }
+          tag_list_tags = tag_list.to_s.split(self.class.tag_separator).map { |t| Cms::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)
@@ -50,7 +57,7 @@ module Cms
               tg.destroy
             end
           end
-          tag_list_tags.each{|t| taggings.create(:tag => t, :taggable => self) }
+          tag_list_tags.each { |t| taggings.create(:tag => t, :taggable => self) }
           self.tag_list = nil
         end
       end

data/lib/cms/behaviors/versioning.rb

@@ -5,7 +5,7 @@ module Cms
     # Skip sanitizing attributes from mass assignment. This should be used sparingly, since it bypasses security.
     # Ideally used for dynamically created classes (like ::Version or ::Attribute) where the attributes are not known at
     # design time.
-    def sanitize(attributes, authorizer)
+    def sanitize(klass, attributes, authorizer)
       attributes
     end
   end
@@ -86,7 +86,6 @@ module Cms
           before_validation :initialize_version
           before_save :build_new_version
           attr_accessor :skip_callbacks
-          attr_accessible :version_comment
 
           #Define the version class
           #puts "is_version called for #{self}"
@@ -96,7 +95,7 @@ module Cms
             end
 
             include VersionRecord
-            self.mass_assignment_sanitizer = Cms::IgnoreSanitizer.new
+            #self.mass_assignment_sanitizer = Cms::IgnoreSanitizer.new
 
             def versioned_class
               self.class.versioned_class
@@ -155,7 +154,7 @@ module Cms
           #Rails 3 could use update_column here instead
           if respond_to? :latest_version
             sql = "UPDATE #{self.class.table_name} SET latest_version = #{draft.version} where id = #{self.id}"
-            connection.execute sql
+            self.class.connection.execute sql
             self.latest_version = draft.version # So we don't need to #reload this object. Probably marks it as dirty though, which could have weird side effects.
           end
         end
@@ -193,16 +192,6 @@ module Cms
           end
         end
 
-        def publish_if_needed
-          #logger.debug { "#{self.class}#publish_if_needed. publish? = '#{!!@publish_on_save}'" }
-
-          if @publish_on_save
-            publish
-            @publish_on_save = nil
-          end
-        end
-
-
         #
         #ActiveRecord 3.0.0 call chain
         # ActiveRecord 3 now uses basic inheritence rather than alias_method_chain.  The order in which ActiveRecord::Base
@@ -264,11 +253,17 @@ module Cms
           save(:validate => perform_validations) || raise(ActiveRecord::RecordNotSaved.new(errors.full_messages))
         end
 
+        # Returns the most recently created Version for this class. Drafts are the most recent change from
+        # the _versions table for a given content item.
+        #    i.e. For Cms::Page, this would return Cms::Page::Version
+        #
+        # @return [<Class>::Version] The version for this class that represents the draft.
         def draft
-          versions.first(:order => "version desc")
+          versions.order("version desc").first
         end
 
         def draft_version?
+          return true unless draft
           version == draft.version
         end
 
@@ -285,7 +280,7 @@ module Cms
         end
 
         def find_version(number)
-          versions.first(:conditions => {:version => number})
+          versions.where(:version => number).first
         end
 
         def as_of_draft_version
@@ -324,6 +319,7 @@ module Cms
 
           self.after_revert(revert_to_version) if self.respond_to?(:after_revert)
           self.version_comment = "Reverted to version #{version}"
+          self.publish_on_save = false
           self
         end
 

data/lib/cms/commands/to_version400.rb

@@ -0,0 +1,10 @@
+module Cms
+  module Commands
+    module ToVersion400
+
+      def generate_devise_configuration
+        template 'devise.rb.erb', 'config/initializers/devise.rb'
+      end
+    end
+  end
+end

data/lib/cms/concerns.rb

@@ -0,0 +1,7 @@
+# Each concern should be automatically added to each ActiveRecord class using extend.
+module Cms::Concerns; end
+
+Dir["#{File.dirname(__FILE__)}/concerns/*.rb"].each do |b|
+  require File.join("cms", "concerns", File.basename(b, ".rb"))
+  ActiveRecord::Base.extend "Cms::Concerns::#{File.basename(b, ".rb").camelize}".constantize
+end

data/lib/cms/concerns/can_be_addressable.rb

@@ -0,0 +1,326 @@
+module Cms
+  module Concerns
+    module CanBeAddressable
+
+      # Adds Addressable behavior to a model. This allows models to be inserted into the sitemap, having parent
+      # sections. By default, this method is available to all ActiveRecord::Base classes.
+      #
+      # @params [Hash] options
+      # @option options [String] :path The base path where instances will be placed.
+      # @option options [String] :no_dynamic_path Set as true if the Record has a :path attribute managed as a column in the db. (Default: false)
+      # @option options [Symbol] :destroy_if Name of a custom method used to determine when this object should be destroyed. Rather than dependant: destroy to determine if the section node should be destroyed when this object is.
+      def is_addressable(options={})
+        has_one_options = {as: :node, inverse_of: :node, class_name: 'Cms::SectionNode', validate: true}
+        unless options[:destroy_if]
+          has_one_options[:dependent] = :destroy
+        else
+          before_destroy options[:destroy_if]
+          after_destroy :destroy_node
+        end
+
+        has_one :section_node, has_one_options
+        # For reasons that aren't clear, just using :autosave doesn't work.
+        after_save do
+          if section_node && section_node.changed?
+            section_node.save
+          end
+        end
+
+        after_validation do
+          # Copy errors from association for slug
+          if section_node && !section_node.valid?
+            section_node.errors[:slug].each do |message|
+              errors.add(:slug, message)
+            end
+          end
+        end
+
+        include Cms::Concerns::Addressable
+        extend Cms::Concerns::Addressable::ClassMethods
+        include Cms::Concerns::Addressable::NodeAccessors
+        include Cms::Concerns::Addressable::MarkAsDirty
+        extend Cms::Configuration::ConfigurableTemplate
+
+        if options[:path]
+          @path = options[:path]
+          include GenericSitemapBehavior
+        end
+
+        @template = options[:template]
+
+        unless options[:no_dynamic_path]
+          include Addressable::DynamicPath
+        end
+      end
+
+      # @return [Boolean] Until is_addressable is called, this will always be false.
+      def addressable?
+        false
+      end
+
+      # @return [Boolean] Some addressable content types don't require a slug.
+      def requires_slug?
+        false
+      end
+    end
+
+    # Implements behavior for displaying content blocks that should appear in the sitemap.
+    #
+    module GenericSitemapBehavior
+      def self.included(klass)
+        klass.before_validation :assign_parent_if_needed
+      end
+
+      def partial_for
+        "addressable_content_block"
+      end
+
+      def hidden?
+        false
+      end
+
+      def assign_parent_if_needed
+        unless parent || parent_id
+          new_parent = Cms::Section.with_path(self.class.path).first
+
+          unless new_parent
+            logger.warn "Creating default section for #{self.try(:display_name)} in #{self.class.path}."
+            section_attributes = {:name => self.class.name.demodulize.pluralize,
+                                  :path => self.class.path,
+                                  :hidden => true,
+                                  allow_groups: :all}
+            section_parent = Cms::Section.root.first
+            if section_parent
+              section_attributes[:parent] = section_parent
+            end
+            new_parent = Cms::Section.create!(section_attributes)
+          end
+          self.parent_id = new_parent.id
+        end
+      end
+    end
+
+    module Addressable
+
+      module ClassMethods
+
+        def requires_slug?
+          !@path.nil?
+        end
+
+        # The base path where new records will be added.
+        # @return [String]
+        def path
+          @path
+        end
+
+        # @return [Boolean] Once is_addressable is called, this will always be true.
+        def addressable?
+          true
+        end
+
+        def calculate_path(slug)
+          "#{self.path}/#{slug}"
+        end
+
+        # Used in UI forms to show what the complete URL will look like with a slug added to it.
+        def base_path
+          "#{self.path}/"
+        end
+
+        # Find an addressable object with the given content type.
+        #
+        # @param [String] slug
+        # @return [Addressable] The content block with that slug (if it exists). Nil otherwise
+        def with_slug(slug)
+          section_node = SectionNode.where(slug: slug).where(node_type: self.name).first
+          section_node ? section_node.node : nil
+        end
+
+        # Returns the layout (Page Template) that should be used to render instances of this content.
+        # Can be specified as is_addressable template: 'subpage'
+        # @return [String] template/default unless template was set.
+        def layout
+          normalize_layout(self, @template)
+        end
+      end
+
+      module DynamicPath
+
+        # @return [String] The relative path to this content
+        def path
+          self.class.calculate_path(slug)
+        end
+
+        def slug
+          if section_node
+            section_node.slug
+          else
+            nil
+          end
+        end
+
+        def slug=(slug)
+          if section_node
+            section_node.slug = slug
+          else
+            @slug = slug # Store temporarily until there is a section_node created.
+          end
+          dirty!
+        end
+      end
+
+      # Resources are accessible to guests if their parent section is. Variables are passed in for performance reasons
+      # since this gets called 'MANY' times on the sitemap.
+      #
+      # @param [Array<Section>] public_sections
+      # @param [Section] parent
+      def accessible_to_guests?(public_sections, parent)
+        public_sections.include?(parent)
+      end
+
+      # Returns all classes which need a custom route to show themselves.
+      def self.classes_that_require_custom_routes
+        descendants.select { |klass| klass.path != nil }
+      end
+
+      # List of all classes that can be in the sitemap.
+      #
+      # @return [Array<Class>] Returns all classes which inherit from Cms::Concerns::Addressable
+      def self.descendants
+        ObjectSpace.each_object(::Class).select { |klass| klass < Cms::Concerns::Addressable }
+      end
+
+      # Allows for manual destruction of node
+      def destroy_node
+        node.destroy
+      end
+
+      # Whether or not this content is the 'landing' page for its section.
+      #
+      # @return [Boolean] false always, since a content block won't ever be the landing page for the section
+      def landing_page?
+        false
+      end
+
+      # Returns the value that will appear in the <title> element of the page when this content is rendered.
+      # Subclasses can override this.
+      #
+      # @return [String]
+      # @example Override the page title
+      #   class MyWidget < ActiveRecord::Base
+      #     def page_title
+      #       "My Widget | #{name}"
+      #     end
+      #   end
+      def page_title
+        name
+      end
+
+      # 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>] Or [] if no ancestors and/or has no parent.
+      #
+      def ancestors(options={})
+        return [] unless node
+        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_id
+        parent.try(:id)
+      end
+
+      def parent_id=(id)
+        self.parent = Cms::Section.find(id)
+        # Handles slug being set before there is a parent
+        if @slug
+          self.slug = @slug
+          @slug = nil
+        end
+      end
+
+      def parent=(sec)
+        if node
+          node.move_to_end(sec)
+        else
+          build_section_node(:node_id => self.id, :section => sec)
+        end
+      end
+
+      # Computes the name of the partial used to render this object in the sitemap.
+      def partial_for
+        self.class.name.demodulize.underscore
+      end
+
+      # alias :node, :section_node
+      module NodeAccessors
+        def node
+          section_node
+        end
+
+        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
+
+        def self.included(model_class)
+          #model_class.attr_accessible :section_id, :section
+        end
+
+
+        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
+
+        end
+      end
+
+      # Allows records to be marked as being changed, which can be called to trigger updates when
+      # associated objects may have been changed.
+      module MarkAsDirty
+        # Forces this record to be changed, even if nothing has changed
+        # This is necessary if just the section.id has changed, for example
+        # test if this is necessary now that the attributes are in the
+        # model itself.
+        def dirty!
+          # Seems like a hack, is there a better way?
+          self.updated_at = Time.now
+        end
+      end
+    end
+
+
+  end
+end