alchemy_cms 7.4.10 → 8.0.0.a

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

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

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class Picture < BaseRecord
-    class Preprocessor
+  class StorageAdapter
+    class Dragonfly::Preprocessor
       def initialize(image_file)
         @image_file = image_file
       end
 
       # Preprocess images after upload
       #
-      # Define preprocessing options in the Alchemy::Config
+      # 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)
+        max_image_size = Alchemy.config.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!