alchemy_cms 7.4.16 → 8.0.0.a

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

data/app/models/alchemy/ingredient.rb

@@ -4,8 +4,6 @@ module Alchemy
   class Ingredient < BaseRecord
     class DefinitionError < StandardError; end
 
-    include Hints
-
     self.table_name = "alchemy_ingredients"
 
     attribute :data, :json
@@ -16,7 +14,7 @@ module Alchemy
     has_one :page, through: :element, class_name: "Alchemy::Page"
 
     after_initialize :set_default_value,
-      if: -> { definition.key?(:default) && value.nil? }
+      if: -> { definition.default && value.nil? }
 
     validates :type, presence: true
     validates :role, presence: true, uniqueness: {scope: :element_id, case_sensitive: false}
@@ -38,6 +36,8 @@ module Alchemy
     scope :texts, -> { where(type: "Alchemy::Ingredients::Text") }
     scope :videos, -> { where(type: "Alchemy::Ingredients::Video") }
 
+    delegate :has_hint?, :hint, to: :definition
+
     class << self
       # Defines getter and setter method aliases for related object
       #
@@ -54,7 +54,7 @@ module Alchemy
 
         define_method :"#{name}_id=" do |id|
           self.related_object_id = id
-          self.related_object_type = id.nil? ? nil : class_name
+          self.related_object_type = class_name
         end
       end
 
@@ -97,15 +97,15 @@ module Alchemy
 
     # Settings for this ingredient from the +elements.yml+ definition.
     def settings
-      definition[:settings] || {}
+      definition.settings
     end
 
     # Definition hash for this ingredient from +elements.yml+ file.
     #
     def definition
-      return {} unless element
+      return IngredientDefinition.new unless element
 
-      element.ingredient_definition_for(role) || {}
+      element.ingredient_definition_for(role) || IngredientDefinition.new
     end
 
     # The first 30 characters of the value
@@ -118,12 +118,6 @@ module Alchemy
       value.to_s[0..maxlength - 1]
     end
 
-    # The path to the view partial of the ingredient
-    # @return [String]
-    def to_partial_path
-      "alchemy/ingredients/#{partial_name}_view"
-    end
-
     # The demodulized underscored class name of the ingredient
     # @return [String]
     def partial_name
@@ -132,17 +126,12 @@ module Alchemy
 
     # @return [Boolean]
     def has_validations?
-      !!definition[:validate]
-    end
-
-    # @return [Boolean]
-    def has_hint?
-      !!definition[:hint]
+      definition.validate.any?
     end
 
     # @return [Boolean]
     def deprecated?
-      !!definition[:deprecated]
+      !!definition.deprecated
     end
 
     # @return [Boolean]
@@ -152,7 +141,7 @@ module Alchemy
 
     # @return [Boolean]
     def preview_ingredient?
-      !!definition[:as_element_title]
+      !!definition.as_element_title
     end
 
     # The view component of the ingredient with mapped options.
@@ -169,30 +158,8 @@ module Alchemy
       @_view_component_class ||= "#{self.class.name}View".constantize
     end
 
-    def hint_translation_attribute
-      role
-    end
-
-    def hint_translation_scope
-      "ingredient_hints"
-    end
-
     def set_default_value
-      self.value = default_value
-    end
-
-    # Returns the default value from ingredient definition
-    #
-    # If the value is a symbol it gets passed through i18n
-    # inside the +alchemy.default_ingredient_texts+ scope
-    def default_value
-      default = definition[:default]
-      case default
-      when Symbol
-        Alchemy.t(default, scope: :default_ingredient_texts)
-      else
-        default
-      end
+      self.value = definition.default_value
     end
   end
 end

