browsercms 3.4.2 → 3.5.0.rc1

data/lib/cms/content_rendering_support.rb

@@ -13,18 +13,18 @@ module Cms
     end
 
     def handle_not_found_on_page(exception)
-      logger.warn "Page Not Found"
+      logger.warn "Resource not found: Returning the 404 page."
       handle_error_with_cms_page(Cms::ErrorPages::NOT_FOUND_PATH, exception, :not_found)
     end
 
     def handle_access_denied_on_page(exception)
-      logger.warn "Access Denied"
+      logger.warn "Access denied for user '#{current_user.login}': Returning the 403 page."
       handle_error_with_cms_page(Cms::ErrorPages::FORBIDDEN_PATH, exception, :forbidden)
     end
 
     def handle_server_error_on_page(exception)
-      logger.warn "Exception: #{exception.message}\n"
-      logger.warn "#{exception.backtrace.join("\n")}\n"
+      logger.error "An Unexpected exception occurred: #{exception.message}\n"
+      logger.error "#{exception.backtrace.join("\n")}\n"
       handle_error_with_cms_page(Cms::ErrorPages::SERVER_ERROR_PATH, exception, :internal_server_error)
     end
 
@@ -43,7 +43,7 @@ module Cms
       # We must be showing the page outside of the CMS
       # So we will show the error page
       if @page = Cms::Page.find_live_by_path(error_page_path)
-        logger.info "Rendering Error Page: #{@page.inspect}"
+        logger.debug "Rendering Error Page: #{@page.inspect}"
         @mode = "view"
         @show_page_toolbar = false
 
@@ -59,7 +59,10 @@ module Cms
         end
 
         prepare_connectables_for_render
-        render :layout => @page.layout, :template => 'cms/content/show', :status => status
+
+        # The error pages are ALWAYS html since they are managed by the CMS as normal pages.
+        # So .gif or .jpg requests that throw errors will return html rather than a format warning.
+        render :layout => @page.layout, :template => 'cms/content/show', :status => status, :formats=>[:html]
       else
         handle_server_error(exception)
       end

data/lib/cms/default_accessible.rb

@@ -0,0 +1,13 @@
+module Cms
+  module DefaultAccessible
+
+    def self.included(model_class)
+      model_class.attribute_names.each do |name|
+        unless [:id, :type, :created_by_id, :updated_by_id, :created_at, :updated_at].include?(name.to_sym)
+          model_class.attr_accessible name
+        end
+      end
+    end
+
+  end
+end

data/lib/cms/domain_support.rb

@@ -11,10 +11,32 @@ module Cms
       "cms"
     end
 
+    def request_is_for_cms_subdomain?
+      cms_site?
+    end
+
     def cms_site?
       subdomains = request.subdomains
       subdomains.shift if subdomains.first == "www"
       subdomains.first == cms_domain_prefix
     end
+
+    # Determines if users should be redirected between the public (www.) and admin (cms.) subdomains.
+    def using_cms_subdomains?
+      result = (wants_to_use_subdomains? && perform_caching)
+      #Rails.logger.debug {"Are we using cms subdomains? #{result} based on 'want subdomain: #{wants_to_use_subdomains?}' and perform_caching: '#{perform_caching}'"}
+      result
+    end
+
+    def should_write_to_page_cache?
+      using_cms_subdomains?
+    end
+
+    private
+
+    def wants_to_use_subdomains?
+      !Rails.configuration.cms.use_single_domain
+    end
+
   end
 end

data/lib/cms/engine.rb

@@ -1,6 +1,7 @@
 require 'rails'
 require 'cms/module'
-require 'cms/init'
+require 'cms/configuration'
+require 'cms/version'
 require 'browsercms'
 
 # Gem name is different than file name
@@ -9,52 +10,72 @@ require 'browsercms'
 require 'ckeditor-rails'
 
 # Explicitly require this, so that CMS projects do not need to add it to their Gemfile
