spree_core 6.0.0.rc3 → 6.0.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59f0dc211ad34ae5b6985f353cf1a92237d937834cc2135ad93249ee8868aab1
-  data.tar.gz: 96e00c6df2bb8f8172c231e672403cd9d25cda61a5deef1413938a327cdce4f5
+  metadata.gz: 9e7960e9257c5de15c7d9e69d8916c669c5ab082fccd02e17c5ee9c9d9d378c8
+  data.tar.gz: 3c160cd58beb2d3fc3c99bead42bc0d3f365952ae7c2b2c103d92004303f7d13
 SHA512:
-  metadata.gz: f5000bd075a0d24d328b56f4fd5f691e9dbcd1a689f1285dcdbb4558e3c8328b3acc9a8ac44e70afff39000daa015722277e3751527c827f2146ec22c34482d4
-  data.tar.gz: 3282389785170a88dae97b1f95a51364056955ecb1d8d393e25c7f1c911d94e053681e35f1bf5e80bd4f3533fb8c0cb669e93d1d9ce898b199766970dffbeae7
+  metadata.gz: b396fb4c3d553e372dab904f57cb794015b4c2670028fea33c775fc343ac844db1d0d2733a9c47cfb2450898408ad4696ba312114719f7b3d1ad55716149f674
+  data.tar.gz: 89e9eb2e33742ec34f5c89e5e732544a868e4241ba5886cfa357e0ca43929107d895024ff6e936952c3648cf51ac379e7839ac2d211dc2515697d2ff52d8e7a7

data/app/mailers/spree/email_template_mailer.rb

@@ -11,11 +11,14 @@ module Spree
     # @param record_id [String, nil] the record to build sample data from
     # @param email_key [String, nil] for the layout or a partial, the email to show it in
     # @param branding [Hash] unsaved branding values
-    def test_email(store, recipient, key, locale: nil, subject: nil, body: nil, record_id: nil, email_key: nil, branding: {})
+    # @param mailer_logo_signed_id [String, nil] the signed id of an unsaved, uploaded email logo
+    # @param mailer_logo_cleared [Boolean] whether the email logo is sent as removed
+    def test_email(store, recipient, key, locale: nil, subject: nil, body: nil, record_id: nil, email_key: nil, branding: {},
+                   mailer_logo_signed_id: nil, mailer_logo_cleared: false)
       @current_store = store
       email = Spree::EmailTemplates::Preview.new(
         store: store, key: key, locale: locale, subject: subject, body: body, record_id: record_id, email_key: email_key,
-        branding: branding
+        branding: branding, mailer_logo_signed_id: mailer_logo_signed_id, mailer_logo_cleared: mailer_logo_cleared
       ).call
 
       mail(to: recipient, subject: I18n.t('spree.email_templates.test_email_subject', subject: email.subject)) do |format|

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

@@ -11,13 +11,14 @@ module Spree
       # Scope-friendly so controllers can chain it onto an already store-scoped
       # relation: `current_store.products.with_external_id('erp', 'MAT-100')`.
       # Scoping the lookup to the store is the caller's job, exactly as with any
