alchemy_cms 5.2.4 → 6.0.0.b1

data/app/models/alchemy/page.rb

@@ -35,6 +35,12 @@
 #  locked_at        :datetime
 #
 
+require_dependency "alchemy/page/fixed_attributes"
+require_dependency "alchemy/page/page_scopes"
+require_dependency "alchemy/page/page_natures"
+require_dependency "alchemy/page/page_naming"
+require_dependency "alchemy/page/page_elements"
+
 module Alchemy
   class Page < BaseRecord
     include Alchemy::Hints
@@ -82,7 +88,7 @@ module Alchemy
 
     acts_as_nested_set(dependent: :destroy, scope: [:layoutpage, :language_id])
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     belongs_to :language
 
@@ -109,6 +115,9 @@ module Alchemy
     has_many :folded_pages
     has_many :legacy_urls, class_name: "Alchemy::LegacyPageUrl"
     has_many :nodes, class_name: "Alchemy::Node", inverse_of: :page
+    has_many :versions, class_name: "Alchemy::PageVersion", inverse_of: :page, dependent: :destroy
+    has_one :draft_version, -> { drafts }, class_name: "Alchemy::PageVersion"
+    has_one :public_version, -> { published }, class_name: "Alchemy::PageVersion"
 
     before_validation :set_language,
       if: -> { language.nil? }
@@ -117,6 +126,9 @@ module Alchemy
     validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { page_layout.blank? }
     validates_presence_of :parent, unless: -> { layoutpage? || language_root? }
 
+    before_create -> { versions.build },
+      if: -> { versions.none? }
+
     before_save :set_language_code,
       if: -> { language.present? }
 
@@ -126,9 +138,6 @@ module Alchemy
     before_save :inherit_restricted_status,
       if: -> { parent && parent.restricted? }
 
-    before_save :set_published_at,
-      if: -> { public_on.present? && published_at.nil? }
-
     before_save :set_fixed_attributes,
       if: -> { fixed_attributes.any? }
 
@@ -138,14 +147,22 @@ module Alchemy
     after_update -> { nodes.update_all(updated_at: Time.current) }
 
     # Concerns
-    include Alchemy::Page::PageScopes
-    include Alchemy::Page::PageNatures
-    include Alchemy::Page::PageNaming
-    include Alchemy::Page::PageElements
+    include PageScopes
+    include PageNatures
+    include PageNaming
+    include PageElements
 
     # site_name accessor
     delegate :name, to: :site, prefix: true, allow_nil: true
 
+    # Old public_on and public_until attributes for historical reasons
+    #
+    # These attributes now exist on the page versions
+    #
+    attr_readonly :legacy_public_on, :legacy_public_until
+    deprecate :legacy_public_on, deprecator: Alchemy::Deprecation
+    deprecate :legacy_public_until, deprecator: Alchemy::Deprecation
+
     # Class methods
     #
     class << self
@@ -207,11 +224,13 @@ module Alchemy
       # @return [Alchemy::Page]
       #
       def copy(source, differences = {})
-        page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
-        page.tag_list = source.tag_list
-        if page.save!
-          copy_elements(source, page)
-          page
+        transaction do
+          page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
+          page.tag_list = source.tag_list
+          if page.save!
+            copy_elements(source, page)
+            page
+          end
         end
       end
 
@@ -291,7 +310,9 @@ module Alchemy
     # Instance methods
     #
 
-    # Returns elements from page.
+    # Returns elements from pages public version.
+    #
+    # You can pass another page_version to load elements from in the options.
     #
     # @option options [Array<String>|String] :only
     #   Returns only elements with given names
@@ -310,11 +331,14 @@ module Alchemy
     # @option options [Class] :finder (Alchemy::ElementsFinder)
     #   A class that will return elements from page.
     #   Use this for your custom element loading logic.
+    # @option options [Alchemy::PageVersion] :page_version
+    #   A page version to load elements from.
+    #   Uses the pages public_version by default.
     #
     # @return [ActiveRecord::Relation]
     def find_elements(options = {})
       finder = options[:finder] || Alchemy::ElementsFinder.new(options)
-      finder.elements(page: self)
+      finder.elements(page_version: options[:page_version] || public_version)
     end
 
     # = The url_path for this page
@@ -423,22 +447,36 @@ module Alchemy
       end
     end
 
-    # Publishes the page.
+    # Creates a public version of the page.
     #