data/app/models/alchemy/ingredient_definition.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class IngredientDefinition
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Alchemy::Hints
+
+    extend ActiveModel::Translation
+
+    attribute :role, :string
+    attribute :type, :string
+    attribute :as_element_title, :boolean, default: false
+    attribute :settings, default: {}
+    attribute :validate, default: []
+    attribute :group, :string
+    attribute :default
+    attribute :deprecated
+    attribute :hint
+
+    validates :role,
+      presence: true,
+      format: {
+        with: /\A[a-z_-]+\z/
+      }
+
+    validates :type,
+      presence: true,
+      format: {
+        with: /\A[A-Z][a-zA-Z]+\z/
+      }
+
+    delegate :blank?, to: :role
+
+    def attributes
+      super.with_indifferent_access
+    end
+
+    def settings
+      super.with_indifferent_access
+    end
+
+    def validate
+      super.map do |validation|
+        case validation
+        when Hash
+          validation.with_indifferent_access
+        else
+          validation
+        end
+      end
+    end
+
+    # Returns the default value from ingredient definition
+    #
+    # If the value is a symbol it gets passed through i18n
+    # inside the +alchemy.default_ingredient_texts+ scope
+    def default_value
+      case default
+      when Symbol
+        Alchemy.t(default, scope: :default_ingredient_texts)
+      when String
+        default
+      end
+    end
+
+    # Returns a deprecation notice for ingredients marked deprecated
+    #
+    # You can either use localizations or pass a String as notice
+    # in the ingredient definition.
+    #
+    # == Custom deprecation notices
+    #
+    # Use general ingredient deprecation notice
+    #
+    #     - name: element_name
+    #       ingredients:
+    #         - role: old_ingredient
+    #           type: Text
+    #           deprecated: true
+    #
+    # Add a translation to your locale file for a per ingredient notice.
+    #
+    #     en:
+    #       alchemy:
+    #         ingredient_deprecation_notices:
+    #           old_ingredient: Foo baz widget is deprecated
+    #
+    # You can scope the translation per element as well.
+    #
+    #     en:
+    #       alchemy:
+    #         ingredient_deprecation_notices:
+    #           element_name:
+    #             old_ingredient: Elements foo baz widget is deprecated
+    #
+    # or use the global translation that apply to all deprecated ingredients.
+    #
+    #     en:
+    #       alchemy:
+    #         ingredient_deprecation_notice: Foo baz widget is deprecated
+    #
+    # or pass string as deprecation notice.
+    #
+    #     - name: element_name
+    #       ingredients:
+    #         - role: old_ingredient
+    #           type: Text
+    #           deprecated: This ingredient will be removed soon.
+    #
+    def deprecation_notice(element_name: nil)
+      case deprecated
+      when String
+        deprecated
+      when TrueClass
+        Alchemy.t(
+          role,
+          scope: [:ingredient_deprecation_notices, element_name].compact,
+          default: Alchemy.t(:ingredient_deprecated)
+        )
+      end
+    end
+
+    private
+
+    def hint_translation_scope
+      :ingredient_hints
+    end
+
+    def hint_translation_attribute
+      role
+    end
+  end
+end

data/app/models/alchemy/ingredient_validator.rb

@@ -64,7 +64,7 @@ module Alchemy
     attr_reader :ingredient
 
     def validations
-      ingredient.definition.fetch(:validate, [])
+      ingredient.definition.validate
     end
 
     def validate_presence(*)
@@ -80,8 +80,12 @@ module Alchemy
     end
 
     def validate_format(format)
-      matcher = Alchemy::Config.get("format_matchers")[format] || format
-      if !ingredient.value.to_s.match?(Regexp.new(matcher))
+      matcher = if format.is_a?(String) || format.is_a?(Symbol)
+        Alchemy.config.format_matchers.get(format)
+      else
+        format
+      end
+      if !ingredient.value.to_s.match?(matcher)
         ingredient.errors.add(:value, :invalid)
       end
     end

data/app/models/alchemy/ingredients/number.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A number
+    #
+    # Either a decimal or integer number
+    #
+    class Number < Alchemy::Ingredient
+      allow_settings %i[
+        input_type
+        step
+        min
+        max
+        unit
+      ]
+    end
+  end
+end

data/app/models/alchemy/language/code.rb

@@ -13,7 +13,6 @@ module Alchemy::Language::Code
 
   module ClassMethods
     def find_by_code(code)
