alchemy_cms 2.9.1 → 3.0.0.rc5

data/app/controllers/alchemy/contents_controller.rb

@@ -0,0 +1,17 @@
+module Alchemy
+  class ContentsController < BaseController
+    load_and_authorize_resource
+    layout false
+
+    rescue_from CanCan::AccessDenied do |exception|
+      raise ActiveRecord::RecordNotFound
+    end
+
+    respond_to :json
+
+    def show
+      respond_with @content
+    end
+
+  end
+end

data/app/controllers/alchemy/elements_controller.rb

@@ -1,9 +1,12 @@
 module Alchemy
   class ElementsController < Alchemy::BaseController
-
-    filter_access_to :show, :attribute_check => true, :model => Alchemy::Element, :load_method => :load_element
+    load_and_authorize_resource
     layout false
 
+    rescue_from CanCan::AccessDenied do |exception|
+      raise ActiveRecord::RecordNotFound
+    end
+
     # == Renders the element view partial
     #
     # === Accepted Formats
@@ -18,35 +21,9 @@ module Alchemy
 
       respond_to do |format|
         format.html
-        format.js { @container_id = params[:container_id] }
-        format.json do
-          render json: @element.to_json(
-            only: [:id, :name, :updated_at],
-            methods: [:tag_list],
-            include: {
-              contents: {
-                only: [:id, :name, :updated_at, :essence_type],
-                methods: [:ingredient],
-                include: {
-                  essence: {
-                    except: [:created_at, :creator_id, :do_not_index, :public, :updater_id]
-                  }
-                }
-              }
-            }
-          )
-        end
-      end
-    end
-
-  private
-
-    def load_element
-      element = Element.available
-      if !current_alchemy_user
-        element = element.not_restricted
+        format.js   { @container_id = params[:container_id] }
+        format.json { render json: @element }
       end
-      @element = element.find(params[:id])
     end
 
   end

data/app/controllers/alchemy/messages_controller.rb

@@ -37,32 +37,30 @@ module Alchemy
   #   <%= render_essence_editor_by_name(element, 'mail_from') %>
   #   <%= render_essence_editor_by_name(element, 'mail_to') %>
   #   <%= render_essence_editor_by_name(element, 'subject') %>
-  #   <%= page_selector(element, 'success_page', :page_attribute => :urlname) %>
+  #   <%= page_selector(element, 'success_page', page_attribute: :urlname) %>
   #
   # Please have a look at the +alchemy/config/config.yml+ file for further Message settings.
   #
   class MessagesController < Alchemy::BaseController
-    include Alchemy::Ferret::Search
-
-    before_filter :get_page, :except => :create
+    before_filter :get_page, except: :create
 
     helper 'alchemy/pages'
 
     def index #:nodoc:
-      redirect_to show_page_path(:urlname => @page.urlname, :lang => multi_language? ? @page.language_code : nil)
+      redirect_to show_page_path(urlname: @page.urlname, lang: multi_language? ? @page.language_code : nil)
     end
 
     def new #:nodoc:
       @message = Message.new
-      render :template => 'alchemy/pages/show', :layout => layout_for_page
+      render template: 'alchemy/pages/show'
     end
 
     def create #:nodoc:
       @message = Message.new(params[:message])
       @message.ip = request.remote_ip
-      @element = Element.find_by_id(@message.contact_form_id)
+      @element = Element.find_by(id: @message.contact_form_id)
       if @element.nil?
-        raise ActiveRecord::RecordNotFound, "Contact form id not found. Please pass the :contact_form_id in a hidden field. Example: <%= f.hidden_field :contact_form_id, :value => element.id %>"
+        raise ActiveRecord::RecordNotFound, "Contact form id not found. Please pass the :contact_form_id in a hidden field. Example: <%= f.hidden_field :contact_form_id, value: element.id %>"
       end
       @page = @element.page
       @root_page = @page.get_language_root
