solidus_core 2.10.5 → 2.11.0

data/lib/spree/core/state_machines/return_item/reception_status.rb

@@ -19,8 +19,8 @@ module Spree
 
           included do
             state_machine :reception_status, initial: :awaiting do
-              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES,  do: :attempt_accept
-              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES,  do: :check_unexchange
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :attempt_accept, if: :can_attempt_accept?
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :check_unexchange
               after_transition to: :received, do: :process_inventory_unit!
 
               event(:cancel) { transition to: :cancelled, from: :awaiting }

data/lib/spree/core/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  VERSION = "2.10.5"
+  VERSION = "2.11.0"
 
   def self.solidus_version
     VERSION

data/lib/spree/encryptor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Spree
+  # Spree::Encryptor is a thin wrapper around ActiveSupport::MessageEncryptor.
+  class Encryptor
+    # @param key [String] the 256 bits signature key
+    def initialize(key)
+      @crypt = ActiveSupport::MessageEncryptor.new(key)
+    end
+
+    # Encrypt a value
+    # @param value [String] the value to encrypt
+    # @return [String] the encrypted value
+    def encrypt(value)
+      @crypt.encrypt_and_sign(value)
+    end
+
+    # Decrypt an encrypted value
+    # @param encrypted_value [String] the value to decrypt
+    # @return [String] the decrypted value
+    def decrypt(encrypted_value)
+      @crypt.decrypt_and_verify(encrypted_value)
+    end
+  end
+end

data/lib/spree/event.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'event/adapters/active_support_notifications'
+require_relative 'event/subscriber_registry'
 require_relative 'event/configuration'
 require_relative 'event/subscriber'
 
@@ -8,6 +9,8 @@ module Spree
   module Event
     extend self
 
+    delegate :activate_autoloadable_subscribers, :activate_all_subscribers, :deactivate_all_subscribers, to: :subscriber_registry
+
     # Allows to trigger events that can be subscribed using #subscribe. An
     # optional block can be passed that will be executed immediately. The
     # actual code implementation is delegated to the adapter.
@@ -21,16 +24,37 @@ module Spree
     #     @order.finalize!
     #   end
     def fire(event_name, opts = {})
-      adapter.fire name_with_suffix(event_name.to_s), opts do
+      adapter.fire normalize_name(event_name), opts do
         yield opts if block_given?
       end
     end
 
+    # @deprecated Loads all Solidus' core and application's event subscribers files.
+    # The latter are loaded automatically only when the preference
+    # Spree::Config.events.autoload_subscribers is set to a truthy value.
+    #
+    # Files must be placed under the directory `app/subscribers` and their
+    # name must end with `_subscriber.rb`.
+    #
+    # Loading the files has the side effect of adding their module to the
+    # list in Spree::Event.subscribers.
+    def require_subscriber_files
+      Spree::Deprecation.warn("#{self}.require_subscriber_files is deprecated and will be removed in Solidus 3.0.", caller)
+      subscriber_registry.send(:require_subscriber_files)
+    end
+
     # Subscribe to an event with the given name. The provided block is executed
     # every time the subscribed event is fired.
     #
-    # @param [String] event_name the name of the event. The suffix ".spree"
-    #  will be added automatically if not present
+    # @param [String, Regexp] event_name the name of the event.
+    #  When String, the suffix ".spree" will be added automatically if not present,
+    #  when using the default adapter for ActiveSupportNotifications.
+    #  When Regexp, due to the unpredictability of all possible regexp combinations,
+    #  adding the suffix is developer's responsibility (if you don't, you will
+    #  subscribe to all notifications, including internal Rails notifications
+    #  as well).
+    #
+    # @see Spree::Event::Adapters::ActiveSupportNotifications#normalize_name
     #
     # @return a subscription object that can be used as reference in order
     #  to remove the subscription
@@ -43,7 +67,7 @@ module Spree
     #
     # @see Spree::Event#unsubscribe
     def subscribe(event_name, &block)
-      name = name_with_suffix(event_name)
+      name = normalize_name(event_name)
       listener_names << name
       adapter.subscribe(name, &block)
     end
@@ -61,7 +85,7 @@ module Spree
     # @example Unsubscribe an event by name with explicit prefix
     #   Spree::Event.unsubscribe('order_finalized.spree')
     def unsubscribe(subscriber)
-      name_or_subscriber = subscriber.is_a?(String) ? name_with_suffix(subscriber) : subscriber
+      name_or_subscriber = subscriber.is_a?(String) ? normalize_name(subscriber) : subscriber
       adapter.unsubscribe(name_or_subscriber)
     end
 
