spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/spree/payment/gateway_options.rb

@@ -10,40 +10,19 @@ module Spree
 
       attr_reader :payment, :order
       delegate :currency, to: :payment
-      delegate :email, to: :order
-
-      def statement_descriptor_suffix
-        order.number
-      end
-
-      def customer
-        order.email
-      end
-
-      def customer_id
-        order.customer_id
-      end
-
-      def ip
-        order.last_ip_address
-      end
-
-      # The payment number already names its order (`R1001-P1`), so this is
-      # the payment number alone rather than the two concatenated.
-      def order_id
-        payment.number
-      end
-
-      def payment_id
-        payment.number
-      end
-
+      delegate :email, :customer_id, to: :order
       # Stable handle for a gateway to find its own payment back. The derived
       # number cannot be queried (its column is NULL on 6.0 rows) and shifts
       # if an earlier sibling is destroyed — nothing durable may key on it.
-      def payment_prefixed_id
-        payment.prefixed_id
-      end
+      delegate :prefixed_id, to: :payment, prefix: true
+
+      def statement_descriptor_suffix = order.number
+      def customer = order.email
+      def ip = order.last_ip_address
+      # The payment number already names its order (`R1001-P1`), so this is
+      # the payment number alone rather than the two concatenated.
+      def order_id = payment.number
+      def payment_id = payment.number
 
       # Built on the prefixed ID, not the number: a derived number shifts if
       # an earlier sibling payment is destroyed, and a shifted idempotency
@@ -53,7 +32,7 @@ module Spree
       end
 
       def shipping
-        order.ship_total * exchange_multiplier
+        order.delivery_total * exchange_multiplier
       end
 
       def tax
@@ -77,35 +56,18 @@ module Spree
       end
 
       def hash_methods
-        [
-          :email,
-          :customer,
-          :customer_id,
-          :ip,
-          :order_id,
-          :payment_id,
-          :payment_prefixed_id,
-          :idempotency_key,
-          :shipping,
-          :tax,
-          :subtotal,
-          :discount,
-          :currency,
-          :billing_address,
-          :shipping_address
-        ]
+        %i[email customer customer_id ip order_id payment_id payment_prefixed_id idempotency_key shipping tax
+           subtotal discount currency billing_address shipping_address]
       end
 
       def to_hash
-        Hash[hash_methods.map do |method|
-          [method, send(method)]
-        end]
+        hash_methods.index_with { |method| send(method) }
       end
 
       private
 
       def exchange_multiplier
-        payment.payment_method.try(:exchange_multiplier) || 1.0
+        payment.payment_method.try(:exchange_multiplier) || 1
       end
     end
   end

data/app/models/spree/payment/processing.rb

@@ -1,5 +1,3 @@
-require_dependency 'spree/payment/gateway_options'
-
 module Spree
   class Payment < Spree.base_class
     # Gateway mechanics shared by the payments workflows and the payment
@@ -144,11 +142,11 @@ module Spree
         text = if error.is_a? Spree::PaymentResponse
                  error.params['message'] || error.params['response_reason_text'] || error.message
                elsif error.is_a? Spree::PaymentConnectionError
-                 Spree.t(:unable_to_connect_to_gateway)
+                 I18n.t('spree.unable_to_connect_to_gateway')
                else
                  error.to_s
                end
-        Rails.logger.error(Spree.t(:gateway_error))
+        Rails.logger.error(I18n.t('spree.gateway_error'))
         Rails.logger.error("  #{error.to_yaml}")
         raise Core::GatewayError, text
       end

data/app/models/spree/payment.rb

@@ -1,5 +1,3 @@
-require_dependency 'spree/payment/processing'
-
 module Spree
   class Payment < Spree.base_class
     has_prefix_id :py  # Stripe: py_
@@ -8,6 +6,9 @@ module Spree
     derives_number infix: 'P'
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :amount
     if defined?(Spree::Security::Payments)
       include Spree::Security::Payments
     end
@@ -18,6 +19,7 @@ module Spree
     include Spree::Payment::CustomEvents
 
     publishes_lifecycle_events
+    publishes_events :captured, :completed, :paid, :refunded, :voided
 
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
@@ -244,6 +246,9 @@ module Spree
       return amount if owner.nil?
 
       amount_from_order = owner.total - owner.payment_total
