spree_core 6.0.0.rc2 → 6.0.0.rc4

data/app/models/spree/price.rb

@@ -9,7 +9,6 @@ module Spree
 
     has_prefix_id :price
 
-    include Spree::VatPriceCalculation
     include Spree::StorePreferences
     include Spree::CanonicalDecimals
 
@@ -135,44 +134,28 @@ module Spree
     alias_attribute :price, :amount
     alias_attribute :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
-    # that geography, so they are charged exactly as entered — restating one would
-    # net it out with the *home* rate and destroy the price point the merchant
-    # chose. Lists narrowed by anything else (a quantity, a group) were not set
-    # for a country, so their prices restate like any other.
-    #
-    # @return [Boolean]
-    def final_for_destination?
-      rules = price_list&.price_rules.to_a
-      return false unless rules.any?(&:geographic?)
-
-      # Under 'any' the list can win on a non-geographic rule alone, so a
-      # geographic rule being present does not mean this buyer's geography is why
-      # the price applied. Under 'all' every rule matched, so it does.
-      price_list.match_policy == 'all' || rules.all?(&:geographic?)
-    end
-
-    def price_including_vat_for(price_options)
-      return price if final_for_destination?
-
-      options = price_options.merge(tax_category: variant.tax_category)
-      gross_amount(price, options)
+    # @deprecated Prices are charged as entered for every buyer since 6.0. Use {#price}; removed in 6.1.
+    def price_including_vat_for(_price_options = {})
+      Spree::Deprecation.warn('Spree::Price#price_including_vat_for is deprecated and will be removed in Spree 6.1. Prices are charged as entered; use #price instead.')
+      price
     end
 
-    def compare_at_price_including_vat_for(price_options)
-      return compare_at_price if final_for_destination?
-
-      options = price_options.merge(tax_category: variant.tax_category)
-      gross_amount(compare_at_price, options)
+    # @deprecated Use {#compare_at_price}; removed in 6.1.
+    def compare_at_price_including_vat_for(_price_options = {})
+      Spree::Deprecation.warn('Spree::Price#compare_at_price_including_vat_for is deprecated and will be removed in Spree 6.1. Prices are charged as entered; use #compare_at_price instead.')
+      compare_at_price
     end
 
-    def display_price_including_vat_for(price_options)
-      Spree::Money.new(price_including_vat_for(price_options), currency: currency)
+    # @deprecated Use {#display_price}; removed in 6.1.
+    def display_price_including_vat_for(_price_options = {})
+      Spree::Deprecation.warn('Spree::Price#display_price_including_vat_for is deprecated and will be removed in Spree 6.1. Prices are charged as entered; use #display_price instead.')
+      display_price
     end
 
-    def display_compare_at_price_including_vat_for(price_options)
-      Spree::Money.new(compare_at_price_including_vat_for(price_options), currency: currency)
+    # @deprecated Use {#display_compare_at_price}; removed in 6.1.
+    def display_compare_at_price_including_vat_for(_price_options = {})
+      Spree::Deprecation.warn('Spree::Price#display_compare_at_price_including_vat_for is deprecated and will be removed in Spree 6.1. Prices are charged as entered; use #display_compare_at_price instead.')
+      display_compare_at_price
     end
 
     # returns the name of the price in a format of variant name and currency

data/app/models/spree/price_rule.rb

@@ -16,18 +16,6 @@ module Spree
       raise NotImplementedError, "#{self.class.name} must implement #applicable?"
     end
 
-    # Whether this rule narrows its price list by geography. A list carrying one
-    # states the price for that geography outright, so its prices are charged as
-    # entered and never restated for the buyer's VAT rate
-    # (Spree::VatPriceCalculation). A rule that narrows by anything else — a
-    # quantity, a group, a channel — leaves its prices open to restatement, since
-    # they were not set for a country.
-    #
-    # @return [Boolean]
-    def geographic?
-      false
-    end
-
     # Whether this rule narrows by something about the purchase rather than
     # about the buyer. A catalog-owned price list has already been matched on
     # audience by the time the resolver holds it — the catalog assignment is
