alchemy_cms 3.4.2 → 3.5.0.rc1

data/app/models/alchemy/essence_picture.rb

@@ -25,7 +25,7 @@ module Alchemy
   class EssencePicture < ActiveRecord::Base
     acts_as_essence ingredient_column: 'picture'
 
-    belongs_to :picture
+    belongs_to :picture, required: false
     delegate :image_file_width, :image_file_height, :image_file, to: :picture
     before_save :fix_crop_values
     before_save :replace_newlines
@@ -56,7 +56,37 @@ module Alchemy
     #
     def picture_url(options = {})
       return if picture.nil?
-      routes.show_picture_path(picture_params(options))
+
+      options = {
+        format: picture.default_render_format,
+        crop_from: crop_from,
+        crop_size: crop_size
+      }.merge(options)
+
+      picture.url(options)
+    end
+
+    # Renders a thumbnail representation of the assigned image
+    #
+    # It takes cropping values into account, so it always represents the current
+    # image displayed in the frontend.
+    #
+    def thumbnail_url(options = {})
+      return if picture.nil?
+
+      crop = crop_values_present? || content.settings_value(:crop, options)
+      size = render_size || content.settings_value(:size, options)
+
+      options = {
+        size: thumbnail_size(size, crop),
+        crop: !!crop,
+        crop_from: crop_from.presence,
+        crop_size: crop_size.presence,
+        flatten: true,
+        format: picture.image_file_format
+      }
+
+      picture.url(options)
     end
 
     # The name of the picture used as preview text in element editor views.
@@ -88,11 +118,15 @@ module Alchemy
     def allow_image_cropping?(options = {})
       content && content.settings_value(:crop, options) && picture &&
         picture.can_be_cropped_to(
-          content.settings_value(:image_size, options),
+          content.settings_value(:size, options),
           content.settings_value(:upsample, options)
         )
     end
 
+    def crop_values_present?
+      crop_from.present? && crop_size.present?
+    end
+
     private
 
     def fix_crop_values
@@ -114,49 +148,5 @@ module Alchemy
       return nil if caption.nil?
       caption.gsub!(/(\r\n|\r|\n)/, "<br/>")
     end
-
-    # Returns Alchemy's url helpers.
-    def routes
-      @routes ||= Engine.routes.url_helpers
-    end
-
-    # Params for picture_path and picture_url methods
-    #
-    # @see +picture_url+ for options
-    #
-    def picture_params(options = {})
-      return {} if picture.nil?
-
-      params = {
-        id: picture.id,
-        name: picture.urlname,
-        format: picture.default_render_format
-      }.merge(options)
-
-      if options[:crop] && crop_from.present? && crop_size.present?
-        params = {
-          crop: true,
-          crop_from: crop_from,
-          crop_size: crop_size
-        }.merge(params)
-      end
-
-      params = clean_picture_params(params)
-      params.merge(sh: picture.security_token(params))
-    end
-
-    # Ensures correct and clean params for show picture path.
-    #
-    def clean_picture_params(params)
-      if params[:crop] == true
-        params[:crop] = 'crop'
-      end
-      if params[:image_size]
-        params[:size] = params.delete(:image_size)
-      end
-      secure_attributes = PictureAttributes::SECURE_ATTRIBUTES.dup
-      secure_attributes += %w(name format sh)
-      params.delete_if { |k, v| !secure_attributes.include?(k.to_s) || v.blank? }
-    end
   end
 end

data/app/models/alchemy/essence_picture_view.rb

@@ -15,6 +15,13 @@ module Alchemy
     def initialize(content, options = {}, html_options = {})
       @content = content
       @options = DEFAULT_OPTIONS.merge(content.settings).merge(options)
+      if @options[:image_size].present?
+        ActiveSupport::Deprecation.warn(
+          "Passing `image_size` to EssencePicture is deprecated. Please use `size` instead.",
+          caller.unshift
+        )
+        @options[:size] = @options.delete(:image_size)
+      end
       @html_options = html_options
       @essence = content.essence
       @picture = essence.picture
