alchemy_cms 8.0.0.a → 8.0.0.c

data/lib/alchemy/configuration/base_option.rb

@@ -9,15 +9,28 @@ module Alchemy
 
       def initialize(value:, name:, **args)
         @name = name
-        @value = validate(value) unless value.nil?
+        validate(value) unless value.nil?
+        @value = value
       end
       attr_reader :name, :value
 
-      private
-
       def validate(value)
-        raise TypeError, "#{name} must be set as a #{self.class.value_class.name}, given #{value.inspect}" unless value.is_a?(self.class.value_class)
-        value
+        raise ConfigurationError.new(name, value, allowed_classes) unless allowed_classes.any? { value.is_a?(_1) }
+      end
+
+      def allowed_classes
+        [self.class.value_class]
+      end
+
+      def raw_value = @value
+
+      def ==(other)
+        self.class == other.class && raw_value == other.raw_value
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [self.class, raw_value].hash
       end
     end
   end

data/lib/alchemy/configuration/boolean_option.rb

@@ -5,11 +5,8 @@ require "alchemy/configuration/base_option"
 module Alchemy
   class Configuration
     class BooleanOption < BaseOption
-      private
-
-      def validate(value)
-        raise TypeError, "#{name} must be a Boolean, given #{value.inspect}" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
-        value
+      def allowed_classes
+        [TrueClass, FalseClass]
       end
     end
   end

data/lib/alchemy/configuration/collection_option.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "alchemy/configuration/base_option"
+
+module Alchemy
+  class Configuration
+    class CollectionOption < BaseOption
+      include Enumerable
+
+      def self.value_class
+        Enumerable
+      end
+
+      attr_reader :collection_class, :item_class, :item_args
+
+      def initialize(value:, name:, item_type:, collection_class: Array, **args)
+        @collection_class = collection_class
+        @item_class = get_item_class(item_type)
+        @item_args = args
+        value = [] if value.nil?
+        collection = @collection_class.new(value.map { |value| to_item(value) })
+        super(value: collection, name: name)
+      rescue ConfigurationError => configuration_error
+        raise ConfigurationError.new(name, configuration_error.value, configuration_error.allowed_classes)
+      end
+
+      def value
+        self
+      end
+
+      def <<(value)
+        @value << to_item(value)
+      end
+      alias_method(:add, :<<)
+
+      def concat(values)
+        values.each do |value|
+          add(value)
+        end
+      end
+
+      delegate :join, :[], to: :to_a
+
+      delegate :clear, :empty?, to: :@value
+
+      def each(&block)
+        @value.each do |option|
+          yield option.value
+        end
+      end
+
+      def to_serializable_array
+        to_a.map do |item|
+          item.respond_to?(:to_h) ? item.to_h : item
+        end
+      end
+
+      private
+
+      def to_item(value)
+        @item_class.new(value: value, name: "#{name}_item", **item_args)
+      end
+
+      def get_item_class(item_type)
+        "Alchemy::Configuration::#{item_type.to_s.classify}Option".constantize
+      end
+    end
+  end
+end

data/lib/alchemy/configuration/configuration_option.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "alchemy/configuration/base_option"
+
+module Alchemy
+  class Configuration
+    class ConfigurationOption < BaseOption
+      def self.value_class
+        Hash
+      end
+
+      attr_reader :config_class
+
+      def initialize(value:, name:, config_class:, **args)
+        @name = name
+        @config_class = config_class
+        validate(value)
+        @value = if value.is_a?(config_class)
+          value
+        else
+          config_class.new(value)
+        end
+      end
+
+      def validate(value)
+        return true if value.is_a?(config_class)
+        super
+      end
+
+      def allowed_classes
+        super + [config_class]
+      end
+    end
+  end
+end

data/lib/alchemy/configuration/pathname_option.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "alchemy/configuration/base_option"
+module Alchemy
+  class Configuration
+    class PathnameOption < BaseOption
+      def self.value_class
+        Pathname
+      end
+    end
+  end
+end

data/lib/alchemy/configuration.rb

@@ -4,16 +4,28 @@ require "active_support"
 require "active_support/core_ext/string"
 
 require "alchemy/configuration/boolean_option"
+require "alchemy/configuration/collection_option"
+require "alchemy/configuration/configuration_option"
 require "alchemy/configuration/class_option"
-require "alchemy/configuration/class_set_option"
 require "alchemy/configuration/integer_option"
-require "alchemy/configuration/integer_list_option"
+require "alchemy/configuration/pathname_option"
 require "alchemy/configuration/regexp_option"
