alchemy_cms 3.2.1 → 3.3.0.rc1

data/app/controllers/alchemy/base_controller.rb

@@ -23,16 +23,17 @@ module Alchemy
     # Sets +I18n.locale+ to current Alchemy language.
     #
     def set_locale
-      ::I18n.locale = Language.current.code
+      ::I18n.locale = Language.current.locale
     end
 
     def not_found_error!(msg = "Not found \"#{request.fullpath}\"")
-      raise ActionController::RoutingError.new(msg)
+      raise ActionController::RoutingError, msg
     end
 
     # Shortcut for Alchemy::I18n.translate method
     def _t(key, *args)
-      I18n.t(key, *args)
+      ActiveSupport::Deprecation.warn("Alchemys `_t` method is deprecated! Use `Alchemy.t` instead.", caller.unshift)
+      Alchemy.t(key, *args)
     end
 
     # Store current request path into session,
@@ -63,7 +64,7 @@ WARN
     end
 
     def handle_redirect_for_user
-      flash[:warning] = _t('You are not authorized')
+      flash[:warning] = Alchemy.t('You are not authorized')
       if can?(:index, :alchemy_admin_dashboard)
         redirect_or_render_notice
       else
@@ -88,7 +89,7 @@ WARN
     end
 
     def handle_redirect_for_guest
-      flash[:info] = _t('Please log in')
+      flash[:info] = Alchemy.t('Please log in')
       if request.xhr?
         render :permission_denied
       else

data/app/controllers/alchemy/elements_controller.rb

@@ -3,7 +3,7 @@ module Alchemy
     load_and_authorize_resource
     layout false
 
-    rescue_from CanCan::AccessDenied do |exception|
+    rescue_from CanCan::AccessDenied do
       raise ActiveRecord::RecordNotFound
     end
 

data/app/controllers/alchemy/messages_controller.rb

@@ -47,7 +47,10 @@ module Alchemy
     helper 'alchemy/pages'
 
     def index #:nodoc:
-      redirect_to show_page_path(urlname: @page.urlname, locale: multi_language? ? @page.language_code : nil)
+      redirect_to show_page_path(
+        urlname: @page.urlname,
+        locale: prefix_locale? ? @page.language_code : nil
+      )
     end
 
     def new #:nodoc:
@@ -91,7 +94,7 @@ module Alchemy
     end
 
     def redirect_to_success_page
-      flash[:notice] = _t(:success, scope: 'contactform.messages')
+      flash[:notice] = Alchemy.t(:success, scope: 'contactform.messages')
       if @element.ingredient(:success_page)
         urlname = @element.ingredient(:success_page)
       elsif mailer_config['forward_to_page'] && mailer_config['mail_success_page']
@@ -99,7 +102,10 @@ module Alchemy
       else
         urlname = Language.current_root_page.urlname
       end
-      redirect_to show_page_path(urlname: urlname, locale: multi_language? ? Language.current.code : nil)
+      redirect_to show_page_path(
+        urlname: urlname,
+        locale: prefix_locale? ? Language.current.code : nil
+      )
     end
 
     def get_page
@@ -109,6 +115,5 @@ module Alchemy
       end
       @root_page = @page.get_language_root
     end
-
   end
 end

data/app/controllers/alchemy/pages_controller.rb

@@ -1,28 +1,70 @@
 module Alchemy
   class PagesController < Alchemy::BaseController
+    include OnPageLayout::CallbacksRunner
 
-    before_action :enforce_primary_host_for_site
-    before_action :render_page_or_redirect, only: [:show]
+    # Redirecting concerns. Order is important here!
+    include SiteRedirects
+    include LocaleRedirects
 