@@ -45,10 +33,9 @@ module Spree
       false
     end
 
-    # Instance-side reader, so rules are classified the same way
-    # `geographic?` classifies them (`rules.any?(&:geographic?)`). A kind
-    # whose answer depends on how it is configured overrides this, exactly
-    # as MarketRule does for `geographic?`.
+    # Instance-side reader, so rules can be classified per row
+    # (`price_rules.select(&:contextual?)`). A kind whose answer depends on how it is
+    # configured overrides this.
     #
     # @return [Boolean]
     def contextual?

data/app/models/spree/price_rules/market_rule.rb

@@ -23,12 +23,6 @@ module Spree
         preferred_market_ids.map(&:to_s).include?(context.market.id.to_s)
       end
 
-      # An empty market list matches every buyer (see #applicable?), so it names
-      # no geography — and that is the state a freshly created rule row is in.
-      def geographic?
-        preferred_market_ids.present?
-      end
-
       def self.description
         'Apply pricing based on the market'
       end

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

@@ -6,7 +6,7 @@ module Spree
     # A provider returns a {Spree::Price}: {Internal} returns the persisted
     # catalog row, an external provider an **unsaved, readonly** instance. The
     # Active Record shape is deliberately the contract, so everything
-    # downstream — tax-inclusive restatement, +discounted?+, the serializers —
+    # downstream — the line item, +discounted?+, the serializers —
     # keeps working without knowing where the number came from. +readonly!+ is
     # what stops an external answer being written back into the catalog.
     #

data/app/models/spree/product.rb

@@ -887,7 +887,7 @@ module Spree
         next unless variant.should_track_inventory?
         next if variant.sku.blank? && variant != default_variant
 
-        variant.stock_levels.each do |stock_level|
+        variant.stock_levels.sort_by(&:id).each do |stock_level|
           location = stock_level.stock_location
           next if location.nil? || location == default_stock_location
           next unless location.store_id == store.id && location_owner_ids.include?(location.seller_id)

data/app/models/spree/purchase_order_item.rb

@@ -11,7 +11,7 @@ module Spree
     belongs_to :purchase_order, class_name: 'Spree::PurchaseOrder', inverse_of: :items, touch: true
 
     validates :quantity_ordered, numericality: { greater_than: 0, only_integer: true }
-    validates :unit_cost, numericality: { greater_than_or_equal_to: 0 }
+    validates :unit_cost, presence: true, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
     validates :variant_id, uniqueness: { scope: :purchase_order_id }
 
     delegate :currency, to: :purchase_order, allow_nil: true

data/app/models/spree/return.rb

@@ -19,6 +19,7 @@ module Spree
     include Spree::SingleStoreResource
     include Spree::HasStatus
     include Spree::HasCustomFields
+    include Spree::HasExternalReferences
     include Spree::Metadata
     include Spree::PostSale::Taxation
 

data/app/models/spree/search_provider/database.rb

@@ -135,7 +135,7 @@ module Spree
             end
           }.join(',')
 
-          scope.ransack({ s: ransack_sort }, auth_object: @audience).result
+          scope.ransack({ s: ransack_sort }, auth_object: @audience).result.with_translation_fallback_order
         end
       end
 

data/app/models/spree/stock/estimator.rb

@@ -1,8 +1,6 @@
 module Spree
   module Stock
     class Estimator
-      include Spree::VatPriceCalculation
-
       attr_reader :order, :currency
 
       def initialize(order)
@@ -69,7 +67,7 @@ module Spree
       # through the calculator, carrier providers call their API and may
       # return several estimates (one per carrier service). An empty result
       # suppresses the method, matching the calculator contract. Service
-      # filtering, markup, naming, VAT gross-up, tax resolution and sorting
+      # filtering, markup, naming, tax resolution and sorting
       # stay here so every provider gets them identically.
       def calculate_delivery_rates(package, audience)
         delivery_methods(package, audience).flat_map do |delivery_method|
@@ -103,14 +101,12 @@ module Spree
       end
 
       # An unpriced quote has no amount to mark up or tax — a percentage of an