+      # A refund for returned goods settled what was owed for them; without
+      # this the order would accept a fresh charge for goods it took back.
+      amount_from_order -= owner.returned_items_refund_total if owner.respond_to?(:returned_items_refund_total)
 
       if payment_method&.store_credit?
         store_credits = owner.available_store_credits
@@ -253,14 +258,17 @@ module Spree
       end
     end
 
-    def amount=(amount)
-      self[:amount] =
-        case amount
-        when String
-          separator = I18n.t('number.currency.format.separator')
-          number    = amount.delete("^0-9-#{separator}\.").tr(separator, '.')
-          number.to_d if number.present?
-        end || amount
+    # Resizes a store credit payment that has not been taken yet. Completion
+    # takes it against the eligibility event recorded for its amount, so the
+    # new amount needs one of its own.
+    #
+    # @param new_amount [BigDecimal]
+    # @return [void]
+    def update_store_credit_amount!(new_amount)
+      return if amount == new_amount
+
+      update_column(:amount, new_amount)
+      create_eligible_credit_event
     end
 
     def offsets_total
@@ -502,7 +510,7 @@ module Spree
     end
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart, order_group].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart, order_group].compact.one?
     end
 
     def set_amount
@@ -532,8 +540,8 @@ module Spree
     end
 
     def add_source_error(field, message)
-      field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-      errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{message}")
+      field_name = source.class.human_attribute_name(field)
+      errors.add(source.class.model_name.human, "#{field_name} #{message}")
     end
 
 

data/app/models/spree/payment_method/check.rb

@@ -1,5 +1,7 @@
 module Spree
   class PaymentMethod::Check < ::Spree::PaymentMethod
+    self.accepts_money_amounts = true
+
     def actions
       %w{capture void}
     end

data/app/models/spree/payment_method/session_instrumentation.rb

@@ -16,6 +16,7 @@ module Spree
         create_payment_session
         update_payment_session
         complete_payment_session
+        cancel_payment_session
         create_payment_setup_session
         complete_payment_setup_session
       ].freeze

data/app/models/spree/payment_method/store_credit.rb

@@ -1,5 +1,7 @@
 module Spree
   class PaymentMethod::StoreCredit < ::Spree::PaymentMethod
+    self.accepts_money_amounts = true
+
     def payment_source_class
       ::Spree::StoreCredit
     end
@@ -20,13 +22,13 @@ module Spree
       payment.pending?
     end
 
-    def authorize(amount_in_cents, store_credit, gateway_options = {})
+    def authorize(money, store_credit, gateway_options = {})
       if store_credit.nil?
-        Spree::PaymentResponse.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+        Spree::PaymentResponse.new(false, I18n.t('spree.store_credit_payment_method.unable_to_find'), {}, {})
       else
         action = lambda do |store_credit|
           store_credit.authorize(
-            amount_in_cents / 100.0.to_d,
+            money.to_d,
             gateway_options[:currency],
             action_originator: gateway_options[:originator]
           )
@@ -35,10 +37,10 @@ module Spree
       end
     end
 