@@ -95,19 +119,28 @@ module Spree
     #
     # @see Spree::Event::Configuration#suffix
     def suffix
+      Spree::Deprecation.warn "This method is deprecated and will be removed. Please use Event::Adapters::ActiveSupportNotifications#suffix"
       Spree::Config.events.suffix
     end
 
+    # @deprecated
     # @!attribute [r] subscribers
     #   @return [Array<Spree::Event::Subscriber>] A list of subscribers used to support class reloading for Spree::Event::Subscriber instances
     def subscribers
+      Spree::Deprecation.warn("`#{self}.subscribers` is deprecated. Please use `#{self}.subscriber_registry` instead.", caller)
       Spree::Config.events.subscribers
     end
 
+    # @!attribute [r] subscribers
+    #   @return <Spree::Event::SubscriberRegistry> The registry for supporting class reloading for Spree::Event::Subscriber instances
+    def subscriber_registry
+      Spree::Config.events.subscriber_registry
+    end
+
     private
 
-    def name_with_suffix(name)
-      name.end_with?(suffix) ? name : [name, suffix].join
+    def normalize_name(name)
+     adapter.normalize_name(name)
     end
 
     def listener_names

data/lib/spree/event/adapters/active_support_notifications.rb

@@ -4,6 +4,8 @@ module Spree
   module Event
     module Adapters
       module ActiveSupportNotifications
+        class InvalidEventNameType < StandardError; end
+
         extend self
 
         def fire(event_name, opts)
@@ -29,6 +31,36 @@ module Spree
             memo[name] = listeners if listeners.present?
           end
         end
+
+        # Normalizes the event name according to this specific adapter rules.
+        #  When the event name is a string or a symbol, if the suffix is missing, then
+        #  it is added automatically.
+        #  When the event name is a regexp, due to the huge variability of regexps, adding
+        #  or not the suffix is developer's responsibility (if you don't, you will subscribe
+        #  to all internal rails events as well).
+        #  When the event type is not supported, an error is raised.
+        #
+        # @param [String, Symbol, Regexp] event_name the event name, with or without the
+        #  suffix (Spree::Config.events.suffix defaults to `.spree`).
+        def normalize_name(event_name)
+          case event_name
+          when Regexp
+            event_name
+          when String, Symbol
+            name = event_name.to_s
+            name.end_with?(suffix) ? name : [name, suffix].join
+          else
+            raise InvalidEventNameType, "Invalid event name type: #{event_name.class}"
+          end
+        end
+
+        # The suffix used for namespacing event names, defaults to
+        # `.spree`
+        #
+        # @see Spree::Event::Configuration#suffix
+        def suffix
+          Spree::Config.events.suffix
+        end
       end
     end
   end

data/lib/spree/event/configuration.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
 
-require 'spree/core/class_constantizer'
-
 module Spree
   module Event
     class Configuration
+      def subscriber_registry
+        @subscriber_registry ||= Spree::Event::SubscriberRegistry.new
+      end
+
       def subscribers
-        @subscribers ||= ::Spree::Core::ClassConstantizer::Set.new.tap do |set|
-          set << 'Spree::MailerSubscriber'
-        end
+        Spree::Deprecation.warn("`Spree::Config.events.subscribers` is deprecated. Please use `Spree::Config.events.subscriber_registry`.", caller)
+        subscriber_registry.send(:registry).keys.map { |module_name| module_name.constantize }
       end
 
-      attr_writer :adapter, :suffix
+      attr_writer :adapter, :suffix, :autoload_subscribers
+
+      def autoload_subscribers
+        @autoload_subscribers.nil? ? true : !!@autoload_subscribers
+      end
 
       def adapter
         @adapter ||= Spree::Event::Adapters::ActiveSupportNotifications

data/lib/spree/event/subscriber.rb

@@ -19,13 +19,20 @@ module Spree
     #     end
     #   end
     #
-    #  EmailSender.subscribe!
+    #  # Optional, required only when the subscriber needs to be loaded manually.
+    #  #
+    #  # If Spree::Config.events.autoload_subscribers is set to `true` and the module
+    #  # file matches the pattern `app/subscribers/**/*_subscriber.rb` then it will
+    #  # be loaded automatically at boot and this line can be removed:
+    #  EmailSender.activate
     module Subscriber
       def self.included(base)
         base.extend base
 
         base.mattr_accessor :event_actions
         base.event_actions = {}