-    # Showing page from params[:urlname]
+    before_action :load_index_page, only: [:index]
+    before_action :load_page, only: [:show]
+
+    # Page redirects need to run after the page was loaded. Order is important here!
+    include LegacyPageRedirects
+    include PageRedirects
+
+    # We only need to set the +@root_page+ if we are sure that no more redirects happen.
+    before_action :set_root_page, only: [:index, :show]
+
+    # Page layout callbacks need to run after all other callbacks
+    before_action :run_on_page_layout_callbacks,
+      if: :run_on_page_layout_callbacks?,
+      only: [:index, :show]
+
+    rescue_from ActionController::UnknownFormat, with: :page_not_found!
+
+    # == The index action gets invoked if one requests '/' or '/:locale'
+    #
+    # If the locale is the default locale, then it redirects to '/' without the locale.
+    #
+    # Loads the current language root page. The current language is either loaded via :locale
+    # parameter or, if that's missing, the default language is used.
+    #
+    # If this page is not published then it loads the first published descendant it finds.
+    #
+    # If no public page can be found it renders a 404 error.
+    #
+    def index
+      @page || page_not_found!
+
+      if Alchemy::Config.get(:redirect_index)
+        ActiveSupport::Deprecation.warn("The configuration option `redirect_index` is deprecated and will be removed with the release of Alchemy v4.0")
+        raise "Remove deprecated `redirect_index` configuration!" if Alchemy.version == "4.0.0.rc1"
+        redirect_permanently_to page_redirect_url
+      else
+        authorize! :index, @page
+        render_page if render_fresh_page?
+      end
+    end
+
+    # == The show action gets invoked if one requests '/:urlname' or '/:locale/:urlname'
+    #
+    # If the locale is the default locale, then it redirects to '/' without the locale.
+    #
+    # Loads the page via it's urlname. If more than one language is published the
+    # current language is either loaded via :locale parameter or, if that's missing,
+    # the page language is used and a redirect to the page with prefixed locale happens.
+    #
+    # If the requested page is not published then it redirects to the first published
+    # descendant it finds. If no public page can be found it renders a 404 error.
     #
     def show
-      authorize! :show, @page
-
-      if render_fresh_page?
-        respond_to do |format|
-          format.html { render layout: !request.xhr? }
-          format.rss do
-            if @page.contains_feed?
-              render layout: false, handlers: [:builder]
-            else
-              render xml: {error: 'Not found'}, status: 404
-            end
-          end
-        end
+      if redirect_url.present?
+        redirect_permanently_to redirect_url
+      else
+        authorize! :show, @page
+        render_page if render_fresh_page?
       end
-    rescue ActionController::UnknownFormat
-      page_not_found!
     end
 
     # Renders a search engine compatible xml sitemap.
@@ -35,101 +77,59 @@ module Alchemy
 
     private
 
-    # Load the current page and store it in @page.
+    # == Loads index page
     #
-    def load_page
-      @page ||= if params[:urlname].present?
-        # Load by urlname. If a language is specified in the request parameters,
-        # scope pages to it to make sure we can raise a 404 if the urlname
-        # is not available in that language.
-        Page.contentpages.where(
-          urlname:       params[:urlname],
-          language_id:   Language.current.id,
-          language_code: params[:locale] || Language.current.code
-        ).first
-      else
-        # No urlname was given, so just load the language root for the
-        # currently active language.
-        Language.current_root_page
-      end
-    end
-
-    def enforce_primary_host_for_site
-      if needs_redirect_to_primary_host?
-        redirect_to url_for(host: current_alchemy_site.host), :status => 301
-      end
+    # Loads the current public language root page.
+    #
+    # If the root page is not public it loads the first published child.
+    # This can be configured via +redirect_to_public_child+ [default: true]
+    #
+    # If no index page and no admin users are present we show the "Welcome to Alchemy" page.
+    #
+    def load_index_page
+      @page ||= public_root_page || first_public_child
+      render template: 'alchemy/welcome', layout: false if signup_required?
     end
 
