browsercms 3.5.7 → 4.0.0.alpha

data/lib/cms/authentication/test_password_strategy.rb

@@ -0,0 +1,19 @@
+module Cms
+  module Authentication
+    # For testing external authentication.
+    class TestPasswordStrategy < Devise::Strategies::Authenticatable
+      EXPECTED_LOGIN = EXPECTED_PASSWORD = 'test'
+      def authenticate!
+        if(authentication_hash[:login] == password && password == EXPECTED_PASSWORD)
+          user = Cms::ExternalUser.authenticate(authentication_hash[:login], 'Test Password', {first_name: "Test", last_name: "User"})
+          user.authorize('cms-admin', 'content-editor')
+          success!(user)
+        else
+          pass
+        end
+      end
+    end
+  end
+end
+
+Warden::Strategies.add(:test_password, Cms::Authentication::TestPasswordStrategy)

data/lib/cms/behaviors.rb

@@ -31,3 +31,4 @@ 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

@@ -12,8 +12,8 @@ module Cms
           @is_archivable = true
           include InstanceMethods
 
-          scope :archived, :conditions => {:archived => true}
-          scope :not_archived, :conditions => {:archived => false}        
+          scope :archived, ->{where(:archived => true)}
+          scope :not_archived, ->{where(:archived => false)}
         end
       end
       module InstanceMethods

data/lib/cms/behaviors/attaching.rb

@@ -3,56 +3,24 @@ module Cms
   module Behaviors
     # Allows one or more files to be attached to content blocks.
     #
-    # class Book
+    # class Book < ActiveRecord::Base
     #   acts_as_content_block
-    #   uses_paperclip
+    #   has_attachment :cover
     # end
     #
-    # It would probably be nice to do something like:
-    #
-    # class Book
-    #   acts_as_content_block :uses_paperclip => true
-    # end
     #
-    # has_attached_asset and has_many_attached_assets are very similar.
-    # They both define a couple of methods in the content block:
+    # To add a set of multiple attachments:
     #
     # class Book
-    #   uses_paperclip
+    #   acts_as_content_block
     #
-    #   has_attached_asset :cover
-    #   has_many_attached_assets :drafts
+    #   has_attachment :cover
+    #   has_many_attachments :drafts
     # end
     #
-    #  book = Book.new
-    #  book.cover = nil #is basically calling: book.assets.named(:cover).first
-    #  book.drafts = [] #is calling book.assets.named(:drafts)
-    #
-    #  Book#cover and Book#drafts both return Asset objects as opposed to what
-    #  happens with stand alone Paperclip:
-    #
-    #  class Book
-    #     has_attached_file :invoice #straight Paperclip
-    #  end
-    #
-    #  Book.new.invoice # returns an instance of Paperclip::Attachment
-    #
-    #  However, Asset instances respond to most of the same methods
-    #  Paperclip::Attachments do (at least the most usefull ones and the ones
-    #  that make sense for this implementation). Please see asset.rb for more on
-    #  this.
-    #
-    #  At the moment, calling has_attached_asset does not enforce that only
-    #  one asset is created, it only defines a method that returns the first one
-    #  ActiveRecord finds. It would be possible to do if that makes sense.
-    #
-    #  In terms of validations, I'm aiming to expose the same 3 class methods
-    #  Paperclip exposes, apart from those needed by BCMS itself (like enforcing
-    #  unique attachment paths) but this is not ready yet:
-    #
-    #  validates_asset_size
-    #  validates_asset_presence
-    #  validates_asset_content_type
+    #  Adds the following methods to Book:
+    #  - Book#cover @return [Cms::Attachment]
+    #  - Book#drafts @return [Array<Cms::Attachment>]
     #
     module Attaching
 
@@ -83,7 +51,6 @@ module Cms
                                         :allow_destroy => true,
                                         # New attachments must have an uploaded file
                                         :reject_if => lambda { |a| a[:data].blank? && a[:id].blank? }
-          attr_accessible :attachments_attributes, :attachment_id_list, :attachments_changed
 
           validates_associated :attachments
           before_validation :initialize_attachments, :check_for_updated_attachments
@@ -140,7 +107,8 @@ module Cms
           end
         end
 
-        # Define at :set_attachment_path if you would like to override the way file_path is set
+        # Define the #set_attachment_path method if you would like to override the way file_path is set.
+        # A path input will be rendered for content types having #set_attachment_path.
         def handle_setting_attachment_path
           if self.respond_to? :set_attachment_path
             set_attachment_path
@@ -152,6 +120,14 @@ module Cms
 
       module ClassMethods
 
