alchemy_cms 7.4.6 → 8.0.0.a

data/app/models/alchemy/admin/filters/select.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module Filters
+      class Select < Base
+        attr_reader :options
+
+        # Creates a resource filter that displays as a select.
+        # @param name [String] The name of the filter.
+        # @param resource_name [String] The name of the resource.
+        # @param options [Proc, Array] A proc that returns the options for the select, or an array of options.
+        def initialize(name:, resource_name:, options:)
+          super(name:, resource_name:)
+          @options = options_to_proc(options)
+        end
+
+        # Returns a select filter component.
+        # @param params [Hash] The search filter params.
+        # @param query [Ransack::Search] The current search query.
+        # @return [ Alchemy::Admin::Resource::SelectFilter] The select filter component.
+        def input_component(params, query)
+          Alchemy::Admin::Resource::SelectFilter.new(
+            name:,
+            resource_name:,
+            label: translated_name,
+            include_blank:,
+            options: get_options_for_select(query),
+            params:
+          )
+        end
+
+        private
+
+        def include_blank
+          Alchemy.t(:all, scope: [:filters, resource_name, name])
+        end
+
+        def options_to_proc(options)
+          if options.is_a? Proc
+            options
+          else
+            ->(_query) { options }
+          end
+        end
+
+        def get_options_for_select(query)
+          options_for_select = options.call(query)
+          # The result of the query is an Array of Arrays, where the first element is the translated name and the second element is the value.
+          # If the first element is an Array, we assume that the options are already translated.
+          if options_for_select.first.is_a? Array
+            options_for_select
+          # If the values are translatable, we translate them.
+          elsif Alchemy.t(:values, scope: [:filters, resource_name, name])
+            options_for_select.map do |value|
+              [Alchemy.t(value.to_sym, scope: [:filters, resource_name, name, :values]), value]
+            end
+          # Otherwise we return the options as they are.
+          else
+            options_for_select.map { |option| [option, option] }
+          end
+        end
+
+        def translated_value(value, query)
+          get_options_for_select(query).detect { |option| option[1].to_s == value }&.first
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/admin/resource_name.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module ResourceName
+      def resource_model_name
+        resource_array.join("/").classify
+      end
+
+      def resource_name
+        resources_name.singularize
+      end
+
+      def resource_array
+        controller_path_array.reject { |el| el == "admin" }
+      end
+
+      def resources_name
+        resource_array.last
+      end
+
+      def controller_path_array
+        controller_path.split("/")
+      end
+    end
+  end
+end

data/app/models/alchemy/attachment.rb

@@ -24,11 +24,9 @@ module Alchemy
     include Alchemy::Taggable
     include Alchemy::TouchElements
 
-    dragonfly_accessor :file, app: :alchemy_attachments do
-      after_assign { |f| write_attribute(:file_mime_type, f.mime_type) }
-    end
+    include Alchemy.storage_adapter.attachment_class_methods
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :file_ingredients,
       class_name: "Alchemy::Ingredients::File",
@@ -38,7 +36,10 @@ module Alchemy
     has_many :elements, through: :file_ingredients
     has_many :pages, through: :elements
 
-    scope :by_file_type, ->(file_type) { where(file_mime_type: file_type) }
+    scope :by_file_type, ->(file_type) do
+      Alchemy.storage_adapter.by_file_type_scope(file_type)
+    end
+
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
     scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: {id: nil}) }
 
@@ -46,9 +47,8 @@ module Alchemy
     class << self
       # The class used to generate URLs for attachments
       #
-      # @see Alchemy::Attachment::Url
       def url_class
-        @_url_class ||= Alchemy::Attachment::Url
+        @_url_class ||= Alchemy.storage_adapter.attachment_url_class
       end
 
       # Set a different attachment url class
@@ -58,19 +58,6 @@ module Alchemy
         @_url_class = klass
       end
 
-      def alchemy_resource_filters
-        [
-          {
-            name: :by_file_type,
-            values: distinct.pluck(:file_mime_type).map { |type| [Alchemy.t(type, scope: "mime_types"), type] }.sort_by(&:first)
-          },
-          {
-            name: :misc,
-            values: %w[recent last_upload without_tag]
-          }
-        ]
-      end
-
       def last_upload
         last_id = Attachment.maximum(:id)
         return Attachment.all unless last_id
@@ -79,33 +66,43 @@ module Alchemy
       end
 
       def searchable_alchemy_resource_attributes
