alchemy_cms 5.0.3 → 5.1.1

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

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PictureThumb < BaseRecord
+    class Signature
+      # Returns a unique image process signature
+      #
+      # @param [Alchemy::PictureVariant]
+      #
+      # @return [String]
+      def self.call(variant)
+        steps_without_fetch = variant.image.steps.reject do |step|
+          step.is_a?(::Dragonfly::Job::Fetch)
+        end
+
+        steps_with_id = [[variant.picture.id]] + steps_without_fetch
+        job_string = steps_with_id.map(&:to_a).to_dragonfly_unique_s
+
+        Digest::SHA1.hexdigest(job_string)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PictureThumb < BaseRecord
+    class Uid
+      # Returns a image variant uid for storage
+      #
+      # @param [String]
+      # @param [Alchemy::PictureVariant]
+      #
+      # @return [String]
+      def self.call(signature, variant)
+        picture = variant.picture
+        filename = variant.image_file_name || "image"
+        name = File.basename(filename, ".*").gsub(/[^\w.]+/, "_")
+        ext = variant.render_format
+
+        "pictures/#{picture.id}/#{signature}/#{name}.#{ext}"
+      end
+    end
+  end
+end

data/app/models/alchemy/picture_variant.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Alchemy
+  # Represents a rendered picture
+  #
+  # Resizes, crops and encodes the image with imagemagick
+  #
+  class PictureVariant
+    extend Forwardable
+
+    include Alchemy::Logger
+    include Alchemy::Picture::Transformations
+
+    attr_reader :picture, :render_format
+
+    def_delegators :@picture,
+      :image_file,
+      :image_file_width,
+      :image_file_height,
+      :image_file_name,
+      :image_file_size
+
+    # @param [Alchemy::Picture]
+    #
+    # @param [Hash] options passed to the image processor
+    # @option options [Boolean] :crop Pass true to enable cropping
+    # @option options [String] :crop_from Coordinates to start cropping from
+    # @option options [String] :crop_size Size of the cropping area
+    # @option options [Boolean] :flatten Pass true to flatten GIFs
+    # @option options [String|Symbol] :format Image format to encode the image in
+    # @option options [Integer] :quality JPEG compress quality
+    # @option options [String] :size Size of resulting image in WxH
+    # @option options [Boolean] :upsample Pass true to upsample (grow) an image if the original size is lower than the resulting size
+    #
+    def initialize(picture, options = {})
+      raise ArgumentError, "Picture missing!" if picture.nil?
+
+      @picture = picture
+      @options = options
+      @render_format = options[:format] || picture.default_render_format
+    end
+
+    # Process a variant of picture
+    #
+    # @return [Dragonfly::Attachment|Dragonfly::Job] The processed image variant
+    #
+    def image
+      image = image_file
+
+      raise MissingImageFileError, "Missing image file for #{picture.inspect}" if image.nil?
+
+      image = processed_image(image, @options)
+      image = encoded_image(image, @options)
+      image
+    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? && picture.has_convertible_format?
+
+      if options[:crop]
+        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 = {})
+      unless render_format.in?(Alchemy::Picture.allowed_filetypes)
+        raise WrongImageFormatError.new(picture, @render_format)
+      end
+
+      options = {
+        flatten: render_format != "gif" && picture.image_file_format == "gif",
+      }.with_indifferent_access.merge(options)
+
+      encoding_options = []
+
+      convert_format = render_format.sub("jpeg", "jpg") != picture.image_file_format.sub("jpeg", "jpg")
+
+      if render_format =~ /jpe?g/ && convert_format
+        quality = options[:quality] || Config.get(:output_image_jpg_quality)
+        encoding_options << "-quality #{quality}"
+      end
+
+      if options[:flatten]
+        encoding_options << "-flatten"
+      end
+
+      convertion_needed = convert_format || encoding_options.present?
+
+      if picture.has_convertible_format? && convertion_needed
+        image = image.encode(render_format, encoding_options.join(" "))
+      end
+
+      image
+    end
+  end
+end