@@ -49,7 +56,7 @@ module Alchemy
 
     def img_tag
       @_img_tag ||= image_tag(
-        essence.picture_url(options), {
+        essence.picture_url(options.except(*DEFAULT_OPTIONS.keys)), {
           alt: essence.alt_tag.presence,
           title: essence.title.presence,
           class: caption ? nil : essence.css_class.presence

data/app/models/alchemy/folded_page.rb

@@ -10,7 +10,8 @@
 
 module Alchemy
   class FoldedPage < ActiveRecord::Base
-    belongs_to :page
-    belongs_to :user, class_name: Alchemy.user_class_name
+    belongs_to :page, required: true
+    belongs_to :user, required: true,
+      class_name: Alchemy.user_class_name
   end
 end

data/app/models/alchemy/legacy_page_url.rb

@@ -10,10 +10,10 @@
 #
 
 class Alchemy::LegacyPageUrl < ActiveRecord::Base
-  belongs_to :page, class_name: 'Alchemy::Page'
+  belongs_to :page,
+    class_name: 'Alchemy::Page',
+    required: true
 
-  validates :page_id,
-    presence: true
   validates :urlname,
     presence: true,
     format: {with: /\A[:\.\w\-+_\/\?&%;=]*\z/}

data/app/models/alchemy/page.rb

@@ -87,7 +87,7 @@ module Alchemy
 
     stampable stamper_class_name: Alchemy.user_class_name
 
-    belongs_to :language
+    belongs_to :language, required: false
 
     has_one :site, through: :language
     has_many :site_languages, through: :site, source: :languages
@@ -115,9 +115,12 @@ module Alchemy
       unless: :systempage?
 
     before_save :set_published_at,
-      if: -> { public? && published_at.nil? },
+      if: -> { public_on.present? && published_at.nil? },
       unless: :systempage?
 
+    before_save :set_fixed_attributes,
+      if: -> { fixed_attributes.any? }
+
     before_create :set_language_from_parent_or_default,
       if: -> { language_id.blank? },
       unless: :systempage?
@@ -336,7 +339,7 @@ module Alchemy
     def fold!(user_id, status)
       folded_page = folded_pages.find_or_create_by(user_id: user_id)
       folded_page.folded = status
-      folded_page.save
+      folded_page.save!
     end
 
     def set_restrictions_to_child_pages
@@ -382,8 +385,8 @@ module Alchemy
       current_time = Time.current
       update_columns(
         published_at: current_time,
-        public_on: current_time,
-        public_until: nil
+        public_on: already_public_for?(current_time) ? public_on : current_time,
+        public_until: still_public_for?(current_time) ? public_until : nil
       )
     end
 
@@ -406,8 +409,50 @@ module Alchemy
       update_columns(hash)
     end
 
+    # Holds an instance of +FixedAttributes+
+    def fixed_attributes
+      @_fixed_attributes ||= Alchemy::Page::FixedAttributes.new(self)
+    end
+
+    # True if given attribute name is defined as fixed
+    def attribute_fixed?(name)
+      fixed_attributes.fixed?(name)
+    end
+
+    # Checks the current page's list of editors, if defined.
+    #
+    # This allows us to pass in a user and see if any of their roles are enable
+    # them to make edits
+    #
+    def editable_by?(user)
+      return true unless has_limited_editors?
+      (editor_roles & user.alchemy_roles).any?
+    end
+
+    # Returns the value of +public_on+ attribute
+    #
+    # If it's a fixed attribute then the fixed value is returned instead
+    #
+    def public_on
+      attribute_fixed?(:public_on) ? fixed_attributes[:public_on] : self[:public_on]
+    end
+
+    # Returns the value of +public_until+ attribute
+    #
+    # If it's a fixed attribute then the fixed value is returned instead
+    #
+    def public_until
+      attribute_fixed?(:public_until) ? fixed_attributes[:public_until] : self[:public_until]
+    end
+
     private
 
+    def set_fixed_attributes
+      fixed_attributes.all.each do |attribute, value|
+        send("#{attribute}=", value)
+      end
+    end
+
     # Returns the next or previous page on the same level or nil.
     #
     # @param [String]

data/app/models/alchemy/page/fixed_attributes.rb

@@ -0,0 +1,63 @@
+module Alchemy
+  # = Fixed page attributes
+  #
+  # Fixed page attributes are not allowed to be changed by the user.
+  #
+  # Define fixed page attributes on the page layout definition of a page.
+  #
+  # == Example
+  #
+  #     # page_layout.yml
+  #     - name: Index
+  #       unique: true
+  #       fixed_attributes:
+  #         - public_on: nil
+  #         - public_until: nil
+  #         - visible: false
+  #
+  class Page::FixedAttributes
+    attr_reader :page
+
+    def initialize(page)
+      @page = page
+    end
+
+    # All fixed attributes defined on page
+    #
+    # Aliased as +#all+
+    #
+    # @return Hash
+    #
+    def attributes
+      @_attributes ||= page.definition.fetch('fixed_attributes', {}).symbolize_keys
+    end
+    alias_method :all, :attributes
+
+    # True if fixed attributes are defined on page
+    #
+    # Aliased as +#present?+
+    #
+    # @return Boolean
+    #
+    def any?
+      attributes.present?
+    end
+    alias_method :present?, :any?
+
+    # True if given attribute name is defined on page
+    #
+    # @return Boolean
+    #
+    def fixed?(name)
+      return false if name.nil?
+      attributes.key?(name.to_sym)
+    end
+
+    # Returns the attribute by key
+    #
+    def [](name)
+      return nil if name.nil?
+      attributes[name.to_sym]
+    end
+  end
+end

data/app/models/alchemy/page/page_elements.rb

@@ -24,13 +24,6 @@ module Alchemy
       after_create :autogenerate_elements, unless: -> { systempage? || do_not_autogenerate }
       after_update :trash_not_allowed_elements!, if: :page_layout_changed?
       after_update :autogenerate_elements, if: :page_layout_changed?
-
-      after_destroy do
-        elements.each do |element|
-          next if element.trashed?
-          element.destroy
-        end
-      end
     end
 
     module ClassMethods
@@ -150,6 +143,16 @@ module Alchemy
       @_element_definitions ||= element_definitions_by_name(element_definition_names)
     end
 
+    # All element definitions defined for page's page layout including nestable element definitions
+    #
+    def descendent_element_definitions
+      definitions = element_definitions_by_name(element_definition_names)
+      definitions.select { |d| d.key?('nestable_elements') }.each do |d|
+        definitions += element_definitions_by_name(d['nestable_elements'])
+      end
+      definitions.uniq { |d| d['name'] }
+    end
+
     # All names of elements that are defined in the corresponding
     # page and cell definition.
     #

data/app/models/alchemy/page/page_natures.rb

@@ -33,6 +33,25 @@ module Alchemy
       definition["feed"]
     end
 
+    # Returns an Array of Alchemy roles which are able to edit this template
+    #
+    #     # config/alchemy/page_layouts.yml
+    #     - name: contact
+    #       editable_by:
+    #         - freelancer
+    #         - admin
+    #
+    # @returns Array
+    #
+    def has_limited_editors?
+      definition["editable_by"].present?
+    end
+
+    def editor_roles
+      return unless has_limited_editors?
+      definition["editable_by"]
+    end
+
     # Returns true or false if the pages definition for config/alchemy/page_layouts.yml contains redirects_to_external: true
     def redirects_to_external?
       !!definition["redirects_to_external"]

data/app/models/alchemy/picture.rb

@@ -26,6 +26,7 @@ module Alchemy
     include Alchemy::Touching
     include Alchemy::Picture::Sweeping
     include Alchemy::Picture::Transformations
+    include Alchemy::Picture::Url
 
     has_many :essence_pictures, class_name: 'Alchemy::EssencePicture', foreign_key: 'picture_id'
     has_many :contents, through: :essence_pictures

data/app/models/alchemy/picture/transformations.rb

@@ -120,7 +120,7 @@ module Alchemy
     # Returns true if the class we're included in has a meaningful render_size attribute
     #
     def render_size?
-      respond_to?(:render_size) && !render_size.nil? && !render_size.empty?
+      respond_to?(:render_size) && render_size.present?
     end
 
     # Returns true if the class we're included in has a meaningful crop_size attribute

data/app/models/alchemy/picture/url.rb

@@ -0,0 +1,82 @@
+module Alchemy
+  module Picture::Url
+    TRANSFORMATION_OPTIONS = [
+      :crop,
+      :crop_from,
+      :crop_size,
+      :flatten,
+      :format,
+      :quality,
+      :size,
+      :upsample
+    ]
+
+    # Returns a path to picture for use inside a image_tag helper.
+    #
+    # Any additional options are passed to the url_helper, so you can add arguments to your url.
+    #
+    # Example:
+    #
+    #   <%= image_tag picture.url(size: '320x200', format: 'png') %>
+    #
+    def url(options = {})
+      image = image_file
+
+      raise MissingImageFileError, "Missing image file for #{inspect}" if image.nil?
+
+      image = processed_image(image, options)
+      image = encoded_image(image, options)
+
+      image.url(options.except(*TRANSFORMATION_OPTIONS).merge(name: name))
+    end
+
+    private
+
+    # Returns the processed image dependent of size and cropping parameters
+    def processed_image(image, options = {})
+      size = options[:size]
+      upsample = !!options[:upsample]
+
+      return image unless size.present? && has_convertible_format?
+
+      if options[:crop_size].present? && options[:crop_from].present? || options[:crop].present?
+        crop(size, options[:crop_from], options[:crop_size], upsample)
+      else
+        resize(size, upsample)
+      end
+    end
+
+    # Returns the encoded image
+    #
+    # Flatten animated gifs, only if converting to a different format.
+    # Can be overwritten via +options[:flatten]+.
+    #
+    def encoded_image(image, options = {})
+      target_format = options[:format] || default_render_format
+      raise WrongImageFormatError if !target_format.in?(Alchemy::Picture.allowed_filetypes)
+
+      options = {
+        flatten: target_format != 'gif' && image_file_format == 'gif'
+      }.merge(options)
+
+      encoding_options = []
+
+      if target_format =~ /jpe?g/
+        quality = options[:quality] || Config.get(:output_image_jpg_quality)
+        encoding_options << "-quality #{quality}"
+      end
+
+      if options[:flatten]
+        encoding_options << '-flatten'
+      end
+
+      convertion_needed = target_format != image_file_format || encoding_options.present?
+
+      if has_convertible_format? && convertion_needed
+        image = image.encode(target_format, encoding_options.join(' '))
+      end
+
+      image
+    end
+  end
+end