solidus_core 3.0.0 → 4.5.1

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

@@ -18,7 +18,7 @@ module Spree
           if product.save
             variants_attrs.each do |variant_attribute|
               # make sure the product is assigned before the options=
-              product.variants.create({ product: product }.merge(variant_attribute))
+              product.variants.create({ product: }.merge(variant_attribute))
             end
 
             set_up_options
@@ -35,7 +35,7 @@ module Spree
                 product.variants.find(variant_attribute['id'].to_i).update(variant_attribute)
               else
                 # make sure the product is assigned before the options=
-                product.variants.create({ product: product }.merge(variant_attribute))
+                product.variants.create({ product: }.merge(variant_attribute))
               end
             end
 
@@ -49,7 +49,7 @@ module Spree
 
         def set_up_options
           options_attrs.each do |name|
-            option_type = Spree::OptionType.where(name: name).first_or_initialize do |ot|
+            option_type = Spree::OptionType.where(name:).first_or_initialize do |ot|
               ot.presentation = name
               ot.save!
             end

data/lib/spree/core/nested_class_set.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "spree/core/class_constantizer"
+
+module Spree
+  module Core
+    class NestedClassSet
+      attr_reader :klass_sets
+
+      def initialize(hash = {})
+        @klass_sets = hash.map do |key, value|
+          [
+            key.to_s,
+            ClassConstantizer::Set.new(default: value)
+          ]
+        end.to_h
+      end
+
+      def [](klass)
+        klass_sets[klass.to_s] || []
+      end
+
+      def []=(klass, klasses)
+        klass_sets[klass.to_s] = ClassConstantizer::Set.new(default: klasses.map(&:to_s))
+      end
+    end
+  end
+end

data/lib/spree/core/null_promotion_configuration.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class NullPromotionConfiguration < Spree::Preferences::Configuration
+      include Spree::Core::EnvironmentExtension
+
+      # order_adjuster_class allows extensions to provide their own Order Adjuster
+      class_name_attribute :order_adjuster_class, default: 'Spree::NullPromotionAdjuster'
+
+      # Allows providing a different coupon code handler.
+      # @!attribute [rw] coupon_code_handler_class
+      # @see Spree::NullPromotionHandler
+      # @return [Class] an object that conforms to the API of
+      #   the standard coupon code handler class
+      #   Spree::NullPromotionHandler.
+      class_name_attribute :coupon_code_handler_class, default: 'Spree::NullPromotionHandler'
+
+      # Allows providing a different promotion finder.
+      # @!attribute [rw] promotion_finder_class
+      # @see Spree::NullPromotionFinder
+      # @return [Class] an object that conforms to the API of
+      #   the standard promotion finder class
+      #   Spree::NullPromotionFinder.
+      class_name_attribute :promotion_finder_class, default: 'Spree::NullPromotionFinder'
+
+      # Allows getting and setting `Spree::Config.promotion_code_batch_mailer_class`.
+      # Both will issue a deprecation warning.
+      class_name_attribute :promotion_code_batch_mailer_class, default: 'Spree::DeprecatedConfigurableClass'
+      deprecate :promotion_code_batch_mailer_class, :promotion_code_batch_mailer_class=, deprecator: Spree.deprecator
+
+      # Allows getting and setting `Spree::Config.promotion_chooser_class`.
+      # Both will issue a deprecation warning.
+      class_name_attribute :promotion_chooser_class, default: 'Spree::DeprecatedConfigurableClass'
+      deprecate :promotion_chooser_class, :promotion_chooser_class=, deprecator: Spree.deprecator
+
+      # Allows getting and setting rules. Deprecated.
+      # @!attribute [rw] rules
+      # @return [Array] a set of rules
+      add_class_set :rules
+      deprecate :rules, :rules=, deprecator: Spree.deprecator
+
+      # Allows getting and setting actions. Deprecated.
+      # @!attribute [rw] actions
+      # @return [Array] a set of actions
+      add_class_set :actions
+      deprecate :actions, :actions=, deprecator: Spree.deprecator
+
+      # Allows getting and setting shipping actions. Deprecated.
+      # @!attribute [rw] shipping_actions
+      # @return [Array] a set of shipping_actions
+      add_class_set :shipping_actions
+      deprecate :shipping_actions, :shipping_actions=, deprecator: Spree.deprecator
+
+      # Allows getting an setting calculators for actions. Deprecated.
+      # @!attribute [rw] calculators
+      # @return [Spree::Core::NestedClassSet] a set of calculators
+      add_nested_class_set :calculators
+      deprecate :calculators, :calculators=, deprecator: Spree.deprecator
+
+      # Allows providing a different promotion shipping promotion handler.
+      # @!attribute [rw] shipping_promotion_handler_class
+      # @see Spree::NullPromotionHandler
+      # @return [Class] an object that conforms to the API of
+      #   the standard promotion finder class
+      #   Spree::NullPromotionHandler.
+      class_name_attribute :shipping_promotion_handler_class, default: 'Spree::NullPromotionHandler'
+      deprecate :shipping_promotion_handler_class, deprecator: Spree.deprecator
+      deprecate :shipping_promotion_handler_class=, deprecator: Spree.deprecator
+
+      # Allows providing a different promotion advertiser.
+      # @!attribute [rw] advertiser_class
+      # @see Spree::NullPromotionAdvertiser
+      # @return [Class] an object that conforms to the API of
+      #   the standard promotion advertiser class
+      #   Spree::NullPromotionAdvertiser.
+      class_name_attribute :advertiser_class, default: 'Spree::NullPromotionAdvertiser'
+
+      # !@attribute [rw] promotion_api_attributes
+      #   @return [Array<Symbol>] Attributes to be returned by the API for a promotion
+      preference :promotion_api_attributes, :array, default: []
+    end
+  end
+end

