alchemy_cms 7.4.10 → 8.0.0.a

data/app/models/alchemy/page.rb

@@ -36,7 +36,7 @@
 #
 
 require_dependency "alchemy/page/fixed_attributes"
-require_dependency "alchemy/page/page_layouts"
+require_dependency "alchemy/page/definitions"
 require_dependency "alchemy/page/page_scopes"
 require_dependency "alchemy/page/page_natures"
 require_dependency "alchemy/page/page_naming"
@@ -44,7 +44,6 @@ require_dependency "alchemy/page/page_elements"
 
 module Alchemy
   class Page < BaseRecord
-    include Alchemy::Hints
     include Alchemy::Logger
     include Alchemy::Taggable
 
@@ -90,7 +89,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
 
@@ -156,7 +155,7 @@ module Alchemy
     after_update :touch_nodes
 
     # Concerns
-    include PageLayouts
+    include Definitions
     include PageScopes
     include PageNatures
     include PageNaming
@@ -164,6 +163,7 @@ module Alchemy
 
     # site_name accessor
     delegate :name, to: :site, prefix: true, allow_nil: true
+    delegate :has_hint?, :hint, to: :definition
 
     # Class methods
     #
@@ -183,37 +183,10 @@ module Alchemy
         @_url_path_class = klass
       end
 
-      def alchemy_resource_filters
-        [
-          {
-            name: :by_page_layout,
-            values: PageLayout.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] }
-          },
-          {
-            name: :status,
-            values: %w[published not_public restricted]
-          }
-        ]
-      end
-
       def searchable_alchemy_resource_attributes
         %w[name urlname title]
       end
 
-      # Used to store the current page previewed in the edit page template.
-      # @deprecated Use {Alchemy::Current#preview_page=} instead.
-      def current_preview=(page)
-        Current.preview_page = page
-      end
-      deprecate "current_preview=": :"Alchemy::Current.preview_page=", deprecator: Alchemy::Deprecation
-
-      # Returns the current page previewed in the edit page template.
-      # @deprecated Use {Alchemy::Current#preview_page} instead.
-      def current_preview
-        Current.preview_page
-      end
-      deprecate current_preview: :"Alchemy::Current.preview_page", deprecator: Alchemy::Deprecation
-
       # @return the language root page for given language id.
       # @param language_id [Fixnum]
       #
@@ -265,13 +238,13 @@ module Alchemy
 
         clipboard_pages = all_from_clipboard(clipboard)
         allowed_page_layouts = Alchemy::Page.selectable_layouts(language_id, layoutpages: layoutpages)
-        allowed_page_layout_names = allowed_page_layouts.collect { |p| p["name"] }
+        allowed_page_layout_names = allowed_page_layouts.collect(&:name)
         clipboard_pages.select { |cp| allowed_page_layout_names.include?(cp.page_layout) }
       end
 
       def link_target_options
         options = [[Alchemy.t(:default, scope: "link_target_options"), ""]]
-        link_target_options = Config.get(:link_target_options)
+        link_target_options = Alchemy.config.link_target_options
         link_target_options.each do |option|
           # add an underscore to the options to provide the default syntax
           # @link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#target
@@ -280,6 +253,11 @@ module Alchemy
         end
         options
       end
+
+      # Allow all string and text attributes to be searchable by Ransack.
+      def ransackable_attributes(_auth_object = nil)
+        searchable_alchemy_resource_attributes + ["updated_at"]
+      end
     end
 
     # Instance methods

