spree_core 5.6.1 → 6.0.0.beta1

data/app/models/spree/tax_line.rb

@@ -0,0 +1,79 @@
+module Spree
+  # A single tax charge on a line item, fulfillment or fee. Written exclusively
+  # by the tax provider (see Spree::Purchase::Taxation#tax_provider) with replace-all set semantics
+  # per estimate. Snapshot columns (+rate+, +label+, +provider_id+) keep rows
+  # self-describing after a TaxRate is deleted or when an external provider
+  # computed them.
+  class TaxLine < Spree.base_class
+    include Spree::TypedAdjustmentLine
+
+    has_prefix_id :tl
+
+    # Why this line was taxed the way it was — the machine-readable cause, kept
+    # free of any one jurisdiction's invoice vocabulary so reporting and
+    # e-invoicing can map it to whatever codes their regime requires.
+    #
+    # Configuration, not a frozen constant — a provider modelling a treatment
+    # core doesn't know about registers its reason here. The bar for a new
+    # value: it distinguishes a treatment that reporting or invoicing has to
+    # tell apart, not merely a different amount.
+    class_attribute :taxability_reasons,
+                    default: %w[standard_rated reduced_rated zero_rated reverse_charge
+                                intra_community_supply export customer_exempt product_exempt
+                                not_collecting not_subject_to_tax]
+
+    # Provider payloads (jurisdiction breakdowns, external ids) read nil-safe.
+    attribute :data, default: -> { {} }
+
+    # The jurisdiction snapshot the provider stamped on the line.
+    has_iso_geography
+
+    # Source — nil for externally-computed tax
+    belongs_to :tax_rate, class_name: 'Spree::TaxRate', optional: true
+
+    # Adjustable — exactly one
+    belongs_to :line_item, class_name: 'Spree::LineItem', optional: true
+    belongs_to :fulfillment, class_name: 'Spree::Fulfillment', optional: true
+    belongs_to :fee, class_name: 'Spree::Fee', optional: true
+
+    # Tax included in price vs additional. Per-row (mixed regimes on one order).
+    attribute :included, :boolean, default: false
+
+    validates :rate, numericality: { greater_than_or_equal_to: 0 }
+    # The lambda re-reads the list at validation time, so a reason an extension
+    # registers after boot is accepted.
+    validates :taxability_reason,
+              inclusion: { in: ->(tax_line) { tax_line.class.taxability_reasons } },
+              allow_nil: true
+    validate :exactly_one_adjustable
+
+    # Tax reporting is the reason the treatment columns exist — "which country's
+    # tax was this, and which sales were reverse-charged" has to be answerable.
+    self.whitelisted_ransackable_attributes = %w[taxability_reason country_code state_code included provider_id]
+
+    scope :included_in_price, -> { where(included: true) }
+    scope :additional, -> { where(included: false) }
+    scope :for_line_items, -> { where.not(line_item_id: nil) }
+    scope :for_fulfillments, -> { where.not(fulfillment_id: nil) }
+    scope :for_fees, -> { where.not(fee_id: nil) }
+
+    # @return [Spree::LineItem, Spree::Fulfillment, Spree::Fee, nil]
+    def adjustable
+      line_item || fulfillment || fee
+    end
+
+    def included?
+      included
+    end
+
+    def additional?
+      !included
+    end
+
+    private
+
+    def exactly_one_adjustable
+      errors.add(:base, :exactly_one_adjustable, message: Spree.t('errors.messages.exactly_one_adjustable')) unless [line_item, fulfillment, fee].compact.one?
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+module Spree
+  module TaxProvider
+    # Contract for tax providers — the only sanctioned writers of
+    # {Spree::TaxLine} rows. +estimate+ must use replace-all set semantics per
+    # target item (delete the item's stale lines, insert fresh ones); that is
+    # what keeps tax correct after address or item changes. Commit/void/refund
+    # are lifecycle no-ops for providers without a remote ledger.
+    #
+    # Providers are stateless and constructed without arguments, so anything
+    # request-specific arrives as an argument rather than through the instance.
+    class Base
+      # Domains this provider cannot handle, so a merchant is warned when
+      # pairing it with a market instead of silently under-collecting. Declared
+      # on the class because core reads it while presenting the choice, before
+      # any provider is instantiated.
+      #
+      # @return [Array<Symbol>]
+      def self.unsupported_capabilities
+        []
+      end
+
+      # Whether this provider can be selected for a store. External providers
+      # override it to require a connected integration or credentials.
+      #
+      # @param store [Spree::Store]
+      # @return [Boolean]
+      def self.available_for_store?(_store)
+        true
+      end
+
+      # The name a merchant sees when choosing an engine. Override in a provider
+      # gem — a class name mangled into words rarely matches what the service is
+      # actually called.
+      #
+      # @return [String]
+      def self.display_name
+        name.demodulize.titleize
+      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
+      # still reads sensibly.
+      #
+      # @return [Array<Hash>]
+      def self.unsupported_capability_details
+        unsupported_capabilities.map do |capability|
+          {
+            key: capability.to_s,
+            label: Spree.t("tax_capabilities.#{capability}.label", default: capability.to_s.humanize),
+            description: Spree.t("tax_capabilities.#{capability}.description", default: nil)
+          }.compact
+        end
+      end
+
+      # How this engine describes itself to the admin, mirroring
+      # Spree::PreferenceSchema#subclasses_with_preference_schema: the class
+      # being described owns its own presentation, not the controller.
+      #
+      # @param store [Spree::Store]
+      # @return [Hash]
+      def self.to_api_hash(store)
+        {
+          id: name,
+          name: display_name,
+          available: available_for_store?(store),
+          unsupported_capabilities: unsupported_capability_details,
+          default: name == Spree.default_tax_provider.to_s
+        }
+      end
+
+      # Recomputes tax for the given items and writes the TaxLine rows.
+      # Replace-all set semantics per target item, and one row for every item
+      # the provider formed a treatment for — zero-amount treatments included.
+      # Never called on a completed order; the order-level money freeze gates it.
+      #
+      # @param owner [Spree::Cart, Spree::Order]
+      # @param items [Array<Spree::LineItem, Spree::Fulfillment, Spree::Fee>, nil]
+      #   nil = every taxable item on the owner
+      # @param tax_date [Time, nil] date whose rates apply; nil = now
+      # @param tax_identifier [Spree::TaxIdentifier, nil] resolved buyer
+      #   registration, nil for a consumer sale
+      # @param exemptions [Array] exemption evidence to apply
+      # @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: {})
+        raise NotImplementedError, "Please implement 'estimate' in your tax provider: #{self.class.name}"
+      end
+
+      # Finalizes tax with the provider when the order is placed. No-op for a
+      # provider without a remote ledger — the rows are already the record.
+      #
+      # **Must be idempotent.** Completion is replayable: a crash between the
+      # order commit and the cart stamp leaves `Carts::Complete` to re-run its
+      # finalize phase, which calls this again for an order already committed.
+      # Key the filing on the order and treat a duplicate as success, rather
+      # than filing a second document for one sale.
+      #
+      # @param order [Spree::Order]
+      # @return [void]
+      def commit(order); end
+
+      # Reverses a committed tax document on cancellation.
+      #
+      # @param order [Spree::Order]
+      # @return [void]
+      def void(order); end
+
+      # The tax rate, as a fraction, on a service the platform itself supplies
+      # and invoices — today only a marketplace's commission to a seller.
+      #
+      # Distinct from +estimate+ because nothing here is a sale: there is no
+      # order, no buyer and no item, only a B2B supply between the platform and
+      # a business it invoices. Returning a rate rather than writing rows is
+      # deliberate for the same reason — the caller snapshots the number onto
+      # its own ledger row, which is not a TaxLine.
+      #
+      # Providers that cannot price a service supply return nil rather than
+      # zero: zero is the claim that the supply is untaxed, and the caller has
+      # a configured default to fall back on that a wrong zero would silence.
+      #
+      # @param address [Spree::Address, nil] where the business being invoiced
+      #   is established — for commission, the seller's billing address
+      # @param store [Spree::Store]
+      # @return [BigDecimal, nil] e.g. 0.21 for 21%; nil if it has no opinion
+      def service_tax_rate(address:, store:)
+        nil
+      end
+
+      # Reports a partial credit against the committed document, keyed to the
+      # original transaction rather than voiding and re-committing it.
+      #
+      # +amount+ is what the customer was actually refunded, which is not always
+      # the returned lines' worth: an admin may keep a restocking fee or refund
+      # a goodwill figure of their own. A provider must credit no more tax than
+      # that refund carries — crediting every returned line when only part of
+      # their value went back would reclaim tax the merchant never repaid, and a
+      # return is marked refunded once, so nothing later corrects it. Where the
+      # amount is short, allocate proportionally.
+      #
+      # @param order [Spree::Order]
+      # @param return_items [Array<Spree::ReturnLineItem>] the returned lines
+      # @param amount [BigDecimal, nil] the refund issued; nil = the lines' full worth
+      # @param tax_date [Time, nil] the original supply date; nil = order.completed_at
+      # @return [void]
+      def refund(order, return_items, amount: nil, tax_date: nil); end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+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.
+    # 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
+      # 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
+      # goods it carries. Declared so a merchant pairing this with a market is
+      # told, rather than discovering it in a return.
+      def self.unsupported_capabilities
+        %i[us_local_tax reverse_charge oss_thresholds proportional_delivery_tax]
+      end
+
+      # +tax_date+ is accepted and ignored: TaxRate rows carry no validity
+      # 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: {})
+        full_estimate = items.nil?
+        items ||= owner.taxable_items
+        # A duty this engine taxed before it was excluded — or through an
+        # explicit item list — is never revisited by the per-item cleanup
+        # below, since duties are absent from the default set. Left alone the
+        # row would inflate the total for the life of the order.
+        sweep_internal_duty_tax_lines(owner) if full_estimate
+        return if items.empty?
+
+        rates = Spree::TaxRate.for_store(owner.store).for_jurisdiction(owner.tax_country&.iso, owner.tax_address&.state_code).to_a
+
+        items.group_by(&:class).each do |klass, group|
+          # Replace-all set semantics per estimate: stale lines die with the
+          # address/items change that triggered the re-estimate.
+          Spree::TaxLine.where(tax_line_foreign_key(klass) => group.map(&:id)).delete_all
+        end
+
+        items.each do |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:
+          # a zero rate is a treatment ("this is zero-rated"), which reporting
+          # and e-invoicing both need to see. No matched rate means no opinion,
+          # and writes nothing.
+          taxed = relevant_rates.map do |rate|
+            jurisdiction = jurisdiction_for(rate, owner)
+            [rate, jurisdiction, exemption_for(item, exemptions, jurisdiction)]
+          end
+
+          # 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)
+
+          taxed.each do |rate, jurisdiction, exemption|
+            if exemption
+              write_tax_line(owner, item, rate, 0, 'customer_exempt', jurisdiction,
+                             data: exemption_data(exemption, item))
+            else
+              write_tax_line(owner, item, rate, compute_tax(rate, item, relevant_rates),
+                             reason_for(rate), jurisdiction)
+            end
+          end
+        end
+      end
+
+      # Reads the service rate off the same TaxRate configuration as everything
+      # 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.
+      #
+      # 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
+      # reading silence as "not taxed".
+      def service_tax_rate(address:, store:)
+        return nil if address&.country_code.blank?
+
+        category = default_tax_category_for(store)
+        return nil if category.nil?
+
+        rates = Spree::TaxRate.for_store(store).
+                for_jurisdiction(address.country_code, address.state_code).
+                for_tax_category(category).
+                where(included_in_price: false)
+        return nil if rates.empty?
+
+        rates.sum(:amount)
+      end
+
+      private
+
+      # Scoped to this engine's own rows: a landed-cost provider writes the
+      # import VAT that genuinely belongs on a duty, and clearing that would
+      # be deleting another provider's work.
+      def sweep_internal_duty_tax_lines(owner)
+        duty_fee_ids = owner.fees.where(kind: 'duty').ids
+        return if duty_fee_ids.empty?
+
+        owner.tax_lines.where(fee_id: duty_fee_ids, provider_id: 'internal').delete_all
+      end
+
+      def tax_line_foreign_key(klass)
+        case klass.name
+        when 'Spree::LineItem' then :line_item_id
+        when 'Spree::Fulfillment' then :fulfillment_id
+        when 'Spree::Fee' then :fee_id
+        else raise ArgumentError, "#{klass} is not taxable"
+        end
+      end
+
+      def tax_category_id_for(item, owner)
+        if item.respond_to?(:tax_category_id) && item.tax_category_id
+          item.tax_category_id
+        else
+          default_tax_category_for(owner.store)&.id
+        end
+      end
+
+      # The given store's default, not any store's: defaults are per store
+      # since 6.0, and a foreign category id would match none of this store's
+      # rates, silently leaving the item untaxed.
+      #
+      # Memoized per store rather than per owner, so one `estimate` over a
+      # basket asks once. It buys nothing across calls — Purchase::Taxation
+      # builds a fresh provider every time — which is why commission memoizes
+      # its own answer rather than relying on this.
+      def default_tax_category_for(store)
+        @default_tax_categories ||= {}
+        return @default_tax_categories[store.id] if @default_tax_categories.key?(store.id)
+
+        @default_tax_categories[store.id] = Spree::TaxCategory.default(store)
+      end
+
+      def taxable_basis(item)
+        item.respond_to?(:taxable_basis) ? item.taxable_basis : item.amount
+      end
+
+      def compute_tax(rate, item, relevant_rates)
+        basis = taxable_basis(item)
+
+        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).round(2)
+        else
+          (basis * rate.amount).round(2)
+        end
+      end
+
+      # 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)
+        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?
+
+        item.update_column(:pre_tax_amount, pre_tax_amount)
+      end
+
+      # Finer distinctions — a reduced rate, an exempt supply — are a matter of
+      # rate configuration rather than something to infer from the number.
+      def reason_for(rate)
+        rate.amount.to_d.zero? ? 'zero_rated' : 'standard_rated'
+      end
+
+      # The jurisdiction that taxed the line, read off the rate that matched.
+      # A rate covering every country falls back to the address, so the row can
+      # still say where the sale was taxed.
+      def jurisdiction_for(rate, owner)
+        {
+          country_code: rate.country_code.presence || owner.tax_country&.iso,
+          state_code: rate.state_code.presence || owner.tax_address&.state_code
+        }
+      end
+
+      # The first exemption entry that claims both this item and the
+      # jurisdiction being taxed. Multiple certificates mean multiple entries,
+      # and one claim is enough.
+      def exemption_for(item, exemptions, jurisdiction)
+        Array(exemptions).find do |exemption|
+          exemption.covers_item?(item) &&
+            exemption.covers_jurisdiction?(jurisdiction[:country_code], jurisdiction[:state_code])
+        end
+      end
+
+      # Keeps the claim with the row it produced: the invoice exemption code for
+      # a genuinely exempt supply depends on which exemption applied, which the
+      # reason alone cannot say.
+      def exemption_data(exemption, item)
+        {
+          'exemption' => {
+            'reason_code' => exemption.reason_code_for(item),
+            'certificate_number' => exemption.certificate_number
+          }.compact
+        }
+      end
+
+      def write_tax_line(owner, item, rate, amount, reason, jurisdiction, data: {})
+        owner_key = owner.is_a?(Spree::Order) ? :order : :cart
+        Spree::TaxLine.create!(
+          {
+            tax_line_foreign_key(item.class) => item.id,
+            owner_key => owner,
+            tax_rate: rate,
+            amount: amount,
+            rate: rate.amount,
+            label: rate.adjustment_label,
+            included: rate.included_in_price,
+            provider_id: 'internal',
+            taxability_reason: reason,
+            data: data
+          }.merge(jurisdiction)
+        )
+      end
+    end
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -1,37 +1,62 @@
 module Spree
