alchemy_cms 5.0.1 → 5.1.0

data/app/models/alchemy/picture.rb

@@ -30,11 +30,22 @@ module Alchemy
 
     CONVERTIBLE_FILE_FORMATS = %w(gif jpg jpeg png).freeze
 
+    TRANSFORMATION_OPTIONS = [
+      :crop,
+      :crop_from,
+      :crop_size,
+      :flatten,
+      :format,
+      :quality,
+      :size,
+      :upsample,
+    ]
+
+    include Alchemy::Logger
     include Alchemy::NameConversions
     include Alchemy::Taggable
     include Alchemy::TouchElements
-    include Alchemy::Picture::Transformations
-    include Alchemy::Picture::Url
+    include Calculations
 
     has_many :essence_pictures,
       class_name: "Alchemy::EssencePicture",
@@ -44,6 +55,7 @@ module Alchemy
     has_many :contents, through: :essence_pictures
     has_many :elements, through: :contents
     has_many :pages, through: :elements
+    has_many :thumbs, class_name: "Alchemy::PictureThumb", dependent: :destroy
 
     # Raise error, if picture is in use (aka. assigned to an EssencePicture)
     #
@@ -78,6 +90,9 @@ module Alchemy
       end
     end
 
+    # Create important thumbnails upfront
+    after_create -> { PictureThumb.generate_thumbs!(self) }
+
     # We need to define this method here to have it available in the validations below.
     class << self
       def allowed_filetypes
@@ -103,6 +118,20 @@ module Alchemy
     # Class methods
 
     class << self
+      # The class used to generate URLs for pictures
+      #
+      # @see Alchemy::Picture::Url
+      def url_class
+        @_url_class ||= Alchemy::Picture::Url
+      end
+
+      # Set a different picture url class
+      #
+      # @see Alchemy::Picture::Url
+      def url_class=(klass)
+        @_url_class = klass
+      end
+
       def searchable_alchemy_resource_attributes
         %w(name image_file_name)
       end
@@ -145,6 +174,33 @@ module Alchemy
 
     # Instance methods
 
+    # Returns an url (or relative path) to a processed image for use inside an image_tag helper.
+    #
+    # Any additional options are passed to the url method, so you can add params to your url.
+    #
+    # Example:
+    #
+    #   <%= image_tag picture.url(size: '320x200', format: 'png') %>
+    #
+    # @see Alchemy::PictureVariant#call for transformation options
+    # @see Alchemy::Picture::Url#call for url options
+    # @return [String|Nil]
+    def url(options = {})
+      return unless image_file
+
+      variant = PictureVariant.new(self, options.slice(*TRANSFORMATION_OPTIONS))
+      self.class.url_class.new(variant).call(
+        options.except(*TRANSFORMATION_OPTIONS).merge(
+          basename: name,
+          ext: variant.render_format,
+          name: name,
+        )
+      )
+    rescue ::Dragonfly::Job::Fetch::NotFound => e
+      log_warning(e.message)
+      nil
+    end
+
     def previous(params = {})
       query = Picture.ransack(params[:q])
       Picture.search_by(params, query).where("name < ?", name).last

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Picture < BaseRecord
+    module Calculations
+      # An Image smaller than dimensions
+      # can not be cropped to given size - unless upsample is true.
+      #
+      def can_be_cropped_to?(string, upsample = false)
+        return true if upsample
+
+        is_bigger_than? sizes_from_string(string)
+      end
+
+      # Returns true if both dimensions of the base image are bigger than the dimensions hash.
+      #
+      def is_bigger_than?(dimensions)
+        image_file_width > dimensions[:width] && image_file_height > dimensions[:height]
+      end
+
+      # Returns true is one dimension of the base image is smaller than the dimensions hash.
+      #
+      def is_smaller_than?(dimensions)
+        !is_bigger_than?(dimensions)
+      end
+
+      # 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?
+
+        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,
+        }
+      end
+
+      # This function returns the :width and :height of the image file
+      # as a Hash
+      def image_size
+        {
+          width: image_file_width,
+          height: image_file_height,
+        }
+      end
+    end
+  end
+end

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