-      # unknown price is still unknown, and rounding zero through the VAT
-      # gross-up would only invent a number. Its cost stays zero and every
-      # display surface reads +unpriced+ instead.
+      # unknown price is still unknown. Its cost stays zero and every display
+      # surface reads +unpriced+ instead.
       def rate_cost(estimate, delivery_method, service_row, provider)
         return 0 if estimate.unpriced
 
-        cost = apply_markup(estimate.cost, delivery_method, service_row, provider)
-        gross_amount(cost, taxation_options_for(delivery_method))
+        apply_markup(estimate.cost, delivery_method, service_row, provider)
       end
 
       # Handling fee on top of provider quotes: the service row's values when
@@ -132,18 +128,6 @@ module Spree
           [estimate.carrier, estimate.service_level].compact.join(' ').presence
       end
 
-      # Override this if you need the prices for delivery methods to be handled just like the
-      # prices for products in terms of included tax manipulation.
-      #
-      def taxation_options_for(delivery_method)
-        {
-          tax_category: delivery_method.tax_category,
-          address: @order.tax_address,
-          country: @order.tax_country,
-          market: @order.market
-        }
-      end
-
       def first_tax_rate_for(tax_category)
         return unless @order.tax_address && tax_category
 

data/app/models/spree/store.rb

@@ -8,6 +8,12 @@ module Spree
 
     include FriendlyId
     include Spree::TranslatableResource
+
+    # The store itself is settings — see Admin::StoreController.
+    def self.translation_write_permission
+      'write_settings'
+    end
+
     include Spree::HasCustomFields
     include Spree::Metadata
     include Spree::Stores::Setup
@@ -209,6 +215,7 @@ module Spree
     has_many :claim_reasons, class_name: 'Spree::ClaimReason', inverse_of: :store, dependent: :destroy
     has_many :refund_reasons, class_name: 'Spree::RefundReason', inverse_of: :store, dependent: :destroy
     has_many :order_cancellation_reasons, class_name: 'Spree::OrderCancellationReason', inverse_of: :store, dependent: :destroy
+    has_many :tax_exemption_reasons, class_name: 'Spree::TaxExemptionReason', inverse_of: :store, dependent: :destroy
 
     # :nullify (not :destroy) — clearing the collection must not cascade into
     # Promotion#not_used? / payment records; orphaned rows are detached, not deleted.
@@ -339,6 +346,7 @@ module Spree
     has_many :catalogs, class_name: 'Spree::Catalog', dependent: :destroy, inverse_of: :store
 
     has_many :api_keys, class_name: 'Spree::ApiKey', dependent: :destroy
+    has_many :oauth_applications, class_name: 'Spree::OauthApplication', dependent: :destroy
     has_many :allowed_origins, class_name: 'Spree::AllowedOrigin', dependent: :destroy
 
     #

data/app/models/spree/tax_exemption/item_override.rb

@@ -17,6 +17,20 @@ module Spree
       def exempt?
         exempt
       end
+
+      # @return [Hash]
+      def to_snapshot
+        attributes
+      end
+
+      # Unknown keys are dropped rather than raising: a snapshot is read back
+      # long after it was written, possibly by a different version of Spree.
+      #
+      # @param snapshot [Hash]
+      # @return [Spree::TaxExemption::ItemOverride]
+      def self.from_snapshot(snapshot)
+        new(snapshot.to_h.stringify_keys.slice(*attribute_names).symbolize_keys)
+      end
     end
   end
 end

data/app/models/spree/tax_exemption.rb

@@ -14,6 +14,9 @@ module Spree
     # Why the sale is exempt, in the provider's vocabulary — Avalara's
     # entityUseCode territory.
     attribute :reason_code, :string
+    # The merchant's wording for the reason, kept with the claim so a placed
+    # order still reads the way it did when it was taxed.
+    attribute :reason_name, :string
     attribute :certificate_number, :string
 
     # Where the claim holds. Nil country = everywhere the provider taxes,
@@ -62,6 +65,29 @@ module Spree
       override_for(item)&.reason_code.presence || reason_code
     end
 