data/lib/spree/core/product_duplicator.rb

@@ -45,7 +45,7 @@ module Spree
         new_master.sku = "COPY OF #{master.sku}"
         new_master.deleted_at = nil
         new_master.images = master.images.map { |image| duplicate_image image } if @include_images
-        new_master.price = master.price
+        new_master.prices = master.prices.map(&:dup)
       end
     end
 

data/lib/spree/core/product_filters.rb

@@ -61,7 +61,7 @@ module Spree
           scope = scope.or(new_scope)
         end
 
-        Spree::Product.joins(master: :default_price).where(scope)
+        Spree::Product.joins(master: :prices).where(scope)
       end
 
       def self.format_price(amount)
@@ -112,7 +112,7 @@ module Spree
         {
           name:   'Brands',
           scope:  :brand_any,
-          conds:  conds,
+          conds:,
           labels: brands.sort.map { |key| [key, key] }
         }
       end

data/lib/spree/core/search/base.rb

@@ -4,6 +4,12 @@ module Spree
   module Core
     module Search
       class Base
+        class InvalidOptions < ArgumentError
+          def initialize(option)
+            super("Invalid option passed to the searcher: '#{option}'")
+          end
+        end
+
         attr_accessor :properties
         attr_accessor :current_user
         attr_accessor :pricing_options
@@ -51,22 +57,25 @@ module Spree
           # separate queries most of the time but opt for a join as soon as any
           # `where` constraints affecting joined tables are added to the search;
           # which is the case as soon as a taxon is added to the base scope.
-          scope = scope.preload(master: :currently_valid_prices)
+          scope = scope.preload(master: :prices)
           scope = scope.preload(master: :images) if @properties[:include_images]
           scope
         end
 
         def add_search_scopes(base_scope)
-          if @properties[:search]
-            @properties[:search].each do |name, scope_attribute|
-              scope_name = name.to_sym
-              if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
-                base_scope = base_scope.send(scope_name, *scope_attribute)
-              else
-                base_scope = base_scope.merge(Spree::Product.ransack({ scope_name => scope_attribute }).result)
-              end
+          return base_scope unless @properties[:search].present?
+          raise InvalidOptions.new(:search) unless @properties[:search].respond_to?(:each_pair)
+
+          @properties[:search].each_pair do |name, scope_attribute|
+            scope_name = name.to_sym
+
+            if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
+              base_scope = base_scope.send(scope_name, *scope_attribute)
+            else
+              base_scope = base_scope.merge(Spree::Product.ransack({ scope_name => scope_attribute }).result)
             end
           end
+
           base_scope
         end
 

data/lib/spree/core/search/variant.rb

@@ -22,7 +22,7 @@ module Spree
 
         def initialize(query_string, scope: Spree::Variant.all)
           @query_string = query_string
-          @scope = scope
+          @scope = scope.non_template_variants
         end
 
         # Searches the variants table using the ransack 'search_terms' defined on the class.
@@ -39,7 +39,7 @@ module Spree
             @scope.ransack(search_term_params(word)).result.pluck(:id)
           end
 
-          Spree::Variant.where(id: matches.inject(:&))
+          @scope.where(id: matches.inject(:&))
         end
 
         private

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