@@ -7,6 +7,10 @@ module Alchemy
   module Picture::Transformations
     extend ActiveSupport::Concern
 
+    included do
+      include Alchemy::Picture::Calculations
+    end
+
     THUMBNAIL_WIDTH = 160
     THUMBNAIL_HEIGHT = 120
 
@@ -66,24 +70,6 @@ module Alchemy
       image_file.thumb(upsample ? size : "#{size}>")
     end
 
-    # 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?
-
-      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,
-      }
-    end
-
     # Returns true if picture's width is greater than it's height
     #
     def landscape_format?
@@ -105,24 +91,6 @@ module Alchemy
     end
     alias_method :square?, :square_format?
 
-    # This function returns the :width and :height of the image file
-    # as a Hash
-    def image_size
-      {
-        width: image_file_width,
-        height: image_file_height,
-      }
-    end
-
-    # An Image smaller than dimensions
-    # can not be cropped to given size - unless upsample is true.
-    #
-    def can_be_cropped_to(string, upsample = false)
-      return true if upsample
-
-      is_bigger_than sizes_from_string(string)
-    end
-
     # Returns true if the class we're included in has a meaningful render_size attribute
     #
     def render_size?
@@ -217,22 +185,10 @@ module Alchemy
       "#{dimensions[:width]}x#{dimensions[:height]}"
     end
 
-    # Returns true if both dimensions of the base image are bigger than the dimensions hash.
-    #
-    def is_bigger_than(dimensions)
-      image_file_width > dimensions[:width] && image_file_height > dimensions[:height]
-    end
-
-    # Returns true is one dimension of the base image is smaller than the dimensions hash.
-    #
-    def is_smaller_than(dimensions)
-      !is_bigger_than(dimensions)
-    end
-
     # Uses imagemagick to make a centercropped thumbnail. Does not scale the image up.
     #
     def center_crop(dimensions, upsample)
-      if is_smaller_than(dimensions) && upsample == false
+      if is_smaller_than?(dimensions) && upsample == false
         dimensions = reduce_to_image(dimensions)
       end
       image_file.thumb("#{dimensions_to_string(dimensions)}#")

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

@@ -1,94 +1,45 @@
 # frozen_string_literal: true
 
 module Alchemy
-  module Picture::Url
-    include Alchemy::Logger
+  class Picture < BaseRecord
+    class Url
+      attr_reader :variant
 
-    TRANSFORMATION_OPTIONS = [
-      :crop,
-      :crop_from,
-      :crop_size,
-      :flatten,
-      :format,
-      :quality,
-      :size,
-      :upsample,
-    ]
+      # @param [Alchemy::PictureVariant]
+      #
+      def initialize(variant)
+        raise ArgumentError, "Variant missing!" if variant.nil?
 
-    # 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))
-    rescue MissingImageFileError, WrongImageFormatError => e
-      log_warning e.message
-      nil
-    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]
-        crop(size, options[:crop_from], options[:crop_size], upsample)
-      else
-        resize(size, upsample)
+        @variant = variant
       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
+      # The URL to a variant of a picture
+      #
+      # @return [String]
+      #
+      def call(params = {})
+        return variant.image.url(params) unless processible_image?
 
-      unless target_format.in?(Alchemy::Picture.allowed_filetypes)
-        raise WrongImageFormatError.new(self, target_format)
+        "/#{uid}"
       end
 
-      options = {
-        flatten: target_format != "gif" && image_file_format == "gif",
-      }.with_indifferent_access.merge(options)
-
-      encoding_options = []
+      private
 