-    def needs_redirect_to_primary_host?
-      current_alchemy_site.redirect_to_primary_host? &&
-        current_alchemy_site.host != '*' &&
-        current_alchemy_site.host != request.host
+    # == Loads page by urlname
+    #
+    # If a locale is specified in the request parameters,
+    # scope pages to it to make sure we can raise a 404 if the urlname
+    # is not available in that language.
+    #
+    # @return Alchemy::Page
+    # @return NilClass
+    #
+    def load_page
+      @page ||= Language.current.pages.contentpages.find_by(
+        urlname: params[:urlname],
+        language_code: params[:locale] || Language.current.code
+      )
     end
 
-    def render_page_or_redirect
-      @page ||= load_page
-
-      if signup_required?
-        redirect_to Alchemy.signup_path
-      elsif (@page.nil? || request.format.nil?) && last_legacy_url
-        @page = last_legacy_url.page
-        # This drops the given query string.
-        redirect_legacy_page
-      elsif @page.blank?
-        page_not_found!
-      elsif multi_language? && params[:locale].blank?
-        redirect_page(locale: Language.current.code)
-      elsif multi_language? && params[:urlname].blank? && !params[:locale].blank? && configuration(:redirect_index)
-        redirect_page(locale: params[:locale])
-      elsif configuration(:redirect_to_public_child) && !@page.public?
-        redirect_to_public_child
-      elsif params[:urlname].blank? && configuration(:redirect_index)
-        redirect_page
-      elsif !multi_language? && !params[:locale].blank?
-        redirect_page
-      elsif @page.has_controller?
-        redirect_to main_app.url_for(@page.controller_and_action)
-      else
-        # setting the language to page.language to be sure it's correct
-        set_alchemy_language(@page.language)
-        if params[:urlname].blank?
-          @root_page = @page
-        else
-          @root_page = Language.current_root_page
-        end
-      end
+    # Returns the current language root page, if it's published.
+    #
+    # Otherwise it returns nil.
+    #
+    def public_root_page
+      @root_page ||= Language.current_root_page
+      @root_page if @root_page && @root_page.public?
     end
 
-    def signup_required?
-      if Alchemy.user_class.respond_to?(:admins)
-        Alchemy.user_class.admins.size == 0 && @page.nil?
+    # Returns the first public child of the current language root page.
+    #
+    # If +redirect_to_public_child+ is configured to +false+ it returns +nil+.
+    #
+    def first_public_child
+      if Alchemy::Config.get(:redirect_to_public_child)
+        return unless @root_page
+        @root_page.descendants.published.first
       end
     end
 
-    def redirect_to_public_child
-      @page = @page.self_and_descendants.published.not_restricted.first
-      @page ? redirect_page : page_not_found!
-    end
-
-    # Redirects page to given url with 301 status while keeping all additional params
-    def redirect_page(options = {})
-      options = {
-        locale: (multi_language? ? @page.language_code : nil),
-        urlname: @page.urlname
-      }.merge(options)
-
-      redirect_to show_page_path(additional_params.merge(options)), status: 301
-    end
-
-    # Use the bare minimum to redirect to @page
-    # Don't use query string of legacy urlname
-    def redirect_legacy_page(options={})
-      defaults = {
-        locale: (multi_language? ? @page.language_code : nil),
-        urlname: @page.urlname
-      }
-      options = defaults.merge(options)
-      redirect_to show_page_path(options), status: 301
+    # Redirects to given url with 301 status
+    def redirect_permanently_to(url)
+      redirect_to url, status: :moved_permanently
     end
 
     # Returns url parameters that are not internal show page params.
@@ -145,49 +145,45 @@ module Alchemy
       end
     end
 
-    def legacy_urls
-      # /slug/tree => slug/tree
-      urlname = (request.fullpath[1..-1] if request.fullpath[0] == '/') || request.fullpath
-      LegacyPageUrl.joins(:page).where(urlname: urlname, Page.table_name => {language_id: Language.current.id})
+    # == Renders the page :show template
+    #
+    # Handles html and rss requests (for pages containing a feed)
+    #
+    # Omits the layout, if the request is a XHR request.
+    #
+    def render_page
+      respond_to do |format|
+        format.html do
+          render action: :show, layout: !request.xhr?
+        end
+
+        format.rss do
+          if @page.contains_feed?
+            render action: :show, layout: false, handlers: [:builder]
+          else
+            render xml: {error: 'Not found'}, status: 404
+          end
+        end
+      end
     end
 