+        # Finds all instances of this Attaching content that exist in a given section.
+        # @param [Cms::Section] section
+        # @return [ActiveRecord::Relation] A relation that will return Attaching instances.
+        def by_section(section)
+          where(["#{SectionNode.table_name}.ancestry = ?", section.node.ancestry_path])
+            .includes(:attachments => :section_node)
+            .references(:section_nodes)
+        end
 
         # Defines an single attachement with a given name.
         #
@@ -199,7 +175,7 @@ module Cms
           found_versions = Cms::Attachment::Version.where(:attachable_id => attachable.id).
               where(:attachable_type => attachable.attachable_type).
               where(:attachable_version => version_number).
-              order(:version).all
+              order(:version).load
           found_attachments = []
 
           found_versions.each do |av|
@@ -369,7 +345,7 @@ module Cms
         end
 
         def initialize_attachments
-          attachments.each { |a| a.attachable_class = self.class.name }
+          attachments.each { |a| a.attachable_class = self.attachable_type }
         end
 
 

data/lib/cms/behaviors/connecting.rb

@@ -18,7 +18,7 @@ module Cms
           include InstanceMethods
 
           attr_accessor :connect_to_page_id, :connect_to_container,:connected_page
-          attr_accessible :connect_to_page_id, :connect_to_container,:connected_page
+          #attr_accessible :connect_to_page_id, :connect_to_container,:connected_page
 
           has_many :connectors, :as => :connectable, :class_name => 'Cms::Connector'
 
@@ -33,7 +33,7 @@ module Cms
       module ClassMethods
 
         def content_block_type
-          ActiveModel::Naming.singular(self)
+          ::ActiveModel::Naming.singular(self)
         end
         def display_name
           Connecting.default_naming_for(self)
@@ -44,6 +44,12 @@ module Cms
       end
       module InstanceMethods
 
+        # Returns a machine readable key that identifies the type of content this is.
+        # Should match the key passed to ContentType.find_by_key
+        def content_name
+          self.class.name.demodulize.underscore
+        end
+
         def connected_pages
           return @connected_pages if @connected_pages
           @connected_pages = Page.connected_to(self)
@@ -75,6 +81,10 @@ module Cms
           true
         end
 
+        # By default, all content types will support inline editing. Subclasses can override this.
+        def supports_inline_editing?
+          true
+        end
         #
         # After blocks are updated, all pages they are connected to should also be updated,
         # connecting the page to the new version of the block, as well as putting the pages into
@@ -87,7 +97,7 @@ module Cms
 
             #Get all the pages the previous version of this connectable was connected to
             draft_version = draft.version
-            connected_pages = Page.connected_to(:connectable => self, :version => (draft_version - 1)).all
+            connected_pages = Page.connected_to(:connectable => self, :version => (draft_version - 1)).to_a
 #            puts "Found #{connected_pages}"
             connected_pages.each do |p|
               # This is needed in the case of updating page,
@@ -95,7 +105,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.demodulize} ##{id} was #{action}")
+                p.update_attributes(:version_comment => "#{self.class.name.demodulize} ##{id} was #{action}", :publish_on_save=>false)
 
                 #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

@@ -128,7 +128,7 @@ module Cms
           include InstanceMethods
 
           # Provide default options
-          options[:class_name] ||= self.model_name + 'Attribute'
+          options[:class_name] ||= "#{self.model_name}Attribute"
           options[:table_name] ||= options[:class_name].tableize
           options[:relationship_name] ||= options[:class_name].tableize.to_sym
           options[:foreign_key] ||= self.model_name.foreign_key
@@ -150,7 +150,7 @@ module Cms
           rescue
             Object.const_set(options[:class_name], Class.new(ActiveRecord::Base)).class_eval do
               self.table_name = options[:table_name]
-              self.mass_assignment_sanitizer = Cms::IgnoreSanitizer.new
+              #self.mass_assignment_sanitizer = Cms::IgnoreSanitizer.new
 
               def self.reloadable? #:nodoc:
                 false
@@ -167,7 +167,7 @@ module Cms
           attribute_class.class_eval do
             belongs_to base_class, :foreign_key => options[:base_foreign_key]
             alias_method :base, base_class # For generic access
-            attr_accessible :name, :value, "#{base_class.to_s}_id".to_sym
+           #attr_accessible :name, :value, "#{base_class.to_s}_id".to_sym
           end
 
           # Modify main class

data/lib/cms/behaviors/hiding.rb

@@ -13,8 +13,8 @@ module Cms
           extend ClassMethods
           include InstanceMethods
         
-          scope :hidden, :conditions => {:hidden => true}
-          scope :not_hidden, :conditions => {:hidden => false}        
+          scope :hidden, ->{where(:hidden => true)}
+          scope :not_hidden, ->{where(:hidden => false)}
         end
       end
       module ClassMethods

