alchemy_cms 8.0.12 → 8.1.0

data/lib/alchemy/auth_accessors.rb

@@ -1,134 +1,68 @@
 # frozen_string_literal: true
 
-# Provides authentication accessors.
-#
-# Alchemy has some defaults for user model name and login logout path names:
-#
-# +Alchemy.user_class_name+ defaults to +'User'+
-# +Alchemy.user_class_primary_key+ defaults to +:id+
-# +Alchemy.current_user_method defaults to +'current_user'+
-# +Alchemy.signup_path defaults to +'/signup'+
-# +Alchemy.login_path defaults to +'/login'+
-# +Alchemy.logout_path defaults to +'/logout'+
-# +Alchemy.logout_method defaults to +'delete'+
-# +Alchemy.unauthorized_path defaults to +'/'+
-#
-# Anyway, you can tell Alchemy about your authentication model configuration:
-#
-#   1. Your user class name - @see: Alchemy.user_class
-#   2. Your users table primary key - @see: Alchemy.user_class_primary_key
-#   3. A method on your ApplicationController to get current user -
-#      @see: Alchemy.current_user_method
-#   4. The path to the signup form - @see: Alchemy.signup_path
-#   5. The path to the login form - @see: Alchemy.login_path
-#   6. The path to the logout method - @see: Alchemy.logout_path
-#   7. The http verb for the logout method - @see: Alchemy.logout_method
-#   8. The path to the page showing the user she's unauthorized - @see: Alchemy.unauthorized_path
-#
-# == Example
-#
-#     # config/initializers/alchemy.rb
-#     Alchemy.user_class_name = 'Admin'
-#     Alchemy.user_class_primary_key = :user_id
-#     Alchemy.current_user_method = 'current_admin'
-#     Alchemy.signup_path = '/auth/signup'
-#     Alchemy.login_path = '/auth/login'
-#     Alchemy.logout_path = '/auth/logout'
-#     Alchemy.logout_method = 'get'
-#     Alchemy.unauthorized_path = '/home'
-#
-# If you don't have your own user model or don't want to provide one,
-# add the `alchemy-devise` gem into your App's Gemfile.
-#
-# == Adding your own CanCan abilities
-#
-# If your app or your engine has own CanCan abilities you must register them:
-#
-#     Alchemy.register_ability MyCustom::Ability
-#
 module Alchemy
-  mattr_accessor :user_class_primary_key,
-    :current_user_method,
-    :signup_path,
-    :login_path,
-    :logout_path,
-    :logout_method,
-    :unauthorized_path
-
-  # Defaults
-  #
-  @@user_class_name = "User"
-  @@user_class_primary_key = :id
-  @@current_user_method = "current_user"
-  @@signup_path = "/signup"
-  @@login_path = "/login"
-  @@logout_path = "/logout"
-  @@logout_method = "delete"
-  @@unauthorized_path = "/"
-
-  # Returns the user class
-  #
-  # Set your App's user class to Alchemy.user_class_name in an initializer.
-  #
-  # Defaults to +User+
-  #
-  # == Example
-  #
-  #     # config/initializers/alchemy.rb
-  #     Alchemy.user_class_name = 'Admin'
-  #
-
-  # Prefix with :: when getting to avoid constant name conflicts
-  def self.user_class_name
-    if !@@user_class_name.is_a?(String)
-      raise TypeError, "Alchemy.user_class_name must be a String, not a Class."
-    end
+  class << self
+    delegate :user_class_primary_key, to: :config
+    deprecate user_class_primary_key: "Use `Alchemy.config.user_class_primary_key instead", deprecator: Alchemy::Deprecation
 
-    "::#{@@user_class_name}"
-  end
+    delegate :user_class_primary_key=, to: :config
+    deprecate :user_class_primary_key= => "Use `Alchemy.config.user_class_primary_key instead", :deprecator => Alchemy::Deprecation
 