+    # The claim as plain data, for freezing onto a placed order. Certificates
+    # lapse, get revoked and are edited, so a provider filing or crediting that
+    # sale later has to read the evidence the sale was priced with rather than
+    # whatever resolves on the day.
+    #
+    # @return [Hash]
+    def to_snapshot
+      attributes.except('item_overrides').
+        merge('item_overrides' => Array(item_overrides).map(&:to_snapshot))
+    end
+
+    # Unknown keys are dropped rather than raising: a snapshot is read back long
+    # after it was written, possibly by a different version of Spree.
+    #
+    # @param snapshot [Hash]
+    # @return [Spree::TaxExemption]
+    def self.from_snapshot(snapshot)
+      snapshot = snapshot.to_h.stringify_keys
+      overrides = Array(snapshot['item_overrides']).map { |override| ItemOverride.from_snapshot(override) }
+
+      new(snapshot.slice(*attribute_names).symbolize_keys.merge(item_overrides: overrides))
+    end
+
     private
 
     # An override that cannot say which line it applies to does not narrow this

data/app/models/spree/tax_exemption_certificate.rb

@@ -22,6 +22,7 @@ module Spree
     has_status :pending, :verified, :expired, :revoked, default: :pending
 
     belongs_to :company, class_name: 'Spree::Company', inverse_of: :tax_exemption_certificates
+    belongs_to :tax_exemption_reason, class_name: 'Spree::TaxExemptionReason', inverse_of: :tax_exemption_certificates
     belongs_to :verified_by, class_name: Spree.admin_user_class.to_s, optional: true
 
     # Confidential, so the private service rather than the public one that
@@ -29,12 +30,15 @@ module Spree
     has_one_attached :document, service: Spree.private_storage_service_name
     signed_id_attachments :document
 
-    validates :certificate_number, :reason_code, presence: true
+    validates :certificate_number, presence: true
     # Certificates exist only on legal-entity nodes — a division's purchases
     # read exemption through its legal entity. A validation rather than a
     # schema difference, so a per-division registration can be allowed later
     # by relaxing this alone.
     validate :company_is_legal_entity
+    # Checked when the reason is set, not on every save: a reason the merchant
+    # retires later leaves the certificates that already record it valid.
+    validate :reason_offered_by_store, if: :will_save_change_to_tax_exemption_reason_id?
 
     # A certificate is a scanned form, not an archive. Bounded because the
     # download action reads the whole blob into memory to serve it, so an
@@ -64,7 +68,7 @@ module Spree
         where(state_code: [address.state_code.presence, nil].uniq)
     }
 
-    self.whitelisted_ransackable_attributes = %w[certificate_number reason_code status expires_at]
+    self.whitelisted_ransackable_attributes = %w[certificate_number tax_exemption_reason_id status expires_at]
 
     delegate :store, :store_id, to: :company
 
@@ -94,5 +98,12 @@ module Spree
 
       errors.add(:company, :must_be_legal_entity)
     end
+
+    def reason_offered_by_store
+      return if tax_exemption_reason.nil? || company.nil?
+      return if tax_exemption_reason.active? && tax_exemption_reason.store_id == store_id
+
+      errors.add(:tax_exemption_reason, :not_offered)
+    end
   end
 end

data/app/models/spree/tax_exemption_reason.rb