data/lib/cms/behaviors/namespacing.rb

@@ -1,45 +1,15 @@
 module Cms
 
-  # Provides a global configuration setting to set a table prefix for all CMS tables.
-  #
-  # For example, Cms.table_prefix = "cms_" would create tables like:
-  #   cms_html_blocks cms_pages
-  # rather than
-  #   html_blocks pages
-  #
+  # @deprecated To be removed in BrowserCMS 4.1 or later.
   def self.table_prefix=(prefix)
-    @table_prefix = prefix
-  end
-
-
-  # Returns the table name prefix for models in the Cms:: Namespace
-  # Prefer calling table_name_prefix to this methods
-  # @return [String] nil if no namespace has been set.
-  #
-  def self.table_prefix
-    @table_prefix
-  end
-
-  # By setting this, ActiveRecord will automatically prefix all tables in the Cms:: module to start with the value of prefix_
-  # Defaults to "" if not specified.
-  def self.table_name_prefix
-    self.table_prefix ? self.table_prefix : ""
-  end
-
-  module Namespacing
-
-    def self.prefixed_table_name(unprefixed_name)
-      "#{Cms.table_prefix}#{unprefixed_name}"
-    end
-    def self.prefix(unprefixed_name)
-      self.prefixed_table_name(unprefixed_name)
-    end
+    message = "Calling Cms.table_prefix('#{prefix}') is no longer necessary and can be removed from your project. See https://github.com/browsermedia/browsercms/issues/639"
+    ActiveSupport::Deprecation.warn(message, caller(1))
   end
 
   module Behaviors
-    # Noop - This will be automatically included on all ActiveRecord classes. I don't want to move this, so
-    # I'm leaving it as a harmless NOOP for now.
     module Namespacing
+
+
     end
   end
-end
+end

data/lib/cms/behaviors/publishing.rb

@@ -12,30 +12,28 @@ module Cms
           end
         end
       end
+
       module MacroMethods
         def publishable?
           !!@is_publishable
         end
+
         def is_publishable(options={})
           @is_publishable = true
           extend ClassMethods
           include InstanceMethods
-        
-          attr_accessor :publish_on_save
-          attr_accessible :publish_on_save
 
+          #attr_accessible :publish_on_save, :as
           after_save :publish_for_non_versioned
