alchemy_cms 7.4.16 → 8.0.0.a

data/app/models/alchemy/page/page_elements.rb

@@ -81,8 +81,8 @@ module Alchemy
       #
       def available_element_definitions(only_element_named = nil)
         @_available_element_definitions ||= if only_element_named
-          definition = Element.definition_by_name(only_element_named)
-          element_definitions_by_name(definition["nestable_elements"])
+          element_definition = Element.definition_by_name(only_element_named)
+          element_definitions_by_name(element_definition.nestable_elements)
         else
           element_definitions.dup
         end
@@ -100,7 +100,7 @@ module Alchemy
       # All names of elements that can actually be placed on current page.
       #
       def available_element_names
-        @_available_element_names ||= available_element_definitions.map { |e| e["name"] }
+        @_available_element_names ||= available_element_definitions.map(&:name)
       end
 
       # Available element definitions excluding nested unique elements.
@@ -109,7 +109,7 @@ module Alchemy
         @_available_elements = if parent
           parents_unique_nested_elements = parent.nested_elements.where(unique: true).pluck(:name)
           available_element_definitions(parent.name).reject do |e|
-            parents_unique_nested_elements.include? e["name"]
+            parents_unique_nested_elements.include?(e.name)
           end
         else
           available_element_definitions
@@ -129,10 +129,9 @@ module Alchemy
       #
       def descendent_element_definitions
         definitions = element_definitions_by_name(element_definition_names)
-        definitions.select { |d| d.key?("nestable_elements") }.each do |d|
-          definitions += element_definitions_by_name(d["nestable_elements"])
-        end
-        definitions.uniq { |d| d["name"] }
+        definitions.select { _1.nestable_elements.any? }.flat_map do |d|
+          element_definitions_by_name(d.nestable_elements)
+        end.uniq(&:name)
       end
 
       # All names of elements that are defined in the page definition.
@@ -145,7 +144,7 @@ module Alchemy
       #     elements: [headline, contactform]
       #
       def element_definition_names
-        definition["elements"] || []
+        definition.elements || []
       end
 
       # Element definitions with given name(s)
@@ -161,7 +160,7 @@ module Alchemy
         if names.to_s == "all"
           Element.definitions
         else
-          Element.definitions.select { |e| names.include? e["name"] }
+          Element.definitions.select { names.include?(_1.name) }
         end
       end
 
@@ -181,7 +180,7 @@ module Alchemy
       # And if so, it generates them.
       #
       def generate_elements
-        definition.fetch("autogenerate", []).each do |element_name|
+        definition.autogenerate&.each do |element_name|
           Element.create(page: self, page_version: draft_version, name: element_name)
         end
       end
@@ -190,7 +189,7 @@ module Alchemy
       #
       def delete_unique_element_definitions!
         @_available_element_definitions.delete_if do |element|
-          element["unique"] && @_existing_element_names.include?(element["name"])
+          element.unique && @_existing_element_names.include?(element.name)
         end
       end
 
@@ -198,8 +197,8 @@ module Alchemy
       #
       def delete_outnumbered_element_definitions!
         @_available_element_definitions.delete_if do |element|
-          outnumbered = @_existing_element_names.select { |name| name == element["name"] }
-          element["amount"] && outnumbered.count >= element["amount"].to_i
+          outnumbered = @_existing_element_names.select { |name| name == element.name }
+          element.amount && outnumbered.count >= element.amount
         end
       end
     end

data/app/models/alchemy/page/page_naming.rb

@@ -5,7 +5,6 @@ module Alchemy
     module PageNaming
       extend ActiveSupport::Concern
       include NameConversions
-
       RESERVED_URLNAMES = %w[admin messages new]
 
       included do

data/app/models/alchemy/page/page_natures.rb

@@ -38,13 +38,13 @@ module Alchemy
       # @returns Array
       #
       def has_limited_editors?
-        definition["editable_by"].present?
+        definition.editable_by.present?
       end
 
       def editor_roles
         return unless has_limited_editors?
 
-        definition["editable_by"]
+        definition.editable_by
       end
 
       # True if page locked_at timestamp and locked_by id are set
@@ -80,10 +80,10 @@ module Alchemy
 
       # Returns the self#page_layout definition from config/alchemy/page_layouts.yml file.
       def definition
-        definition = PageLayout.get(page_layout)
+        definition = PageDefinition.get(page_layout)
         if definition.nil?
           log_warning "Page definition for `#{page_layout}` not found. Please check `page_layouts.yml` file."
-          return {}
+          return PageDefinition.new
         end
         definition
       end
@@ -146,14 +146,14 @@ module Alchemy
       def cache_page?
         return false unless caching_enabled?
 
-        page_layout = PageLayout.get(self.page_layout)
-        page_layout["cache"] != false && page_layout["searchresults"] != true
+        page_layout = PageDefinition.get(self.page_layout)
+        page_layout.cache != false && page_layout.searchresults != true
       end
 
       private
 
       def caching_enabled?
-        Alchemy::Config.get(:cache_pages) &&
+        Alchemy.config.cache_pages &&
           Rails.application.config.action_controller.perform_caching
       end
     end

data/app/models/alchemy/page/page_scopes.rb

@@ -124,7 +124,7 @@ module Alchemy
         end
 
         def ransackable_scopes(_auth_object)
-          [:published, :contentpages, :from_current_site, :searchables, :layoutpages]
+          [:published, :not_public, :restricted, :contentpages, :from_current_site, :searchables, :layoutpages, :by_page_layout]
         end
       end
     end

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, if: :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