+
+        Spree::Event.subscriber_registry.register(base)
       end
 
       # Declares a method name in the including module that can be subscribed/unsubscribed
@@ -52,32 +59,45 @@ module Spree
       #     end
       #   end
       def event_action(method_name, event_name: nil)
-        mattr_accessor "#{method_name}_handler"
+        mattr_writer "#{method_name}_handler"
+
+        define_method "#{method_name}_handler" do
+          Spree::Deprecation.warn("#{name}.#{method_name}_handler and #{name}.#{method_name}_handler= from the old events mapping interface are deprecated. Please use the new mapping stored in Spree::Event.subscribers.", caller)
+
+          class_variable_get("@@#{method_name}_handler")
+        end
+
         event_actions[method_name] = (event_name || method_name).to_s
       end
 
-      # Subscribes all declared event actions to their events. Only actions that are subscribed
+      # Activates all declared event actions to their events. Only actions that are activated
       # will be called when their event fires.
       #
-      # @example subscribe all event actions for module 'EmailSender'
-      #    EmailSender.subscribe!
+      # @example activate all event actions for module 'EmailSender'
+      #    EmailSender.activate
+      def activate
+        Spree::Event.subscriber_registry.activate_subscriber(self)
+      end
+
+      # Deactivates all declared event actions (or a single specific one) from their events.
+      # This means that when an event fires then none of its unsubscribed event actions will
+      # be called.
+      # @example deactivate all event actions for module 'EmailSender'
+      #    EmailSender.deactivate
+      # @example deactivate only order_finalized for module 'EmailSender'
+      #    EmailSender.deactivate(:order_finalized)
+      def deactivate(event_action_name = nil)
+        Spree::Event.subscriber_registry.deactivate_subscriber(self, event_action_name)
+      end
+
       def subscribe!
-        unsubscribe!
-        event_actions.each do |event_action, event_name|
-          send "#{event_action}_handler=", Spree::Event.subscribe(event_name) { |event|
-            send event_action, event
-          }
-        end
+        Spree::Deprecation.warn("#{self}.subscribe! is deprecated. Please use `#{self}.activate`.", caller)
+        activate
       end
 
-      # Unsubscribes all declared event actions from their events. This means that when an event
-      # fires then none of its unsubscribed event actions will be called.
-      # @example unsubscribe all event actions for module 'EmailSender'
-      #    EmailSender.unsubscribe!
       def unsubscribe!
-        event_actions.keys.each do |event_action|
-          Spree::Event.unsubscribe send("#{event_action}_handler")
-        end
+        Spree::Deprecation.warn("#{self}.unsubscribe! is deprecated. Please use `#{self}.deactivate`.", caller)
+        deactivate
       end
     end
   end

data/lib/spree/event/subscriber_registry.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Spree
+  module Event
+    class SubscriberRegistry
+      def initialize
+        @registry = {}
+        @semaphore = Mutex.new
+      end
+
+      def register(subscriber)
+        registry[subscriber.name] ||= {}
+      end
+
+      def activate_autoloadable_subscribers
+        require_subscriber_files
+        activate_all_subscribers
+      end
+
+      def activate_all_subscribers
+        registry.each_key { |subscriber_name| activate_subscriber(subscriber_name.constantize) }
+      end
+
+      def deactivate_all_subscribers
+        registry.each_key { |subscriber_name| deactivate_subscriber(subscriber_name.constantize) }
+      end
+
+      def activate_subscriber(subscriber)
+        return unless registry[subscriber.name]
+
+        subscriber.event_actions.each do |event_action, event_name|
+          @semaphore.synchronize do
+            unsafe_deactivate_subscriber(subscriber, event_action)
+
+            subscription = Spree::Event.subscribe(event_name) { |event| subscriber.send(event_action, event) }
+
+            # deprecated mappings, to be removed when Solidus 2.10 is not supported anymore:
+            subscriber.send("#{event_action}_handler=", subscription)
+
+            registry[subscriber.name][event_action] = subscription
+          end
+        end
+      end
+
+      def deactivate_subscriber(subscriber, event_action_name = nil)
+        @semaphore.synchronize do
+          unsafe_deactivate_subscriber(subscriber, event_action_name)
+        end
+      end
+
+      private
+
+      attr_reader :registry
+
+      # Loads all Solidus' core and application's event subscribers files.
+      # The latter are loaded automatically only when the preference
+      # Spree::Config.events.autoload_subscribers is set to a truthy value.
+      #
+      # Files must be placed under the directory `app/subscribers` and their
+      # name must end with `_subscriber.rb`.
+      #
+      # Loading the files has the side effect of adding their module to the
+      # list in Spree::Event.subscribers.
+      def require_subscriber_files
+        pattern = "app/subscribers/**/*_subscriber.rb"
+
+        # Load Solidus subscribers
+        # rubocop:disable Rails/DynamicFindBy
+        solidus_core_dir = Gem::Specification.find_by_name('solidus_core').gem_dir
+        # rubocop:enable Rails/DynamicFindBy
+        Dir.glob(File.join(solidus_core_dir, pattern)) { |c| require_dependency(c.to_s) }
+
+        # Load application subscribers, only when the flag is set to true:
+        if Spree::Config.events.autoload_subscribers
+          Rails.root.glob(pattern) { |c| require_dependency(c.to_s) }
+        end
+      end
+
+      def unsafe_deactivate_subscriber(subscriber, event_action_name = nil)
+        to_unsubscribe = Array.wrap(event_action_name || subscriber.event_actions.keys)
+
+        to_unsubscribe.each do |event_action|
+          if (subscription = registry.dig(subscriber.name, event_action))
+            Spree::Event.unsubscribe(subscription)
+
+            registry[subscriber.name].delete(event_action)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spree/i18n.rb