-        %w[name file_name]
+        Alchemy.storage_adapter.searchable_alchemy_resource_attributes(name)
+      end
+
+      def ransackable_attributes(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_attributes(name)
+      end
+
+      def ransackable_associations(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_associations(name)
+      end
+
+      def file_types(scope = all)
+        Alchemy.storage_adapter.file_formats(name, scope:)
       end
 
       def allowed_filetypes
-        Config.get(:uploader).fetch("allowed_filetypes", {}).fetch("alchemy/attachments", [])
+        Alchemy.config.uploader.allowed_filetypes.alchemy_attachments
+      end
+
+      def ransackable_scopes(_auth_object = nil)
+        %i[by_file_type recent last_upload without_tag]
       end
     end
 
     validates_presence_of :file
-    validates_size_of :file, maximum: Config.get(:uploader)["file_size_limit"].megabytes
-    validates_property :ext,
-      of: :file,
-      in: allowed_filetypes,
-      case_sensitive: false,
-      message: Alchemy.t("not a valid file"),
+    validates_size_of :file, maximum: Alchemy.config.uploader.file_size_limit.megabytes
+    validate :file_type_allowed,
       unless: -> { self.class.allowed_filetypes.include?("*") }
 
-    before_save :set_name, if: :file_name_changed?
+    before_save :set_name, if: -> { Alchemy.storage_adapter.set_attachment_name?(self) }
 
     scope :with_file_type, ->(file_type) { where(file_mime_type: file_type) }
 
     # Instance methods
 
     def url(options = {})
-      if file
-        self.class.url_class.new(self).call(options)
-      end
+      self.class.url_class.new(self).call(options)
     end
 
     # An url save filename without format suffix
@@ -118,9 +115,23 @@ module Alchemy
       pages.any? && pages.not_restricted.blank?
     end
 
+    # File name
+    def file_name
+      Alchemy.storage_adapter.file_name(self)
+    end
+
+    # File size
+    def file_size
+      Alchemy.storage_adapter.file_size(self)
+    end
+
+    def file_mime_type
+      Alchemy.storage_adapter.file_mime_type(self)
+    end
+
     # File format suffix
     def extension
-      file_name.split(".").last
+      Alchemy.storage_adapter.file_extension(self)
     end
 
     alias_method :suffix, :extension
@@ -156,8 +167,14 @@ module Alchemy
 
     private
 
+    def file_type_allowed
+      unless extension&.in?(self.class.allowed_filetypes)
+        errors.add(:file, Alchemy.t("not a valid file"))
+      end
+    end
+
     def set_name
-      self.name = convert_to_humanized_name(file_name, file.ext)
+      self.name ||= convert_to_humanized_name(file_name, extension)
     end
   end
 end

data/app/models/alchemy/base_record.rb

@@ -6,6 +6,8 @@ module Alchemy
   end
 
   class BaseRecord < ActiveRecord::Base
+    include ConfigMissing
+    extend ConfigMissing
     extend Alchemy::SearchableResource
 
     self.abstract_class = true

data/app/models/alchemy/element/definitions.rb

@@ -46,7 +46,7 @@ module Alchemy
         else
           log_warning "Could not find element definition for #{name}. " \
                       "Please check your elements.yml file!"
-          {}
+          ElementDefinition.new
         end
       end
     end

data/app/models/alchemy/element/element_ingredients.rb

@@ -53,16 +53,16 @@ module Alchemy
 
       # Returns all element ingredient definitions from the +elements.yml+ file
       def ingredient_definitions
-        definition.fetch(:ingredients, [])
+        definition.ingredients
       end
 
       # Returns the definition for given ingredient role
       def ingredient_definition_for(role)
         if ingredient_definitions.blank?
-          log_warning "Element #{name} is missing the ingredient definition for #{role}"
           nil
         else
-          ingredient_definitions.find { |d| d[:role] == role.to_s }
+          ingredient_definitions.find { _1.role == role.to_s } ||
+            log_warning("Element #{name} is missing the ingredient definition for #{role}")
         end
       end
 
@@ -99,10 +99,10 @@ module Alchemy
 
       # Builds ingredients for this element as described in the +elements.yml+
       def build_ingredients
-        ingredient_definitions.each do |attributes|
+        ingredient_definitions.each do |definition|
           ingredients.build(
-            role: attributes[:role],
-            type: Alchemy::Ingredient.normalize_type(attributes[:type])
+            role: definition.role,
+            type: Alchemy::Ingredient.normalize_type(definition.type)
           )
         end
       end

data/app/models/alchemy/element/presenters.rb

@@ -33,7 +33,7 @@ module Alchemy
       # @see Alchemy::Element::Presenters#display_name_for
       #
       def display_name
-        self.class.display_name_for(definition["name"] || name)
+        self.class.display_name_for(definition.name || name)
       end
 
       # Returns a preview text for element.
@@ -78,15 +78,6 @@ module Alchemy
         "#{display_name}: #{preview_text(maxlength)}"
       end
 
-      # Returns a dom id used for elements html id tag.
-      # @deprecated
-      def dom_id
-        if caller.none? { |l| l =~ Regexp.new("alchemy/elements_block_helper.rb:117:in `element_view_for'") }
-          Alchemy::Deprecation.warn("dom_id is deprecated and will be removed from Alchemy 8.0. Please pass an id to the element_view_for helper instead.")
-        end
-        self.class.dom_id_class.new(self).call
-      end
-
       # The ingredient that's used for element's preview text.
       #
       # It tries to find one of element's ingredients that is defined +as_element_title+.
@@ -113,8 +104,8 @@ module Alchemy
       def first_ingredient_by_definition
         return if ingredient_definitions.empty?
 
-        role = ingredient_definitions.first["role"]
-        ingredients.detect { |ingredient| ingredient.role == role }
+        role = ingredient_definitions.first.role
+        ingredients.detect { _1.role == role }
       end
     end
   end

data/app/models/alchemy/element.rb

@@ -30,7 +30,6 @@ module Alchemy
 
     include Alchemy::Logger
     include Alchemy::Taggable
-    include Alchemy::Hints
 
     FORBIDDEN_DEFINITION_ATTRIBUTES = [
       "amount",
@@ -55,7 +54,7 @@ module Alchemy
     #
     acts_as_list scope: [:page_version_id, :fixed, :parent_element_id]
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     before_destroy :delete_all_nested_elements
 
@@ -107,6 +106,7 @@ module Alchemy
     scope :not_nested, -> { where(parent_element_id: nil) }
 
     delegate :restricted?, to: :page, allow_nil: true
+    delegate :deprecation_notice, :has_hint?, :hint, to: :definition
 
     # Concerns
     include Definitions
@@ -131,27 +131,9 @@ module Alchemy
           raise(ElementDefinitionError, attributes)
         end
 
-        super(element_definition.merge(element_attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
+        super(element_definition.attributes.merge(element_attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
       end
 
-      # The class responsible for the +dom_id+ of elements.
-      # Defaults to +Alchemy::Element::DomId+.
-      # @deprecated
-      def dom_id_class
-        if caller.none? { |l| l =~ Regexp.new("alchemy/element/presenters.rb:87:in `dom_id'") }
-          Alchemy::Deprecation.warn("dom_id_class is deprecated and will be removed from Alchemy 8.0. Please pass an id to the element_view_for helper instead.")
-        end
-        @_dom_id_class || DomId
-      end
-
-      # Register a custom +DomId+ class responsible for the +dom_id+ of elements.
-      # Defaults to +Alchemy::Element::DomId+.
-      # @deprecated
-      def dom_id_class=(klass)
-        @_dom_id_class = klass
-      end
-      deprecate :dom_id_class=, deprecator: Alchemy::Deprecation
-
       # This methods does a copy of source and all its ingredients.
       #
       # == Options
@@ -185,7 +167,7 @@ module Alchemy
       def all_from_clipboard_for_parent_element(clipboard, parent_element)
         return none if clipboard.nil? || parent_element.nil?
 
-        all_from_clipboard(clipboard).where(name: parent_element.definition["nestable_elements"])
+        all_from_clipboard(clipboard).where(name: parent_element.definition.nestable_elements)
       end
     end
 
@@ -229,7 +211,7 @@ module Alchemy
 
     # Returns true if the definition of this element has a taggable true value.
     def taggable?
-      definition["taggable"] == true
+      definition.taggable == true
     end
 
     # The opposite of folded?
@@ -239,7 +221,7 @@ module Alchemy
 
     # Defined as compact element?
     def compact?
-      definition["compact"] == true
+      definition.compact
     end
 
     # Defined as deprecated element?
@@ -271,7 +253,7 @@ module Alchemy
     #
     # @return Boolean
     def deprecated?
-      !!definition["deprecated"]
+      !!definition.deprecated
     end
 
     # The element's view partial is dependent from its name
@@ -294,13 +276,13 @@ module Alchemy
 
     # A collection of element names that can be nested inside this element.
     def nestable_elements
-      definition.fetch("nestable_elements", [])
+      definition.nestable_elements
     end
 
     private
 
     def generate_nested_elements
-      definition.fetch("autogenerate", []).each do |nestable_element|
+      definition.autogenerate.each do |nestable_element|
         if nestable_elements.include?(nestable_element)
           Element.create(page_version: page_version, parent_element_id: id, name: nestable_element)
         else

data/app/models/alchemy/element_definition.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class ElementDefinition
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Alchemy::Hints
+
+    extend ActiveModel::Translation
+
+    attribute :name, :string
+    attribute :unique, :boolean, default: false
+    attribute :amount, :integer, default: Float::INFINITY
+    attribute :taggable, :boolean, default: false
+    attribute :compact, :boolean, default: false
+    attribute :fixed, :boolean, default: false
+    attribute :ingredients, default: []
+    attribute :nestable_elements, default: []
+    attribute :autogenerate, default: []
+    attribute :deprecated
+    attribute :message
+    attribute :warning
+    attribute :hint
+
+    validates :name,
+      presence: true,
+      format: {
+        with: /\A[a-z_-]+\z/
+      }
+
+    delegate :blank?, to: :name
+
+    class << self
+      # Returns the definitions from elements.yml file.
+      #
+      # Place a +elements.yml+ file inside your apps +config/alchemy+ folder to define
+      # your own set of elements
+      #
+      def all
+        @definitions ||= read_definitions_file.map { new(**_1) }
+      end
+
+      # Add additional page definitions to collection.
+      #
+      # Useful for extending the elements from an Alchemy module.
+      #
+      # === Usage Example
+      #
+      #   Call +Alchemy::ElementDefinition.add(your_definition)+ in your engine.rb file.
+      #
+      # @param [Array || Hash]
+      #   You can pass a single element definition as Hash, or a collection of elements as Array.
+      #
+      def add(definition)
+        all
+        @definitions += Array.wrap(definition).map { new(**_1) }
+      end
+
+      # Returns one element 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 +elements.yml+ file path
+      # @return [Pathname]
+      def definitions_file_path
+        Rails.root.join("config", "alchemy", "elements.yml")
+      end
+
+      private
+
+      def definitions_file
+        File.read(definitions_file_path)
+      end
+
+      def definitions_file_exist?
+        File.exist?(definitions_file_path)
+      end
+
+      # Reads the element definitions from +config/alchemy/elements.yml+.
+      #
+      def read_definitions_file
+        if definitions_file_exist?
+          YAML.safe_load(
+            ERB.new(definitions_file).result,
+            permitted_classes: YAML_PERMITTED_CLASSES,
+            aliases: true
+          ) || []
+        else
+          raise LoadError,
+            "Could not find elements.yml file! Please run `rails generate alchemy:install`"
+        end
+      end
+    end
+
+    def attributes
+      super.with_indifferent_access
+    end
+
+    def ingredients
+      super.map { IngredientDefinition.new(**_1) }
+    end
+
+    # Returns a deprecation notice for elements marked deprecated
+    #
+    # You can either use localizations or pass a String as notice
+    # in the element definition.
+    #
+    # == Custom deprecation notices
+    #
+    # Use general element deprecation notice
+    #
+    #     - name: old_element
+    #       deprecated: true
+    #
+    # Add a translation to your locale file for a per element notice.
+    #
+    #     en:
+    #       alchemy:
+    #         element_deprecation_notices:
+    #           old_element: Foo baz widget is deprecated
+    #
+    # or use the global translation that apply to all deprecated elements.
+    #
+    #     en:
+    #       alchemy:
+    #         element_deprecation_notice: Foo baz widget is deprecated
+    #
+    # or pass string as deprecation notice.
+    #
+    #     - name: old_element
+    #       deprecated: This element will be removed soon.
+    #
+    def deprecation_notice
+      case deprecated
+      when String
+        deprecated
+      when TrueClass
+        Alchemy.t(
+          name,
+          scope: :element_deprecation_notices,
+          default: Alchemy.t(:element_deprecated)
+        )
+      end
+    end
+
+    private
+
+    def hint_translation_scope
+      :element_hints
+    end
+  end
+end