-  def self.user_class_name=(user_class_name)
-    @@user_class_name = user_class_name
-  end
+    delegate :current_user_method, to: :config
+    deprecate current_user_method: "Use `Alchemy.config.current_user_method instead", deprecator: Alchemy::Deprecation
+
+    delegate :current_user_method=, to: :config
+    deprecate :current_user_method= => "Use `Alchemy.config.current_user_method instead", :deprecator => Alchemy::Deprecation
+
+    delegate :signup_path, to: :config
+    deprecate signup_path: "Use `Alchemy.config.signup_path instead", deprecator: Alchemy::Deprecation
+
+    delegate :signup_path=, to: :config
+    deprecate :signup_path= => "Use `Alchemy.config.signup_path instead", :deprecator => Alchemy::Deprecation
+
+    delegate :login_path, to: :config
+    deprecate login_path: "Use `Alchemy.config.login_path instead", deprecator: Alchemy::Deprecation
 
-  def self.user_class
-    @@user_class ||= begin
-      @@user_class_name.constantize
-    rescue NameError => e
-      if /#{Regexp.escape(@@user_class_name)}/.match?(e.message)
-        Rails.logger.warn <<~MSG
-          #{e.message}
-          #{e.backtrace.join("\n")}
+    delegate :login_path=, to: :config
+    deprecate :login_path= => "Use `Alchemy.config.login_path instead", :deprecator => Alchemy::Deprecation
 
-          AlchemyCMS cannot find any user class!
+    delegate :logout_path, to: :config
+    deprecate logout_path: "Use `Alchemy.config.logout_path instead", deprecator: Alchemy::Deprecation
 
-          Please add a user class and tell Alchemy about it:
+    delegate :logout_path=, to: :config
+    deprecate :logout_path= => "Use `Alchemy.config.logout_path instead", :deprecator => Alchemy::Deprecation
 
-              # config/initializers/alchemy.rb
-              Alchemy.user_class_name = 'MyUser'
+    delegate :logout_method, to: :config
+    deprecate logout_method: "Use `Alchemy.config.logout_method instead", deprecator: Alchemy::Deprecation
 
-          Or add the `alchemy-devise` gem to your Gemfile:
+    delegate :logout_method=, to: :config
+    deprecate :logout_method= => "Use `Alchemy.config.logout_method instead", :deprecator => Alchemy::Deprecation
 
-              bundle add alchemy-devise
+    delegate :unauthorized_path, to: :config
+    deprecate unauthorized_path: "Use `Alchemy.config.unauthorized_path instead", deprecator: Alchemy::Deprecation
 
-        MSG
-        nil
-      else
-        raise e
-      end
+    delegate :unauthorized_path=, to: :config
+    deprecate :unauthorized_path= => "Use `Alchemy.config.unauthorized_path instead", :deprecator => Alchemy::Deprecation
+
+    delegate :user_class, to: :config
+    deprecate user_class: "Use `Alchemy.config.user_class instead", deprecator: Alchemy::Deprecation
+
+    delegate :user_class_name, to: :config
+    deprecate user_class_name: "Use `Alchemy.config.user_class_name instead", deprecator: Alchemy::Deprecation
+
+    def user_class_name=(klass_name)
+      config.user_class = klass_name
     end
-  end
+    deprecate :user_class_name= => "Use `Alchemy.config.user_class instead", :deprecator => Alchemy::Deprecation
 
-  # Register a CanCan Ability class
-  #
-  def self.register_ability(klass)
-    @abilities ||= []
-    @abilities << klass
-  end
+    def register_ability(klass)
+      config.abilities.add(klass.name)
+    end
+    deprecate register_ability: 'Use `Alchemy.config.abilities.add("MyClass")` instead', deprecator: Alchemy::Deprecation
 
-  # All CanCan Ability classes registered to Alchemy
-  #
-  def self.registered_abilities
-    @abilities ||= []
+    def registered_abilities
+      config.abilities
+    end
+    deprecate registered_abilities: "Use `Alchemy.config.abilities` instead", deprecator: Alchemy::Deprecation
   end
 end

data/lib/alchemy/configuration.rb

@@ -39,6 +39,7 @@ module Alchemy
 
     alias_method :get, :send
     alias_method :[], :get
+    alias_method :configure, :tap
 
     def show = self
 
@@ -67,8 +68,6 @@ module Alchemy
       ).to_h
     end
 
-    delegate :to_json, to: :to_h
-
     class << self
       def defined_configurations = []
 

data/lib/alchemy/configurations/main.rb

@@ -378,6 +378,69 @@ module Alchemy
       # Default is 1 hour.
       #
       option :update_check_cache_duration, :integer, default: 1