-# Especially while upgrading
+# especially while upgrading
 require 'jquery-rails'
 
 module Cms
 
-  # Configuring BrowserCMS as an engine. This seems to work, but could probably be cleaned up.
-  #
   class Engine < Rails::Engine
     include Cms::Module
     isolate_namespace Cms
 
+    config.cms = ActiveSupport::OrderedOptions.new
+    config.cms.attachments = ActiveSupport::OrderedOptions.new
 
-    # Make sure we use our rails model template
+    # Make sure we use our rails model template (rather then its default) when `rails g cms:content_block` is run.
     config.app_generators do |g|
       path = File::expand_path('../../templates', __FILE__)
       g.templates.unshift path
     end
 
-    Cms.add_generator_paths(Cms.root,
-                            "public/site/**/*",
-                            "db/seeds.rb")
-
-    initializer 'browsercms.add_core_routes', :after => 'action_dispatch.prepare_dispatcher' do |app|
-      Rails.logger.debug "Adding Cms::Routes to ActionDispatch"
-      ActionDispatch::Routing::Mapper.send :include, Cms::RouteExtensions
+    # Ensure Attachments are configured:
+    # 1. Before every request in development mode
+    # 2. Once in production
+    config.to_prepare do
+      Attachments.configure
     end
 
-    initializer 'browsercms.add_load_paths', :after => 'action_controller.deprecated_routes' do |app|
-      Rails.logger.debug "Add Cms::Dependencies and other load_path configurations."
-      ::Cms::Engine.add_cms_load_paths
+    # Set reasonable defaults
+    # These default values can be changed by developers in their projects in their application.rb or environment's files.
+    config.before_configuration do |app|
+
+      # Default cache directories.
+      app.config.cms.mobile_cache_directory = File.join(Rails.root, 'public', 'cache', 'mobile')
+      app.config.cms.page_cache_directory = File.join(Rails.root, 'public', 'cache', 'full')
+
+      # Default storage for uploaded files
+      app.config.cms.attachments.storage = :filesystem
+      app.config.cms.attachments.storage_directory = File.join(Rails.root, 'tmp', 'uploads')
+
+      # Determines if a single domain will be used (i.e. www) or multiple subdomains (www and cms). Enabling this will
+      # turn off page caching and not handle redirects between subdomains.
+      app.config.cms.use_single_domain = false
+
+      # Used to send emails with links back to the Cms Admin. In production, this should include the www. of the public site.
+      # Matters less in development, as emails generally aren't sent.
+      # I.e.
+      #   config.cms.site_domain = "www.browsercms.org"
+      app.config.cms.site_domain = "localhost:3000"
     end
 
-    initializer "browsercms.precompile_assets" do |app|
-      app.config.assets.precompile += ['cms/application.css']
+    initializer 'browsercms.add_core_routes', :after => 'action_dispatch.prepare_dispatcher' do |app|
+      ActionDispatch::Routing::Mapper.send :include, Cms::RouteExtensions
     end
 
