solidus_core 3.1.9 → 3.2.0.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd88c98f5da37d9a89e981aad39979998349f0e2405a4a7095a8f75f4d3839f8
-  data.tar.gz: 656beea8141300d09b62b4970dccd7691556112597a891a4f0d1821a67914ea3
+  metadata.gz: b1b866f15d9df0394383e7f634858ee99f21ed214e8fae6928af514a6421ddbc
+  data.tar.gz: d2f5c689bf6debe86f5b9be575eea7640e496606f8933b85a1d2e7a2cb90123c
 SHA512:
-  metadata.gz: 44d04ac1151fd4f7f2ac20b7f117e500b76be1d39fd2ad5ef72654dca8749bd9dd42eb9acd402adf519d2769d7099b8d44977ccf0a906089c10315675b22cad1
-  data.tar.gz: 93ff18fdf9856b60aec7f484bd468db70c67bd9e446e7fbedf383ff88f21f59fb261d0c53b7db1f46c0a8848f133fb032258ae7d57c968d485503abc248fb606
+  metadata.gz: df2acde7ab4aa4b01e3d5b187b6c47a911714c868237a1ba494095a43bdd07bac5082e2080d4aabc563576d502fecda0d28a94b9cef53db8e6c1e1c89a0cbc97
+  data.tar.gz: c183f6200f52b585a4ae391bd8b412c6a4f58e987fcc6ceb3cd1cf6835b92b1019f6077e4a13c75dbe6a4c0dd64c81fe7c4d8d3deeed2b8fbadc67ed74148cb5

data/app/helpers/spree/products_helper.rb

@@ -68,7 +68,7 @@ module Spree
     # @return [String] a cache invalidation key for products
     def cache_key_for_products
       count = @products.count
-      max_updated_at = (@products.maximum(:updated_at) || Date.today).to_s(:number)
+      max_updated_at = Spree::RailsCompatibility.to_fs((@products.maximum(:updated_at) || Date.today), :number)
       "#{I18n.locale}/#{current_pricing_options.cache_key}/spree/products/all-#{params[:page]}-#{max_updated_at}-#{count}"
     end
   end

data/app/models/concerns/spree/active_storage_adapter/attachment.rb

@@ -4,14 +4,16 @@ require 'mini_magick'
 
 module Spree
   module ActiveStorageAdapter
-    # Decorares AtiveStorage attachment to add methods exptected by Solidus'
+    # Decorates ActiveStorage attachment to add methods expected by Solidus'
     # Paperclip-oriented attachment support.
     class Attachment
       delegate_missing_to :@attachment
 
+      attr_reader :attachment
+
       def initialize(attachment, styles: {})
         @attachment = attachment
-        @styles = normalize_styles(styles)
+        @transformations = styles_to_transformations(styles)
       end
 
       def exists?
@@ -27,13 +29,13 @@ module Spree
       end
 
       def variant(style = nil)
-        size = style_to_size(style)
-        @attachment.variant(
-          resize_to_limit: size,
+        transformation = @transformations[style] || default_transformation(width, height)
+
+        @attachment.variant({
           saver: {
             strip: true
           }
-        ).processed
+        }.merge(transformation)).processed
       end
 
       def height
@@ -59,12 +61,23 @@ module Spree
         @attachment.metadata
       end
 
-      def normalize_styles(styles)
-        styles.transform_values { |v| v.split('x').map(&:to_i) }
+      def styles_to_transformations(styles)
+        styles.transform_values(&method(:imagemagick_to_image_processing_definition))
+      end
+
+      def imagemagick_to_image_processing_definition(definition)
+        width_height = definition.split('x').map(&:to_i)
+
+        case definition[-1].to_sym
+        when :^
+          { resize_to_fill: width_height }
+        else
+          default_transformation(*width_height)
+        end
       end
 
-      def style_to_size(style)
-        @styles.fetch(style&.to_sym) { [width, height] }
+      def default_transformation(width, height)
+        { resize_to_limit: [width, height] }
       end
     end
   end

