solidus_core 2.10.0 → 2.11.0

data/lib/spree/core/state_machines/order.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module Order
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        module ClassMethods
+          attr_accessor :previous_states
+          attr_writer :next_event_transitions
+          attr_writer :checkout_steps
+          attr_writer :removed_transitions
+
+          def checkout_flow(&block)
+            if block_given?
+              @checkout_flow = block
+              define_state_machine!
+            else
+              @checkout_flow
+            end
+          end
+
+          def define_state_machine!
+            self.checkout_steps = {}
+            self.next_event_transitions = []
+            self.previous_states = [:cart]
+            self.removed_transitions = []
+
+            # Build the checkout flow using the checkout_flow defined either
+            # within the Order class, or a decorator for that class.
+            #
+            # This method may be called multiple times depending on if the
+            # checkout_flow is re-defined in a decorator or not.
+            instance_eval(&checkout_flow)
+
+            klass = self
+
+            # To avoid multiple occurrences of the same transition being defined
+            # On first definition, state_machines will not be defined
+            state_machines.clear if respond_to?(:state_machines)
+            state_machine :state, initial: :cart, use_transactions: false do
+              klass.next_event_transitions.each { |state| transition(state.merge(on: :next)) }
+
+              # Persist the state on the order
+              after_transition do |order, transition|
+                order.state = order.state
+                order.state_changes.create(
+                  previous_state: transition.from,
+                  next_state:     transition.to,
+                  name:           'order',
+                  user_id:        order.user_id
+                )
+                order.save
+              end
+
+              event :cancel do
+                transition to: :canceled, if: :allow_cancel?, from: :complete
+              end
+
+              event :return do
+                transition to: :returned, from: [:complete, :awaiting_return], if: :all_inventory_units_returned?
+              end
+
+              event :resume do
+                transition to: :resumed, from: :canceled, if: :canceled?
+              end
+
+              event :authorize_return do
+                transition to: :awaiting_return, from: :complete
+              end
+
+              event :complete do
+                transition to: :complete, from: :confirm
+              end
+
+              if states[:payment]
+                event :payment_failed do
+                  transition to: :payment, from: :confirm
+                end
+
+                after_transition to: :complete, do: :add_payment_sources_to_wallet
+                before_transition to: :payment, do: :add_default_payment_from_wallet
+                before_transition to: :payment, do: :ensure_billing_address
+
+                before_transition to: :confirm, do: :add_store_credit_payments
+
+                # see also process_payments_before_complete below which needs to
+                # be added in the correct sequence.
+              end
+
+              before_transition from: :cart, do: :ensure_line_items_present
+
+              if states[:address]
+                before_transition to: :address, do: :assign_default_user_addresses
+                before_transition from: :address, do: :persist_user_address!
+              end
+
+              if states[:delivery]
+                before_transition to: :delivery, do: :ensure_shipping_address
+                before_transition to: :delivery, do: :create_proposed_shipments
+                before_transition to: :delivery, do: :ensure_available_shipping_rates
+                before_transition from: :delivery, do: :apply_shipping_promotions
+              end
+
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :validate_line_item_availability
+
+              # Sequence of before_transition to: :complete
+              # calls matter so that we do not process payments
+              # until validations have passed
+              before_transition to: :complete, do: :validate_line_item_availability
+              before_transition to: :complete, do: :ensure_promotions_eligible
+              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :complete, do: :ensure_inventory_units
+              if states[:payment]
+                before_transition to: :complete, do: :process_payments_before_complete
+              end
+
+              after_transition to: :complete, do: :finalize!
+              after_transition to: :resumed,  do: :after_resume
+              after_transition to: :canceled, do: :after_cancel
+
+              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+                order.recalculate
+              end
+
+              after_transition do |order, transition|
+                order.logger.debug "Order #{order.number} transitioned from #{transition.from} to #{transition.to} via #{transition.event}"
+              end
+
+              after_failure do |order, transition|
+                order.logger.debug "Order #{order.number} halted transition on event #{transition.event} state #{transition.from}: #{order.errors.full_messages.join}"
+              end
+            end
+          end
+
+          def go_to_state(name, options = {})
+            checkout_steps[name] = options
+            previous_states.each do |state|
+              add_transition({ from: state, to: name }.merge(options))
+            end
+            if options[:if]
+              previous_states << name
+            else
+              self.previous_states = [name]
+            end
+          end
+
+          def insert_checkout_step(name, options = {})
+            before = options.delete(:before)
+            after = options.delete(:after) unless before
+            after = checkout_steps.keys.last unless before || after
+
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(name, options) if key == before
+                go_to_state(key, value)
+                go_to_state(name, options) if key == after
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_checkout_step(name)
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(key, value) unless key == name
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_transition(options = {})
+            removed_transitions << options
+            next_event_transitions.delete(find_transition(options))
+          end
+
+          def find_transition(options = {})
+            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+
+            next_event_transitions.detect do |transition|
+              transition[options[:from].to_sym] == options[:to].to_sym
+            end
+          end
+
+          def next_event_transitions
+            @next_event_transitions ||= []
+          end
+
+          def checkout_steps
+            @checkout_steps ||= {}
+          end
+
+          def checkout_step_names
+            checkout_steps.keys
+          end
+
+          def add_transition(options)
+            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+          end
+
+          def removed_transitions
+            @removed_transitions ||= []
+          end
+        end
+
+        def checkout_steps
+          steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
+            next if options.include?(:if) && !options[:if].call(self)
+
+            checkout_steps << step
+          }.map(&:to_s)
+          # Ensure there is always a complete step
+          steps << "complete" unless steps.include?("complete")
+          steps
+        end
+
+        def has_checkout_step?(step)
+          step.present? && checkout_steps.include?(step)
+        end
+
+        def passed_checkout_step?(step)
+          has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+        end
+
+        def checkout_step_index(step)
+          checkout_steps.index(step).to_i
+        end
+
+        def can_go_to_state?(state)
+          return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+
+          checkout_step_index(state) > checkout_step_index(self.state)
+        end
+      end
+    end
+  end
+end

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/state_machines.rb