+  # Pure tax configuration read by the internal tax provider
+  # (Spree::TaxProvider::Internal). Since 6.0 tax rates have no write path of
+  # their own — TaxLine rows are written exclusively by the sale's tax provider.
   class TaxRate < Spree.base_class
     has_prefix_id :tax
 
+    # Rates name their country and state directly since 6.0. No code reads
+    # zone_id any more, but the column stays in the database through 6.0: it is
+    # what `spree:migrate_tax_zones` converts from, and that task runs after
+    # db:migrate. The physical drop lands in 6.1.
+
     acts_as_paranoid
 
-    include Spree::CalculatedAdjustments
-    include Spree::AdjustmentSource
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::SingleStoreResource
 
     with_options inverse_of: :tax_rates do
-      belongs_to :zone, class_name: 'Spree::Zone', optional: true
       belongs_to :tax_category,
                  class_name: 'Spree::TaxCategory'
     end
 
-    with_options presence: true do
-      validates :amount, numericality: { allow_nil: true }
-      validates :tax_category, :name
-    end
-
-    scope :by_zone, ->(zone) { where(zone_id: zone.id) }
-    scope :potential_rates_for_zone,
-          ->(zone) do
-            where(zone_id: Spree::Zone.potential_matching_zones(zone).pluck(:id))
-          end
-    scope :for_default_zone,
-          -> { potential_rates_for_zone(Spree::Zone.default_tax) }
+    has_many :tax_lines, class_name: 'Spree::TaxLine', dependent: :nullify
+
+    validates :amount, presence: true, numericality: { allow_nil: true }
+    # Per store, so a config file can address a rate by name; a soft-deleted
+    # rate frees its name.
+    validates :name, presence: true
+    validates_store_uniqueness :name
+
+    # The jurisdiction this rate applies in, held as codes: a blank country_code
+    # means everywhere, and a country with no state_code means the whole
+    # country. Upcased on the way in so a rate entered as "de" still matches an
+    # address from Germany.
+    has_iso_geography
+
+    # The primitive: rates that reach a jurisdiction, which is a country and
+    # optionally one of its states. Rates naming neither are included, since a
+    # rate with no country taxes everywhere. Takes the pair rather than an
+    # address because tax applies before a customer has given one — the
+    # provider falls back to the market's country (see
+    # Spree::Purchase::Taxation#tax_country).
+    # +normalizes+ above applies to query values too, so a caller passing "de"
+    # still matches a rate stored as "DE".
+    scope :for_jurisdiction, lambda { |country_code, state_code = nil|
+      where(country_code: [country_code.presence, nil].uniq).where(state_code: [state_code.presence, nil].uniq)
+    }
+    # The same question asked with an address in hand.
+    scope :for_address, ->(address) { for_jurisdiction(address&.country_code, address&.state_code) }
+    # Country-wide: unlike for_jurisdiction(country_code, nil) this leaves the
+    # state unconstrained, so it sums a country's state-level rates too. Used
+    # where the state is irrelevant — backing VAT out of a gross price.
+    scope :for_country, ->(country_code) { where(country_code: [country_code.presence, nil].uniq) }
     scope :for_tax_category,
           ->(category) { where(tax_category_id: category.try(:id)) }
     scope :included_in_price, -> { where(included_in_price: true) }
 