-    # Sets +public_on+ and the +published_at+ value to current time
-    # and resets +public_until+ to nil
+    # Sets the +published_at+ value to current time
     #
     # The +published_at+ attribute is used as +cache_key+.
     #
-    def publish!
-      current_time = Time.current
-      update_columns(
-        published_at: current_time,
-        public_on: already_public_for?(current_time) ? public_on : current_time,
-        public_until: still_public_for?(current_time) ? public_until : nil,
-      )
+    def publish!(current_time = Time.current)
+      update(published_at: current_time)
+      PublishPageJob.perform_later(self, public_on: current_time)
     end
 
+    # Sets the public_on date on the published version
+    #
+    # Builds a new version if none exists yet.
+    # Destroys public version if empty time is set
+    #
+    def public_on=(time)
+      if public_version && time.blank?
+        public_version.destroy!
+        # Need to reset the public version on the instance so we do not need to reload
+        self.public_version = nil
+      elsif public_version
+        public_version.public_on = time
+      elsif time.present?
+        versions.build(public_on: time)
+      end
+    end
+
+    delegate :public_until=, to: :public_version, allow_nil: true
+
     # Updates an Alchemy::Page based on a new ordering to be applied to it
     #
     # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
@@ -460,7 +498,7 @@ module Alchemy
 
     # Holds an instance of +FixedAttributes+
     def fixed_attributes
-      @_fixed_attributes ||= Alchemy::Page::FixedAttributes.new(self)
+      @_fixed_attributes ||= FixedAttributes.new(self)
     end
 
     # True if given attribute name is defined as fixed
@@ -479,12 +517,12 @@ module Alchemy
       (editor_roles & user.alchemy_roles).any?
     end
 
-    # Returns the value of +public_on+ attribute
+    # Returns the value of +public_on+ attribute from public version
     #
     # 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]
+      attribute_fixed?(:public_on) ? fixed_attributes[:public_on] : public_version&.public_on
     end
 
     # Returns the value of +public_until+ attribute
@@ -492,7 +530,7 @@ module Alchemy
     # 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]
+      attribute_fixed?(:public_until) ? fixed_attributes[:public_until] : public_version&.public_until
     end
 
     # Returns the name of the creator of this page.
@@ -556,9 +594,5 @@ module Alchemy
     def create_legacy_url
       legacy_urls.find_or_create_by(urlname: urlname_before_last_save)
     end
-
-    def set_published_at
-      self.published_at = Time.current
-    end
   end
 end

data/app/models/alchemy/page_version.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PageVersion < BaseRecord
+    belongs_to :page, class_name: "Alchemy::Page", inverse_of: :versions
+
+    has_many :elements, -> { order(:position) },
+      class_name: "Alchemy::Element",
+      inverse_of: :page_version
+
+    scope :drafts, -> { where(public_on: nil).order(updated_at: :desc) }
+    scope :published, -> { where.not(public_on: nil).order(public_on: :desc) }
+
+    def self.public_on(time = Time.current)
+      where("#{table_name}.public_on <= :time AND " \
+            "(#{table_name}.public_until IS NULL " \
+            "OR #{table_name}.public_until >= :time)", time: time)
+    end
+
+    before_destroy :delete_elements
+
+    # Determines if this version is public
+    #
+    # Takes the two timestamps +public_on+ and +public_until+
+    # and returns true if the time given (+Time.current+ per default)
+    # is in this timespan.
+    #
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def public?(time = Time.current)
+      already_public_for?(time) && still_public_for?(time)
+    end
+
+    # Determines if this version is already public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def already_public_for?(time = Time.current)
+      !public_on.nil? && public_on <= time
+    end
+
+    # Determines if this version is still public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def still_public_for?(time = Time.current)
+      public_until.nil? || public_until >= time
+    end
+
+    def element_repository
+      ElementsRepository.new(elements.includes({ contents: :essence }, :tags))
+    end
+
+    private
+
+    def delete_elements
+      DeleteElements.new(elements).call
+    end
+  end
+end

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

@@ -27,15 +27,9 @@ module Alchemy
       # Given a string with an x, this function returns a Hash with point
       # :width and :height.
       #
-      def sizes_from_string(string = "0x0")
-        string = "0x0" if string.nil? || string.empty?
+      def sizes_from_string(string)
+        width, height = string.to_s.split("x", 2).map(&:to_i)
 