@@ -70,11 +68,11 @@ module Alchemy
         Messages.contact_form_mail(@message, mail_to, mail_from, subject).deliver
         redirect_to_success_page
       else
-        render :template => 'alchemy/pages/show', :layout => layout_for_page
+        render template: 'alchemy/pages/show'
       end
     end
 
-  private
+    private
 
     def mailer_config
       Alchemy::Config.get(:mailer)
@@ -93,20 +91,22 @@ module Alchemy
     end
 
     def redirect_to_success_page
-      flash[:notice] = _t(:success, :scope => 'contactform.messages')
-      if @element.ingredient("success_page")
-        urlname = @element.ingredient("success_page")
+      flash[:notice] = _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']
-        urlname = Page.find_by_urlname(mailer_config['mail_success_page']).urlname
+        urlname = Page.find_by(urlname: mailer_config['mail_success_page']).urlname
       else
-        urlname = Page.language_root_for(session[:language_id]).urlname
+        urlname = Language.current_root_page.urlname
       end
-      redirect_to show_page_path(:urlname => urlname, :lang => multi_language? ? session[:language_code] : nil)
+      redirect_to show_page_path(urlname: urlname, lang: multi_language? ? Language.current.code : nil)
     end
 
     def get_page
-      @page = Page.find_by_page_layout_and_language_id(mailer_config['page_layout_name'], session[:language_id])
-      raise "Page for page_layout #{mailer_config['page_layout_name']} not found" if @page.blank?
+      @page = Language.current.pages.find_by(page_layout: mailer_config['page_layout_name'])
+      if @page.blank?
+        raise "Page for page_layout #{mailer_config['page_layout_name']} not found"
+      end
       @root_page = @page.get_language_root
     end
 

data/app/controllers/alchemy/pages_controller.rb

@@ -1,7 +1,5 @@
 module Alchemy
   class PagesController < Alchemy::BaseController
-    include Ferret::Search
-
     # We need to include this helper because we need the breadcrumb method.
     # And we cannot define the breadcrump method as helper_method, because rspec does not see helper_methods.
     # Not the best solution, but's working.
@@ -12,40 +10,24 @@ module Alchemy
 
     before_filter :enforce_primary_host_for_site
     before_filter :render_page_or_redirect, :only => [:show]
-    before_filter :perform_search, :only => :show, :if => proc { configuration(:ferret) }
-
-    filter_access_to :show, :attribute_check => true, :model => Alchemy::Page, :load_method => :load_page
-
-    caches_action(:show,
-      :cache_path => proc { @page.cache_key(request) },
-      :if => proc {
-        if @page && Alchemy::Config.get(:cache_pages)
-          pagelayout = PageLayout.get(@page.page_layout)
-          if (pagelayout['cache'].nil? || pagelayout['cache']) && pagelayout['searchresults'] != true
-            true
-          end
-        else
-          false
-        end
-      }, :layout => false)
-
-    layout :layout_for_page
+    before_filter :load_page
+    authorize_resource only: 'show'
 
     # Showing page from params[:urlname]
-    # @page is fetched via before filter
-    # @root_page is fetched via before filter
-    # @language fetched via before_filter in alchemy_controller
-    # querying for search results if any query is present via before_filter
+    #
     def show
-      respond_to do |format|
-        format.html { render }
-        format.rss {
-          if @page.contains_feed?
-            render :action => "show", :layout => false, :handlers => [:builder]
-          else
-            render :xml => {:error => 'Not found'}, :status => 404
+      if render_fresh_page?
+        respond_to do |format|
+          format.html { render layout: !request.xhr? }
+          format.rss do
+            if @page.contains_feed?
+              render action: 'show', layout: false, handlers: [:builder]
+            else
+              render xml: {error: 'Not found'}, status: 404
+            end
           end
-        }
+          format.json { render json: @page }
+        end
       end
     end
 