-      convert_format = target_format != image_file_format.sub("jpeg", "jpg")
-
-      if target_format =~ /jpe?g/ && convert_format
-        quality = options[:quality] || Config.get(:output_image_jpg_quality)
-        encoding_options << "-quality #{quality}"
+      def processible_image?
+        variant.image.is_a?(::Dragonfly::Job)
       end
 
-      if options[:flatten]
-        encoding_options << "-flatten"
+      def uid
+        signature = PictureThumb::Signature.call(variant)
+        thumb = variant.picture.thumbs.detect { |t| t.signature == signature }
+        if thumb
+          uid = thumb.uid
+        else
+          uid = PictureThumb::Uid.call(signature, variant)
+          PictureThumb.generator_class.call(variant, signature, uid)
+        end
+        uid
       end
-
-      convertion_needed = convert_format || encoding_options.present?
-
-      if has_convertible_format? && convertion_needed
-        image = image.encode(target_format, encoding_options.join(" "))
-      end
-
-      image
     end
   end
 end

data/app/models/alchemy/picture_thumb.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # The persisted version of a rendered picture variant
+  #
+  # You can configure the generator class to implement a
+  # different thumbnail store (ie. a remote file storage).
+  #
+  #     config/initializers/alchemy.rb
+  #     Alchemy::PictureThumb.generator_class = My::ThumbnailGenerator
+  #
+  class PictureThumb < BaseRecord
+    belongs_to :picture, class_name: "Alchemy::Picture"
+
+    validates :signature, presence: true
+    validates :uid, presence: true
+
+    class << self
+      # Thumbnail generator class
+      #
+      # @see Alchemy::PictureThumb::Create
+      def generator_class
+        @_generator_class ||= Alchemy::PictureThumb::Create
+      end
+
+      # Set a thumbnail generator class
+      #
+      # @see Alchemy::PictureThumb::Create
+      def generator_class=(klass)
+        @_generator_class = klass
+      end
+
+      # Upfront generation of picture thumbnails
+      #
+      # Called after a Alchemy::Picture has been created (after an image has been uploaded)
+      #
+      # Generates three types of thumbnails that are used by Alchemys picture archive and
+      # persists them in the configures file store (Default Dragonfly::FileDataStore).
+      #
+      # @see Picture::THUMBNAIL_SIZES
+      def generate_thumbs!(picture)
+        Alchemy::Picture::THUMBNAIL_SIZES.values.each do |size|
+          variant = Alchemy::PictureVariant.new(picture, {
+            size: size,
+            flatten: true,
+          })
+          signature = Alchemy::PictureThumb::Signature.call(variant)
+          thumb = find_by(signature: signature)
+          next if thumb
+
+          uid = Alchemy::PictureThumb::Uid.call(signature, variant)
+          generator_class.call(variant, signature, uid)
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/picture_thumb/create.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PictureThumb < BaseRecord
+    # Stores the render result of a Alchemy::PictureVariant
+    # in the configured Dragonfly datastore
+    # (Default: Dragonfly::FileDataStore)
+    #
+    class Create
+      class << self
+        # @param [Alchemy::PictureVariant] variant the to be rendered image
+        # @param [String] signature A unique hashed version of the rendering options
+        # @param [String] uid The Unique Image Identifier the image is stored at
+        #
+        # @return [Alchemy::PictureThumb] The persisted thumbnail record
+        #
+        def call(variant, signature, uid)
+          image = variant.image
+          image.to_file(server_path(uid)).close
+          variant.picture.thumbs.create!(
+            picture: variant.picture,
+            signature: signature,
+            uid: uid,
+          )
+        end
+
+        private
+
+        # Alchemys dragonfly datastore config seperates the storage path from the public server
+        # path for security reasons. The Dragonfly FileDataStorage does not support that,
+        # so we need to build the path on our own.
+        def server_path(uid)
+          dragonfly_app = ::Dragonfly.app(:alchemy_pictures)
+          "#{dragonfly_app.datastore.server_root}/#{uid}"
+        end
+      end
+    end
+  end
+end