-      return unless code.respond_to?(:split)
       codes = code.split("-")
       codes << "" if codes.length == 1
       on_current_site.find_by(

data/app/models/alchemy/language.rb

@@ -71,20 +71,6 @@ module Alchemy
         on_site(Current.site)
       end
 
-      # Store the current language in the current thread.
-      # @deprecated Use {Alchemy::Current#language=} instead.
-      def current=(language)
-        Current.language = language
-      end
-      deprecate "current=": :"Alchemy::Current.language=", deprecator: Alchemy::Deprecation
-
-      # Current language from current thread or default.
-      # @deprecated Use {Alchemy::Current#language} instead.
-      def current
-        Current.language
-      end
-      deprecate current: :"Alchemy::Current.language", deprecator: Alchemy::Deprecation
-
       # The root page of the current language.
       def current_root_page
         Current.language&.pages&.language_roots&.first

data/app/models/alchemy/message.rb

@@ -16,23 +16,19 @@ module Alchemy
   class Message
     include ActiveModel::Model
 
-    def self.config
-      Alchemy::Config.get(:mailer)
-    end
-
     attr_accessor :contact_form_id, :ip
 
-    config["fields"].each do |field|
+    Alchemy.config.mailer.fields.each do |field|
       attr_accessor field.to_sym
     end
 
-    config["validate_fields"].each do |field|
+    Alchemy.config.mailer.validate_fields.each do |field|
       validates_presence_of field
 
       case field.to_sym
       when /email/
         validates_format_of field,
-          with: Alchemy::Config.get("format_matchers")["email"],
+          with: Alchemy.config.format_matchers.email,
           if: -> { send(field).present? }
       when :email_confirmation
         validates_confirmation_of :email

data/app/models/alchemy/node.rb

@@ -7,7 +7,7 @@ module Alchemy
     before_destroy :check_if_related_node_ingredients_present
 
     acts_as_nested_set scope: "language_id", touch: true
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     belongs_to :language, class_name: "Alchemy::Language"
     belongs_to :page, class_name: "Alchemy::Page", optional: true, inverse_of: :nodes
@@ -19,27 +19,6 @@ module Alchemy
       foreign_key: :related_object_id,
       inverse_of: :related_object
 
-    # All nodes of the current site whose language is published.
-    scope :from_current_public_site, -> {
-      joins(:language)
-        .where(Alchemy::Language.table_name => {site_id: Alchemy::Current.site})
-        .merge(Alchemy::Language.published)
-    }
-
-    # Nodes an anonymous visitor may see: external links or nodes attached to a
-    # published, unrestricted page, scoped to the current site.
-    scope :available_to_guests, -> {
-      from_current_public_site.where(page: nil)
-        .or(from_current_public_site.where(page: Alchemy::Page.published.not_restricted))
-    }
-
-    # Like #available_to_guests but including nodes attached to restricted pages,
-    # which logged in members are allowed to see.
-    scope :available_to_members, -> {
-      from_current_public_site.where(page: nil)
-        .or(from_current_public_site.where(page: Alchemy::Page.published))
-    }
-
     before_validation :translate_root_menu_name, if: -> { root? }
     before_validation :set_menu_type_from_root, unless: -> { root? }
 

data/app/models/alchemy/page/{page_layouts.rb → definitions.rb}

@@ -4,13 +4,13 @@ module Alchemy
   class Page < BaseRecord
     # Module concerning page layouts
     #
-    module PageLayouts
+    module Definitions
       extend ActiveSupport::Concern
 
       module ClassMethods
         # Register a custom page layouts repository
         #
-        # The default repository is Alchemy::PageLayout
+        # The default repository is Alchemy::PageDefinition
         #
         def layouts_repository=(klass)
           @_layouts_repository = klass
@@ -19,8 +19,10 @@ module Alchemy
         # Returns page layouts ready for Rails' select form helper.
         #
         def layouts_for_select(language_id, layoutpages: false)
-          @map_array = []
-          mapped_layouts_for_select(selectable_layouts(language_id, layoutpages: layoutpages))
+          layouts = selectable_layouts(language_id, layoutpages: layoutpages)
+          layouts.map do |layout|
+            [layout.human_name, layout.name]
+          end
         end
 
         # Returns all layouts that can be used for creating a new page.
@@ -36,9 +38,9 @@ module Alchemy
           @language_id = language_id
           layouts_repository.all.select do |layout|
             if layoutpages
-              layout["layoutpage"] && layout_available?(layout)
+              layout.layoutpage && layout_available?(layout)
             else
-              !layout["layoutpage"] && layout_available?(layout)
+              !layout.layoutpage && layout_available?(layout)
             end
           end
         end
@@ -62,28 +64,19 @@ module Alchemy
         private
 
         def layouts_repository
-          @_layouts_repository ||= PageLayout
-        end
-
-        # Maps given layouts for Rails select form helper.
-        #
-        def mapped_layouts_for_select(layouts)
-          layouts.each do |layout|
-            @map_array << [human_layout_name(layout["name"]), layout["name"]]
-          end
-          @map_array
+          @_layouts_repository ||= PageDefinition
         end
 
         # Returns true if the given layout is unique and not already taken or it should be hidden.
         #
         def layout_available?(layout)
-          !layout["hide"] && !already_taken?(layout) && available_on_site?(layout)
+          !layout.hide && !already_taken?(layout) && available_on_site?(layout)
         end
 
         # Returns true if this layout is unique and already taken by another page.
         #
         def already_taken?(layout)
-          layout["unique"] && page_with_layout_existing?(layout["name"])
+          layout.unique && page_with_layout_existing?(layout.name)
         end
 
         # Returns true if one page already has the given layout
@@ -106,7 +99,7 @@ module Alchemy
           return false unless Alchemy::Current.site
 
           Alchemy::Current.site.definition.blank? ||
-            Alchemy::Current.site.definition.fetch("page_layouts", []).include?(layout["name"])
+            Alchemy::Current.site.definition.fetch("page_layouts", []).include?(layout.name)
         end
       end
     end

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

@@ -31,7 +31,7 @@ module Alchemy
       # @return Hash
       #
       def attributes
-        @_attributes ||= page.definition.fetch("fixed_attributes", {}).symbolize_keys
+        @_attributes ||= page.definition.fixed_attributes.symbolize_keys
       end
       alias_method :all, :attributes