+
+      # === The user class to be used for Alchemy
+      #
+      # If you don't have your own user model or don't want to provide one,
+      # add the `alchemy-devise` gem into your App's Gemfile.
+      #
+      # == Example
+      #     Alchemy.config.user_class = "MyUser"
+      option :user_class, :class
+
+      # Returns the user class name
+      #
+      # Prefixed with :: when getting to avoid constant name conflicts
+      def user_class_name = "::#{raw_user_class}"
+
+      # === User class primary key
+      #
+      # Your users table primary key. Defaults to +id+
+      #
+      # == Example
+      #     Alchemy.config.user_class_primary_key = :uuid
+      option :user_class_primary_key, :symbol, default: :id
+
+      # === Current user method
+      #
+      # A method on your ApplicationController to get current user. Defaults to +:id+
+      #
+      # == Example
+      #     Alchemy.config.current_user_method = :my_current_user
+      option :current_user_method, :symbol, default: :current_user
+
+      # === Signup Path
+      #
+      # The path to the signup form. Defaults to "/signup"
+      option :signup_path, :string, default: "/signup"
+
+      # === Login Path
+      #
+      # The path to the login form. Defaults to "/login"
+      option :login_path, :string, default: "/login"
+
+      # === Logout Path
+      #
+      # The path to the logout method.
+      option :logout_path, :string, default: "/logout"
+
+      # === Logout Method
+      #
+      # The http verb for the logout method. Defaults to "delete"
+      option :logout_method, :string, default: "delete"
+
+      # === Unauthorized Path
+      #
+      # The path to the page showing the user they're unauthorized
+      option :unauthorized_path, :string, default: "/"
+
+      # === CanCan abilities
+      #
+      # If your app or your engine has own CanCan abilities you must register them.
+      #
+      # == Example
+      #     Alchemy.config.abilities.add("MyCustom::Ability")
+      option :abilities, :collection, item_type: :class
     end
   end
 end

data/lib/alchemy/controller_actions.rb

@@ -34,7 +34,7 @@ module Alchemy
     # you can install the `alchemy-devise` gem that provides everything you need.
     #
     def current_alchemy_user
-      current_user_method = Alchemy.current_user_method
+      current_user_method = Alchemy.config.current_user_method
       raise NoCurrentUserFoundError if !respond_to?(current_user_method, true)
 
       send current_user_method
@@ -80,8 +80,7 @@ module Alchemy
 
     def load_alchemy_language_from_id_or_code(id_or_code)
       Language.find_by(id: id_or_code) ||
-        Language.find_by_code(id_or_code) ||
-        Language.default
+        Language.find_by_code(id_or_code)
     end
 
     # Stores language in +Current.language+

data/lib/alchemy/engine.rb

@@ -79,11 +79,11 @@ module Alchemy
     config.to_prepare do
       # Definition files
       elements_reloader = Rails.application.config.file_watcher.new([ElementDefinition.definitions_file_path]) do
-        Rails.logger.info "[alchemy] Reloading Element Definitions."
+        Logger.info "Reloading Element Definitions."
         ElementDefinition.reset!
       end
       page_layouts_reloader = Rails.application.config.file_watcher.new([PageDefinition.layouts_file_path]) do
-        Rails.logger.info "[alchemy] Reloading Page Layouts."
+        Logger.info "Reloading Page Layouts."
         PageDefinition.reset!
       end
       [elements_reloader, page_layouts_reloader].each do |reloader|
@@ -122,6 +122,10 @@ module Alchemy
         ActiveStorage::Blob.define_singleton_method(:ransackable_attributes) do |_auth_object|
           %w[filename]
         end
+
+        ActiveStorage::Blob.define_singleton_method(:ransackable_associations) do |_auth_object|
+          %w[]
+        end
       end
     end
 
@@ -143,10 +147,10 @@ module Alchemy
     end
 
     config.after_initialize do
-      if Alchemy.user_class
+      if Alchemy.config.user_class
         ActiveSupport.on_load(:active_record) do
-          Alchemy.user_class.model_stamper
-          Alchemy.user_class.stampable(stamper_class_name: Alchemy.user_class_name)
+          Alchemy.config.user_class.model_stamper
+          Alchemy.config.user_class.stampable(stamper_class_name: Alchemy.config.user_class_name)
         end
       end
 