-        raise ArgumentError unless string =~ /(\d*x\d*)/
-
-        width, height = string.scan(/(\d*)x(\d*)/)[0].map(&:to_i)
-
-        width = 0 if width.nil?
-        height = 0 if height.nil?
         {
           width: width,
           height: height,

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

@@ -16,6 +16,8 @@ module Alchemy
       def call
         max_image_size = Alchemy::Config.get(:preprocess_image_resize)
         image_file.thumb!(max_image_size) if max_image_size.present?
+        # Auto orient the image so EXIF orientation data is taken into account
+        image_file.auto_orient!
       end
 
       private

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

@@ -11,53 +11,16 @@ module Alchemy
       include Alchemy::Picture::Calculations
     end
 
-    THUMBNAIL_WIDTH = 160
-    THUMBNAIL_HEIGHT = 120
-
-    # Returns the default centered image mask for a given size.
-    # If the mask is bigger than the image, the mask is scaled down
-    # so the largest possible part of the image is visible.
-    #
-    def default_mask(mask_arg)
-      mask = mask_arg.dup
-      mask[:width] = image_file_width if mask[:width].zero?
-      mask[:height] = image_file_height if mask[:height].zero?
-
-      crop_size = size_when_fitting({width: image_file_width, height: image_file_height}, mask)
-      top_left = get_top_left_crop_corner(crop_size)
-
-      point_and_mask_to_points(top_left, crop_size)
-    end
-
-    # Returns a size value String for the thumbnail used in essence picture editors.
-    #
-    def thumbnail_size(size_string = "0x0", crop = false)
-      size = sizes_from_string(size_string)
-
-      # only if crop is set do we need to actually parse the size string, otherwise
-      # we take the base image size.
-      if crop
-        size[:width] = get_base_dimensions[:width] if size[:width].zero?
-        size[:height] = get_base_dimensions[:height] if size[:height].zero?
-        size = reduce_to_image(size)
-      else
-        size = get_base_dimensions
-      end
-
-      size = size_when_fitting({width: THUMBNAIL_WIDTH, height: THUMBNAIL_HEIGHT}, size)
-      "#{size[:width]}x#{size[:height]}"
-    end
-
     # Returns the rendered cropped image. Tries to use the crop_from and crop_size
     # parameters. When they can't be parsed, it just crops from the center.
     #
     def crop(size, crop_from = nil, crop_size = nil, upsample = false)
       raise "No size given!" if size.empty?
 
-      render_to = sizes_from_string(size)
+      render_to = inferred_sizes_from_string(size)
       if crop_from && crop_size
         top_left = point_from_string(crop_from)
-        crop_dimensions = sizes_from_string(crop_size)
+        crop_dimensions = inferred_sizes_from_string(crop_size)
         xy_crop_resize(render_to, top_left, crop_dimensions, upsample)
       else
         center_crop(render_to, upsample)
@@ -75,21 +38,30 @@ module Alchemy
     def landscape_format?
       image_file.landscape?
     end
+
     alias_method :landscape?, :landscape_format?
+    deprecate landscape_format?: "Use image_file.landscape? instead", deprecator: Alchemy::Deprecation
+    deprecate landscape?: "Use image_file.landscape? instead", deprecator: Alchemy::Deprecation
 
     # Returns true if picture's width is smaller than it's height
     #
     def portrait_format?
       image_file.portrait?
     end
+
     alias_method :portrait?, :portrait_format?
+    deprecate portrait_format?: "Use image_file.portrait? instead", deprecator: Alchemy::Deprecation
+    deprecate portrait?: "Use image_file.portrait? instead", deprecator: Alchemy::Deprecation
 
     # Returns true if picture's width and height is equal
     #
     def square_format?
       image_file.aspect_ratio == 1.0
     end
+
     alias_method :square?, :square_format?
+    deprecate square_format?: "Use image_file.aspect_ratio instead", deprecator: Alchemy::Deprecation
+    deprecate square?: "Use image_file.aspect_ratio instead", deprecator: Alchemy::Deprecation
 
     # Returns true if the class we're included in has a meaningful render_size attribute
     #
@@ -121,62 +93,18 @@ module Alchemy
       }
     end
 
-    # Given dimensions for a possibly destructive crop operation,
-    # this function returns the top left corner as a Hash
-    # with keys :x, :y
-    #
-    def get_top_left_crop_corner(dimensions)
-      {
-        x: (image_file_width - dimensions[:width]) / 2,
-        y: (image_file_height - dimensions[:height]) / 2,
-      }
-    end
+    def inferred_sizes_from_string(string)
+      sizes = sizes_from_string(string)
+      ratio = image_file_width.to_f / image_file_height
 
