solidus_core 2.10.5 → 2.11.0

data/lib/spree/awesome_nested_set_override.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module AwesomeNestedSetOvveride
+  # Add :polimorphic key option only when used to make it work with Rails 6.1+,
+  # required since rails/rails@2c008d9
+  # This can be removed when upgrading to an awesome_nested_set version
+  # compliant with Rails 6.1+, already addressed in
+  # collectiveidea/awesome_nested_set#421
+  module RelateParent
+    def acts_as_nested_set_relate_parent!
+      # Disable Rubocop to keep original code for diffs
+      # rubocop:disable
+      options = {
+        :class_name => self.base_class.to_s,
+        :foreign_key => parent_column_name,
+        :primary_key => primary_column_name,
+        :counter_cache => acts_as_nested_set_options[:counter_cache],
+        :inverse_of => (:children unless acts_as_nested_set_options[:polymorphic]),
+        :touch => acts_as_nested_set_options[:touch]
+      }
+      options[:polymorphic] = true if acts_as_nested_set_options[:polymorphic]
+      options[:optional] = true if ActiveRecord::VERSION::MAJOR >= 5
+      belongs_to :parent, options
+      # rubocop:enable
+    end
+
+    CollectiveIdea::Acts::NestedSet.prepend self
+  end
+
+  # Skip breaking model reload before update depth. Already addressed in
+  # collectiveidea/awesome_nested_set#413
+  # This can be removed when a new version of awesome_nested_set is released.
+  module Model
+    def set_depth!
+      return unless has_depth_column?
+
+      in_tenacious_transaction do
+        update_depth(level)
+      end
+    end
+
+    CollectiveIdea::Acts::NestedSet::Model.prepend self
+  end
+end

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/core/controller_helpers/auth.rb

@@ -11,7 +11,7 @@ module Spree
         # @!attribute [rw] unauthorized_redirect
         #   @!scope class
         #   Extension point for overriding behaviour of access denied errors.
-        #   Default behaviour is to redirect to "/unauthorized" with a flash
+        #   Default behaviour is to redirect back or to "/unauthorized" with a flash
         #   message.
         #   @return [Proc] action to take when access denied error is raised.
 
@@ -22,7 +22,20 @@ module Spree
           class_attribute :unauthorized_redirect
           self.unauthorized_redirect = -> do
             flash[:error] = I18n.t('spree.authorization_failure')
-            redirect_to "/unauthorized"
+            if Spree::Config.redirect_back_on_unauthorized
+              redirect_back(fallback_location: "/unauthorized")
+            else
+              Spree::Deprecation.warn <<-WARN.strip_heredoc, caller
+                Having Spree::Config.redirect_back_on_unauthorized set
+                to `false` is deprecated and will not be supported in Solidus 3.0.
+
+                Please change this configuration to `true` and be sure that your
+                application does not break trying to redirect back when there is
+                an unauthorized access.
+              WARN
+
+              redirect_to "/unauthorized"
+            end
           end
 
           rescue_from CanCan::AccessDenied do
@@ -42,10 +55,10 @@ module Spree
 
         def set_guest_token
           unless cookies.signed[:guest_token].present?
-            cookies.permanent.signed[:guest_token] = {
+            cookies.permanent.signed[:guest_token] = Spree::Config[:guest_token_cookie_options].merge(
               value: SecureRandom.urlsafe_base64(nil, false),
               httponly: true
-            }
+            )
           end
         end
 

data/lib/spree/core/controller_helpers/current_host.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    module ControllerHelpers
+      module CurrentHost
+        extend ActiveSupport::Concern
+
+        included do
+          before_action do
+            ActiveStorage::Current.host = request.base_url
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -30,18 +30,19 @@ module Spree
 
         # The current incomplete order from the guest_token for use in cart and during checkout
         def current_order(options = {})
-          options[:create_order_if_necessary] ||= false
+          should_create = options[:create_order_if_necessary] || false
+          should_build = options[:build_order_if_necessary] || should_create
 
           return @current_order if @current_order
 