-    def last_legacy_url
-      legacy_urls.last
+    def set_root_page
+      @root_page ||= Language.current_root_page
     end
 
-    # Returns true if the page cache control headers should be set.
-    #
-    # == Disable Alchemy's page caching globally
-    #
-    #     # config/alchemy/config.yml
-    #     ...
-    #     cache_pages: false
-    #
-    # == Disable caching on page layout level
-    #
-    #     # config/alchemy/page_layouts.yml
-    #     - name: contact
-    #       cache: false
-    #
-    # Note: This only sets the cache control headers and skips rendering of the page body, if the cache is fresh.
-    # This does not disable the fragment caching in the views. So if you don't want a page and it's elements to be cached,
-    # then be sure to not use <% cache element %> in the views.
-    #
-    # @returns Boolean
-    #
-    def cache_page?
-      return false if @page.nil? ||
-        !Rails.application.config.action_controller.perform_caching ||
-        !Alchemy::Config.get(:cache_pages)
-      page_layout = PageLayout.get(@page.page_layout)
-      page_layout['cache'] != false && page_layout['searchresults'] != true
+    def signup_required?
+      if Alchemy.user_class.respond_to?(:admins)
+        Alchemy.user_class.admins.empty? && @page.nil?
+      end
     end
 
     # Returns the etag used for response headers.
     #
     # If a user is logged in, we append theirs etag to prevent caching of user related content.
     #
-    # IMPORTANT: If your user does not have a +cache_key+ method (i.e. it's not an ActiveRecord model),
+    # IMPORTANT:
+    #
+    # If your user does not have a +cache_key+ method (i.e. it's not an ActiveRecord model),
     # you have to ensure to implement it and return a unique identifier for that particular user.
     # Otherwise all users will see the same cached page, regardless of user's state.
     #
@@ -199,7 +195,7 @@ module Alchemy
     # or the cache is stale, because it's been republished by the user.
     #
     def render_fresh_page?
-      !cache_page? || stale?(etag: page_etag,
+      !@page.cache_page? || stale?(etag: page_etag,
         last_modified: @page.published_at,
         public: !@page.restricted)
     end

data/app/controllers/alchemy/pictures_controller.rb

@@ -17,10 +17,10 @@ module Alchemy
 
     def thumbnail
       case params[:size]
-        when 'small'  then @size = '80x60'
-        when 'medium' then @size = '160x120'
-        when 'large'  then @size = '240x180'
-        when nil      then @size = '111x93'
+      when 'small'  then @size = '80x60'
+      when 'medium' then @size = '160x120'
+      when 'large'  then @size = '240x180'
+      when nil      then @size = '111x93'
       else
         @size = params[:size]
       end
@@ -42,20 +42,23 @@ module Alchemy
 
     def bad_request
       render text: "Bad picture parameters in #{request.path}", status: 400
-      return false
+      false
     end
 
     def send_image(image, format)
       request.session_options[:skip] = true
       ALLOWED_IMAGE_TYPES.each do |type|
         format.send(type) do
+          options = []
           if type == 'jpeg'
             quality = params[:quality] || Config.get(:output_image_jpg_quality)
-            image = image.encode(type, "-quality #{quality}")
-          else
-            image = image.encode(type)
+            options << "-quality #{quality}"
           end
-          render text: image.data
+          # Flatten animated gifs, only if converting to a different format.
+          if type != "gif" && image.ext == 'gif'
+            options << "-flatten"
+          end
+          render text: image.encode(type, options.join(' ')).data
         end
       end
     end
@@ -77,6 +80,5 @@ module Alchemy
         @image
       end
     end
-
   end
 end