-        
-          scope :published, :conditions => {:published => true}
-          scope :unpublished, lambda {
-            if versioned?
-              { :joins => :versions,
-                :conditions =>
-                  "#{connection.quote_table_name(version_table_name)}.#{connection.quote_column_name('version')} > " +
-                  "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name('version')}",
-                :select => "distinct #{connection.quote_table_name(table_name)}.*" }
+
+          scope :published, -> { where(:published => true) }
+          scope :unpublished, -> {
+            if self.versioned?
+              q = "#{connection.quote_table_name(version_table_name)}.#{connection.quote_column_name('version')} > " +
+                  "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name('version')}"
+              select("distinct #{connection.quote_table_name(table_name)}.*").where(q).joins(:versions)
             else
-              { :conditions => { :published => false } }
+              where(:published => false)
             end
           }
 
@@ -44,6 +42,33 @@ module Cms
       module ClassMethods
       end
       module InstanceMethods
+
+        # Can specify whether to save this block as a draft using a terser syntax.
+        # These two calls behave identically
+        #   - Cms::HtmlBlock.create(name: "Shorter", as: :draft)
+        #   - Cms::HtmlBlock.create(name: "Longer",  publish_on_save: false)
+        # @param [Symbol] status :draft to not publish on the next save. All other values are ignored.
+        def as=(status)
+          if status == :draft
+            self.publish_on_save = false
+          end
+        end
+
+        # Whether or not this object will be published the next time '.save' is called.
+        # @return [Boolean] True unless explicitly set otherwise.
+        def publish_on_save
+          if @publish_on_save.nil?
+            @publish_on_save = true
+          end
+          @publish_on_save
+        end
+
+        # Set whether or not this object will be published next time '.save' is called.
+        # This status resets to true after calling '.save'
+        def publish_on_save=(publish)
+          @publish_on_save = publish
+        end
+
         def publishable?
           if self.class.connectable?
             new_record? ? connect_to_page_id.blank? : connected_page_count < 1
@@ -51,7 +76,7 @@ module Cms
             true
           end
         end
-        
+
         def publish_for_non_versioned
           unless self.class.versioned?
             if @publish_on_save
@@ -60,34 +85,40 @@ module Cms
             end
           end
         end
-        
+
+        def publish_if_needed
+          if publish_on_save
+            publish
+          else
+            self.publish_on_save = true
+          end
+        end
+
+        # Publishes the latest previously saved version of content as published. This will not create a new version,
+        # and will not persist changes made to a record.
+        #
+        # @return [Boolean] true if there was a draft record that was published, false otherwise.
         def publish
           publish!
-          true
         rescue Exception => e
           logger.warn("Could not publish, #{e.class}: #{e.message}\n#{e.backtrace.join("\n")}")
           false
         end
 
-        # Force the publishing of this block.
-        #
-        # Warning: The behavior of calling the following on an existing block:
-        #   block.save_on_publish = true
-        #   block.save!
-        #
-        # Is different than calling:
-        #   block.publish!
-        #
-        # And it probably shouldn't be. Try to merge the 'else' with the 'Versioning#create_or_update' method to eliminate duplication.
-        #
-        # In addition, after_publish is NOT called if you do:
-        #   block.save_on_publish = true
-        #   block.save!
-        # which will cause problems if blocks are updated via the method (like with the UI)
+        # Saves a draft copy of this content item. This will create a new record in the _versions table for this item, but
+        # will not update the existing published record.
+        def save_draft
+          self.publish_on_save = false
+          save
+        end
+
+        # Publishes the latest draft version of a block. See .publish for more documentation. Can throw errors if publishing failed for unexpected reasons.
+        # Note: Having separate .publish! and .publish methods is probably no longer necessary. In practice, only .publish is probably needed.
+        # @return [Boolean] true if the block had a draft that was published, false otherwise.
         def publish!
+          did_publish = false
           if new_record?
-            self.publish_on_save = true
-            save!
+            ActiveSupport::Deprecation.warn "Calling .publish! on a new record no longer saves the record. Call '.save' to persist and publish the record.", caller
           else
             # Do this for publishing existing blocks.
             transaction do
@@ -97,11 +128,11 @@ module Cms
                 # We only need to publish if this isn't already published
                 # or the draft version is greater than the live version
                 if !self.published? || d.version > self.version
-                  
+
                   d.update_attributes(:published => true)
 
                   # copy values from the draft to the main record
-                  quoted_attributes = d.send(:arel_attributes_values, false, false, self.class.versioned_columns)
+                  quoted_attributes = d.send(:arel_attributes_with_values_for_update, self.class.versioned_columns)
 
                   #the values from the draft MAY have a relation of the versioned module
                   #as opposed to the actual class itself
@@ -110,26 +141,29 @@ module Cms
                   #I haven't figured out why this is, but I know it happens when you call save! on Page
                   #during seeding of data
                   if self.class.arel_table.name != quoted_attributes.keys[0].relation.name
-                    quoted_attributes = quoted_attributes.inject({}){|hash, pair| hash[self.class.arel_table[pair[0].name]] = pair[1]; hash}
+                    quoted_attributes = quoted_attributes.inject({}) { |hash, pair| hash[self.class.arel_table[pair[0].name]] = pair[1]; hash }
                   end
 
                   # Doing the SQL ourselves to avoid callbacks
                   self.class.unscoped.where(self.class.arel_table[self.class.primary_key].eq(id)).arel.update(quoted_attributes)
+                  did_publish = true
                 end
               else
-                connection.update(
-                  "UPDATE #{self.class.quoted_table_name} " +
-                  "SET published = #{connection.quote(true, self.class.columns_hash["published"])} " +
-                  "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}",
-                  "#{self.class.name.demodulize} Publish"
+                self.class.connection.update(
+                    "UPDATE #{self.class.quoted_table_name} " +
+                        "SET published = #{self.class.connection.quote(true, self.class.columns_hash["published"])} " +
+                        "WHERE #{self.class.connection.quote_column_name(self.class.primary_key)} = #{self.class.quote_value(id)}",
+                    "#{self.class.name.demodulize} Publish"
                 )
+                did_publish = true
               end
               after_publish if respond_to?(:after_publish)
             end
             self.published = true
           end
-        end    
-            
+          did_publish
+        end
+
         def status
           return @status if @status
           @status = live? ? :published : :draft
@@ -139,9 +173,22 @@ module Cms
           status.to_s.titleize
         end
 
+        # Determines if this resource is in draft mode or not. Opposite of #live?
+        #
+        # @return [Boolean] true if the latest version of the resource is a draft.
+        def draft?
+          !live?
+        end
+
+        # Determines if this resource is in published or not.
+        #
+        # @return [Boolean] true if the latest version of the resource is published.
         def live?
           if self.class.versioned?
-            if (respond_to?(:latest_version) && self.latest_version)
+            unless persisted?
+              return false
+            end
+            if respond_to?(:latest_version) && self.latest_version
               version == latest_version && published?
             else
               live_version.version == draft.version && published?
@@ -150,7 +197,7 @@ module Cms
             true
           end
         end
-        
+
       end
     end
   end