-    # Gets the base dimensions (the dimensions of the Picture before scaling).
-    # If anything is missing, it gets padded with zero (Integer 0).
-    # This is the order of precedence: crop_size > image_size
-    def get_base_dimensions
-      if crop_size?
-        sizes_from_string(crop_size)
-      else
-        image_size
+      if sizes[:width].zero?
+        sizes[:width] = image_file_width * ratio
       end
-    end
-
-    # This function takes a target and a base dimensions hash and returns
-    # the dimensions of the image when the base dimensions hash fills
-    # the target.
-    #
-    # Aspect ratio will be preserved.
-    #
-    def size_when_fitting(target, dimensions = get_base_dimensions)
-      zoom = [
-        dimensions[:width].to_f / target[:width],
-        dimensions[:height].to_f / target[:height],
-      ].max
-
-      if zoom == 0.0
-        width = target[:width]
-        height = target[:height]
-      else
-        width = (dimensions[:width] / zoom).round
-        height = (dimensions[:height] / zoom).round
+      if sizes[:height].zero?
+        sizes[:height] = image_file_width / ratio
       end
 
-      {width: width.to_i, height: height.to_i}
-    end
-
-    # Given a point as a Hash with :x and :y, and a mask with
-    # :width and :height, this function returns the area on the
-    # underlying canvas as a Hash of two points
-    #
-    def point_and_mask_to_points(point, mask)
-      {
-        x1: point[:x],
-        y1: point[:y],
-        x2: point[:x] + mask[:width],
-        y2: point[:y] + mask[:height],
-      }
+      sizes
     end
 
     # Converts a dimensions hash to a string of from "20x20"
@@ -197,20 +125,20 @@ module Alchemy
     # Use imagemagick to custom crop an image. Uses -thumbnail for better performance when resizing.
     #
     def xy_crop_resize(dimensions, top_left, crop_dimensions, upsample)
-      crop_argument = "-crop #{dimensions_to_string(crop_dimensions)}"
+      crop_argument = dimensions_to_string(crop_dimensions)
       crop_argument += "+#{top_left[:x]}+#{top_left[:y]}"
 
-      resize_argument = "-resize #{dimensions_to_string(dimensions)}"
+      resize_argument = dimensions_to_string(dimensions)
       resize_argument += ">" unless upsample
-      image_file.convert "#{crop_argument} #{resize_argument}"
+      image_file.crop_resize(crop_argument, resize_argument)
     end
 
     # Used when centercropping.
     #
     def reduce_to_image(dimensions)
       {
-        width: [dimensions[:width], image_file_width].min,
-        height: [dimensions[:height], image_file_height].min,
+        width: [dimensions[:width].to_i, image_file_width.to_i].min,
+        height: [dimensions[:height].to_i, image_file_height.to_i].min,
       }
     end
   end

data/app/models/alchemy/picture.rb

@@ -86,7 +86,9 @@ module Alchemy
     dragonfly_accessor :image_file, app: :alchemy_pictures do
       # Preprocess after uploading the picture
       after_assign do |image|
-        self.class.preprocessor_class.new(image).call
+        if has_convertible_format?
+          self.class.preprocessor_class.new(image).call
+        end
       end
     end
 
@@ -108,7 +110,7 @@ module Alchemy
       case_sensitive: false,
       message: Alchemy.t("not a valid image")
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     scope :named, ->(name) { where("#{table_name}.name LIKE ?", "%#{name}%") }
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }

data/app/models/concerns/alchemy/picture_thumbnails.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Picture thumbnails and cropping concerns
+  module PictureThumbnails
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :fix_crop_values
+
+      delegate :image_file_width, :image_file_height, :image_file, to: :picture, allow_nil: true
+    end
+
+    # The url to show the picture.
+    #
+    # Takes all values like +name+ and crop sizes (+crop_from+, +crop_size+ from the build in graphical image cropper)
+    # and also adds the security token.
+    #
+    # You typically want to set the size the picture should be resized to.
+    #
+    # === Example:
+    #
+    #   essence_picture.picture_url(size: '200x300', crop: true, format: 'gif')
+    #   # '/pictures/1/show/200x300/crop/cats.gif?sh=765rfghj'
+    #
+    # @option options size [String]
+    #   The size the picture should be resized to.
+    #
+    # @option options format [String]
+    #   The format the picture should be rendered in.
+    #   Defaults to the +image_output_format+ from the +Alchemy::Config+.
+    #
+    # @option options crop [Boolean]
+    #   If set to true the picture will be cropped to fit the size value.
+    #
+    # @return [String]
+    def picture_url(options = {})
+      return if picture.nil?
+
+      picture.url(picture_url_options.merge(options)) || "missing-image.png"
+    end
+
+    # Picture rendering options
+    #
+    # Returns the +default_render_format+ of the associated +Alchemy::Picture+
+    # together with the +crop_from+ and +crop_size+ values
+    #
+    # @return [HashWithIndifferentAccess]
+    def picture_url_options
+      return {} if picture.nil?
+
+      crop = !!settings[:crop]
+
+      {
+        format: picture.default_render_format,
+        crop: crop,
+        crop_from: crop && crop_from.presence || nil,
+        crop_size: crop && crop_size.presence || nil,
+        size: settings[:size],
+      }.with_indifferent_access
+    end
+
+    # Returns an url for the thumbnail representation of the assigned picture
+    #
+    # It takes cropping values into account, so it always represents the current
+    # image displayed in the frontend.
+    #
+    # @return [String]
+    def thumbnail_url
+      return if picture.nil?
+
+      picture.url(thumbnail_url_options) || "alchemy/missing-image.svg"
+    end
+
+    # Thumbnail rendering options
+    #
+    # @return [HashWithIndifferentAccess]
+    def thumbnail_url_options
+      crop = !!settings[:crop]
+
+      {
+        size: "160x120",
+        crop: crop,
+        crop_from: crop && crop_from.presence || default_crop_from&.join("x"),
+        crop_size: crop && crop_size.presence || default_crop_size&.join("x"),
+        flatten: true,
+        format: picture&.image_file_format || "jpg",
+      }
+    end
+
+    # Settings for the graphical JS image cropper
+    def image_cropper_settings
+      Alchemy::ImageCropperSettings.new(
+        render_size: dimensions_from_string(render_size.presence || settings[:size]),
+        default_crop_from: default_crop_from,
+        default_crop_size: default_crop_size,
+        fixed_ratio: settings[:fixed_ratio],
+        image_width: picture&.image_file_width,
+        image_height: picture&.image_file_height,
+      ).to_h
+    end
+
+    # Show image cropping link for content
+    def allow_image_cropping?
+      settings[:crop] && picture &&
+        picture.can_be_cropped_to?(
+          settings[:size],
+          settings[:upsample],
+        ) && !!picture.image_file
+    end
+
+    private
+
+    def default_crop_size
+      return nil unless settings[:crop] && settings[:size]
+
+      mask = inferred_dimensions_from_string(settings[:size])
+      zoom = thumbnail_zoom_factor(mask)
+      return nil if zoom.zero?
+
+      [(mask[0] / zoom), (mask[1] / zoom)].map(&:round)
+    end
+
+    def thumbnail_zoom_factor(mask)
+      [
+        mask[0].to_f / (image_file_width || 1),
+        mask[1].to_f / (image_file_height || 1),
+      ].max
+    end
+
+    def default_crop_from
+      return nil unless settings[:crop]
+      return nil if default_crop_size.nil?
+
+      [
+        ((image_file_width || 0) - default_crop_size[0]) / 2,
+        ((image_file_height || 0) - default_crop_size[1]) / 2,
+      ].map(&:round)
+    end
+
+    def dimensions_from_string(string)
+      return if string.nil?
+
+      string.split("x", 2).map(&:to_i)
+    end
+
+    def inferred_dimensions_from_string(string)
+      return if string.nil?
+
+      width, height = dimensions_from_string(string)
+      ratio = image_file_width.to_f / image_file_height.to_i
+
+      if width.zero? && ratio.is_a?(Float)
+        width = height * ratio
+      end
+
+      if height.zero? && ratio.is_a?(Float)
+        height = width / ratio
+      end
+
+      [width.to_i, height.to_i]
+    end
+
+    def fix_crop_values
+      %i[crop_from crop_size].each do |crop_value|
+        if public_send(crop_value).is_a?(String)
+          public_send("#{crop_value}=", normalize_crop_value(crop_value))
+        end
+      end
+    end
+
+    def normalize_crop_value(crop_value)
+      public_send(crop_value).split("x").map { |n| normalize_number(n) }.join("x")
+    end
+
+    def normalize_number(number)
+      number = number.to_f.round
+      number.negative? ? 0 : number
+    end
+  end
+end