-    self.whitelisted_ransackable_attributes = %w[amount zone_id tax_category_id included_in_price name]
+    self.whitelisted_ransackable_attributes = %w[amount country_code state_code tax_category_id included_in_price name]
 
     # Virtual attribute for percentage display in admin forms
     def amount_percentage
@@ -44,88 +69,23 @@ module Spree
       self.amount = value.present? ? (value.to_f / 100) : nil
     end
 
-    # Gets the array of TaxRates appropriate for the specified tax zone
-    def self.match(order_tax_zone)
-      return [] unless order_tax_zone
-
-      potential_rates_for_zone(order_tax_zone)
-    end
-
-    # Pre-tax amounts must be stored so that we can calculate
-    # correct rate amounts in the future. For example:
-    # https://github.com/spree/spree/issues/4318#issuecomment-34723428
+    # The included-in-price rate to back out of a gross price.
     #
-    # NOTE: this deliberately excludes the item's share of whole-order
-    # promotions and is therefore NOT the basis tax is computed on (that is
-    # LineItem#taxable_basis / Shipment#taxable_basis). Refund and reporting
-    # code (e.g. Calculator::Returns::DefaultRefundAmount) weighs order-level
-    # adjustments separately on top of this column, so allocating them here
-    # would double-count discounts.
-    def self.store_pre_tax_amount(item, rates)
-      pre_tax_amount = case item.class.to_s
-                       when 'Spree::LineItem' then item.discounted_amount
-                       when 'Spree::Shipment' then item.discounted_cost
-                       end
-
-      included_rates = rates.select(&:included_in_price)
-      if included_rates.any?
-        pre_tax_amount /= (1 + included_rates.sum(&:amount))
-      end
-
-      item.update_column(:pre_tax_amount, pre_tax_amount)
-    end
-
-    # Deletes all tax adjustments, then applies all applicable rates
-    # to relevant items.
-    def self.adjust(order, items)
-      return if items.none?
-
-      rates = match(order.tax_zone)
-      tax_category_ids = rates.map(&:tax_category_id)
-
-      # using destroy_all to ensure adjustment destroy callback fires.
-      Spree::Adjustment.where(adjustable: items).tax.destroy_all
-
-      relevant_items = if tax_category_ids.any?
-                          items.select do |item|
-                            tax_category_ids.include?(item.tax_category_id)
-                          end
-                        else
-                          []
-                        end
-
-      relevant_items.each do |item|
-        relevant_rates = rates.select do |rate|
-          rate.tax_category_id == item.tax_category_id
-        end
-        store_pre_tax_amount(item, relevant_rates)
-        relevant_rates.each do |rate|
-          rate.adjust(order, item)
-        end
-      end
-
-      # updates pre_tax for items without any tax rates
-      remaining_items = items - relevant_items
-      remaining_items.each do |item|
-        store_pre_tax_amount(item, [])
-      end
-    end
-
+    # @param options [Hash] +:country+ (or +:address+) and +:tax_category+
+    # @return [BigDecimal] 0 when the jurisdiction or category is unknown
     def self.included_tax_amount_for(options)