data/app/models/concerns/spree/active_storage_adapter.rb

@@ -10,7 +10,7 @@ module Spree
     included do
       next if Rails.gem_version >= Gem::Version.new('6.1.0.alpha')
 
-      abort <<~MESSAGE
+      raise <<~MESSAGE
         Configuration Error: Solidus ActiveStorage attachment adpater requires Rails >= 6.1.0.
 
         Spree::Config.image_attachment_module preference is set to #{Spree::Config.image_attachment_module}

data/app/models/concerns/spree/default_price.rb

@@ -16,12 +16,10 @@ module Spree
 
     # Returns `#prices` prioritized for being considered as default price
     #
-    # @deprecated
     # @return [ActiveRecord::Relation<Spree::Price>]
     def currently_valid_prices
       prices.currently_valid
     end
-    deprecate :currently_valid_prices, deprecator: Spree::Deprecation
 
     # Returns {#default_price} or builds it from {Spree::Variant.default_price_attributes}
     #
@@ -35,7 +33,7 @@ module Spree
     # Select from {#prices} the one to be considered as the default
     #
     # This method works with the in-memory association, so non-persisted prices
-    # are taken into account.
+    # are taken into account. Discarded prices are also considered.
     #
     # A price is a candidate to be considered as the default when it meets
     # {Spree::Variant.default_price_attributes} criteria. When more than one candidate is
@@ -46,11 +44,37 @@ module Spree
     # @return [Spree::Price, nil]
     # @see Spree::Variant.default_price_attributes
     def default_price
-      price_selector.price_for_options(Spree::Config.default_pricing_options)
+      prioritized_default(
+        prices_meeting_criteria_to_be_default(
+          (prices + prices.with_discarded).uniq
+        )
+      )
     end
 
     def has_default_price?
       default_price.present? && !default_price.discarded?
     end
+
+    private
+
+    def prices_meeting_criteria_to_be_default(prices)
+      criteria = self.class.default_price_attributes.transform_keys(&:to_s)
+      prices.select do |price|
+        contender = price.attributes.slice(*criteria.keys)
+        criteria == contender
+      end
+    end
+
+    def prioritized_default(prices)
+      prices.min do |prev, succ|
+        contender_one, contender_two = [succ, prev].map do |item|
+          [
+            item.updated_at || Time.zone.now,
+            item.id || Float::INFINITY
+          ]
+        end
+        contender_one <=> contender_two
+      end
+    end
   end
 end

data/app/models/concerns/spree/user_address_book.rb

@@ -37,6 +37,9 @@ module Spree
 
       has_one :default_user_ship_address, ->{ default_shipping }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
       has_one :ship_address, through: :default_user_ship_address, source: :address
+
+      accepts_nested_attributes_for :ship_address
+      accepts_nested_attributes_for :bill_address
     end
 
     # saves address in address book
@@ -104,12 +107,19 @@ module Spree
       return new_address unless new_address.valid?
 
       first_one = user_addresses.empty?
+      user_address = prepare_user_address(new_address)
 
       if address_attributes[:id].present? && new_address.id != address_attributes[:id]
+        if ship_address&.id == address_attributes[:id].to_i
+          user_addresses.mark_default(user_address, address_type: :shipping)
+        end
+
+        if bill_address&.id == address_attributes[:id].to_i
+          user_addresses.mark_default(user_address, address_type: :billing)
+        end
         remove_from_address_book(address_attributes[:id])
       end
 
-      user_address = prepare_user_address(new_address)
       user_addresses.mark_default(user_address, address_type: address_type) if default || first_one
 
       if persisted?

data/app/models/spree/adjustment.rb

@@ -62,6 +62,7 @@ module Spree
                .distinct
       exclude_canceled ? result.merge(Spree::Order.not_canceled) : result
     end
+    deprecate :in_completed_orders, "Please don't use this and rather go through Spree::Promotion#discounted_orders"
 
     def finalize!
       update!(finalized: true)

data/app/models/spree/carton.rb