@@ -167,14 +171,7 @@ module Alchemy
         Rack::Mime::MIME_TYPES[".webp"] = webp
       end
 
-      # ActiveStorage 7.2 adds support for webp, but we still support Rails 7.1
       if app.config.active_storage
-        unless app.config.active_storage.web_image_content_types.include? webp
-          app.config.active_storage.web_image_content_types += [webp]
-        end
-        unless app.config.active_storage.content_types_allowed_inline.include? webp
-          app.config.active_storage.content_types_allowed_inline += [webp]
-        end
         # Rails sends svg images as attachment instead of inline.
         # We want to display svgs and not download them.
         unless app.config.active_storage.content_types_allowed_inline.include? svg

data/lib/alchemy/error_tracking/error_logger.rb

@@ -4,7 +4,7 @@ module Alchemy
   module ErrorTracking
     class ErrorLogger < BaseHandler
       def self.call(exception)
-        ::Rails.logger.tagged("alchemy_cms") do
+        ::Rails.logger.tagged("alchemy") do
           ::Rails.logger.error("#{exception.class.name}: #{exception.message} in #{exception.backtrace.first}")
         end
       end

data/lib/alchemy/errors.rb

@@ -26,7 +26,7 @@ module Alchemy
     end
 
     def message
-      "Element definition for #{@name} not found. Please check your elements.yml"
+      "Element definition for '#{@name}' not found! Please check your element definitions."
     end
   end
 

data/lib/alchemy/logger.rb

@@ -2,14 +2,44 @@
 
 module Alchemy
   module Logger
-    # Logs a debug message to the Rails standard logger and adds some nicer formatting
-    def self.warn(message, caller_string)
-      Rails.logger.debug %(\n++++ WARNING: #{message}\nCalled from: #{caller_string}\n)
+    # Logs a debug message to the Rails standard logger
+    def self.debug(message)
+      Rails.logger.tagged("alchemy") do
+        Rails.logger.debug(message)
+      end
+      nil
+    end
+
+    # Logs a error message to the Rails standard logger
+    def self.error(message)
+      Rails.logger.tagged("alchemy") do
+        Rails.logger.error("ERROR: #{message}")
+      end
+      nil
+    end
+
+    # Logs a info message to the Rails standard logger
+    def self.info(message)
+      Rails.logger.tagged("alchemy") do
+        Rails.logger.info(message)
+      end
+      nil
+    end
+
+    # Logs a warning message to the Rails standard logger
+    def self.warn(message, caller_string = nil)
+      if caller_string
+        Alchemy::Deprecation.warn("Alchemy::Logger.warn second argument is deprecated and will be removed in Alchemy 9.0")
+      end
+      Rails.logger.tagged("alchemy") do
+        Rails.logger.warn("WARNING: #{message}")
+      end
       nil
     end
 
     def log_warning(message)
-      Alchemy::Logger.warn(message, caller(1..1))
+      Alchemy::Logger.warn(message)
     end
+    deprecate log_warning: "Alchemy::Logger.warn", deprecator: Alchemy::Deprecation
   end
 end

data/lib/alchemy/name_conversions.rb

@@ -17,12 +17,6 @@ module Alchemy
         .parameterize
     end
 
-    # Converts a filename and suffix into a human readable name.
-    #
-    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)

data/lib/alchemy/seeder.rb

@@ -63,14 +63,14 @@ module Alchemy
       def seed_users
         desc "Seeding Alchemy users from #{user_seeds_file}"
 
-        if Alchemy.user_class.exists?
+        if Alchemy.config.user_class.exists?
           log "There are already users present in your database. " \
               "Please use `rake db:reset' if you want to rebuild your database.", :skip
           false
         else
           users = load_yaml_file(user_seeds_file)
           users.each do |draft|
-            user = Alchemy.user_class.create!(draft)
+            user = Alchemy.config.user_class.create!(draft)
             log "Created user: #{user.try(:email) || user.try(:login) || user.id}"
           end
         end

data/lib/alchemy/tasks/usage.rb

@@ -18,11 +18,11 @@ module Alchemy
       end
 
       def pages_count_by_type
-        res = Alchemy::Page.all
-          .select("page_layout, COUNT(*) AS count")
+        res = Alchemy::Page
           .group(:page_layout)