data/app/models/alchemy/page_definition.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PageDefinition
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Alchemy::Hints
+
+    extend ActiveModel::Translation
+
+    attribute :name, :string
+    attribute :elements, default: []
+    attribute :autogenerate, default: []
+    attribute :layoutpage, :boolean, default: false
+    attribute :unique, :boolean, default: false
+    attribute :cache, :boolean, default: true
+    attribute :insert_elements_at, :string, default: "bottom"
+    attribute :fixed_attributes, default: {}
+    attribute :searchable, :boolean, default: true
+    attribute :searchresults, :boolean, default: false
+    attribute :hide, :boolean, default: false
+    attribute :editable_by
+    attribute :hint
+
+    validates :name,
+      presence: true,
+      format: {
+        with: /\A[a-z_-]+\z/
+      }
+
+    delegate :[], to: :attributes
+    delegate :blank?, to: :name
+
+    class << self
+      # Returns all page layouts.
+      #
+      # They are defined in +config/alchemy/page_layout.yml+ file.
+      #
+      def all
+        @definitions ||= read_definitions_file.map { new(**_1) }
+      end
+
+      def map(...)
+        all.map(...)
+      end
+      alias_method :collect, :map
+
+      # Add additional page definitions to collection.
+      #
+      # Useful for extending the page layouts from an Alchemy module.
+      #
+      # === Usage Example
+      #
+      #   Call +Alchemy::PageDefinition.add(your_definition)+ in your engine.rb file.
+      #
+      # @param [Array || Hash]
+      #   You can pass a single layout definition as Hash, or a collection of page layouts as Array.
+      #
+      def add(definition)
+        all
+        @definitions += Array.wrap(definition).map { new(**_1) }
+      end
+
+      # Returns one page definition by given name.
+      #
+      def get(name)
+        return new if name.blank?
+
+        all.detect { _1.name.casecmp(name).zero? }
+      end
+
+      def reset!
+        @definitions = nil
+      end
+
+      # The absolute +page_layouts.yml+ file path
+      # @return [Pathname]
+      def layouts_file_path
+        Rails.root.join("config", "alchemy", "page_layouts.yml")
+      end
+
+      private
+
+      # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
+      #
+      def read_definitions_file
+        if File.exist?(layouts_file_path)
+          Array.wrap(
+            YAML.safe_load(
+              ERB.new(File.read(layouts_file_path)).result,
+              permitted_classes: YAML_PERMITTED_CLASSES,
+              aliases: true
+            ) || []
+          )
+        else
+          raise LoadError, "Could not find page_layouts.yml file! Please run `rails generate alchemy:install`"
+        end
+      end
+    end
+
+    def human_name
+      Alchemy::Page.human_layout_name(name)
+    end
+
+    def attributes
+      super.with_indifferent_access
+    end
+
+    private
+
+    def hint_translation_scope
+      :page_hints
+    end
+  end
+end

data/app/models/alchemy/picture.rb

@@ -28,24 +28,10 @@ module Alchemy
       large: "240x180"
     }.with_indifferent_access.freeze
 
-    CONVERTIBLE_FILE_FORMATS = %w[gif jpg jpeg png webp].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 Calculations
 
     has_many :picture_ingredients,
       class_name: "Alchemy::Ingredients::Picture",
@@ -54,7 +40,6 @@ module Alchemy
 
     has_many :elements, through: :picture_ingredients
     has_many :pages, through: :elements
-    has_many :thumbs, class_name: "Alchemy::PictureThumb", dependent: :destroy
     has_many :descriptions, class_name: "Alchemy::PictureDescription", dependent: :destroy
 
     accepts_nested_attributes_for :descriptions, allow_destroy: true, reject_if: ->(attr) { attr[:text].blank? }
@@ -72,7 +57,7 @@ module Alchemy
 
     # Image preprocessing class
     def self.preprocessor_class
-      @_preprocessor_class ||= Preprocessor
+      @_preprocessor_class ||= Alchemy.storage_adapter.preprocessor_class
     end
 
     # Set a image preprocessing class
@@ -84,56 +69,39 @@ module Alchemy
       @_preprocessor_class = klass
     end
 
-    # Enables Dragonfly image processing
-    dragonfly_accessor :image_file, app: :alchemy_pictures do
-      # Preprocess after uploading the picture
-      after_assign do |image|
-        if has_convertible_format?
-          self.class.preprocessor_class.new(image).call
-        end
-      end
-    end
-
-    before_save :sanitize_image_file_name
-    # Create important thumbnails upfront
-    after_create -> { PictureThumb.generate_thumbs!(self) if has_convertible_format? }
+    include Alchemy.storage_adapter.picture_class_methods
 
     # We need to define this method here to have it available in the validations below.
     class << self
       def allowed_filetypes
-        Config.get(:uploader).fetch("allowed_filetypes", {}).fetch("alchemy/pictures", [])
+        Alchemy.config.uploader.allowed_filetypes.alchemy_pictures
       end
     end
 
     validates_presence_of :image_file
-    validates_size_of :image_file, maximum: Config.get(:uploader)["file_size_limit"].megabytes
-    validates_property :format,
-      of: :image_file,
-      in: allowed_filetypes,
-      case_sensitive: false,
-      message: Alchemy.t("not a valid image")
+    validates_size_of :image_file, maximum: Alchemy.config.uploader.file_size_limit.megabytes
+    validate :image_file_type_allowed, if: -> { image_file.present? }
 
-    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) }
-    scope :deletable, -> do
-      where(
-        "#{table_name}.id NOT IN (SELECT related_object_id FROM alchemy_ingredients WHERE related_object_id IS NOT NULL AND related_object_type = ?)",
-        name
-      )
-    end
+    scope :deletable,
+      -> {
+        where("#{table_name}.id NOT IN (SELECT related_object_id FROM alchemy_ingredients WHERE related_object_type = 'Alchemy::Picture')")
+      }
     scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: {id: nil}) }