-          @current_order = find_order_by_token_or_user(options)
+          @current_order = find_order_by_token_or_user(lock: options[:lock])
 
-          if options[:create_order_if_necessary] && (@current_order.nil? || @current_order.completed?)
+          if should_build && (@current_order.nil? || @current_order.completed?)
             @current_order = Spree::Order.new(new_order_params)
             @current_order.user ||= try_spree_current_user
             # See issue https://github.com/spree/spree/issues/3346 for reasons why this line is here
             @current_order.created_by ||= try_spree_current_user
-            @current_order.save!
+            @current_order.save! if should_create
           end
 
           if @current_order
@@ -84,14 +85,14 @@ module Spree
         end
 
         def find_order_by_token_or_user(options = {}, with_adjustments = false)
-          options[:lock] ||= false
+          should_lock = options[:lock] || false
 
           # Find any incomplete orders for the guest_token
           if with_adjustments
             Spree::Deprecation.warn "The second argument to find_order_by_token_or_user is deprecated, and will be removed in a future version."
-            order = Spree::Order.incomplete.includes(:adjustments).lock(options[:lock]).find_by(current_order_params)
+            order = Spree::Order.incomplete.includes(:adjustments).lock(should_lock).find_by(current_order_params)
           else
-            order = Spree::Order.incomplete.lock(options[:lock]).find_by(current_order_params)
+            order = Spree::Order.incomplete.lock(should_lock).find_by(current_order_params)
           end
 
           # Find any incomplete orders for the current user

data/lib/spree/core/engine.rb

@@ -47,11 +47,48 @@ module Spree
       # Setup Event Subscribers
       initializer 'spree.core.initialize_subscribers' do |app|
         app.reloader.to_prepare do
-          Spree::Event.subscribers.each(&:subscribe!)
+          Spree::Event.activate_autoloadable_subscribers
         end
 
         app.reloader.before_class_unload do
-          Spree::Event.subscribers.each(&:unsubscribe!)
+          Spree::Event.deactivate_all_subscribers
+        end
+      end
+
+      config.after_initialize do
+        if Spree::Config.raise_with_invalid_currency == true
+          Spree::Deprecation.warn(
+            'Spree::Config.raise_with_invalid_currency set to true is ' \
+            'deprecated. Please note that by switching this value, ' \
+            'Spree::LineItem::CurrencyMismatch will not be raised anymore.',
+            caller
+          )
+        end
+        if Spree::Config.consider_actionless_promotion_active == true
+          Spree::Deprecation.warn(
+            'Spree::Config.consider_actionless_promotion_active set to true is ' \
+            'deprecated. Please note that by switching this value, ' \
+            'promotions with no actions will be considered active.',
+            caller
+          )
+        end
+        if Spree::Config.run_order_validations_on_order_updater != true
+          Spree::Deprecation.warn(
+            'Spree::Config.run_order_validations_on_order_updater set to false is ' \
+            'deprecated and will not be possibile in Solidus 3.0. Please switch this ' \
+            'value to true and check that everything works as expected.',
+            caller
+          )
+        end
+
+        if Spree::Config.use_legacy_address_state_validator != false
+          Spree::Deprecation.warn(<<~DEPRECATION.squish, caller)
+            Spree::Config.use_legacy_address_state_validator set to true has been
+            deprecated and will be removed in Solidus 3.0. The Spree::Address state
+            validation has been extracted into a configurable external class.
+            Switch Spree::Config.use_legacy_address_state_validator to true to start
+            using the external validation class.
+          DEPRECATION
         end
       end
 

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

@@ -56,7 +56,9 @@ module Spree
           shipments_hash.each do |target|
             shipment = Shipment.new
             shipment.tracking       = target[:tracking]
-            shipment.stock_location = Spree::StockLocation.find_by(admin_name: target[:stock_location]) || Spree::StockLocation.find_by!(name: target[:stock_location])
+            shipment.stock_location = Spree::StockLocation.find_by(id: target[:stock_location_id]) ||
+              Spree::StockLocation.find_by(admin_name: target[:stock_location]) ||
+              Spree::StockLocation.find_by!(name: target[:stock_location])
 
             inventory_units = target[:inventory_units] || []
             inventory_units.each do |inventory_unit|