-          .order("count DESC, page_layout ASC")
-          .map { |p| {"page_layout" => p.page_layout, "count" => p.count} }
+          .order("count_all DESC, page_layout ASC")
+          .count
+          .map { |layout, count| {"page_layout" => layout, "count" => count} }
         Alchemy::PageDefinition.all.reject { |page_layout| res.map { |p| p["page_layout"] }.include?(page_layout.name) }.sort_by(&:name).each do |page_layout|
           res << {"page_layout" => page_layout.name, "count" => 0}
         end

data/lib/alchemy/test_support/factories/page_version_factory.rb

@@ -3,6 +3,9 @@
 FactoryBot.define do
   factory :alchemy_page_version, class: "Alchemy::PageVersion" do
     association :page, factory: :alchemy_page
+    title { nil }
+    meta_description { nil }
+    meta_keywords { nil }
 
     trait :published do
       public_on { Time.current }

data/lib/alchemy/test_support/having_picture_thumbnails_examples.rb

@@ -212,6 +212,22 @@ RSpec.shared_examples_for "having picture thumbnails" do
       thumbnail_url
     end
 
+    context "with size given" do
+      subject(:thumbnail_url) { record.thumbnail_url(size: "10x10") }
+
+      it "passes it to the thumbnail url options." do
+        expect(picture).to receive(:url).with(hash_including(size: "10x10"))
+        thumbnail_url
+      end
+    end
+
+    context "with no size given" do
+      it "passes default size to the thumbnail url options." do
+        expect(picture).to receive(:url).with(hash_including(size: "160x120"))
+        thumbnail_url
+      end
+    end
+
     context "when crop is enabled in the settings" do
       let(:settings) do
         {crop: true}
@@ -300,6 +316,20 @@ RSpec.shared_examples_for "having picture thumbnails" do
       allow(record).to receive(:settings) { settings }
     end
 
+    context "with size given" do
+      subject(:thumbnail_url_options) { record.thumbnail_url_options(size: "10x10") }
+
+      it "passes it to the thumbnail url options." do
+        expect(thumbnail_url_options[:size]).to eq("10x10")
+      end
+    end
+
+    context "with no size given" do
+      it "passes default size to the thumbnail url options." do
+        expect(thumbnail_url_options[:size]).to eq("160x120")
+      end
+    end
+
     context "with picture assigned" do
       let(:picture) do
         create(:alchemy_picture)

data/lib/alchemy/test_support/shared_ingredient_editor_examples.rb

@@ -1,21 +1,41 @@
 # frozen_string_literal: true
 
 RSpec.shared_examples_for "an alchemy ingredient editor" do
-  let(:ingredient_editor) { Alchemy::IngredientEditor.new(ingredient) }
+  let(:ingredient_editor) { described_class.new(ingredient) }
 
   before do
-    view.class.send :include, Alchemy::Admin::BaseHelper
-    view.class.send :include, Alchemy::Admin::IngredientsHelper
-    allow(element_editor).to receive(:ingredients) { [ingredient_editor] }
+    vc_test_view_context.class.include Alchemy::Admin::BaseHelper
+    allow(vc_test_view_context).to receive(:can?).and_return(true)
   end
 
   subject do
-    render element_editor
-    rendered
+    render_inline(ingredient_editor)
+    page
   end
 
   it "renders a ingredient editor", :aggregate_failures do
     is_expected.to have_css(".ingredient-editor.#{ingredient_editor.partial_name}")
     is_expected.to have_css("[data-ingredient-role]")
+    is_expected.to have_css("##{ingredient.class.model_name.param_key}_#{ingredient.id}")
+  end
+
+  it "provides a label" do
+    is_expected.to have_css("label[for]", text: Alchemy.t(
+      ingredient_editor.role,
+      scope: "ingredient_roles.#{element.name}",
+      default: Alchemy.t("ingredient_roles.#{ingredient_editor.role}", default: ingredient_editor.role.humanize)
+    ))
+  end
+
+  it "provides a ingredient input field" do
+    is_expected.to have_css("input[name]")
+  end
+
+  it "provides an ingredient id field for nested attributes" do
+    counter = ingredient_editor.send(:form_field_counter)
+    is_expected.to have_css(
+      "input[type='hidden'][name='element[ingredients_attributes][#{counter}][id]'][value='#{ingredient.id}']",
+      visible: :hidden
+    )
   end
 end