-    def capture(amount_in_cents, auth_code, gateway_options = {})
+    def capture(money, auth_code, gateway_options = {})
       action = lambda do |store_credit|
         store_credit.capture(
-          amount_in_cents / 100.0.to_d,
+          money.to_d,
           auth_code,
           gateway_options[:currency],
           action_originator: gateway_options[:originator]
@@ -47,9 +49,9 @@ module Spree
       handle_action(action, :capture, auth_code)
     end
 
-    def purchase(amount_in_cents, store_credit, gateway_options = {})
+    def purchase(money, store_credit, gateway_options = {})
       eligible_events = store_credit.store_credit_events.where(
-        amount: amount_in_cents / 100.0.to_d,
+        amount: money.to_d,
         action: Spree::StoreCredit::ELIGIBLE_ACTION
       )
       event = eligible_events.detect do |eligible_event|
@@ -58,9 +60,9 @@ module Spree
       end
 
       if event.blank?
-        Spree::PaymentResponse.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+        Spree::PaymentResponse.new(false, I18n.t('spree.store_credit_payment_method.unable_to_find'), {}, {})
       else
-        capture(amount_in_cents, event.authorization_code, gateway_options)
+        capture(money, event.authorization_code, gateway_options)
       end
     end
 
@@ -71,12 +73,12 @@ module Spree
       handle_action(action, :void, auth_code)
     end
 
-    def credit(amount_in_cents, auth_code, gateway_options)
+    def credit(money, auth_code, gateway_options)
       action = lambda do |store_credit|
         currency = gateway_options[:currency] || store_credit.currency
         originator = gateway_options[:originator]
 
-        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+        store_credit.credit(money.to_d, auth_code, currency, action_originator: originator)
       end
 
       handle_action(action, :credit, auth_code)
@@ -115,7 +117,7 @@ module Spree
           # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
           Spree::PaymentResponse.new(
             true,
-            Spree.t('store_credit_payment_method.successful_action', action: action_name),
+            I18n.t('spree.store_credit_payment_method.successful_action', action: action_name),
             {},
             authorization: auth_code || response
           )
@@ -132,7 +134,7 @@ module Spree
       if store_credit.nil?
         Spree::PaymentResponse.new(
           false,
-          Spree.t('store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
+          I18n.t('spree.store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
           {},
           {}
         )

data/app/models/spree/payment_method.rb

@@ -13,11 +13,20 @@ module Spree
     include Spree::StorePreferences
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::SecretPreferences
     include Spree::CaptureMethod
+    include Spree::ProviderListing
     if defined?(Spree::Security::PaymentMethods)
       include Spree::Security::PaymentMethods
     end
 
+    # Whether authorize, purchase, capture and credit take the amount as a
+    # Spree::Money (amount and currency) and convert it to the provider's own
+    # unit. Methods that have not opted in receive an integer in hundredths of
+    # the currency, which is wrong for yen and dinar; that bridge is removed in
+    # Spree 6.1.
+    class_attribute :accepts_money_amounts, default: false, instance_writer: false
+
     # Blank falls back to the store, so a method only overrides when a merchant
     # deliberately picks one — the meaning the auto_capture boolean already had.
     normalizes :capture_method, with: ->(value) { value.presence }
@@ -46,8 +55,9 @@ module Spree
     scope :storefront_visible, -> { where(storefront_visible: true) }
     scope :admin_only, -> { where(storefront_visible: false) }
 
-    # Real column, so admin clients filter it directly — no ransacker needed.
-    self.whitelisted_ransackable_attributes = %w[storefront_visible]
+    # Real columns, so admin clients filter them directly — no ransacker needed.
+    self.whitelisted_ransackable_attributes = %w[storefront_visible active type]
+    search_by :name
 
     after_initialize :set_name, if: :new_record?
 
@@ -57,7 +67,6 @@ module Spree
     validates :storefront_visible, inclusion: { in: [true, false] }
     normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
-    belongs_to :store, class_name: 'Spree::Store'
 
     has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method, dependent: :nullify
     has_many :credit_cards, class_name: 'Spree::CreditCard', dependent: :destroy # CCs are soft deleted
@@ -74,6 +83,20 @@ module Spree
     # `providers`; declaring it keeps subclass resolution to a single rule.
     registers_subclasses_via { providers }
 
+    # Whether this method is backed by an external payment provider (Stripe,
+    # Adyen…) rather than handled by the store itself (check, store credit).
+    # Only third-party methods are listed under Settings → Integrations.
+    #
+    # @return [Boolean]
+    def self.third_party?
+      false
+    end
+
+    # @return [Hash] the listing attributes, plus whether the method is third-party
+    def self.provider_listing
+      super.merge(third_party: third_party?)
+    end
+
     def provider_class
       raise ::NotImplementedError, 'You must implement provider_class method for this gateway.'
     end
@@ -136,6 +159,25 @@ module Spree
       raise ::NotImplementedError, 'You must implement complete_payment_session method for this gateway.'
     end
 
+    # Cancels a session nobody is going to complete, so the provider can no
+    # longer take money against it. Called for the sessions left pending when
+    # an order is placed. The default leaves the session untouched: a
+    # gateway that cannot cancel at the provider must not report as canceled
+    # a session that can still be paid.
+    #
+    # Raise Spree::Core::GatewayError only for a refusal, such as a session
+    # that was already paid. A timeout, a rate limit, an outage, or rejected
+    # credentials is raised as itself. Callers that treat those as a refusal
+    # leave a session the buyer can still pay.
+    #
+    # @param payment_session [Spree::PaymentSession]
+    # @return [Boolean] whether the session was canceled
+    # @raise [Spree::Core::GatewayError] when the provider refuses, e.g. the
+    #   session has already been paid
+    def cancel_payment_session(payment_session:)
+      false
+    end
+
     # Parses an incoming webhook payload from the payment provider.
     # Override in gateway subclasses to implement provider-specific webhook parsing.
     #
@@ -284,9 +326,7 @@ module Spree
     end
 
     def public_preferences
-      public_preference_keys.each_with_object({}) do |key, hash|
-        hash[key] = preferences[key]
-      end
+      public_preference_keys.index_with { |key| get_preference(key) }
     end
 
     # @deprecated Use {#storefront_visible?}; removed in 6.1.
@@ -307,6 +347,27 @@ module Spree
       self.storefront_visible = value.to_s != 'back_end'
     end
 
+
+    # The amount in the form this payment method's gateway calls take.
+    #
+    # @param amount [BigDecimal] in the currency's own units ("19.99")
+    # @param currency [String]
+    # @return [Spree::Money, Integer] a Spree::Money for methods that accept
+    #   money amounts, otherwise hundredths of the currency (deprecated)
+    def gateway_amount(amount, currency)
+      return Spree::Money.new(amount, currency: currency) if accepts_money_amounts
+
+      warn_about_hundredths
+      hundredths = Spree::Money::Rounding.to_hundredths(amount)
+      # A hundredth is the smallest amount these gateways can be sent; zero
+      # reads as "the whole amount" to many of them.
+      if hundredths.zero? && !amount.zero?
+        raise Spree::Core::GatewayError, "#{self.class.name} cannot take an amount below a hundredth of #{currency}"
+      end
+
+      hundredths
+    end
+
     protected
 
     def public_preference_keys
@@ -316,5 +377,16 @@ module Spree
     def set_name
       self.name ||= default_name
     end
+
+    def warn_about_hundredths
+      return if self.class.instance_variable_get(:@warned_about_hundredths)
+
+      self.class.instance_variable_set(:@warned_about_hundredths, true)
+      Spree::Deprecation.warn(
+        "#{self.class.name} receives amounts as an integer in hundredths, which is wrong for currencies " \
+        'without two decimals. Set `self.accepts_money_amounts = true` and take a Spree::Money ' \
+        '(amount and currency); hundredths are removed in Spree 6.1.'
+      )
+    end
   end
 end

data/app/models/spree/payment_session.rb

@@ -9,6 +9,7 @@ module Spree
     self.event_prefix = 'payment_session'
 
     publishes_lifecycle_events
+    publishes_events :canceled, :completed, :expired, :failed, :processing
 
     belongs_to :order, class_name: 'Spree::Order', optional: true
     belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :payment_sessions
@@ -28,6 +29,9 @@ module Spree
 
     scope :not_expired, -> { where('expires_at IS NULL OR expires_at > ?', Time.current) }
     scope :active, -> { not_expired.where(status: %w[pending processing]) }
+    # A declined confirm marks the session failed while its intent can still
+    # be paid, so placement has to cancel those too.
+    scope :unused, -> { where(status: %w[pending failed]).where.missing(:payment) }
 
     before_validation :set_defaults_from_order, on: :create
 
@@ -195,7 +199,7 @@ module Spree
     end
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
 
     def publish_processing_event

data/app/models/spree/payment_setup_session.rb

@@ -9,6 +9,7 @@ module Spree
     self.event_prefix = 'payment_setup_session'
 
     publishes_lifecycle_events
+    publishes_events :canceled, :completed, :expired, :failed, :processing
 
     belongs_to :customer, class_name: Spree.customer_class.to_s, optional: true
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'

data/app/models/spree/payout_provider/base.rb

@@ -22,6 +22,8 @@ module Spree
     # delivery-rate providers are; anything request-specific arrives as an
     # argument.
     class Base
+      extend Spree::ApiTyped
+
       # The name a merchant sees when choosing how sellers are paid.
       #
       # @return [String]
@@ -57,7 +59,7 @@ module Spree
       # @return [Hash]
       def self.to_api_hash(store)
         {
-          id: name,
+          id: api_type,
           name: display_name,
           available: available_for_store?(store),
           requires_payout_account: requires_payout_account?,

data/app/models/spree/pickup_point_provider/base.rb

@@ -10,6 +10,8 @@ module Spree
     # integrations) and +find_nearby+ gains +zipcode:+/+query:+ params.
     # Build third-party providers against 6.1, not this shape.
     class Base
+      extend Spree::ApiTyped
+
       # @return [Array<Spree::PickupPointOption>]
       def find_nearby(latitude:, longitude:, limit: 20)
         raise NotImplementedError, "Please implement 'find_nearby' in your pickup point provider: #{self.class.name}"

data/app/models/spree/policy.rb

@@ -62,6 +62,7 @@ module Spree
     #  Ransack
     #
     self.whitelisted_ransackable_attributes = %w[name owner_type owner_id]
+    search_by :name
 
     before_destroy :really_destroy_slugs!
 

data/app/models/spree/price.rb

@@ -11,12 +11,16 @@ module Spree
 
     include Spree::VatPriceCalculation
     include Spree::StorePreferences
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :amount, :compare_at_amount, places: Spree::Money::Rounding::UNIT_PRICE_DECIMALS
 
     publishes_lifecycle_events
 
     acts_as_paranoid
 
-    MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
+    # The largest amount decimal(19,4) holds.
+    MAXIMUM_AMOUNT = BigDecimal('999_999_999_999_999.9999')
 
     # How many breaks one variant may carry on one list in one currency. A UI
     # sanity bound rather than a technical one — but enforced here so no
@@ -24,7 +28,7 @@ module Spree
     # every priced line (docs/plans/6.0-volume-pricing.md).
     MAXIMUM_BREAKS_PER_VARIANT = 10
 
-    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :prices
     belongs_to :price_list, class_name: 'Spree::PriceList', optional: true
 
     has_many :price_histories, class_name: 'Spree::PriceHistory', dependent: :delete_all
@@ -32,6 +36,8 @@ module Spree
     before_validation :ensure_currency
     before_save :remove_compare_at_amount_if_equals_amount
     after_save :record_price_history, if: :should_record_price_history?
+    after_save :touch_variant, if: -> { saved_changes? && (amount.present? || amount_before_last_save.present?) }
+    after_destroy :touch_variant, if: -> { amount.present? }
 
     # legacy behavior
     validates :amount, allow_nil: true, numericality: {
@@ -100,10 +106,6 @@ module Spree
       Spree::Money.new(amount || 0, currency: currency.upcase)
     end
 
-    def amount=(amount)
-      self[:amount] = amount.blank? ? nil : Spree::LocalizedNumber.parse(amount)
-    end
-
     # Returns the amount in cents
     # @return [Integer]
     def amount_in_cents
@@ -114,12 +116,6 @@ module Spree
       Spree::Money.new(compare_at_amount || 0, currency: currency)
     end
 
-    def compare_at_amount=(value)
-      calculated_value = Spree::LocalizedNumber.parse(value) if value.present?
-
-      self[:compare_at_amount] = calculated_value
-    end
-
     # Returns the compare at amount for display
     # @return [Spree::Money, nil]
     def display_compare_at_amount
@@ -137,9 +133,7 @@ module Spree
     end
 
     alias_attribute :price, :amount
-    alias_method :price=, :amount=
     alias_attribute :compare_at_price, :compare_at_amount
-    alias_method :compare_at_price=, :compare_at_amount=
 
     # Whether this figure is the merchant's answer for the buyer's geography
     # already. A price list narrowed by market or country states its prices for
@@ -342,6 +336,15 @@ module Spree
       rungs.sort_by(&:first)
     end
 
+    # Stands in for `touch: true` on the variant, skipping placeholder rows: a
+    # price list holds one without an amount for every variant and currency
+    # nobody has priced yet, and it charges nothing, so writing one changes no
+    # price a shopper sees — yet the touch would expire the product's cached
+    # responses and reindex it for search.
+    def touch_variant
+      variant&.touch_later
+    end
+
     def should_record_price_history?
       price_list_id.nil? &&
         amount.present? &&

data/app/models/spree/price_adjustment_tier.rb

@@ -10,6 +10,10 @@ module Spree
   # and not twenty percent off an already-discounted number
   # (docs/plans/6.0-volume-pricing.md).
   class PriceAdjustmentTier < Spree.base_class
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :percentage, places: 3
+
     has_prefix_id :pat
 
     # How many bands one list may carry, matching the break cap so a merchant