-      # other id coming off a request.
+      # other id coming off a request. A subquery rather than a join, so a
+      # relation that also preloads `external_references` still loads every
+      # key, not only the matched one.
       scope :with_external_id, lambda { |system, external_id|
-        joins(:external_references).where(
-          spree_external_references: {
-            system: Spree::ExternalReference.normalize_system(system),
-            external_id: external_id.to_s.strip
-          }
+        where(
+          id: Spree::ExternalReference.for_system(system).
+            where(resource_type: polymorphic_name, external_id: external_id.to_s.strip).
+            select(:resource_id)
         )
       }
     end

data/app/models/concerns/spree/preference_schema/json_schema.rb

@@ -52,7 +52,14 @@ module Spree
         schema = value_schema(definition)
         choices = definition[:choices]
         choices = choices.call if choices.respond_to?(:call)
-        schema['enum'] = choices.map { |choice| choice.is_a?(Symbol) ? choice.to_s : choice } if choices.present?
+        if choices.present?
+          # `{ value => label }` names values that cannot label themselves — an
+          # endpoint URL is no i18n key, let alone something to show a merchant.
+          labels = choices.to_h { |value, label| [value.to_s, label.to_s] } if choices.is_a?(Hash)
+          values = choices.is_a?(Hash) ? choices.keys : Array(choices)
+          schema['enum'] = values.map { |choice| choice.is_a?(Symbol) ? choice.to_s : choice }
+          schema['x-spree-choice-labels'] = labels if labels
+        end
         default = definition[:dynamic_default] ? nil : wire_default(default, definition)
         unset_reads_null = default.nil? && !definition[:dynamic_default]
 

data/app/models/concerns/spree/purchase/addresses.rb

@@ -3,8 +3,8 @@ module Spree
     # The full address surface shared by Spree::Cart and Spree::Order:
     # the bill/ship associations and their public aliases, default filling
     # from the customer's saved addresses, address-row deduplication on
-    # write, ownership-guarded address_id assignment, promotion of checkout
-    # addresses to the customer's defaults, and the ship→bill cloning
+    # write, ownership-guarded address_id assignment and deletion, promotion
+    # of checkout addresses to the customer's defaults, and the ship→bill cloning
     # predicate. The shipping address is canonical: use_shipping copies it
     # onto the billing address; the reverse use_billing direction is a
     # deprecated 6.1-removal bridge. Clone callbacks are wired per model.
@@ -12,8 +12,13 @@ module Spree
       extend ActiveSupport::Concern
 
       included do
-        belongs_to :bill_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
-        belongs_to :ship_address, class_name: 'Spree::Address', optional: true, dependent: :destroy
+        belongs_to :bill_address, class_name: 'Spree::Address', optional: true
+        belongs_to :ship_address, class_name: 'Spree::Address', optional: true
+
+        # Stands in for `dependent: :destroy`, which would take any attached
+        # row down with the purchase. See {#owns_address?} for why only some
+        # of them may go.
+        after_destroy :destroy_own_addresses
 
         # The writers these generate are shadowed by the hand-written ones
         # below, which deduplicate address rows. The declarations still earn
@@ -40,9 +45,12 @@ module Spree
         before_validation :clone_shipping_address, if: :use_shipping?
       end
 
+      # Whether both addresses are present and match. With neither present
+      # there is nothing to call the same.
+      #
       # @return [Boolean]
       def shipping_eq_billing_address?
-        bill_address == ship_address
+        ship_address.present? && bill_address == ship_address
       end
 
       # Whether checkout must collect a customer shipping address. Selected
@@ -90,6 +98,68 @@ module Spree
         use_shipping.in?([true, 'true', '1'])
       end
 
+      # The address behind an id a client may select, or nil when the id names
+      # one this purchase has no business shipping to. Takes a prefixed id or a
+      # raw primary key, so the services that resolve a client-supplied id and
+      # the writers below share one rule rather than each inventing their own.
+      #
+      # Two books qualify. The buyer's own is the ordinary case. The company's
+      # is the B2B one: a purchase for a node ships to that node's sites, and
+      # to its ancestors' — the same self-and-ancestors chain the node's
+      # default address is prefilled from, so a division can pick the
+      # headquarters address it already inherits.
+      #
+      # @param id [Integer, String, nil]
+      # @return [Spree::Address, nil]
+      def selectable_address(id)
+        address = ::Spree::Address.not_deleted.find_by_param(id) || ::Spree::Address.not_deleted.find_by(id: id)
+        return if address.nil?
+
+        return address if customer_id.present? && address.customer_owned? && address.owner_id == customer_id
+
+        company = readable_company
+        return if company.nil? || address.owner_type != 'Spree::Company'
+
+        company.self_and_ancestors.any? { |node| node.id == address.owner_id } ? address : nil
+      end
+
+      # Everything a checkout address picker may offer for this purchase: the
+      # buyer's own book plus the book of the company it names, that node's
+      # own entries and the ones it inherits, limited to the countries the
+      # purchase's market sells to. A subset of what {#selectable_address}
+      # accepts, so a picker built from it never offers an address the
+      # checkout cannot deliver to.
+      #
+      # @return [ActiveRecord::Relation<Spree::Address>]
+      def selectable_addresses
+        books = []
+        books << ::Spree::Address.not_deleted.where(owner_type: ::Spree.customer_class.to_s, owner_id: customer_id) if customer_id.present?
+        books << readable_company&.address_book
+
+        addresses = books.compact.reduce { |left, right| left.or(right) } || ::Spree::Address.none
+        return addresses if market.nil?
+
+        addresses.where(country_code: market.market_countries.select(:country_code))
+      end
+
+      # Whether an attached address row is this purchase's own to delete.
+      #
+      # Only the ownerless rows are: the one a guest typed in, and the
+      # snapshot completion copies onto the order. Everything else is an entry
+      # in somebody's address book — the buyer's, a company node's, a seller's
+      # — which the purchase is merely pointing at. A cart may name a company
+      # site every other member ships from, so taking an attached row down
+      # with the cart would let one member empty the shared book.
+      #
+      # A business snapshot keeps its +owner_type+ to stay addressed to a
+      # company rather than to a person, so ownership is the id, not the type.
+      #
+      # @param address [Spree::Address, nil]
+      # @return [Boolean]
+      def owns_address?(address)
+        address.present? && address.owner_id.blank?
+      end
+
       # Fills any blank bill/ship address from the customer's valid saved
       # defaults. The ship address is skipped when no physical delivery is
       # required, so shipping-address validations never fire on digital-only
@@ -174,6 +244,26 @@ module Spree
 
       private
 
+      # The company whose book this purchase may read: only the one the
+      # client named, never one inferred from a sole membership. A cart asks
+      # again rather than trusting the column, which nothing clears when a
+      # membership is revoked; an order's authority is staff or a completed
+      # cart, so it keeps what it was given.
+      #
+      # @return [Spree::Company, nil]
+      def readable_company
+        return company if company.nil? || !is_a?(Spree::Cart)
+
+        company if customer&.standing_for?(company)
+      end
+
+      # Both slots often hold the same row, so destroy it once.
+      def destroy_own_addresses
+        [bill_address, ship_address].compact.uniq.each do |address|
+          address.destroy if owns_address?(address)
+        end
+      end
+
       def items_require_shipping_address?
         # Answered by the profile kind, resolved once per profile.
         profile_requires_address = Hash.new do |cache, profile|
@@ -187,33 +277,6 @@ module Spree
         end
       end
 
-      # The address behind an id a client may select, or nil when the id names
-      # one this purchase has no business shipping to.
-      #
-      # Two books qualify. The buyer's own is the ordinary case. The company's
-      # is the B2B one: a purchase for a node ships to that node's sites, and
-      # to its ancestors' — the same self-and-ancestors chain the node's
-      # default address is prefilled from, so a division can pick the
-      # headquarters address it already inherits.
-      #
-      # Standing is not re-checked here: a cart cannot name a company its
-      # customer lacks standing over, so reaching this point already means the
-      # buyer may act for the node.
-      #
-      # @param id [Integer, String, nil]
-      # @return [Spree::Address, nil]
-      def selectable_address(id)
-        address = ::Spree::Address.find_by(id: id)
-        return nil if address.nil?
-
-        return address if customer_id.present? && address.customer_owned? && address.owner_id == customer_id
-
-        company = resolved_company
-        return nil if company.nil? || address.owner_type != 'Spree::Company'
-
-        company.self_and_ancestors.any? { |node| node.id == address.owner_id } ? address : nil
-      end
-
       # Reuse never reaches past what the buyer already owns: a signed-in buyer
       # may name any entry of their own address book, and a guest — who keeps
       # no book — may only edit the row already in the slot being written.

data/app/models/concerns/spree/purchase/taxation.rb

@@ -28,6 +28,15 @@ module Spree
         market&.tax_provider_instance || Spree.default_tax_provider.new
       end
 
+      # Whether this sale's prices include tax, which its market decides. With
+      # no market yet (an empty cart before currency resolution) the store's
+      # default market answers.
+      #
+      # @return [Boolean]
+      def tax_inclusive?
+        (market || store&.default_market)&.tax_inclusive? || false
+      end
+
       # The typed inputs every +estimate+ call carries. Assembled here rather
       # than at each call site so a single-item re-estimate reaches the provider
       # with the same buyer registration and exemption evidence as a full
@@ -39,7 +48,8 @@ module Spree
         {
           tax_date: Time.current,
           tax_identifier: resolved_tax_identifier,
-          exemptions: usable_exemptions
+          exemptions: usable_exemptions,
+          tax_inclusive: tax_inclusive?
         }
       end
 
@@ -100,15 +110,30 @@ module Spree
         pre_tax_item_amount + fulfillments.sum(:pre_tax_amount)
       end
 
-      private
-
       # The resolver is swappable, so what it returns is host code. An entry
       # whose per-line overrides cannot name their line is not a narrower claim
       # but a wider one — the provider would read it as the whole order being
       # exempt — so it is dropped rather than trusted. Charging tax is the safe
       # direction: under-exempting surfaces as a customer query, over-exempting
       # is tax the merchant owes and never collected.
+      #
+      # Public because a provider filing the sale needs the same evidence core
+      # hands it as an +estimate+ argument: an external engine commits its
+      # document after placement, and resolving again there could file an
+      # exemption the estimate never applied.
+      #
+      # A placed order answers from its frozen snapshot for that reason, the way
+      # +resolved_tax_identifier+ does. Resolving live months later is not the
+      # same evidence: a certificate lapses on its own date with nothing written
+      # to it, can be revoked, and goes with its company when that is deleted —
+      # so a credit for an exempt sale would be filed as a consumer refund and
+      # declare tax the sale never collected. Orders placed before the snapshot
+      # existed have none, and still resolve live.
+      #
+      # @return [Array]
       def usable_exemptions
+        return frozen_tax_exemptions if frozen_tax_exemptions?
+
         resolved = Array(Spree.tax_resolve_exemptions_service.new.call(order: self).value)
 
         resolved.select do |exemption|
@@ -127,6 +152,22 @@ module Spree
         end
       end
 
+      private
+
+      # Carts always resolve live — a buyer's certificates legitimately change
+      # while they shop, and the cart is priced again each time.
+      #
+      # Only nil is an absent snapshot. An empty one records that the sale found
+      # no claim, and reading that as absent would let a certificate added later
+      # explain a sale it was never part of.
+      def frozen_tax_exemptions?
+        is_a?(Spree::Order) && completed? && !applied_tax_exemptions.nil?
+      end
+
+      def frozen_tax_exemptions
+        Array(applied_tax_exemptions).map { |snapshot| Spree::TaxExemption.from_snapshot(snapshot) }
+      end
+
       # Read through the legal entity, never the node — a division holds no
       # registrations of its own.
       def company_tax_identifier

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

@@ -12,6 +12,21 @@ module Spree
         const_get(:TRANSLATABLE_FIELDS)
       end
 
+      # The permission a caller needs in order to write this resource's
+      # translations.
+      #
+      # Declared rather than derived from the class name, because several
+      # resources are guarded by a permission that is not named after them:
+      # option types and values ride `write_products`, a policy rides
+      # `write_settings`. Deriving it produced names outside the permission
+      # catalog, which a credential could never hold and which the API
+      # therefore could not check at all.
+      #
+      # @return [String]
+      def translation_write_permission
+        "write_#{Spree::Base.polymorphic_api_type(name).pluralize}"
+      end
+
       # Maps a public API field name to the internal Mobility field, for a
       # model whose translatable column is named differently from the field the
       # API exposes. The public name is what the serializer and the translation
@@ -70,6 +85,40 @@ module Spree
       def arel_table_alias
         Arel::Table.new(translation_table_alias)
       end
+
+      # Sorts translated fields by the translation, or by the default-language
+      # value in the base column when the translation is missing or empty.
+      # Ransack sorts them by the translation alone, which leaves untranslated
+      # records unordered. On a DISTINCT relation the value is selected as
+      # well, because PostgreSQL rejects an ORDER BY the select list lacks.
+      #
+      # @return [ActiveRecord::Relation]
+      def with_translation_fallback_order
+        relation = all
+        return relation unless relation.order_values.any? { |node| translated_ordering?(node) }
+
+        relation = relation.select(arel_table[Arel.star]) if relation.distinct_value && relation.select_values.empty?
+        orders = relation.order_values.map do |node|
+          next node unless translated_ordering?(node)
+
+          value = Arel::Nodes::NamedFunction.new('COALESCE', [
+            Arel::Nodes::NamedFunction.new('NULLIF', [node.expr, Arel::Nodes.build_quoted('')]),
+            arel_table[node.expr.name]
+          ])
+          relation = relation.select(Arel::Nodes::As.new(value, Arel.sql('translated_sort'))) if relation.distinct_value
+          node.class.new(value)
+        end
+
+        relation.reorder(orders)
+      end
+
+      private
+
+      def translated_ordering?(node)
+        node.is_a?(Arel::Nodes::Ordering) &&
+          node.expr.is_a?(Mobility::Plugins::Arel::Attribute) &&
+          self <= node.expr.backend_class.model_class
+      end
     end
 
     def get_field_with_locale(locale, field_name, fallback: false)

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

@@ -32,6 +32,7 @@ module Spree
       reset_token
       unsubscribe_token
       verification_token
+      confirmation_token
       download_url
       external_client_secret
       client_secret

data/app/models/spree/ability.rb

@@ -167,6 +167,9 @@ module Spree
 
     # Reference data every staff member can read regardless of keys — address
     # forms need countries/states, and the dashboard shell reads the store.
+    # The back office also reads the store's markets and channels: its
+    # currencies and languages come from the markets, and list filters offer
+    # both.
     #
     # The store grant is unrestricted only for the store's own back office.
     # Another panel reads the one store it operates under and no other, so a
@@ -180,6 +183,11 @@ module Spree
       else
         can :read, Spree::Store, id: @store.id
       end
+
+      return unless store_resource?
+
+      can :read, Spree::Market, store_id: @resource.id
+      can :read, Spree::Channel, store_id: @resource.id
     end
 
   end

data/app/models/spree/address.rb

@@ -343,6 +343,12 @@ module Spree
     def snapshot
       dup.tap do |copy|
         copy.owner = nil
+
+        if business_owned?
+          copy.company = company.presence || owner&.name
+          copy.owner_type = owner_type
+        end
+
         copy.label = nil
         copy.deleted_at = nil
       end

data/app/models/spree/cart.rb

@@ -179,6 +179,7 @@ module Spree
 
       fulfillment_ids = fulfillments.map(&:id)
       DeliveryRate.where(fulfillment_id: fulfillment_ids).delete_all
+      Spree::ExternalReference.where(resource_type: Spree::Fulfillment.name, resource_id: fulfillment_ids).delete_all if fulfillment_ids.any?
       fulfillments.delete_all
       fulfillment_items.reset
       return fulfillments.reload unless can_propose_deliveries?
@@ -283,12 +284,9 @@ module Spree
     #
     # @return [ActiveRecord::Relation<Spree::Variant>]
     def orderable_variants
-      products = Spree.products_for_context_service.call(
-        store: store, channel: channel, customer: customer, company: resolved_company,
-        base: store.products.not_discontinued_on(channel)
-      ).value
-
-      Spree::Variant.for_products(products)
+      Spree::SalesContext.new(
+        store: store, channel: channel, customer: customer, company: resolved_company, resolve_company: false
+      ).orderable_variants
     end
 
     # Removes out-of-stock/discontinued items and populates warnings

data/app/models/spree/company.rb

@@ -245,7 +245,7 @@ module Spree
     #
     # @return [ActiveRecord::Relation]
     def address_book
-      Spree::Address.where(owner_type: 'Spree::Company', owner_id: self_and_ancestors.map(&:id))
+      Spree::Address.not_deleted.where(owner_type: 'Spree::Company', owner_id: self_and_ancestors.map(&:id))
     end
 
     private

data/app/models/spree/data_request.rb

@@ -20,9 +20,12 @@ module Spree
 
     publishes_lifecycle_events
     publishes_event :completed
+    publishes_event :confirmation_requested,
+                    serializer: 'Spree::Api::V3::DataRequestConfirmationRequestedEventSerializer',
+                    credential: 'write_customers'
 
     include Spree::HasStatus
-    has_status :pending, :processing, :completed, :failed, default: :pending
+    has_status :awaiting_confirmation, :pending, :processing, :completed, :failed, :lapsed, default: :pending
 
     ACCESS = 'access'.freeze
     ERASURE = 'erasure'.freeze
@@ -33,11 +36,23 @@ module Spree
     # about them is not left lying around.
     DEFAULT_EXPIRY = 7.days
 
+    # How long a request a customer raised waits for confirmation from its
+    # email address before it lapses.
+    CONFIRMATION_WINDOW = 24.hours
+
     # Addresses the finished export. Plaintext like the digital-link token:
     # the URL is the credential, it is only ever sent to the address that
     # asked, and it stops working when the request expires.
     has_secure_token :download_token
 
+    # Proves that whoever confirms reads mail at the address the request
+    # names. Bound to
+    # the download token, so an erasure, which clears it, voids every link
+    # already sent.
+    generates_token_for :confirmation do
+      download_token
+    end
+
     belongs_to :customer, class_name: Spree.customer_class.to_s
     # Null when the subject asked for it themselves; set when staff acted on a
     # request that arrived by email.
@@ -52,6 +67,8 @@ module Spree
     scope :access, -> { where(kind: ACCESS) }
     scope :erasure, -> { where(kind: ERASURE) }
     scope :in_progress, -> { with_status(:pending, :processing) }
+    scope :confirmable, -> { awaiting_confirmation.where(requested_at: CONFIRMATION_WINDOW.ago..) }
+    scope :past_confirmation_window, -> { awaiting_confirmation.where(requested_at: ...CONFIRMATION_WINDOW.ago) }
     scope :recent_first, -> { order(requested_at: :desc) }
 
     self.whitelisted_ransackable_attributes = %w[number kind status email requested_at completed_at]
@@ -89,6 +106,22 @@ module Spree
       expires_at.present? && expires_at.past?
     end
 
+    # Whether the request is still waiting for confirmation, within the window
+    # to receive it, and still names the account's address.
+    # @return [Boolean]
+    def confirmable?
+      awaiting_confirmation? && requested_at > CONFIRMATION_WINDOW.ago && addressed_to_customer?
+    end
+
+    # Whether the request names the address the account has now. The work
+    # matches guest rows by the account's address when it runs, so a request
+    # for an address the account has since left would reach rows it never
+    # named.
+    # @return [Boolean]
+    def addressed_to_customer?
+      customer.present? && email.to_s.casecmp?(customer.email.to_s)
+    end
+
     private
 
     def set_defaults

data/app/models/spree/delivery_rate.rb

@@ -41,7 +41,7 @@ module Spree
       return price if tax_rate.nil? || tax_amount.zero? || !tax_rate.show_rate_in_label
 
       I18n.t(
-        "spree.shipping_rates.display_price.#{tax_rate.included_in_price? ? :including_tax : :excluding_tax}",
+        "spree.shipping_rates.display_price.#{tax_inclusive? ? :including_tax : :excluding_tax}",
         price: price,
         tax_amount: display_tax_amount,
         tax_rate_name: tax_rate.name
@@ -79,7 +79,7 @@ module Spree
     def tax_amount
       @tax_amount ||= if tax_rate.nil?
                         BigDecimal(0)
-                      elsif tax_rate.included_in_price?
+                      elsif tax_inclusive?
                         Spree::Money::Rounding.to_currency(cost / (1 + tax_rate.amount) * tax_rate.amount, currency)
                       else
                         Spree::Money::Rounding.to_currency(cost * tax_rate.amount, currency)
@@ -90,14 +90,22 @@ module Spree
     #
     # @return [BigDecimal]
     def additional_tax_total
-      tax_rate&.included_in_price? ? BigDecimal(0) : tax_amount
+      tax_rate && tax_inclusive? ? BigDecimal(0) : tax_amount
     end
 
     # Returns the included tax total for the shipping rate
     #
     # @return [BigDecimal]
     def included_tax_total
-      tax_rate&.included_in_price? ? tax_amount : BigDecimal(0)
+      tax_rate && tax_inclusive? ? tax_amount : BigDecimal(0)
+    end
+
+    # Whether the cost already includes its tax, which the sale's market
+    # decides (Spree::Purchase::Taxation#tax_inclusive?).
+    #
+    # @return [Boolean]
+    def tax_inclusive?
+      fulfillment&.owner&.tax_inclusive? || false
     end
 
     alias tax_total tax_amount

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

@@ -6,7 +6,7 @@ module Spree
     # Stored as a string class name on DeliveryMethod and constantized at call
     # time; registered via Spree.delivery_rate_providers. The Estimator
     # dispatches here in place of calling the calculator directly, so
-    # filtering, VAT gross-up, tax resolution and sorting stay in one place
+    # filtering, markup, tax resolution and sorting stay in one place
     # for every provider.
     #
     # External providers resolve credentials through the delivery method's

data/app/models/spree/delivery_rate_provider/estimate.rb

@@ -2,10 +2,11 @@ module Spree
   module DeliveryRateProvider
     # A single quote returned by a delivery rate provider.
     #
-    # +cost+ is pre-tax and pre-VAT-gross-up: the Estimator applies
-    # +gross_amount+ and resolves the tax rate afterwards, exactly as it does
-    # for calculator output. Everything else is carrier metadata that flows
-    # onto the persisted DeliveryRate.
+    # +cost+ is the quoted price: the Estimator adds markup and resolves the
+    # tax rate afterwards, exactly as it does for calculator output, and the
+    # market decides whether that tax is inside the cost or added on top.
+    # Everything else is carrier metadata that flows onto the persisted
+    # DeliveryRate.
     class Estimate
       include ActiveModel::Model
       include ActiveModel::Attributes

data/app/models/spree/fulfillment.rb

@@ -5,6 +5,7 @@ module Spree
     include Spree::DerivedNumber
     derives_number infix: 'F'
     include Spree::HasCustomFields
+    include Spree::HasExternalReferences
     include Spree::Metadata
     include Spree::StorePreferences
     if defined?(Spree::Security::Shipments)

data/app/models/spree/gateway/bogus.rb

@@ -70,6 +70,13 @@ module Spree
       Spree::PaymentResponse.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: generate_authorization)
     end
 
+    # A made-up address, so the dashboard link can be tried without a provider.
+    def gateway_dashboard_payment_url(payment)
+      return if payment.transaction_id.blank?
+
+      "https://dashboard.bogus.example/payments/#{payment.transaction_id}"
+    end
+
     def test?
       # Test mode is not really relevant with bogus gateway (no such thing as live server)
       true

data/app/models/spree/line_item.rb

@@ -3,6 +3,7 @@ module Spree
     has_prefix_id :li  # Spree-specific: line item
 
     include Spree::HasCustomFields
+    include Spree::HasExternalReferences
     include Spree::Metadata
 
     publishes_lifecycle_events
@@ -157,12 +158,6 @@ module Spree
 
     # Assigns the current price without saving — the caller is expected to.
     # {#recalculate_price} persists instead.
-    #
-    # Restatement for a tax-inclusive market happens inside
-    # {Spree::Carts::PriceItems}: an address-less cart still has a taxing
-    # country (its market's own), and without it a cross-border cart is taxed
-    # for the destination at a price quoted for home, leaving the merchant to
-    # absorb the difference.
     # persist: false — runs mid-build and from callers that save the record
     # themselves.
     def update_price
@@ -180,8 +175,8 @@ module Spree
       price_record = Spree::PricingProvider::Internal.new.price_for(context)
       return if price_record.blank?
 
-      # Through the same writer every resolved price goes through, so the
-      # tax-inclusive restatement inputs are stated once.
+      # Through the same writer every resolved price goes through, so a line
+      # built here is priced exactly like a resolved one.
       Spree::Carts::PriceItems.apply([[self, price_record]], persist: false)
     end