data/app/models/alchemy/site/layout.rb

@@ -25,10 +25,38 @@ module Alchemy
       end
     end
 
-    # Returns site's layout definition
+    # Returns sites layout definition
     #
     def definition
-      self.class.definitions.detect { |l| l["name"] == partial_name }
+      self.class.definitions.detect { |l| l["name"] == partial_name } || {}
+    end
+
+    # Returns sites page layout names
+    #
+    # If no site layout file is defined all page layouts are returned
+    #
+    # @param [Boolean] layoutpages Return layout pages only (default false)
+    #
+    # @return [Array<String>] Array of page layout names
+    #
+    def page_layout_names(layoutpages: false)
+      page_layout_definitions.select do |layout|
+        !!layout["layoutpage"] && layoutpages || !layout["layoutpage"] && !layoutpages
+      end.collect { |layout| layout["name"] }
+    end
+
+    # Returns sites page layout definitions
+    #
+    # If no site layout file is defined all page layouts are returned
+    #
+    def page_layout_definitions
+      if definition["page_layouts"].presence
+        Alchemy::PageLayout.all.select do |layout|
+          layout["name"].in?(definition["page_layouts"])
+        end
+      else
+        Alchemy::PageLayout.all
+      end
     end
 
     # Returns the name for the layout partial

data/app/views/alchemy/admin/attachments/show.html.erb

@@ -7,15 +7,15 @@
   </div>
   <div class="value with-icon">
     <label><%= Alchemy::Attachment.human_attribute_name(:url) %></label>
-    <p><%= alchemy.show_attachment_url(@attachment) %></p>
-    <a data-clipboard-text="<%= alchemy.show_attachment_url(@attachment) %>" class="icon_button--right">
+    <p><%= @attachment.url %></p>
+    <a data-clipboard-text="<%= @attachment.url %>" class="icon_button--right">
       <%= render_icon(:clipboard, style: 'regular') %>
     </a>
   </div>
   <div class="value with-icon">
     <label><%= Alchemy::Attachment.human_attribute_name(:download_url) %></label>
-    <p><%= alchemy.download_attachment_url(@attachment) %></p>
-    <a data-clipboard-text="<%= alchemy.download_attachment_url(@attachment) %>" class="icon_button--right">
+    <p><%= @attachment.url(download: true) %></p>
+    <a data-clipboard-text="<%= @attachment.url(download: true) %>" class="icon_button--right">
       <%= render_icon(:clipboard, style: 'regular') %>
     </a>
   </div>
@@ -24,18 +24,18 @@
 <% case @attachment.icon_css_class %>
 <% when "file-image" %>
 <div class="attachment_preview_container image-preview">
-  <%= image_tag(alchemy.show_attachment_path(@attachment), class: "full_width") %>
+  <%= image_tag(@attachment.url, class: "full_width") %>
 </div>
 <% when "file-audio" %>
 <div class="attachment_preview_container player-preview">
-  <%= audio_tag(alchemy.show_attachment_path(@attachment), preload: "none", controls: true, class: "full_width") %>
+  <%= audio_tag(@attachment.url, preload: "none", controls: true, class: "full_width") %>
 </div>
 <% when "file-video" %>
 <div class="attachment_preview_container player-preview">
-  <%= video_tag(alchemy.show_attachment_path(@attachment), preload: "metadata", controls: true, class: "full_width") %>
+  <%= video_tag(@attachment.url, preload: "metadata", controls: true, class: "full_width") %>
 </div>
 <% when "file-pdf" %>
-<iframe src="<%= alchemy.show_attachment_path(@attachment) %>" frameborder=0 class="full-iframe">
+<iframe src="<%= @attachment.url %>" frameborder=0 class="full-iframe">
   Your browser does not support frames.
 </iframe>
 <% end %>