alchemy_cms 7.4.16 → 8.0.0.a

data/app/models/alchemy/picture_variant.rb

@@ -11,7 +11,6 @@ module Alchemy
     extend Forwardable
 
     include Alchemy::Logger
-    include Alchemy::Picture::Transformations
 
     ANIMATED_IMAGE_FORMATS = %w[gif webp]
     TRANSPARENT_IMAGE_FORMATS = %w[gif webp png]
@@ -89,20 +88,20 @@ module Alchemy
       end
 
       options = {
-        flatten: !render_format.in?(ANIMATED_IMAGE_FORMATS) && picture.image_file_format == "gif"
+        flatten: !render_format.in?(ANIMATED_IMAGE_FORMATS) && picture.image_file_extension == "gif"
       }.with_indifferent_access.merge(options)
 
       encoding_options = []
 
-      convert_format = render_format.sub("jpeg", "jpg") != picture.image_file_format.sub("jpeg", "jpg")
+      convert_format = render_format.sub("jpeg", "jpg") != picture.image_file_extension.sub("jpeg", "jpg")
 
       if encodable_image? && (convert_format || options[:quality])
-        quality = options[:quality] || Config.get(:output_image_quality)
+        quality = options[:quality] || Alchemy.config.output_image_quality
         encoding_options << "-quality #{quality}"
       end
 
       if options[:flatten]
-        if render_format.in?(TRANSPARENT_IMAGE_FORMATS) && picture.image_file_format.in?(TRANSPARENT_IMAGE_FORMATS)
+        if render_format.in?(TRANSPARENT_IMAGE_FORMATS) && picture.image_file_extension.in?(TRANSPARENT_IMAGE_FORMATS)
           encoding_options << "-background transparent"
         end
         encoding_options << "-flatten"
@@ -120,5 +119,116 @@ module Alchemy
     def encodable_image?
       render_format.in?(ENCODABLE_IMAGE_FORMATS)
     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 = inferred_sizes_from_string(size)