@@ -42,7 +42,7 @@ class Spree::Carton < Spree::Base
   end
 
   def display_shipped_at
-    shipped_at.to_s(:rfc822)
+    Spree::RailsCompatibility.to_fs(shipped_at, :rfc822)
   end
 
   def manifest

data/app/models/spree/option_value.rb

@@ -2,6 +2,8 @@
 
 module Spree
   class OptionValue < Spree::Base
+    # TODO: Remove optional on Solidus v4.0. Don't forget adding a migration to
+    # enforce at the database layer
     belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :option_values, optional: true
     acts_as_list scope: :option_type
 
@@ -13,7 +15,14 @@ module Spree
 
     after_save :touch, if: :saved_changes?
     after_touch :touch_all_variants
+    after_save do
+      Spree::Deprecation.warn <<~MSG if option_type.nil?
+        Having an option_value with no associated option_type will be deprecated
+        on Solidus v4.0
+      MSG
+    end
 
+    # TODO: Remove allow_nil once option_type is required on Solidus v4.0
     delegate :name, :presentation, to: :option_type, prefix: :option_type, allow_nil: true
 
     self.whitelisted_ransackable_attributes = %w[name presentation]

data/app/models/spree/order.rb

@@ -38,9 +38,21 @@ module Spree
     class CannotRebuildShipments < StandardError; end
 
     extend Spree::DisplayMoney
-    money_methods :outstanding_balance, :item_total, :adjustment_total,
-      :included_tax_total, :additional_tax_total, :tax_total,
-      :shipment_total, :total, :order_total_after_store_credit, :total_available_store_credit
+    money_methods(
+      :outstanding_balance,
+      :item_total,
+      :adjustment_total,
+      :included_tax_total,
+      :additional_tax_total,
+      :tax_total,
+      :shipment_total,
+      :total,
+      :order_total_after_store_credit,
+      :total_available_store_credit,
+      :item_total_before_tax,
+      :shipment_total_before_tax,
+      :item_total_excluding_vat
+    )
     alias :display_ship_total :display_shipment_total
 
     checkout_flow do
@@ -102,7 +114,7 @@ module Spree
     # Returns
     has_many :return_authorizations, dependent: :destroy, inverse_of: :order
     has_many :return_items, through: :inventory_units
-    has_many :customer_returns, through: :return_items
+    has_many :customer_returns, -> { distinct }, through: :return_items
     has_many :reimbursements, inverse_of: :order
     has_many :refunds, through: :payments
 
@@ -195,6 +207,10 @@ module Spree
       line_items.to_a.sum(&:total_before_tax)
     end
 
+    def shipment_total_before_tax
+      shipments.to_a.sum(&:total_before_tax)
+    end
+
     # Sum of all line item amounts pre-tax
     def item_total_excluding_vat
       line_items.to_a.sum(&:total_excluding_vat)
@@ -239,7 +255,7 @@ module Spree
         ship_address
       else
         bill_address
-      end || store.default_cart_tax_location
+      end || store&.default_cart_tax_location
     end
 
     def updater
@@ -379,25 +395,16 @@ module Spree
       Spree::CreditCard.where(id: credit_card_ids)
     end
 
-    # Finalizes an in progress order after checkout is complete.
-    # Called after transition to complete state when payments will have been processed
+    # TODO: Remove on Solidus 4.0
+    # @api private
     def finalize!
-      # lock all adjustments (coupon promotions, etc.)
-      all_adjustments.each(&:finalize!)
-
-      # update payment and shipment(s) states, and save
-      updater.update_payment_state
-      shipments.each do |shipment|
-        shipment.update_state
-        shipment.finalize!
-      end
-
-      updater.update_shipment_state
-      save!
-
-      touch :completed_at
-
-      Spree::Event.fire 'order_finalized', order: self
+      Spree::Deprecation.warn <<~MSG
+        Calling `Spree::Order#finalize!` is discouraged. Instead, use
+        `Spree::Order#complete!`, which goes through all the needed safety
+        checks before finalizing an order. This method will be removed
+        altogether on Solidus 4.0.
+      MSG
+      finalize
     end
 
     def fulfill!