@@ -0,0 +1,62 @@
+module Spree
+  # Why a business buys without tax — "Resale", "Government", "Charitable
+  # organisation". Certificates point at a reason the way products point at a
+  # tax category: the `name` is the merchant's own wording, and the `code` is
+  # what a tax engine reads. Spree's own engine only keeps the code for
+  # reference, while an external one (Avalara's entity use codes) decides the
+  # exemption by it, so changing the code changes what every certificate
+  # holding the reason sends from then on.
+  class TaxExemptionReason < Spree.base_class
+    has_prefix_id :txr
+
+    include Spree::NamedType
+    include Spree::Metadata
+
+    # Guarded by hand rather than with :restrict_with_error, which would also
+    # refuse when the whole store is being destroyed.
+    has_many :tax_exemption_certificates, class_name: 'Spree::TaxExemptionCertificate',
+                                          inverse_of: :tax_exemption_reason, dependent: nil
+
+    self.whitelisted_ransackable_attributes = %w[name code active]
+
+    # Upper case because tax engines read codes case-insensitively: `g` and
+    # `G` would be two reasons here and one to Avalara.
+    normalizes :code, with: ->(value) { value.to_s.strip.upcase.presence }
+
+    validates :code, presence: true, length: { maximum: 64 }
+    validates_store_uniqueness :code
+
+    before_destroy :ensure_unused
+
+    # Finds the reason already holding the code, else the one holding the
+    # name, so seeding a store never collides with a reason the merchant added
+    # or renamed. Code first: it is what a tax engine reads, so a match on it
+    # is the same reason whatever the merchant called it.
+    #
+    # @param code [String]
+    # @param name [String]
+    # @return [Spree::TaxExemptionReason]
+    def self.find_or_create_by_code_or_name!(code:, name:)
+      code = normalize_value_for(:code, code)
+
+      find_by(code: code) || find_by(name: name) || create!(code: code, name: name)
+    end
+
+    # Mirrors the destroy guard, so the dashboard can hide the delete control
+    # rather than offer one the model will refuse.
+    #
+    # @return [Boolean]
+    def can_be_deleted?
+      !tax_exemption_certificates.exists?
+    end
+
+    private
+
+    def ensure_unused
+      return if destroyed_by_association.present? || can_be_deleted?
+
+      errors.add(:base, :in_use)
+      throw :abort
+    end
+  end
+end

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

@@ -41,6 +41,16 @@ module Spree
         name.demodulize.titleize
       end
 
+      # The exemption reason codes this engine understands, `{ code => label }`,
+      # offered to a merchant adding a {Spree::TaxExemptionReason}. Nil for an
+      # engine that does not read the code, Spree's own included: any code a
+      # merchant chooses is then as good as another.
+      #
+      # @return [Hash{String => String}, nil]
+      def self.exemption_reason_codes
+        nil
+      end
+
       # The declared limits with the strings a merchant can act on. A capability
       # with no translation degrades to its humanized key rather than a missing
       # translation, so an extension that declares one without shipping strings
@@ -69,6 +79,7 @@ module Spree
           name: display_name,
           available: available_for_store?(store),
           unsupported_capabilities: unsupported_capability_details,
+          exemption_reason_codes: exemption_reason_codes&.map { |code, label| { value: code.to_s, label: label.to_s } },
           default: name == Spree.default_tax_provider.to_s
         }
       end
@@ -85,10 +96,18 @@ module Spree
       # @param tax_identifier [Spree::TaxIdentifier, nil] resolved buyer
       #   registration, nil for a consumer sale
       # @param exemptions [Array] exemption evidence to apply
+      # @param tax_inclusive [Boolean, nil] whether the owner's prices already
+      #   include tax, which its market decides (Spree::Market#tax_inclusive);
+      #   nil = ask the owner (+owner.tax_inclusive?+)
       # @param context [Hash] untyped provider extras from set_tax_line_context
-      # @return [void] the written rows are the output; raise when the
-      #   calculation cannot be completed
-      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], context: {})
+      # @return [void] the written rows are the output
+      # @raise [Spree::Tax::ProviderUnavailable] when the engine could not
+      #   answer — refused, timed out, unreachable. Raise this (or a subclass,
+      #   as a provider's own request error may) rather than a bare error: core
+      #   turns it into a refusal the customer can retry, where anything else
+      #   reaches them as a broken checkout. A provider a merchant switched off
+      #   is not this — it has no opinion and writes no rows.
+      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil, context: {})
         raise NotImplementedError, "Please implement 'estimate' in your tax provider: #{self.class.name}"
       end
 
@@ -171,9 +190,10 @@ module Spree
       # @param tax_date [Time, nil] date whose rates apply; nil = now
       # @param tax_identifier [Spree::TaxIdentifier, nil] the order's frozen registration
       # @param exemptions [Array] exemption evidence to apply
+      # @param tax_inclusive [Boolean, nil] as for +estimate+
       # @return [void]
       # @raise [Spree::Tax::ProviderError] when the tax could not be worked out