@@ -68,30 +50,26 @@ module Alchemy
         # is not available in that language.
         Page.contentpages.where(
           urlname:       params[:urlname],
-          language_id:   @language.id,
-          language_code: params[:lang] || @language.code
+          language_id:   Language.current.id,
+          language_code: params[:lang] || Language.current.code
         ).first
       else
         # No urlname was given, so just load the language root for the
         # currently active language.
-        Page.language_root_for(@language.id)
+        Language.current_root_page
       end
-    rescue ArgumentError => e
-      # If encoding errors raises (ie. because of invalid byte chars in params),
-      # we render a 404 page
-      raise ActionController::RoutingError.new(e.message)
     end
 
     def enforce_primary_host_for_site
       if needs_redirect_to_primary_host?
-        redirect_to url_for(host: current_site.host), :status => 301
+        redirect_to url_for(host: current_alchemy_site.host), :status => 301
       end
     end
 
     def needs_redirect_to_primary_host?
-      current_site.redirect_to_primary_host? &&
-        current_site.host != '*' &&
-        current_site.host != request.host
+      current_alchemy_site.redirect_to_primary_host? &&
+        current_alchemy_site.host != '*' &&
+        current_alchemy_site.host != request.host
     end
 
     def render_page_or_redirect
@@ -104,9 +82,9 @@ module Alchemy
       elsif @page.blank?
         raise_not_found_error
       elsif multi_language? && params[:lang].blank?
-        redirect_page(:lang => session[:language_code])
+        redirect_page(lang: Language.current.code)
       elsif multi_language? && params[:urlname].blank? && !params[:lang].blank? && configuration(:redirect_index)
-        redirect_page(:lang => params[:lang])
+        redirect_page(lang: params[:lang])
       elsif configuration(:redirect_to_public_child) && !@page.public?
         redirect_to_public_child
       elsif params[:urlname].blank? && configuration(:redirect_index)
@@ -117,11 +95,11 @@ module Alchemy
         redirect_to main_app.url_for(@page.controller_and_action)
       else
         # setting the language to page.language to be sure it's correct
-        set_language(@page.language)
+        set_alchemy_language(@page.language)
         if params[:urlname].blank?
           @root_page = @page
         else
-          @root_page = Page.language_root_for(session[:language_id])
+          @root_page = Language.current_root_page
         end
       end
     end
@@ -157,12 +135,59 @@ module Alchemy
     end
 
     def legacy_urls
-      LegacyPageUrl.joins(:page).where(urlname: params[:urlname], alchemy_pages: {language_id: session[:language_id]})
+      LegacyPageUrl.joins(:page).where(urlname: params[:urlname], alchemy_pages: {language_id: Language.current.id})
     end
 
     def last_legacy_url
       legacy_urls.last
     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 unless @page && Alchemy::Config.get(:cache_pages)
+      page_layout = PageLayout.get(@page.page_layout)
+      page_layout['cache'] != false && page_layout['searchresults'] != true
+    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),
+    # 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.
+    #
+    def page_etag
+      @page.cache_key + current_alchemy_user.try(:cache_key).to_s
+    end
+
+    # We only render the page if either the cache is disabled for this page
+    # or the cache is stale, because it's been republished by the user.
+    #
+    def render_fresh_page?
+      !cache_page? || stale?(etag: page_etag,
+        last_modified: @page.published_at,
+        public: !@page.restricted)
+    end
+
   end
 end

data/app/controllers/alchemy/pictures_controller.rb

@@ -1,28 +1,25 @@
 module Alchemy
   class PicturesController < Alchemy::BaseController
-
     ALLOWED_IMAGE_TYPES = %w(png jpeg gif)
 
     caches_page :show, :thumbnail, :zoom
 
-    before_filter :load_picture, :ensure_secure_params
+    before_filter :ensure_secure_params
 
-    filter_access_to :show, :attribute_check => true, :model => Alchemy::Picture, :load_method => :load_picture
-    filter_access_to :thumbnail
+    load_and_authorize_resource
 
     def show
       @size = params[:size]