+      if crop_from && crop_size
+        top_left = point_from_string(crop_from)
+        crop_dimensions = inferred_sizes_from_string(crop_size)
+        xy_crop_resize(render_to, top_left, crop_dimensions, upsample)
+      else
+        center_crop(render_to, upsample)
+      end
+    end
+
+    # Returns the rendered resized image using imagemagick directly.
+    #
+    def resize(size, upsample = false)
+      image_file.thumbnail(upsample ? size : "#{size}>")
+    end
+
+    # Given a string with an x, this function return a Hash with key :x and :y
+    #
+    def point_from_string(string = "0x0")
+      string = "0x0" if string.empty?
+      raise ArgumentError if !string.match(/(\d*x)|(x\d*)/)
+
+      x, y = string.scan(/(\d*)x(\d*)/)[0].map(&:to_i)
+
+      x = 0 if x.nil?
+      y = 0 if y.nil?
+      {
+        x: x,
+        y: y
+      }
+    end
+
+    def inferred_sizes_from_string(string)
+      sizes = sizes_from_string(string)
+      ratio = image_file_width.to_f / image_file_height
+
+      if sizes[:width].zero?
+        sizes[:width] = (sizes[:height] * ratio).round.to_i
+      end
+      if sizes[:height].zero?
+        sizes[:height] = (sizes[:width] / ratio).round.to_i
+      end
+
+      sizes
+    end
+
+    # Given a string with an x, this function returns a Hash with point
+    # :width and :height.
+    #
+    def sizes_from_string(string)
+      width, height = string.to_s.split("x", 2).map(&:to_i)
+
+      {
+        width: width,
+        height: 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
+
+    # Converts a dimensions hash to a string of from "20x20"
+    #
+    def dimensions_to_string(dimensions)
+      "#{dimensions[:width]}x#{dimensions[:height]}"
+    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
+        dimensions = reduce_to_image(dimensions)
+      end
+      image_file.thumbnail("#{dimensions_to_string(dimensions)}#")
+    end
+
+    # 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 = dimensions_to_string(crop_dimensions)
+      crop_argument += "+#{top_left[:x]}+#{top_left[:y]}"
+
+      resize_argument = dimensions_to_string(dimensions)
+      resize_argument += ">" unless upsample
+      image_file.crop_resize(crop_argument, resize_argument)
+    end
+
+    # Used when centercropping.
+    #
+    def reduce_to_image(dimensions)
+      {
+        width: [dimensions[:width].to_i, image_file_width.to_i].min,
+        height: [dimensions[:height].to_i, image_file_height.to_i].min
+      }
+    end
   end
 end

data/{lib → app/models}/alchemy/resource.rb

@@ -98,8 +98,10 @@ module Alchemy
   #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, Gutentag::Tag)
   #
   class Resource
+    include Alchemy::Admin::ResourceName
+
     attr_accessor :resource_relations, :model_associations
-    attr_reader :model
+    attr_reader :model, :controller_path
 
     DEFAULT_SKIPPED_ATTRIBUTES = %w[id created_at creator_id]
     DEFAULT_SKIPPED_ASSOCIATIONS = %w[creator]
@@ -119,18 +121,6 @@ module Alchemy
       end
     end
 
-    def resource_array
-      @_resource_array ||= controller_path_array.reject { |el| el == "admin" }
-    end
-
-    def resources_name
-      @_resources_name ||= resource_array.last
-    end
-
-    def resource_name
-      @_resource_name ||= resources_name.singularize
-    end
-
     def namespaced_resource_name
       @_namespaced_resource_name ||= begin
         namespaced_resources_name.to_s.singularize
@@ -296,11 +286,7 @@ module Alchemy
     end
 
     def guess_model_from_controller_path
-      resource_array.join("/").classify.constantize
-    end
-
-    def controller_path_array
-      @controller_path.split("/")
+      resource_model_name.classify.constantize
     end
 
     def namespace_diff

data/{lib → app/models}/alchemy/searchable_resource.rb

@@ -21,6 +21,21 @@ module Alchemy
       searchable_alchemy_resource_associations
     end
 
+    # Allow all scopes used in resource filters to be used with Ransack
+    def ransackable_scopes(_auth_object = nil)
+      if respond_to?(:alchemy_resource_filters)
+        alchemy_resource_filters.flat_map do |filter_set|
+          if respond_to?(filter_set[:name])
+            filter_set[:name].to_s
+          else
+            filter_set[:values].map(&:to_s)
+          end
+        end
+      else
+        []
+      end
+    end
+
     protected
 
     def searchable_alchemy_resource_attributes

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

@@ -3,7 +3,6 @@
 module Alchemy
   module Site::Layout
     extend ActiveSupport::Concern
-
     SITE_DEFINITIONS_FILE = Rails.root.join("config/alchemy/site_layouts.yml")
 
     module ClassMethods
@@ -42,8 +41,8 @@ module Alchemy
     #
     def page_layout_names(layoutpages: false)
       page_layout_definitions.select do |layout|
-        !!layout["layoutpage"] && layoutpages || !layout["layoutpage"] && !layoutpages
-      end.collect { |layout| layout["name"] }
+        !!layout.layoutpage && layoutpages || !layout.layoutpage && !layoutpages
+      end.tap { _1.collect!(&:name) }
     end
 
     # Returns sites page layout definitions
@@ -52,11 +51,11 @@ module Alchemy
     #
     def page_layout_definitions
       if definition["page_layouts"].presence
-        Alchemy::PageLayout.all.select do |layout|
-          layout["name"].in?(definition["page_layouts"])
+        Alchemy::PageDefinition.all.select do |layout|
+          layout.name.in?(definition["page_layouts"])
         end
       else
-        Alchemy::PageLayout.all
+        Alchemy::PageDefinition.all
       end
     end
 

data/app/models/alchemy/site.rb

@@ -57,21 +57,6 @@ module Alchemy
     end
 
     class << self
-      # @deprecated Use {Alchemy::Current#site=} instead.
-      def current=(site)
-        Current.site = site
-      end
-      deprecate "current=": :"Alchemy::Current.site=", deprecator: Alchemy::Deprecation
-
-      # @deprecated Use {Alchemy::Current#site} instead.
-      def current
-        Current.site
-      end
-      deprecate current: :"Alchemy::Current.site", deprecator: Alchemy::Deprecation
-
-      alias_method :default, :first
-      deprecate default: :first, deprecator: Alchemy::Deprecation
-
       def find_for_host(host)
         # These are split up into two separate queries in order to run the
         # fastest query first (selecting the domain by its primary host name).

data/app/models/alchemy/storage_adapter/active_storage/attachment_url.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    # The class representing an URL to an ActiveStorage attachment
+    #
+    class ActiveStorage::AttachmentUrl
+      attr_reader :attachment
+
+      def initialize(attachment)
+        @attachment = attachment
+      end
+
+      # The attachment url
+      #
+      # @param [Hash] options
+      # @option options [Symbol] :download return a URL for downloading the attachment
+      # @option options [Symbol] :name The filename
+      # @option options [Symbol] :format The file extension
+      #
+      # @return [String]
+      #
+      def call(options = {})
+        if attachment.file.attached?
+          options[:format] ||= attachment.suffix
+          if options.delete(:download)
+            routes.download_attachment_path(attachment, options)
+          else
+            routes.show_attachment_path(attachment, options)
+          end
+        end
+      end
+
+      private
+
+      def routes
+        Alchemy::Engine.routes.url_helpers
+      end
+    end
+  end
+end

data/app/models/alchemy/storage_adapter/active_storage/picture_url.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    # Returns the URL to a variant of a picture using ActiveStorage
+    class ActiveStorage::PictureUrl
+      attr_reader :picture, :image_file
+
+      # @param [Alchemy::Picture]
+      #
+      def initialize(picture)
+        @picture = picture
+        @image_file = picture.image_file
+      end
+
+      # The URL to a variant of a picture
+      #
+      # @return [String]
+      #
+      def call(options = {})
+        variant_options = DragonflyToImageProcessing.call(options)
+        variant_options[:format] = options[:format] || default_output_format
+        variant = image_file&.variant(variant_options)
+        return unless variant
+
+        Rails.application.routes.url_helpers.rails_blob_path(
+          variant,
+          {
+            filename: filename(options),
+            format: variant_options[:format],
+            only_path: true
+          }
+        )
+      end
+
+      private
+
+      def filename(options = {})
+        if picture.name.presence
+          picture.name.to_param
+        else
+          picture.image_file_name
+        end
+      end
+
+      def default_output_format
+        if Alchemy.config.image_output_format == "original"
+          picture.image_file_extension
+        else
+          Alchemy.config.image_output_format
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/storage_adapter/active_storage/preprocessor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    class ActiveStorage::Preprocessor
+      def initialize(attachable)
+        @attachable = attachable
+      end
+
+      # Preprocess images after upload
+      #
+      # Define preprocessing options in the Alchemy.config
+      #
+      #   preprocess_image_resize [String] - Downsizing example: '1000x1000>'
+      #
+      def call
+        max_image_size = Alchemy.config.get(:preprocess_image_resize)
+        if max_image_size.present?
+          self.class.process_thumb(attachable, size: max_image_size)
+        end
+      end
+
+      attr_reader :attachable
+
+      class << self
+        def generate_thumbs!(attachable)
+          Alchemy::Picture::THUMBNAIL_SIZES.values.each do |size|
+            process_thumb(attachable, size: size, flatten: true)
+          end
+        end
+
+        def process_thumb(attachable, options = {})
+          attachable.variant :thumb,
+            **Alchemy::DragonflyToImageProcessing.call(options),
+            preprocessed: true
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/storage_adapter/active_storage.rb

@@ -0,0 +1,173 @@
+module Alchemy
+  class StorageAdapter
+    module ActiveStorage
+      module PictureClassMethods
+        def self.included(base)
+          base.has_one_attached :image_file do |attachable|
+            # Only works in Rails 7.1+
+            # https://github.com/rails/rails/pull/47473
+            Alchemy.storage_adapter.preprocessor_class.new(attachable).call
+            Alchemy.storage_adapter.preprocessor_class.generate_thumbs!(attachable)
+          end
+        end
+      end
+
+      module AttachmentClassMethods
+        def self.included(base)
+          base.has_one_attached :file
+        end
+      end
+
+      extend self
+
+      def attachment_url_class
+        AttachmentUrl
+      end
+
+      def preprocessor_class
+        Preprocessor
+      end
+
+      def picture_url_class
+        PictureUrl
+      end
+
+      def file_formats(class_name, scope:)
+        attachment_scope = case class_name
+        when "Alchemy::Attachment" then scope.with_attached_file
+        when "Alchemy::Picture" then scope.with_attached_image_file
+        end
+
+        attachment_scope.pluck("active_storage_blobs.content_type").uniq.tap(&:compact!).presence || []
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def searchable_alchemy_resource_attributes(class_name)
+        case class_name
+        when "Alchemy::Attachment"
+          %w[name file_blob_filename]
+        when "Alchemy::Picture"
+          %w[name image_file_blob_filename]
+        end
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def ransackable_attributes(_class_name)
+        %w[name]
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def ransackable_associations(class_name)
+        case class_name
+        when "Alchemy::Attachment"
+          %w[file_blob]
+        when "Alchemy::Picture"
+          %w[image_file_blob]
+        end
+      end
+
+      def rescuable_errors
+        ::ActiveStorage::Error
+      end
+
+      # @param [String]
+      # @return [Alchemy::Picture::ActiveRecord_Relation]
+      def by_file_format_scope(file_format)
+        Picture.with_attached_image_file.joins(:image_file_blob).where(active_storage_blobs: {content_type: file_format})
+      end
+
+      # @param [String]
+      # @return [Alchemy::Atachment::ActiveRecord_Relation]
+      def by_file_type_scope(file_type)
+        Attachment.with_attached_file.joins(:file_blob).where(active_storage_blobs: {content_type: file_type})
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_name(attachment)
+        attachment.file&.filename&.to_s
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [Integer]
+      def file_size(attachment)
+        attachment.file&.byte_size
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_mime_type(attachment)
+        attachment.file&.content_type
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_extension(attachment)
+        attachment.file&.filename&.extension
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def has_convertible_format?(picture)
+        picture.image_file&.variable?
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_name(picture)
+        picture.image_file&.filename&.to_s
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_format(picture)
+        picture.image_file&.content_type
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_size(picture)
+        picture.image_file&.byte_size
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_width(picture)
+        picture.image_file&.metadata&.fetch(:width, nil)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_height(picture)
+        picture.image_file&.metadata&.fetch(:height, nil)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_extension(picture)
+        picture.image_file&.filename&.extension&.downcase
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def image_file_present?(picture)
+        picture.image_file.attached?
+      end
+
+      # @param Alchemy::Picture::ActiveRecord_Relation
+      # @return Alchemy::Picture::ActiveRecord_Relation
+      def preloaded_pictures(pictures)
+        pictures.with_attached_image_file
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [TrueClass, FalseClass]
+      def set_attachment_name?(attachment)
+        attachment.file.changed?
+      end
+    end
+  end
+end

data/app/models/alchemy/{attachment/url.rb → storage_adapter/dragonfly/attachment_url.rb}

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class Attachment < BaseRecord
-    # The class representing an URL to an attachment
+  class StorageAdapter
+    # The class representing an URL to an Dragonfly attachment
     #
-    # Set a different one
-    #
-    #     Alchemy::Attachment.url_class = MyRemoteUrlClass
-    #
-    class Url
+    class Dragonfly::AttachmentUrl
+      attr_reader :attachment
+
       def initialize(attachment)
         @attachment = attachment
       end
@@ -23,11 +21,13 @@ module Alchemy
       # @return [String]
       #
       def call(options = {})
-        options[:format] ||= @attachment.suffix
-        if options.delete(:download)
-          routes.download_attachment_path(@attachment, options)
-        else
-          routes.show_attachment_path(@attachment, options)
+        if attachment.file
+          options[:format] ||= attachment.suffix
+          if options.delete(:download)
+            routes.download_attachment_path(attachment, options)
+          else
+            routes.show_attachment_path(attachment, options)
+          end
         end
       end
 

data/app/models/alchemy/{picture/url.rb → storage_adapter/dragonfly/picture_url.rb}

@@ -1,23 +1,39 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class Picture < BaseRecord
-    class Url
-      attr_reader :variant, :thumb
+  class StorageAdapter
+    class Dragonfly::PictureUrl
+      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?
+      attr_reader :picture, :variant, :thumb
 
-        @variant = variant
+      # @param [Alchemy::Picture]
+      #
+      def initialize(picture)
+        @picture = picture
       end
 
       # The URL to a variant of a picture
       #
       # @return [String]
       #
-      def call(params = {})
+      def call(options = {})
+        @variant = PictureVariant.new(picture, options.slice(*TRANSFORMATION_OPTIONS))
+        params = {
+          basename: picture.name,
+          ext: variant.render_format,
+          name: picture.name
+        }
+
         return variant.image.url(params) unless processible_image?
 
         "/#{uid}"
@@ -43,10 +59,10 @@ module Alchemy
       end
 
       def find_thumb_by(signature)
-        @thumb = if variant.picture.thumbs.loaded?
-          variant.picture.thumbs.find { |t| t.signature == signature }
+        @thumb = if picture.thumbs.loaded?
+          picture.thumbs.find { |t| t.signature == signature }
         else
-          variant.picture.thumbs.find_by(signature: signature)
+          picture.thumbs.find_by(signature: signature)
         end
       end
     end