@@ -495,7 +502,8 @@ module Spree
     end
 
     def create_shipments_for_line_item(line_item)
-      units = Spree::Stock::InventoryUnitBuilder.new(self).missing_units_for_line_item(line_item)
+      units = Spree::Config.stock.inventory_unit_builder_class.new(self).missing_units_for_line_item(line_item)
+
       Spree::Config.stock.coordinator_class.new(self, units).shipments.each do |shipment|
         shipments << shipment
       end
@@ -526,7 +534,7 @@ module Spree
         state: 'cart',
         updated_at: Time.current
       )
-      next! if !line_items.empty?
+      self.next
     end
 
     def refresh_shipment_rates
@@ -741,6 +749,27 @@ module Spree
       end
     end
 
+    # Finalizes an in progress order after checkout is complete.
+    # Called after transition to complete state when payments will have been processed
+    def finalize
+      # lock all adjustments (coupon promotions, etc.)
+      all_adjustments.each(&:finalize!)
+
+      # update payment and shipment(s) states, and save
+      updater.update_payment_state
+      shipments.each do |shipment|
+        shipment.update_state
+        shipment.finalize!
+      end
+
+      updater.update_shipment_state
+      save!
+
+      touch :completed_at
+
+      Spree::Bus.publish :order_finalized, order: self
+    end
+
     def associate_store
       self.store ||= Spree::Store.default
     end
@@ -761,9 +790,12 @@ module Spree
 
     def ensure_inventory_units
       if has_checkout_step?("delivery")
-        inventory_validator = Spree::Stock::InventoryValidator.new
+        inventory_validator = Spree::Config.stock.inventory_validator_class.new
+
+        errors = line_items.map { |line_item|
+          inventory_validator.validate(line_item)
+        }.compact
 
-        errors = line_items.map { |line_item| inventory_validator.validate(line_item) }.compact
         raise InsufficientStock if errors.any?
       end
     end
@@ -781,8 +813,15 @@ module Spree
     end
 
     def validate_line_item_availability
-      availability_validator = Spree::Stock::AvailabilityValidator.new
-      raise InsufficientStock unless line_items.all? { |line_item| availability_validator.validate(line_item) }
+      availability_validator = Spree::Config.stock.availability_validator_class.new
+
+      # NOTE: This code assumes that the availability validator will return
+      # true for success and false for failure. This is not normally the
+      # behaviour of validators, as the framework only cares about the
+      # population of the errors, not the return value of the validate method.
+      raise InsufficientStock unless line_items.all? { |line_item|
+        availability_validator.validate(line_item)
+      }
     end
 
     def ensure_line_items_present

data/app/models/spree/order_contents.rb

@@ -42,8 +42,8 @@ module Spree
           # If we do not update first, then the item total will be wrong and ItemTotal
           # promotion rules would not be triggered.
           reload_totals
-          PromotionHandler::Cart.new(order).activate
           order.ensure_updated_shipments
+          PromotionHandler::Cart.new(order).activate
         end
         reload_totals
         true
@@ -89,6 +89,7 @@ module Spree
       line_item ||= order.line_items.new(
         quantity: 0,
         variant: variant,
+        adjustments: [],
       )
 
       line_item.quantity += quantity.to_i

data/app/models/spree/order_inventory.rb

@@ -62,7 +62,7 @@ module Spree
       potential_shipments.detect do |shipment|
         shipment.include?(variant)
       end || potential_shipments.detect do |shipment|
-        stock_item = shipment.stock_location.stock_item(variant.id)
+        stock_item = variant.stock_items.detect { |stock_item| stock_item.stock_location == shipment.stock_location }
         if stock_item
           stock_item.backorderable? || stock_item.count_on_hand >= quantity
         end

data/app/models/spree/order_merger.rb