-      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [])
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil)
         raise NotImplementedError, "Please implement 'estimate_replacement' in your tax provider: #{self.class.name}"
       end
 

data/app/models/spree/tax_provider/internal.rb

@@ -1,12 +1,19 @@
 module Spree
   module TaxProvider
     # Computes tax directly from TaxRate configuration: rate × discounted
-    # base, with VAT included-in-price math backed out of the gross basis.
+    # base, backed out of the price instead when the market's prices include
+    # tax.
     # Rates are matched on the owner's tax address, each naming its own country
     # and optionally a state. Fees without a tax category are taxed with the
     # default tax category's rates — except customs duties, which +taxable_items+
     # withholds (see Spree::Purchase::Taxation).
     class Internal < Base
+      # What a merchant sees when picking a market's tax engine: the class name
+      # says nothing to someone who never read the code.
+      def self.display_name
+        I18n.t('spree.tax_providers.internal')
+      end
+
       # Rates are configured per country or state with no local-tax breakdown, no buyer
       # registration handling, no distance-selling thresholds, and delivery taxed
       # at its own method's rate rather than apportioned across the rates of the
@@ -20,7 +27,8 @@ module Spree
       # period, so there is only ever one version of the configuration to read.
       # +tax_identifier+ likewise — reverse charge is on the unsupported list,
       # so a buyer registration changes nothing here.
-      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], context: {})
+      def estimate(owner, items = nil, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil, context: {})
+        tax_inclusive = owner.tax_inclusive? if tax_inclusive.nil?
         full_estimate = items.nil?
         items ||= owner.taxable_items
         # A duty this engine taxed before it was excluded — or through an
@@ -38,7 +46,7 @@ module Spree
           Spree::TaxLine.where(Spree::TaxLine.adjustable_key_for(klass) => group.map(&:id)).delete_all
         end
 
-        items.each { |item| tax_item(owner, item, rates, exemptions) }
+        items.each { |item| tax_item(owner, item, rates, exemptions, tax_inclusive) }
       end
 
       # Gives back each credited unit's share of the TaxLines the sale actually
@@ -57,16 +65,17 @@ module Spree
       # An exemption is read as it applied to the line being replaced: a
       # certificate's per-line carve-out names that line, and the exchange line
       # replacing it would otherwise match no carve-out and come out exempt.
-      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [])
+      def estimate_replacement(order, items, tax_date: nil, tax_identifier: nil, exemptions: [], tax_inclusive: nil)
         return if items.empty?
 
+        tax_inclusive = order.tax_inclusive? if tax_inclusive.nil?
         Spree::TaxLine.charges.where(exchange_line_item_id: items.map(&:id)).delete_all
 
         rates = rates_for(order)
         items.each do |item|
           next unless item.credited_quantity.to_i.positive?
 
-          tax_item(order, item, rates, exemptions, exemption_subject: item.line_item || item)
+          tax_item(order, item, rates, exemptions, tax_inclusive, exemption_subject: item.line_item || item)
         end
       end
 
@@ -74,11 +83,8 @@ module Spree
       # else, matched on where the invoiced business sits and taxed under the
       # store's default category — this engine has no separate notion of a
       # services category, and a marketplace commission is standard-rated
-      # nearly everywhere.
-      #
-      # Additional (not included-in-price) rates only: a commission is quoted
-      # net and its VAT is added on top, so a rate configured as
-      # tax-inclusive describes consumer pricing rather than this supply.
+      # nearly everywhere. A commission is quoted net and its tax added on top,
+      # whatever the store's markets do with their prices.
       #
       # Nil when the jurisdiction is unknown or configured with no matching
       # rate at all, so the caller falls back to its own default instead of
@@ -91,8 +97,7 @@ module Spree
 
         rates = Spree::TaxRate.for_store(store).
                 for_jurisdiction(address.country_code, address.state_code).
-                for_tax_category(category).
-                where(included_in_price: false)
+                for_tax_category(category)
         return nil if rates.empty?
 
         rates.sum(:amount)
@@ -114,7 +119,7 @@ module Spree
         Spree::TaxRate.for_store(owner.store).for_jurisdiction(owner.tax_country&.iso, owner.tax_address&.state_code).to_a
       end
 