-
       expires_in 1.month, public: !@picture.restricted?
       respond_to { |format| send_image(processed_image, format) }
     end
 
     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
@@ -35,18 +32,7 @@ module Alchemy
       respond_to { |format| send_image(image_file, format) }
     end
 
-  private
-
-    def normalized_size(size)
-      return "" if size.blank?
-      size.split("x").map do |s|
-        s.to_i < 0 ? 0 : s.to_i
-      end.join('x')
-    end
-
-    def load_picture
-      @picture ||= Picture.find(params[:id])
-    end
+    private
 
     def ensure_secure_params
       token = params[:sh]
@@ -55,59 +41,72 @@ module Alchemy
     end
 
     def bad_request
-      render :text => "Bad picture parameters in #{request.path}", :status => 400
+      render text: "Bad picture parameters in #{request.path}", status: 400
       return false
     end
 
     def send_image(image_file, format)
       ALLOWED_IMAGE_TYPES.each do |type|
         format.send(type) do
-          if type == "jpeg"
+          if type == 'jpeg'
             quality = params[:quality] || Config.get(:output_image_jpg_quality)
             image_file = image_file.encode(type, "-quality #{quality}")
           else
             image_file = image_file.encode(type)
           end
-          render :text => image_file.data
+          render text: image_file.data
         end
       end
     end
 
     # Return the processed image dependent of size and cropping parameters
     def processed_image
-      if params[:upsample] == 'true'
-        resize_string = @size.to_s
-      else
-        resize_string = "#{@size}>"
-      end
       image_file = @picture.image_file
       if image_file.nil?
         raise MissingImageFileError, "Missing image file for #{@picture.inspect}"
       end
       if params[:crop_size].present? && params[:crop_from].present?
-        crop_from = params[:crop_from].split('x')
-        image_file = image_file.process(:thumb, "#{params[:crop_size]}+#{crop_from[0]}+#{crop_from[1]}")
-        image_file.process(:resize, resize_string)
+        image_file = image_file.thumb crop_geometry_string(params)
+        image_file.thumb(resize_geometry_string)
       elsif params[:crop] == 'crop' && @size.present?
-        width, height = @size.split('x').collect(&:to_i)
-        raise ArgumentError, "You have to state both width and height in the form 'widthxheight' when cropping" if width.nil? || height.nil?
-        # prevent upscaling unless :upsample param is true
-        # unfurtunally dragonfly does not handle this correctly while cropping
-        unless params[:upsample] == 'true'
-          if width > image_file.width
-            width = image_file.width
-          end
-          if height > image_file.height
-            height = image_file.height
-          end
-        end
-        image_file.process(:resize_and_crop, :width => width, :height => height, :gravity => 'c')
+        width, height = normalize_sizes(image_file)
+        image_file.thumb("#{width}x#{height}#")
       elsif @size.present?
-        image_file.process(:resize, resize_string)
+        image_file.thumb(resize_geometry_string)
       else
         image_file
       end
     end
 
+    # Returns the Imagemagick geometry string for cropping the image.
+    def crop_geometry_string(params)
+      crop_from_x, crop_from_y = params[:crop_from].split('x')
+      "#{params[:crop_size]}+#{crop_from_x}+#{crop_from_y}"
+    end
+
+    # Returns the Imagemagick geometry string used to resize the image.
+    def resize_geometry_string
+      @resize_geometry_string ||= begin
+        params[:upsample] == 'true' ? @size.to_s : "#{@size}>"
+      end
+    end
+
+    # Returns normalized width and height values
+    #
+    # Prevents upscaling unless :upsample param is true,
+    # because unfurtunally Dragonfly does not handle this correctly while cropping
+    #
+    def normalize_sizes(image_file)
+      width, height = @size.split('x').collect(&:to_i)
+      return width, height if params[:upsample] == 'true'
+      if width > image_file.width
+        width = image_file.width
+      end
+      if height > image_file.height
+        height = image_file.height
+      end
+      return width, height
+    end
+
   end
 end