@@ -115,8 +115,8 @@ module Spree
         current_line_item.quantity += other_order_line_item.quantity
         handle_error(current_line_item) unless current_line_item.save
       else
-        order.line_items << other_order_line_item
-        handle_error(other_order_line_item) unless other_order_line_item.save
+        new_line_item = order.line_items.build(other_order_line_item.attributes.except("id"))
+        handle_error(new_line_item) unless new_line_item.save
       end
     end
 

data/app/models/spree/order_taxation.rb

@@ -17,13 +17,15 @@ module Spree
 
     # Apply taxes to the order.
     #
-    # This method will create or update adjustments on all line items and
-    # shipments in the order to reflect the appropriate taxes passed in. It
-    # will also remove any now inapplicable tax adjustments.
+    # This method will create or update adjustments on the order and all line
+    # items and shipments in the order to reflect the appropriate taxes passed
+    # in. It will also remove any now inapplicable tax adjustments.
     #
     # @param [Spree::Tax::OrderTax] taxes the taxes to apply to the order
     # @return [void]
     def apply(taxes)
+      update_adjustments(@order, taxes.order_taxes) if taxes.order_taxes
+
       @order.line_items.each do |item|
         taxed_items = taxes.line_item_taxes.select { |element| element.item_id == item.id }
         update_adjustments(item, taxed_items)
@@ -70,7 +72,7 @@ module Spree
 
       tax_adjustment ||= item.adjustments.new(
         source: tax_item.tax_rate,
-        order_id: item.order_id,
+        order_id: item.is_a?(Spree::Order) ? item.id : item.order_id,
         label: tax_item.label,
         included: tax_item.included_in_price
       )

data/app/models/spree/order_updater.rb

@@ -26,7 +26,7 @@ module Spree
           update_shipments
           update_shipment_state
         end
-        Spree::Event.fire 'order_recalculated', order: order
+        Spree::Bus.publish :order_recalculated, order: order
         persist_totals
       end
     end
@@ -157,10 +157,11 @@ module Spree
       recalculate_adjustments
 
       all_items = line_items + shipments
+      order_tax_adjustments = adjustments.select(&:eligible?).select(&:tax?)
 
       order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).sum(&:amount)
-      order.included_tax_total = all_items.sum(&:included_tax_total)
-      order.additional_tax_total = all_items.sum(&:additional_tax_total)
+      order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
 
       order.promo_total = all_items.sum(&:promo_total) + adjustments.select(&:eligible?).select(&:promotion?).sum(&:amount)
 

data/app/models/spree/payment_method.rb

@@ -13,6 +13,7 @@ module Spree
   #
   class PaymentMethod < Spree::Base
     include Spree::Preferences::Persistable
+    class UnsupportedPaymentMethod < StandardError; end
 
     preference :server, :string, default: 'test'
     preference :test_mode, :boolean, default: true
@@ -60,6 +61,16 @@ module Spree
       def model_name
         ModelName.new(self, Spree)
       end
+
+      def find_sti_class(type_name)
+        super(type_name)
+      rescue ActiveRecord::SubclassNotFound
+        raise UnsupportedPaymentMethod, "Found invalid payment type '#{type_name}'.\n"\
+          "This may happen after switching payment service provider, when payment methods "\
+          "reference old types that are not supported any more.\n"\
+          "If that is the case, consider running 'rake payment_method:deprecate_unsupported_payment_methods' "\
+          "to fix the issue."
+      end
     end
 
     # Represents the gateway of this payment method

data/app/models/spree/price.rb

@@ -55,7 +55,7 @@ module Spree
 
     def display_country
       if country_iso
-        "#{country_iso} (#{I18n.t(country_iso, scope: [:spree, :country_names])})"
+        "#{country_iso} (#{country.name})"
       else
         I18n.t(:any_country, scope: [:spree, :admin, :prices])
       end

data/app/models/spree/product/scopes.rb

@@ -194,13 +194,31 @@ module Spree
             group("spree_products.id").joins(:taxons).where(Spree::Taxon.arel_table[:name].eq(name))
           end
 