-      def tax_item(owner, item, rates, exemptions, exemption_subject: item)
+      def tax_item(owner, item, rates, exemptions, tax_inclusive, exemption_subject: item)
         relevant_rates = rates.select { |rate| rate.tax_category_id == tax_category_id_for(item, owner) }
 
         # A matched rate always produces a row, zero-amount ones included:
@@ -129,15 +134,15 @@ module Spree
         # An exempt item has no tax to back out of its price, so its whole
         # basis is pre-tax.
         exempt_rates = taxed.select { |_rate, _jurisdiction, exemption| exemption }.map(&:first)
-        store_pre_tax_amount(item, relevant_rates - exempt_rates)
+        store_pre_tax_amount(item, relevant_rates - exempt_rates, tax_inclusive)
 
         taxed.each do |rate, jurisdiction, exemption|
           if exemption
-            write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction,
+            write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction, tax_inclusive,
                            data: exemption_data(exemption, exemption_subject))
           else
-            write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates, owner.currency),
-                           reason_for(rate), jurisdiction)
+            write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates, owner.currency, tax_inclusive),
+                           reason_for(rate), jurisdiction, tax_inclusive)
           end
         end
       end
@@ -171,13 +176,11 @@ module Spree
 
       # Rounded per line, half up, to the order's currency — the internal
       # provider's choice; other providers round as their jurisdictions require.
-      def compute_tax(rate, item, relevant_rates, currency)
+      def compute_tax(rate, item, relevant_rates, currency, tax_inclusive)
         basis = taxable_basis(item)
 
-        tax = if rate.included_in_price
-                included_sum = relevant_rates.select(&:included_in_price).sum(&:amount)
-                included_sum = rate.amount if included_sum.zero?
-                basis / (1 + included_sum) * rate.amount
+        tax = if tax_inclusive
+                basis / (1 + relevant_rates.sum(&:amount)) * rate.amount
               else
                 basis * rate.amount
               end
@@ -186,12 +189,11 @@ module Spree
 
       # Pre-tax amounts are stored so refund and reporting code can weigh
       # discounted, tax-exclusive values later (see #4318).
-      def store_pre_tax_amount(item, rates)
+      def store_pre_tax_amount(item, rates, tax_inclusive)
         return unless item.respond_to?(:pre_tax_amount)
 
         pre_tax_amount = taxable_basis(item)
-        included_rates = rates.select(&:included_in_price)
-        pre_tax_amount /= (1 + included_rates.sum(&:amount)) if included_rates.any?
+        pre_tax_amount /= (1 + rates.sum(&:amount)) if tax_inclusive && rates.any?
 
         item.update_column(:pre_tax_amount, pre_tax_amount)
       end
@@ -226,15 +228,20 @@ module Spree
       # a genuinely exempt supply depends on which exemption applied, which the
       # reason alone cannot say.
       def exemption_data(exemption, item)
+        reason_code = exemption.reason_code_for(item)
+
         {
           'exemption' => {
-            'reason_code' => exemption.reason_code_for(item),
+            'reason_code' => reason_code,
+            # A per-line override names only a code, so the entry's name would
+            # describe a different reason.
+            'reason_name' => (exemption.reason_name if reason_code == exemption.reason_code),
             'certificate_number' => exemption.certificate_number
           }.compact
         }
       end
 
-      def write_tax_line(owner, item, rate, amount, reason, jurisdiction, data: {})
+      def write_tax_line(owner, item, rate, amount, reason, jurisdiction, tax_inclusive, data: {})
         owner_key = owner.is_a?(Spree::Order) ? :order : :cart
         Spree::TaxLine.create!(
           {
@@ -243,8 +250,8 @@ module Spree
             tax_rate: rate,
             amount: amount,
             rate: rate.amount,
-            label: rate.adjustment_label,
-            included: rate.included_in_price,
+            label: rate.adjustment_label(included: tax_inclusive),
+            included: tax_inclusive,
             provider_id: 'internal',
             taxability_reason: reason,
             data: data