-    scope :by_file_format, ->(format) { where(image_file_format: format) }
+    scope :by_file_format, ->(file_format) do
+      Alchemy.storage_adapter.by_file_format_scope(file_format)
+    end
 
     # Class methods
 
     class << self
       # The class used to generate URLs for pictures
       #
-      # @see Alchemy::Picture::Url
       def url_class
-        @_url_class ||= Alchemy::Picture::Url
+        @_url_class ||= Alchemy.storage_adapter.picture_url_class
       end
 
       # Set a different picture url class
@@ -143,22 +111,16 @@ module Alchemy
         @_url_class = klass
       end
 
-      def alchemy_resource_filters
-        @_file_formats ||= distinct.pluck(:image_file_format).compact.presence || []
-        [
-          {
-            name: :by_file_format,
-            values: @_file_formats
-          },
-          {
-            name: :misc,
-            values: %w[recent last_upload without_tag deletable]
-          }
-        ]
+      def searchable_alchemy_resource_attributes
+        Alchemy.storage_adapter.searchable_alchemy_resource_attributes(name)
+      end
+
+      def ransackable_attributes(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_attributes(name)
       end
 
-      def searchable_alchemy_resource_attributes
-        %w[name image_file_name]
+      def ransackable_associations(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_associations(name)
       end
 
       def last_upload
@@ -167,33 +129,30 @@ module Alchemy
 
         Picture.where(upload_hash: last_picture.upload_hash)
       end
+
+      def ransackable_scopes(_auth_object = nil)
+        [:by_file_format, :recent, :last_upload, :without_tag, :deletable]
+      end
+
+      def file_formats(scope = all)
+        Alchemy.storage_adapter.file_formats(name, scope:)
+      end
     end
 
     # 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
+      self.class.url_class.new(self).call(options)
+    rescue Alchemy.storage_adapter.rescuable_errors => e
       log_warning(e.message)
       nil
     end
@@ -208,7 +167,7 @@ module Alchemy
 
       url(
         flatten: true,
-        format: image_file_format || "jpg",
+        format: image_file_extension || "jpg",
         size: size
       )
     end
@@ -242,18 +201,12 @@ module Alchemy
       end
     end
 
-    # Returns the suffix of the filename.
-    #
-    def suffix
-      image_file.ext
-    end
-
     # Returns a humanized, readable name from image filename.
     #
     def humanized_name
       return "" if image_file_name.blank?
 
-      convert_to_humanized_name(image_file_name, suffix)
+      convert_to_humanized_name(image_file_name, image_file_extension)
     end
 
     # Returns the format the image should be rendered with
@@ -263,9 +216,9 @@ module Alchemy
     #
     def default_render_format
       if convertible?
-        Config.get(:image_output_format)
+        Alchemy.config.image_output_format
       else
-        image_file_format
+        image_file_extension
       end
     end
 
@@ -275,15 +228,15 @@ module Alchemy
     # image has not a convertible file format (i.e. SVG) this returns +false+
     #
     def convertible?
-      Config.get(:image_output_format) &&
-        Config.get(:image_output_format) != "original" &&
+      Alchemy.config.image_output_format &&
+        Alchemy.config.image_output_format != "original" &&
         has_convertible_format?
     end
 
     # Returns true if the image can be converted into other formats
     #
     def has_convertible_format?
-      image_file_format.in?(CONVERTIBLE_FILE_FORMATS)
+      Alchemy.storage_adapter.has_convertible_format?(self)
     end
 
     # Checks if the picture is restricted.
@@ -304,6 +257,32 @@ module Alchemy
       picture_ingredients.empty?
     end
 
+    def image_file_name
+      Alchemy.storage_adapter.image_file_name(self)
+    end
+
+    def image_file_format
+      Alchemy.storage_adapter.image_file_format(self)
+    end
+
+    def image_file_size
+      Alchemy.storage_adapter.image_file_size(self)
+    end
+
+    def image_file_width
+      Alchemy.storage_adapter.image_file_width(self)
+    end
+
+    def image_file_height
+      Alchemy.storage_adapter.image_file_height(self)
+    end
+
+    def image_file_extension
+      Alchemy.storage_adapter.image_file_extension(self)
+    end
+    alias_method :suffix, :image_file_extension
+    deprecate suffix: :image_file_extension, deprecator: Alchemy::Deprecation
+
     # A size String from original image file values.
     #
     # == Example
@@ -314,8 +293,12 @@ module Alchemy
       "#{image_file_width}x#{image_file_height}"
     end
 
-    def sanitize_image_file_name
-      self.image_file_name = sanitized_filename(image_file_name)
+    private
+
+    def image_file_type_allowed
+      unless image_file_extension&.in?(self.class.allowed_filetypes)
+        errors.add(:image_file, Alchemy.t("not a valid image"))
+      end
     end
   end
 end

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