-          def self.with_variant_sku_cont(sku)
-            sku_match = "%#{sku}%"
+          def self.with_all_variant_sku_cont(sku)
+            variant_table = Spree::Variant.arel_table
+            subquery = Spree::Variant.with_discarded.where(
+              variant_table[:sku].matches("%#{sku}%").and(
+                variant_table[:product_id].eq(arel_table[:id])
+              )
+            )
+            where(subquery.arel.exists)
+          end
+
+          def self.with_kept_variant_sku_cont(sku)
             variant_table = Spree::Variant.arel_table
-            subquery = Spree::Variant.where(variant_table[:sku].matches(sku_match).and(variant_table[:product_id].eq(arel_table[:id])))
+            subquery = Spree::Variant.where(
+              variant_table[:sku].matches("%#{sku}%").and(
+                variant_table[:product_id].eq(arel_table[:id])
+              )
+            )
             where(subquery.arel.exists)
           end
 
+          def self.with_variant_sku_cont(sku)
+            Spree::Deprecation.warn("use .with_kept_variant_sku_cont instead")
+            with_kept_variant_sku_cont(sku)
+          end
+
           class << self
             private
 

data/app/models/spree/product.rb

@@ -135,7 +135,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name slug]
 
     def self.ransackable_scopes(_auth_object = nil)
-      %i(with_discarded with_variant_sku_cont)
+      %i(with_discarded with_variant_sku_cont with_all_variant_sku_cont with_kept_variant_sku_cont)
     end
 
     # @return [Boolean] true if there are any variants

data/app/models/spree/promotion/actions/create_adjustment.rb

@@ -15,6 +15,10 @@ module Spree
         before_destroy :remove_adjustments_from_incomplete_orders
         before_discard :remove_adjustments_from_incomplete_orders
 
+        def preload_relations
+          [:calculator]
+        end
+
         # Creates the adjustment related to a promotion for the order passed
         # through options hash
         #

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -15,6 +15,10 @@ module Spree
         before_destroy :remove_adjustments_from_incomplete_orders
         before_discard :remove_adjustments_from_incomplete_orders
 
+        def preload_relations
+          [:calculator]
+        end
+
         def perform(payload = {})
           order = payload[:order]
           promotion = payload[:promotion]
@@ -83,13 +87,8 @@ module Spree
         end
 
         def line_items_to_adjust(promotion, order)
-          excluded_ids = adjustments.
-            where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-            pluck(:adjustable_id).
-            to_set
-
           order.line_items.select do |line_item|
-            !excluded_ids.include?(line_item.id) &&
+            line_item.adjustments.none? { |adjustment| adjustment.source == self } &&
               promotion.line_item_actionable?(order, line_item)
           end
         end

data/app/models/spree/promotion/rules/product.rb

@@ -12,6 +12,10 @@ module Spree
                                            class_name: 'Spree::ProductPromotionRule'
         has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
 
+        def preload_relations
+          [:products]
+        end
+
         MATCH_POLICIES = %w(any all none)
 
         validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
@@ -31,17 +35,19 @@ module Spree
           return true if eligible_products.empty?
 
           case preferred_match_policy
-          when 'all'
-            unless eligible_products.all? { |product| order.products.include?(product) }
+          when "all"
+            unless eligible_products.all? { |product| order_products(order).include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
-          when 'any'
-            unless order.products.any? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
+          when "any"
+            unless order_products(order).any? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
+                                     error_code: :no_applicable_products)
             end
-          when 'none'
-            unless order.products.none? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
+          when "none"
+            unless order_products(order).none? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+                                     error_code: :has_excluded_product)
             end
           else
             raise "unexpected match policy: #{preferred_match_policy.inspect}"
@@ -68,6 +74,12 @@ module Spree
         def product_ids_string=(product_ids)
           self.product_ids = product_ids.to_s.split(',').map(&:strip)
         end
+
+        private
+
+        def order_products(order)
+          order.line_items.map(&:variant).map(&:product)
+        end
       end
     end
   end