@@ -98,19 +100,31 @@ module Spree
 
         def self.create_line_items_from_params(line_items_hash, order)
           return {} unless line_items_hash
-          line_items_hash.each_key do |key|
-            extra_params = line_items_hash[key].except(:variant_id, :quantity, :sku)
-            line_item = ensure_variant_id_from_params(line_items_hash[key])
-            line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
-            # Raise any errors with saving to prevent import succeeding with line items failing silently.
-            if extra_params.present?
-              line_item.update!(extra_params)
-            else
-              line_item.save!
+
+          case line_items_hash
+          when Hash
+            line_items_hash.each_key do |key|
+              create_line_item(line_items_hash[key], order)
+            end
+          when Array
+            line_items_hash.each do |line_item_hash|
+              create_line_item(line_item_hash, order)
             end
           end
         end
 
+        def self.create_line_item(line_item_hash, order)
+          extra_params = line_item_hash.except(:variant_id, :quantity, :sku)
+          line_item = ensure_variant_id_from_params(line_item_hash)
+          line_item = order.contents.add(Spree::Variant.find(line_item[:variant_id]), line_item[:quantity])
+          # Raise any errors with saving to prevent import succeeding with line items failing silently.
+          if extra_params.present?
+            line_item.update!(extra_params)
+          else
+            line_item.save!
+          end
+        end
+
         def self.create_adjustments_from_params(adjustments, order)
           return [] unless adjustments
           adjustments.each do |target|

data/lib/spree/core/permalinks.rb

@@ -9,7 +9,7 @@ module Spree
         class_attribute :permalink_options
       end
 
-      module ClassMethods
+      class_methods do
         def make_permalink(options = {})
           options[:field] ||= :permalink
           self.permalink_options = options
@@ -63,5 +63,3 @@ module Spree
     end
   end
 end
-
-ActiveRecord::Base.send :include, Spree::Core::Permalinks

data/lib/spree/core/product_filters.rb

@@ -60,6 +60,7 @@ module Spree
         conds.each do |new_scope|
           scope = scope.or(new_scope)
         end
+
         Spree::Product.joins(master: :default_price).where(scope)
       end
 
@@ -70,9 +71,9 @@ module Spree
       def self.price_filter
         value = Spree::Price.arel_table
         conds = [[I18n.t('spree.under_price', price: format_price(10)), value[:amount].lteq(10)],
-                 ["#{format_price(10)} - #{format_price(15)}", value[:amount].in(10..15)],
-                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].in(15..18)],
-                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].in(18..20)],
+                 ["#{format_price(10)} - #{format_price(15)}", value[:amount].between(10..15)],
+                 ["#{format_price(15)} - #{format_price(18)}", value[:amount].between(15..18)],
+                 ["#{format_price(18)} - #{format_price(20)}", value[:amount].between(18..20)],
                  [I18n.t('spree.or_over_price', price: format_price(20)), value[:amount].gteq(20)]]
         {
           name:   I18n.t('spree.price_range'),
@@ -107,7 +108,7 @@ module Spree
         brand_property = Spree::Property.find_by(name: 'brand')
         brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
         pp = Spree::ProductProperty.arel_table
-        conds = Hash[*brands.map { |brand| [brand, pp[:value].eq(brand)] }.flatten]
+        conds = Hash[*brands.flat_map { |brand| [brand, pp[:value].eq(brand)] }]
         {
           name:   'Brands',
           scope:  :brand_any,
@@ -184,7 +185,7 @@ module Spree
       # idea: expand the format to allow nesting of labels?
       def self.all_taxons
         Spree::Deprecation.warn "all_taxons is deprecated in solidus_core. Please add it to your own application to continue using it."
-        taxons = Spree::Taxonomy.all.map { |element| [element.root] + element.root.descendants }.flatten
+        taxons = Spree::Taxonomy.all.flat_map { |element| [element.root] + element.root.descendants }
         {
           name:   'All taxons',
           scope:  :taxons_id_equals_any,

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