@@ -31,7 +31,7 @@ module Spree
         Instead use I18n.t('spree.your_translation_key')
       WARN
       options[:scope] = [:spree, *options[:scope]]
-      TranslationHelperWrapper.new.translate(key, options)
+      TranslationHelperWrapper.new.translate(key, **options)
     end
 
     alias_method :t, :translate

data/lib/spree/mailer_previews/carton_preview.rb

@@ -5,7 +5,8 @@ module Spree
     class CartonPreview < ActionMailer::Preview
       def shipped
         carton = Carton.joins(:orders).last
-        raise "Your database needs at one shipped order with a carton to render this preview" unless carton
+        raise "Your database needs at least one shipped order with a carton to render this preview" unless carton
+
         Spree::Config.carton_shipped_email_class.shipped_email(order: carton.orders.first, carton: carton)
       end
     end

data/lib/spree/paranoia_deprecations.rb

@@ -2,20 +2,40 @@
 
 module Spree
   module ParanoiaDeprecations
-    def paranoia_destroy
-      Spree::Deprecation.warn <<-WARN.strip_heredoc, caller
-        Calling #destroy (or #paranoia_destroy) on a #{self.class} currently performs a soft-destroy using the paranoia gem.
-        In Solidus 3.0, paranoia will be removed, and this will perform a HARD destroy instead. To continue soft-deleting, use #discard instead.
-      WARN
-      super
+    module InstanceMethods
+      def paranoia_destroy
+        Spree::Deprecation.warn <<~WARN, caller
+          Calling #destroy (or #paranoia_destroy) on a #{self.class} currently performs a soft-destroy using the paranoia gem.
+          In Solidus 3.0, paranoia will be removed, and this will perform a HARD destroy instead. To continue soft-deleting, use #discard instead.
+        WARN
+        super
+      end
+
+      def paranoia_delete
+        Spree::Deprecation.warn <<~WARN, caller
+          Calling #delete (or #paranoia_delete) on a #{self.class} currently performs a soft-destroy using the paranoia gem.
+          In Solidus 3.0, paranoia will be removed, and this will perform a HARD destroy instead. To continue soft-deleting, use #discard instead.
+        WARN
+        super
+      end
     end
 
-    def paranoia_delete
-      Spree::Deprecation.warn <<-WARN.strip_heredoc, caller
-        Calling #delete (or #paranoia_delete) on a #{self.class} currently performs a soft-destroy using the paranoia gem.
-        In Solidus 3.0, paranoia will be removed, and this will perform a HARD destroy instead. To continue soft-deleting, use #discard instead.
-      WARN
-      super
+    module ClassMethods
+      def with_deleted
+        Spree::Deprecation.warn <<~WARN, caller
+          #{self}.with_deleted has been deprecated. Use #{self}.with_discarded instead.
+          In Solidus 3.0, paranoia will be removed, and this method will be replaced by #{self}.with_discarded.
+        WARN
+        super
+      end
+
+      def only_deleted
+        Spree::Deprecation.warn <<~WARN, caller
+          #{self}.only_deleted has been deprecated. Use #{self}.discarded instead.
+          In Solidus 3.0, paranoia will be removed, and this method will be replaced by #{self}.discarded.
+        WARN
+        super
+      end
     end
   end
 end