@@ -9,7 +9,8 @@ module Spree
                   :return_item_reception,
                   :payment,
                   :inventory_unit,
-                  :shipment
+                  :shipment,
+                  :order
 
       def return_authorization
         @return_authorization ||= begin
@@ -65,6 +66,24 @@ module Spree
         @shipment.constantize
       end
 
+      def order
+        @order ||= begin
+          if Spree::Config.use_legacy_order_state_machine
+            Spree::Deprecation.warn(
+              "Spree::Order state machine defined in Spree::Order::Checkout is deprecated. " \
+              "Future versions of Solidus will use Spree::Core::StateMachines::Order}",
+              caller
+            )
+            'Spree::Order::Checkout'
+          else
+            require 'spree/core/state_machines/order'
+            'Spree::Core::StateMachines::Order'
+          end
+        end
+
+        @order.constantize
+      end
+
       def reimbursement
         @reimbursement ||= begin
           require 'spree/core/state_machines/reimbursement'

data/lib/spree/core/version.rb

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

data/lib/spree/core.rb

@@ -53,17 +53,6 @@ module Spree
   end
 end
 
-if Gem::Version.new(Rails.version) < Gem::Version.new('5.2')
-  warn <<~HEREDOC
-    Rails 5.1 (EOL) is deprecated and will not be supported anymore from the next Solidus version.
-    Please, upgrade to a more recent Rails version.
-
-    Read more on upgrading from Rails 5.1 to Rails 5.2 here:
-    https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#upgrading-from-rails-5-1-to-rails-5-2
-
-  HEREDOC
-end
-
 require 'spree/core/version'
 
 require 'spree/core/active_merchant_dependencies'
@@ -89,6 +78,7 @@ require 'spree/core/product_duplicator'
 require 'spree/core/current_store'
 require 'spree/core/controller_helpers/auth'
 require 'spree/core/controller_helpers/common'
+require 'spree/core/controller_helpers/current_host'
 require 'spree/core/controller_helpers/order'
 require 'spree/core/controller_helpers/payment_parameters'
 require 'spree/core/controller_helpers/pricing'
@@ -104,3 +94,7 @@ require 'spree/permission_sets'
 require 'spree/preferences/store'
 require 'spree/preferences/static_model_preferences'
 require 'spree/preferences/scoped_store'
+
+if Rails.gem_version >= Gem::Version.new('6.1.0.alpha')
+  require 'spree/awesome_nested_set_override'
+end

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/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