-require "alchemy/configuration/string_list_option"
 require "alchemy/configuration/string_option"
 
 module Alchemy
   class Configuration
+    class ConfigurationError < StandardError
+      attr_reader :name, :value, :allowed_classes
+
+      def initialize(name, value, allowed_classes)
+        @name = name
+        @value = value
+        @allowed_classes = allowed_classes
+        expected_classes_message = allowed_classes.map(&:name).to_sentence(two_words_connector: " or ", last_word_connector: ", or ")
+        super("Invalid configuration value for #{name}: #{value.inspect} (expected #{expected_classes_message})")
+      end
+    end
+
     def initialize(configuration_hash = {})
       set(configuration_hash)
     end
@@ -45,7 +57,8 @@ module Alchemy
 
     def to_h
       self.class.defined_options.map do |option|
-        [option, send(option)]
+        value = send(option)
+        [option, value.respond_to?(:to_serializable_array) ? value.to_serializable_array : value]
       end.concat(
         self.class.defined_configurations.map do |configuration|
           [configuration, send(configuration).to_h]
@@ -58,6 +71,10 @@ module Alchemy
 
       def defined_options = []
 
+      def defined_values
+        defined_options + defined_configurations
+      end
+
       def configuration(name, configuration_class)
         # The defined configurations on a class are all those defined directly on
         # that class as well as those defined on ancestors.
@@ -99,11 +116,19 @@ module Alchemy
           super() + singleton_options
         end
 
-        define_method(name) do
+        define_method("#{name}_option") do
           unless instance_variable_defined?(:"@#{name}")
             send(:"#{name}=", default)
           end
-          instance_variable_get(:"@#{name}").value
+          instance_variable_get(:"@#{name}")
+        end
+
+        define_method(name) do
+          send("#{name}_option").value
+        end
+
+        define_method("raw_#{name}") do
+          send("#{name}_option").raw_value
         end
 
         define_method(:"#{name}=") do |value|
@@ -111,5 +136,18 @@ module Alchemy
         end
       end
     end
+
+    def hash
+      self.class.defined_values.map do |ivar|
+        [ivar, send(ivar).hash]
+      end.hash
+    end
+
+    def ==(other)
+      equal?(other) || self.class == other.class && self.class.defined_values.all? do |var|
+        send(var) == other.send(var)
+      end
+    end
+    alias_method :eql?, :==
   end
 end

data/lib/alchemy/configurations/format_matchers.rb

@@ -4,7 +4,7 @@ module Alchemy
   module Configurations
     class FormatMatchers < Alchemy::Configuration
       option :email, :regexp, default: /\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/
-      option :url, :regexp, default: /\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix
+      option :url, :regexp, default: /\A[a-z0-9]+([-.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix
       option :link_url, :regexp, default: /^(tel:|mailto:|\/|[a-z]+:\/\/)/
     end
   end

data/lib/alchemy/configurations/importmap.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Configurations
+    class Importmap < Alchemy::Configuration
+      option :importmap_path, :pathname
+      option :source_paths, :collection, item_type: :pathname
+      option :name, :string
+    end
+  end
+end

data/lib/alchemy/configurations/mailer.rb

@@ -9,8 +9,8 @@ module Alchemy
       option :mail_from, :string, default: "your.mail@your-domain.com"
       option :mail_to, :string, default: "your.mail@your-domain.com"
       option :subject, :string, default: "A new contact form message"
-      option :fields, :string_list, default: %w[salutation firstname lastname address zip city phone email message]
-      option :validate_fields, :string_list, default: %w[lastname email]
+      option :fields, :collection, item_type: :string, default: %w[salutation firstname lastname address zip city phone email message]
+      option :validate_fields, :collection, item_type: :string, default: %w[lastname email]
     end
   end
 end

data/lib/alchemy/configurations/main.rb

@@ -3,8 +3,10 @@
 require "alchemy/configuration"
 require "alchemy/configurations/default_language"
 require "alchemy/configurations/default_site"
+require "alchemy/configurations/importmap"
 require "alchemy/configurations/format_matchers"
 require "alchemy/configurations/mailer"
+require "alchemy/configurations/page_cache"
 require "alchemy/configurations/preview"
 require "alchemy/configurations/sitemap"
 require "alchemy/configurations/uploader"
@@ -31,6 +33,12 @@ module Alchemy
       #
       option :cache_pages, :boolean, default: true
 
+      # === Page caching max age
+      #
+      # max-age [Integer] # The duration in seconds for which the page is cached before revalidation.
+      # stale-while-revalidate [Boolean] # If true, enables the stale-while-revalidate caching strategy.
+      configuration :page_cache, PageCache
+
       # === Sitemap
       #
       # Alchemy creates a XML, Google compatible, sitemap for you.
@@ -155,7 +163,7 @@ module Alchemy
       #     user_roles:
       #       rolename: Name of the role
       #
-      option :user_roles, :string_list, default: %w[member author editor admin]
+      option :user_roles, :collection, item_type: :string, default: %w[member author editor admin]
 
       # === Uploader Settings
       #
@@ -177,7 +185,7 @@ module Alchemy
       #
       #   jQuery(a[data-link-target="overlay"]).dialog();
       #
-      option :link_target_options, :string_list, default: %w[blank]
+      option :link_target_options, :collection, item_type: :string, default: %w[blank]
 
       # === Format matchers
       #
@@ -194,7 +202,7 @@ module Alchemy
       option :admin_page_preview_layout, :string, default: "application"
 
       # The sizes for the preview size select in the page editor.
-      option :page_preview_sizes, :integer_list, default: [360, 640, 768, 1024, 1280, 1440]
+      option :page_preview_sizes, :collection, item_type: :integer, default: [360, 640, 768, 1024, 1280, 1440]
 
       # Enable full text search configuration
       #
@@ -211,6 +219,143 @@ module Alchemy
       # The storage adapter for Pictures and Attachments
       #
       option :storage_adapter, :string, default: "dragonfly"
+
+      # Define page preview sources
+      #
+      # A preview source is a Ruby class returning an URL
+      # that is used as source for the preview frame in the
+      # admin UI.
+      #
+      # == Example
+      #
+      #     # lib/acme/preview_source.rb
+      #     class Acme::PreviewSource < Alchemy::Admin::PreviewUrl
+      #       def url_for(page)
+      #         if page.site.name == "Next"
+      #           "https://user:#{ENV['PREVIEW_HTTP_PASS']}@next.acme.com"
+      #         else
+      #           "https://www.acme.com"
+      #         end
+      #       end
+      #     end
+      #
+      #     # config/initializers/alchemy.rb
+      #     require "acme/preview_source"
+      #     Alchemy.config.preview_sources << "Acme::PreviewSource"
+      #
+      #     # config/locales/de.yml
+      #     de:
+      #       activemodel:
+      #         models:
+      #           acme/preview_source: Acme Vorschau
+      #
+      option :preview_sources, :collection, item_type: :class, collection_class: Set, default: ["Alchemy::Admin::PreviewUrl"]
+
+      # Additional JS modules to be imported in the Alchemy admin UI
+      #
+      # Be sure to also pin the modules with +Alchemy.importmap+.
+      #
+      # == Example
+      #
+      #    Alchemy.importmap.pin "flatpickr/de",
+      #      to: "https://ga.jspm.io/npm:flatpickr@4.6.13/dist/l10n/de.js"
+      #
+      #    Alchemy.config.admin_js_imports << "flatpickr/de"
+      #
+      option :admin_js_imports, :collection, item_type: :string, collection_class: Set, default: []
+
+      # Additional importmaps to be included in the Alchemy admin UI
+      #
+      # Be sure to also pin modules with +Alchemy.importmap+.
+      #
+      # == Example
+      #
+      #    # config/alchemy/importmap.rb
+      #    Alchemy.importmap.pin "alchemy_solidus", to: "alchemy_solidus.js", preload: true
+      #    Alchemy.importmap.pin_all_from Alchemy::Solidus::Engine.root.join("app/javascript/alchemy_solidus"),
+      #      under: "alchemy_solidus",
+      #      preload: true
+      #
+      #    # lib/alchemy/solidus/engine.rb
+      #    initializer "alchemy_solidus.assets", before: "alchemy.importmap" do |app|
+      #      Alchemy.admin_importmaps.add({
+      #        importmap_path: root.join("config/importmap.rb"),
+      #        source_paths: [
+      #          root.join("app/javascript")
+      #        ],
+      #        name: "alchemy_solidus"
+      #      })
+      #      app.config.assets.precompile << "alchemy_solidus/manifest.js"
+      #    end
+      #
+      option :admin_importmaps, :collection, collection_class: Set, item_type: :configuration, config_class: Alchemy::Configurations::Importmap, default: []
+
+      # Additional stylesheets to be included in the Alchemy admin UI
+      #
+      # == Example
+      #
+      #    # lib/alchemy/devise/engine.rb
+      #    initializer "alchemy.devise.stylesheets", before: "alchemy.admin_stylesheets" do
+      #      Alchemy.config.admin_stylesheets << "alchemy/devise/admin.css"
+      #    end
+      #
+      option :admin_stylesheets, :collection, collection_class: Set, item_type: :string, default: ["alchemy/admin/custom.css"]
+
+      # Define page publish targets
+      #
+      # A publish target is a ActiveJob that gets performed
+      # whenever a user clicks the publish page button.
+      #
+      # Use this to trigger deployment hooks of external
+      # services in an asychronous way.
+      #
+      # == Example
+      #
+      #     # app/jobs/publish_job.rb
+      #     class PublishJob < ApplicationJob
+      #       def perform(page)
+      #         RestClient.post(ENV['BUILD_HOOK_URL'])
+      #       end
+      #     end
+      #
+      #     # config/initializers/alchemy.rb
+      #     Alchemy.config.publish_targets << PublishJob
+      #
+      option :publish_targets, :collection, collection_class: Set, item_type: :class, default: []
+
+      # Configure tabs in the link dialog
+      #
+      # With this configuration that tabs in the link dialog can be extended
+      # without overwriting or defacing the Admin Interface.
+      #
+      # == Example
+      #
+      #    # components/acme/link_tab.rb
+      #    module Acme
+      #      class LinkTab < ::Alchemy::Admin::LinkDialog::BaseTab
+      #        def title
+      #          "Awesome Tab Title"
+      #        end
+      #
+      #        def name
+      #          :unique_name
+      #        end
+      #
+      #        def fields
+      #           [ title_input, target_select ]
+      #        end
+      #      end
+      #    end
+      #
+      #    # config/initializers/alchemy.rb
+      #    Alchemy.config.link_dialog_tabs << "Acme::LinkTab"
+      #
+      option :link_dialog_tabs, :collection, collection_class: Set, item_type: :class, default: [
+        "Alchemy::Admin::LinkDialog::InternalTab",
+        "Alchemy::Admin::LinkDialog::AnchorTab",
+        "Alchemy::Admin::LinkDialog::ExternalTab",
+        "Alchemy::Admin::LinkDialog::FileTab"
+      ]
     end
   end
 end

data/lib/alchemy/configurations/page_cache.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Configurations
+    class PageCache < Alchemy::Configuration
+      # === Page caching max age
+      #
+      # Control the max-age duration in seconds in the cache-control header.
+      #
+      option :max_age, :integer, default: 600
+
+      # === Page caching stale-while-revalidate
+      #
+      # Set stale-while-revalidate cache-control header.
+      #
+      option :stale_while_revalidate, :integer
+    end
+  end
+end

data/lib/alchemy/configurations/uploader.rb

@@ -4,8 +4,8 @@ module Alchemy
   module Configurations
     class Uploader < Alchemy::Configuration
       class AllowedFileTypes < Alchemy::Configuration
-        option :alchemy_attachments, :string_list, default: ["*"]
-        option :alchemy_pictures, :string_list, default: %w[jpg jpeg gif png svg webp]
+        option :alchemy_attachments, :collection, item_type: :string, default: ["*"]
+        option :alchemy_pictures, :collection, item_type: :string, default: %w[jpg jpeg gif png svg webp]
 
         def set(configuration_hash)
           super(configuration_hash.transform_keys { transform_key(_1) })

data/lib/alchemy/deprecation.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Alchemy
-  Deprecation = ActiveSupport::Deprecation.new("8.0", "Alchemy")
+  Deprecation = ActiveSupport::Deprecation.new("9.0", "Alchemy")
 end

data/lib/alchemy/engine.rb

@@ -26,7 +26,7 @@ module Alchemy
 
     initializer "alchemy.admin_stylesheets" do |app|
       if defined?(Sprockets)
-        Alchemy.admin_stylesheets.each do |stylesheet|
+        Alchemy.config.admin_stylesheets.each do |stylesheet|
           app.config.assets.precompile << stylesheet
         end
       end
@@ -42,33 +42,48 @@ module Alchemy
       end
     end
 
+    initializer "alchemy.admin_importmap" do
+      Alchemy.config.admin_importmaps.add(
+        importmap_path: root.join("config/importmap.rb"),
+        source_paths: [
+          root.join("app/javascript"),
+          root.join("vendor/javascript")
+        ],
+        name: "alchemy_admin"
+      )
+    end
+
     initializer "alchemy.importmap" do |app|
-      watch_paths = []
-
-      Alchemy.admin_importmaps.each do |admin_import|
-        Alchemy.importmap.draw admin_import[:importmap_path]
-        watch_paths += admin_import[:source_paths]
-        app.config.assets.paths += admin_import[:source_paths]
-        if admin_import[:name] != "alchemy_admin"
-          Alchemy.admin_js_imports.add(admin_import[:name])
+      app.config.to_prepare do
+        watch_paths = []
+
+        Alchemy.config.admin_importmaps.each do |admin_import|
+          Alchemy.importmap.draw admin_import.importmap_path
+          watch_paths += admin_import.source_paths.to_a
+          app.config.assets.paths += admin_import.source_paths.to_a
+          if admin_import[:name] != "alchemy_admin"
+            Alchemy.config.admin_js_imports.add(admin_import.name)
+          end
         end
-      end
 
-      if app.config.importmap.sweep_cache
-        Alchemy.importmap.cache_sweeper(watches: watch_paths)
-        ActiveSupport.on_load(:action_controller_base) do
-          before_action { Alchemy.importmap.cache_sweeper.execute_if_updated }
+        if app.config.importmap.sweep_cache
+          Alchemy.importmap.cache_sweeper(watches: watch_paths)
+          ActiveSupport.on_load(:action_controller_base) do
+            before_action { Alchemy.importmap.cache_sweeper.execute_if_updated }
+          end
         end
       end
     end
 
+    # All the initialization that needs to be re-triggered during reloads
     config.to_prepare do
+      # Definition files
       elements_reloader = Rails.application.config.file_watcher.new([ElementDefinition.definitions_file_path]) do
-        Rails.logger.info "[#{engine_name}] Reloading Element Definitions."
+        Rails.logger.info "[alchemy] Reloading Element Definitions."
         ElementDefinition.reset!
       end
       page_layouts_reloader = Rails.application.config.file_watcher.new([PageDefinition.layouts_file_path]) do
-        Rails.logger.info "[#{engine_name}] Reloading Page Layouts."
+        Rails.logger.info "[alchemy] Reloading Page Layouts."
         PageDefinition.reset!
       end
       [elements_reloader, page_layouts_reloader].each do |reloader|
@@ -77,12 +92,19 @@ module Alchemy
           reloader.execute_if_updated
         end
       end
-    end
 
-    # Gutentag downcases all tags before save
-    # and Gutentag validations are not case sensitive.
-    # But we support having tags with uppercase characters.
-    config.to_prepare do
+      # The storage adapter for Pictures and Attachments
+      #
+      # Chose between 'active_storage' (default) or 'dragonfly' (legacy)
+      #
+      # Can be set via 'ALCHEMY_STORAGE_ADAPTER' env var.
+      Alchemy.storage_adapter = Alchemy::StorageAdapter.new(
+        ENV.fetch("ALCHEMY_STORAGE_ADAPTER", Alchemy.config.storage_adapter)
+      )
+
+      # Gutentag downcases all tags before save
+      # and Gutentag validations are not case sensitive.
+      # But we support having tags with uppercase characters.
       Gutentag.normaliser = ->(value) { value.to_s }
       Gutentag.tag_validations = Alchemy::TagValidations
     end

data/lib/alchemy/install/tasks.rb

@@ -22,18 +22,6 @@ module Alchemy
             {after: SENTINEL, verbose: true}
         end
 
-        def set_primary_language(code: "en", name: "English", auto_accept: false)
-          unless auto_accept
-            code = ask("- What is the language code of your site's primary language?", default: code)
-          end
-          unless auto_accept
-            name = ask("- What is the name of your site's primary language?", default: name)
-          end
-          gsub_file "./config/alchemy/config.yml", /default_language:\n\s\scode:\sen\n\s\sname:\sEnglish/m do
-            "default_language:\n  code: #{code}\n  name: #{name}"
-          end
-        end
-
         def inject_seeder
           seed_file = Rails.root.join("db", "seeds.rb")
           args = [seed_file, "Alchemy::Seeder.seed!\n"]

data/lib/alchemy/name_conversions.rb

@@ -22,5 +22,11 @@ module Alchemy
     def convert_to_humanized_name(name, suffix)
       name.gsub(/\.#{::Regexp.quote(suffix)}$/i, "").tr("_", " ").strip
     end
+
+    # Sanitizes a given filename by removing directory traversal attempts and HTML entities.
+    def sanitized_filename(file_name)
+      file_name = File.basename(file_name)
+      CGI.escapeHTML(file_name)
+    end
   end
 end