@@ -1,42 +1,7 @@
 # frozen_string_literal: true
 
-module Spree
-  module Core
-    class StateMachines
-      # Inventory Units' state machine
-      #
-      # for each event the following instance methods are dynamically implemented:
-      #   #<event_name>
-      #   #<event_name>!
-      #   #can_<event_name>?
-      #
-      # for each state the following instance methods are implemented:
-      #   #<state_name>?
-      #
-      module InventoryUnit
-        extend ActiveSupport::Concern
-
-        included do
-          state_machine initial: :on_hand do
-            event :fill_backorder do
-              transition to: :on_hand, from: :backordered
-            end
-            after_transition on: :fill_backorder, do: :fulfill_order
-
-            event :ship do
-              transition to: :shipped, if: :allow_ship?
-            end
-
-            event :return do
-              transition to: :returned, from: :shipped
-            end
-
-            event :cancel do
-              transition to: :canceled, from: ::Spree::InventoryUnit::CANCELABLE_STATES.map(&:to_sym)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,249 +1,7 @@
 # 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
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,61 +1,7 @@
 # frozen_string_literal: true
 
-module Spree
-  module Core
-    class StateMachines
-      # Payments' state machine
-      #
-      # for each event the following instance methods are dynamically implemented:
-      #   #<event_name>
-      #   #<event_name>!
-      #   #can_<event_name>?
-      #
-      # for each state the following instance methods are implemented:
-      #   #<state_name>?
-      #
-      module Payment
-        extend ActiveSupport::Concern
-
-        included do
-          state_machine initial: :checkout do
-            # With card payments, happens before purchase or authorization happens
-            #
-            # Setting it after creating a profile and authorizing a full amount will
-            # prevent the payment from being authorized again once Order transitions
-            # to complete
-            event :started_processing do
-              transition from: [:checkout, :pending, :completed, :processing], to: :processing
-            end
-            # When processing during checkout fails
-            event :failure do
-              transition from: [:pending, :processing], to: :failed
-            end
-            # With card payments this represents authorizing the payment
-            event :pend do
-              transition from: [:checkout, :processing], to: :pending
-            end
-            # With card payments this represents completing a purchase or capture transaction
-            event :complete do
-              transition from: [:processing, :pending, :checkout], to: :completed
-            end
-            event :void do
-              transition from: [:pending, :processing, :completed, :checkout], to: :void
-            end
-            # when the card brand isnt supported
-            event :invalidate do
-              transition from: [:checkout], to: :invalid
-            end
-
-            after_transition do |payment, transition|
-              payment.state_changes.create!(
-                previous_state: transition.from,
-                next_state:     transition.to,
-                name:           'payment'
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,33 +1,7 @@
 # frozen_string_literal: true
 
-module Spree
-  module Core
-    class StateMachines
-      # Reimbursement' state machine
-      #
-      # for each event the following instance methods are dynamically implemented:
-      #   #<event_name>
-      #   #<event_name>!
-      #   #can_<event_name>?
-      #
-      # for each state the following instance methods are implemented:
-      #   #<state_name>?
-      #
-      module Reimbursement
-        extend ActiveSupport::Concern
-
-        included do
-          state_machine :reimbursement_status, initial: :pending do
-            event :errored do
-              transition to: :errored, from: [:pending, :errored]
-            end
-
-            event :reimbursed do
-              transition to: :reimbursed, from: [:pending, :errored]
-            end
-          end
-        end
-      end
-    end
-  end
-end
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)

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

@@ -1,32 +1,7 @@
 # frozen_string_literal: true
 
-module Spree
-  module Core
-    class StateMachines
-      # Return Authorizations' state machine
-      #
-      # for each event the following instance methods are dynamically implemented:
-      #   #<event_name>
-      #   #<event_name>!
-      #   #can_<event_name>?
-      #
-      # for each state the following instance methods are implemented:
-      #   #<state_name>?
-      #
-      module ReturnAuthorization
-        extend ActiveSupport::Concern
-
-        included do
-          state_machine initial: :authorized do
-            before_transition to: :canceled, do: :cancel_return_items
-
-            event :cancel do
-              transition to: :canceled, from: :authorized,
-                if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
-            end
-          end
-        end
-      end
-    end
-  end
-end
+Spree.deprecator.warn(
+  <<~MSG
+    The file "#{__FILE__}" does not need to be `require`d any longer, it is now autoloaded.
+  MSG
+)