-    def self.add_cms_load_paths
+    initializer 'browsercms.add_load_paths', :after => 'action_controller.deprecated_routes' do |app|
       ActiveSupport::Dependencies.autoload_paths += %W( #{self.root}/vendor #{self.root}/app/mailers #{self.root}/app/helpers)
       ActiveSupport::Dependencies.autoload_paths += %W( #{self.root}/app/controllers #{self.root}/app/models #{self.root}/app/portlets)
       ActiveSupport::Dependencies.autoload_paths += %W( #{Rails.root}/app/portlets )
       ActiveSupport::Dependencies.autoload_paths += %W( #{Rails.root}/app/portlets/helpers )
       ActionController::Base.append_view_path DynamicView.base_path
       ActionController::Base.append_view_path %W( #{self.root}/app/views)
-
       ActionView::Base.default_form_builder = Cms::FormBuilder
       require 'jdbc_adapter' if defined?(JRUBY_VERSION)
     end
+
+    initializer "browsercms.precompile_assets" do |app|
+      app.config.assets.precompile += ['cms/application.css']
+    end
+
   end
 end

data/lib/cms/engine_helper.rb

@@ -1,4 +1,58 @@
 module Cms
+
+  class EngineAwarePathBuilder
+
+    def initialize(model_class_or_content_type_or_model)
+      # ContentType
+      if model_class_or_content_type_or_model.respond_to? :model_class
+        @path_subject = model_class_or_content_type_or_model.model_class
+      else # Class or Model
+        @path_subject = model_class_or_content_type_or_model
+      end
+    end
+
+    # The object that will be added to the constructed path.
+    def path_subject
+      @path_subject
+    end
+
+    def subject_class
+      if @path_subject.instance_of?(Class)
+        @path_subject
+      else
+        @path_subject.class
+      end
+    end
+
+    def build(view)
+      path = []
+      path << engine_name
+      path << "cms" if main_app_model?
+      path << path_subject
+
+      path[0] = view.send(path[0]) # Replace the engine name with an actual lookup of the proper Engine routeset
+      path
+    end
+
+    def main_app_model?
+      engine_name == "main_app"
+    end
+
+    # Determine which 'Engine' this model is from based on the class
+    def engine_name
+      name = EngineHelper.module_name(subject_class)
+      return "main_app" unless name
+
+      begin
+        engine = "#{name}::Engine".constantize
+      rescue NameError
+        # This means there is no Engine for this model, so its from the main Rails App.
+        return "main_app"
+      end
+      engine.engine_name
+    end
+  end
+
   module EngineHelper
 
     def main_app_model?

data/lib/cms/extensions/active_record/connection_adapters/abstract/schema_statements.rb

@@ -100,16 +100,22 @@ module ActiveRecord
 
       alias :drop_content_table :drop_versioned_table
 
+      # Rename a column for both its
+      def rename_content_column(table_name, old_name, new_name)
+        rename_column table_name, old_name, new_name
+        rename_column version_table_name(table_name), old_name, new_name
+      end
+
       # Adds a column to both the primary and versioned table. Save needing two calls.
       # This is only needed if your content block is versioned, otherwise add_column will work just fine.
       def add_content_column(table_name, column_name, type, options={})
         add_column table_name, column_name, type, options
-        add_column "#{table_name.to_s.singularize}_versions".to_sym, column_name, type, options
+        add_column version_table_name(table_name), column_name, type, options
       end
 
       def remove_content_column(table_name, column_name)
         remove_column table_name, column_name
-        remove_column "#{table_name.to_s.singularize}_versions".to_sym, column_name
+        remove_column version_table_name(table_name), column_name
       end
 
       # Will namespace the content table
@@ -117,6 +123,12 @@ module ActiveRecord
         table_exists?(Cms::Namespacing.prefixed_table_name(table_name))
       end
 
+      private
+
+      def version_table_name(table_name)
+        "#{table_name.to_s.singularize}_versions".to_sym
+      end
+
     end
   end
 end

data/lib/cms/mobile_aware.rb

@@ -0,0 +1,67 @@
+module Cms
+
+  module MobileAware
+
+    include Cms::DefaultCaches
+
+    # Looks for a mobile template if the request is mobile, falling back to the html template if it can't be found.
+    #
+    # @return [String] relative path/name of the layout to be rendered by a page (i.e. 'layouts/templates/default')
+    def determine_page_layout
+      if respond_as_mobile?
+        mobile_exists = template_exists?(@page.layout_name, "layouts/mobile")
+        return @page.layout(:mobile) if mobile_exists
+      end
+      @page.layout(:full)
+    end
+
+    # This is changing a class attribute in order to write the page cache to a different directory based on mobile vs full page request.
+    # @warning - May not be thread safe?
+    def select_cache_directory
+      if respond_as_mobile?
+        self.class.page_cache_directory = mobile_cache_directory
+      else
+        self.class.page_cache_directory = cms_cache_directory
+      end
+    end
+
+    # Because of caching, CMS pages should only return mobile content on a separate subdomain.
+    # or if a CMS editor wants to see the mobile version of the page.
+    #
+    # @return [Boolean] true if this request is considered 'mobile', false otherwise
+    def respond_as_mobile?
+      log "For mobile optimization, checking the subdomain for '#{request.domain}' is '#{request.subdomain}'."
+      if params[:template] =='mobile'
+        session[:mobile_mode] = true
+      elsif params[:template] =='full'
+        session[:mobile_mode] = false
+      end
+
+      request.subdomain == "m" || (session[:mobile_mode] == true && current_user.able_to?(:edit_content))
+    end
+
+    private
+
+    def print_request_info
+      log "*" * 20
+      log "User Agent: #{request.user_agent}"
+      m = "Mobile Request?: "
+      if respond_as_mobile?
+        m += "Yes"
+      else
+        m += "No"
+      end
+      log m
+    end
+
+    def log(m)
+      logger.debug m
+    end
+
+    def banner(m)
+      log "*" * 20
+      log m
+    end
+  end
+
+end

data/lib/cms/route_extensions.rb

@@ -40,6 +40,9 @@ module Cms::RouteExtensions
     mount Cms::Engine => "/cms", :as => "cms"
 
     add_page_routes_defined_in_database
+
+    # Handle 'stock' attachments
+    match "/attachments/:id/:filename", :to=>"cms/attachments#download"
     match "/", :to=>"cms/content#show"
     match "*path", :to=>"cms/content#show"
   end

data/lib/cms/upgrades/v3_5_0.rb

@@ -0,0 +1,155 @@
+require 'fileutils'
+
+module Cms
+  module Upgrades
+
+    module V3_5_0
+      def upgrade_to_3_5_0
+        gsub_file "config/environments/production.rb", /config.action_controller.page_cache_directory.+$/, ""
+      end
+
+      # Add additional methods to ActiveRecord::Migration when this file is required.
+      module FileStorageUpdates
+
+
+        # Old paths are:
+        #       uploads/:year/:month/:day/:fingerprint
+        # i.e.  uploads/2012/04/27/fb598......
+        #
+        # New paths use paperclip's :id_partition which creates paths like:
+        #       uploads/000/000/001/:fingerprint
+        # where it splits the id into multiple directories
+        #
+        # @param [Cms::Attachment] attachment
+        # @return [String] path to location where an attachment should be (based on id)
+        def path_for_attachment(attachment)
+          new_id_dir = "#{Paperclip::Interpolations.id_partition(AttachmentWrapper.new(attachment), nil)}/original"
+          "#{new_id_dir}/#{attachment.data_fingerprint}"
+        end
+
+        # @return [String] Path to where an attachment should be
+        def path_to_attachment(attachment)
+          loc = path_for_attachment(attachment)
+          file_in_attachments_dir(loc)
+        end
+        # For a given class with an Attachment association (pre-3.5.0), migrate its attachment data to match the new
+        # table structure.
+        def migrate_attachment_for(klass)
+          klass.unscoped.find_each do |block|
+            Cms::Attachment.unscoped.update_all({:attachable_id => block.id,
+                                                 :attachable_version => block.version,
+                                                 :attachable_type => klass.name,
+                                                 :attachment_name => "file",
+                                                 :cardinality => 'single'},
+                                                {:id => block.attachment_id})
+          end
+
+          attachable_type = klass.name
+          # Special handling for File/Image blocks
+          if klass == Cms::FileBlock
+            attachable_type = "Cms::AbstractFileBlock"
+          elsif klass == Cms::ImageBlock
+            # Only need to do this once for both Image and File blocks since they share a table.
+            return
+          end
+
+          migrated_attachment_for_versioned_table(klass, attachable_type)
+
+        end
+
+        def migrated_attachment_for_versioned_table(model_class, attachable_type)
+          version_model = model_class.version_class
+
+          found = version_model.find_by_sql("SELECT original_record_id, attachment_id, attachment_version, version from #{version_model.table_name}")
+          found.each do |version_record|
+            Cms::Attachment::Version.unscoped.update_all({:attachable_id => version_record.original_record_id,
+                                                          :attachable_version => version_record.version,
+                                                          :attachable_type => attachable_type,
+                                                          :attachment_name => "file",
+                                                          :cardinality => 'single'},
+                                                         {:original_record_id => version_record.attachment_id, :version => version_record.attachment_version})
+          end
+        end
+
+        # Move the attachment files from the old file path path to new one. Updates the Attachment record to match.
+        def migrate_attachment_files_to_new_location
+          migrate_attachments_file_location(Cms::Attachment)
+          migrate_attachments_file_location(Cms::Attachment::Version)
+        end
+
+        # Remove the attachment_version and attachment_id columns for all core CMS blocks.
+        def cleanup_attachment_columns_for_core_cms
+          cleanup_attachment_columns(Cms::FileBlock)
+        end
+
+        # The 'attachment_id and attachment_version are no longer stored in the model, but in the attachments table'
+        # @param [Class] model_class The model to have its columns cleaned up.
+        def cleanup_attachment_columns(model_class)
+          remove_content_column model_class.table_name, :attachment_id if column_exists?(model_class.table_name, :attachment_id)
+          remove_content_column model_class.table_name, :attachment_version if column_exists?(model_class.table_name, :attachment_id)
+        end
+
+        # Removes the cms_attachments.file_location column
+        #
+        # data_fingerprint is used to store the file name instead now.
+        def cleanup_attachments_file_location
+          remove_content_column :cms_attachments, :file_location if column_exists?(:cms_attachments, :file_location)
+        end
+
+        # Deletes the old file storage folders from the uploads directory.
+        #
+        def cleanup_attachment_file_storage
+          ["2009", "2010", "2011", "2012"].each do |year|
+            folder_to_remove = File.join(attachments_dir, year)
+            FileUtils.rm_rf(folder_to_remove, :verbose => true)
+          end
+        end
+
+        private
+
+        # Multiple version of attachments may point to the same file, so we need to test
+        # a file exists before moving. Failure to move isn't necessary an error, since it may have been moved in
+        # an earlier version
+        def migrate_attachments_file_location(model_class)
+          model_class.unscoped.each do |attachment|
+            from = File.join(attachments_dir, attachment.file_location)
+            to = path_to_attachment(attachment)
+            move_attachment_file(from, to)
+
+            new_fingerprint = attachment.file_location.split("/").last
+            model_class.unscoped.update_all({:data_fingerprint => new_fingerprint}, :id => attachment.id)
+          end
+        end
+
+        def file_in_attachments_dir(file_name)
+          File.join(Cms::Attachment.configuration.attachments_root, file_name)
+        end
+
+        def move_attachment_file(old_location, new_location)
+          if File.exists?(old_location)
+            FileUtils.mkdir_p(File.dirname(new_location), :verbose => false)
+            FileUtils.mv(old_location, new_location, :verbose => true)
+          else
+            puts "'#{old_location}' does not exist, and may have been moved already. Skipping move."
+          end
+        end
+
+        def attachments_dir
+          Cms::Attachment.configuration.attachments_root
+        end
+
+        # Allows us to use the Paperclip interpolations logic directly
+        class AttachmentWrapper
+          def initialize(attachment)
+            @attachment = attachment
+          end
+
+          def instance
+            @attachment
+          end
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Migration.send(:include, Cms::Upgrades::V3_5_0::FileStorageUpdates) if defined?(ActiveRecord::Migration)