-      return 0 unless options[:tax_zone] && options[:tax_category]
-
-      potential_rates_for_zone(options[:tax_zone]).
-        included_in_price.
-        for_tax_category(options[:tax_category]).
-        sum(:amount)
-    end
-
-    def adjust(order, item)
-      create_adjustment(order, item, included_in_price)
-    end
-
-    def compute_amount(item)
-      compute(item)
+      # +:country+ is a documented override point and the VAT path still hands
+      # it a Spree::Country, so take the code off whichever arrives.
+      country = options[:country]
+      country_code = country.try(:iso) || country.presence || options[:address]&.country_code
+      return 0 unless country_code && options[:tax_category]
+
+      scope = options[:address] ? for_address(options[:address]) : for_country(country_code)
+      # Per-store tax configuration is the norm since 6.0, so without this the
+      # sum would add up every store's rate for the same country.
+      store = options[:store] || Spree::Current.store
+      scope = scope.for_store(store) if store
+      scope.included_in_price.for_tax_category(options[:tax_category]).sum(:amount)
     end
 
     def included?
@@ -136,15 +96,18 @@ module Spree
       !included_in_price
     end
 
-    private
-
-    def label
+    # The customer-facing label snapshotted onto TaxLine rows.
+    #
+    # @return [String]
+    def adjustment_label
       Spree.t included_in_price? ? :including_tax : :excluding_tax,
               scope: 'adjustment_labels.tax_rates',
               name: name.presence || tax_category.name,
               amount: amount_for_label
     end
 
+    private
+
     def amount_for_label
       return '' unless show_rate_in_label?
       return '' if amount.zero?