spree_core 5.6.0.rc2 → 5.6.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df2eef5a82cf40bca9b5c518b663153584a72dc1dadf05880a5c2ce344766394
-  data.tar.gz: 48771116e279ccb8c5ed4f83896a60e8063b74cb8785ff51953c9d8446a804f2
+  metadata.gz: 45a9c3a76133036f89b3eabe73c9e53cd57dfd6417ee32211f88335424b9da94
+  data.tar.gz: f409d6453ba2a5a6fa9f66c3b26ffa8686c05723bcae99110cb7eede6d3fedb1
 SHA512:
-  metadata.gz: 3a27318377cb47ae53d0405a9a034642119446d4507f03c68966cd550cf41430dcdb0cc3ff7c67f8bf1435b695816c26f92b73e525f2ead42eaf83070c019f40
-  data.tar.gz: 1ac22bf54e39352eede750b630b7e2d6ca6a0d4713c776f0efd20e9cf552f3689b24b154c0694db3ae0edabba37a0bc1c7ad91aa5a0e84cca62aa5cc459d48f7
+  metadata.gz: 596464be183b137236eb76e984a2b8d84091ea95e22a553d7ffb3ab0a5bc3055d380d1283946517ad20e3a8bbd3617d9a246ebbe2157923943e64b054a014aaa
+  data.tar.gz: 58e3bb7aed929b0d17ac96510dee26475cdcfc645b49e491fa38625c958d5228ef81e5f9d703488dbe576167e2ef8c2078d993cce6a37feaad714f62c0b6b8c6

data/app/helpers/spree/rich_text_helper.rb

@@ -0,0 +1,37 @@
+module Spree
+  # Converts stored rich text HTML (Tiptap output persisted in plain text
+  # columns, e.g. +Spree::Product#description+) into a faithful plain-text
+  # rendering for API +description+/+body+ fields.
+  #
+  # Tiptap serializes blocks with no whitespace between them
+  # (+<p>a</p><p>b</p>+), so a naive tag strip glues adjacent blocks into a
+  # single run ("ab") and loses every paragraph and line break. This maps
+  # block boundaries and +<br>+ to newlines before stripping tags, keeping the
+  # text readable for storefronts, feeds, search indexing, and meta tags.
+  #
+  # Newlines already present in the markup (pretty-printed source from the
+  # legacy admin's TinyMCE code view, imports, seeds) render as a single space
+  # in a browser and are treated the same way here — only +<br>+ and block
+  # boundaries produce line breaks.
+  module RichTextHelper
+    # Closing block tags whose boundaries become line breaks.
+    BLOCK_BOUNDARY = %r{</(?:p|div|li|h[1-6]|blockquote|tr|ul|ol|table|section|article|header|footer|pre)>}i
+
+    # Hard line breaks.
+    LINE_BREAK = %r{<br\s*/?>}i
+
+    # @param html [String, nil] rich text HTML
+    # @return [String] plain text with paragraph and line breaks preserved
+    def self.to_plain_text(html)
+      return '' if html.blank?
+
+      with_breaks = html.gsub(/\s+/, ' ').gsub(LINE_BREAK, "\n").gsub(BLOCK_BOUNDARY, "\\0\n")
+
+      Nokogiri::HTML.fragment(with_breaks).text
+                    .gsub(/[^\S\n]+/, ' ') # collapse runs of non-newline whitespace
+                    .gsub(/ *\n */, "\n")  # trim spaces hugging newlines
+                    .gsub(/\n{3,}/, "\n\n") # cap consecutive blank lines
+                    .strip
+    end
+  end
+end

data/app/jobs/spree/imports/process_group_job.rb

@@ -1,6 +1,22 @@
 module Spree
   module Imports
     class ProcessGroupJob < Spree::Imports::BaseJob
+      # A large import fans out into many group jobs; without a cap they
+      # occupy every worker thread as one frees up, starving checkout-critical
+      # queues that share the pool. Cap concurrent groups per import at 75%
+      # of JOB_THREADS (at least 1), or SPREE_IMPORT_JOB_CONCURRENCY when set
+      # (0 disables the cap) — excess jobs wait as blocked executions, not in
+      # worker threads. Both values are read by the process enqueueing the
+      # import, so on a split web/worker deployment set the explicit override
+      # on the web service. The semaphore duration must outlive the slowest
+      # group; expiry just lifts the cap, it doesn't lose jobs. Solid
+      # Queue-specific (no-op on other adapters).
+      import_concurrency = ENV['SPREE_IMPORT_JOB_CONCURRENCY'].presence&.to_i ||
+        [Integer(ENV.fetch('JOB_THREADS', 3)) * 3 / 4, 1].max
+      if import_concurrency.positive? && respond_to?(:limits_concurrency)
+        limits_concurrency to: import_concurrency, key: ->(import_id, _row_ids) { import_id }, duration: 30.minutes
+      end
+
       # Rows are loaded in slices so a large group never holds every ImportRow
       # (and its raw CSV data) in memory for the whole job.
       ROWS_BATCH_SIZE = 100
@@ -12,6 +28,9 @@ module Spree
         mappings = import.mappings.mapped.to_a
         schema_fields = import.schema_fields
         large = import.large_import?
+        grouped = import.group_column.present? && mappings.any? { |m| m.schema_field == import.group_column }
+        started_at = Time.current
+        processed_rows = []
 
         row_ids.each_slice(ROWS_BATCH_SIZE) do |ids|
           # Skip rows already completed on a prior attempt so retries don't double-process them.
@@ -25,18 +44,45 @@ module Spree
             Spree::Events.disable do
               rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
             end
+          elsif grouped
+            # A group is one product plus its variants: per-record lifecycle
+            # events (variant.created, price.created, product.updated per
+            # touch) are noise to subscribers — one product event is published
+            # for the whole group below. import_row.* events still flow.
+            Spree::Events.disable_lifecycle do
+              rows.each { |row| row.process!(mappings: mappings, schema_fields: schema_fields) }
+            end
           else
             rows.each do |row|
               row.process!(mappings: mappings, schema_fields: schema_fields)
             end
           end
+          processed_rows.concat(rows)
         end
 
+        publish_group_events(processed_rows, started_at) if grouped
         check_import_completion(import, large)
       end
 
       private
 
+      # One event per product touched by this group: `product.created` when the
+      # product came into existence during this run, `product.updated` otherwise
+      # (including retries of a group whose first attempt created it).
+      def publish_group_events(rows, started_at)
+        products = rows.select { |row| row.status == 'completed' }.filter_map do |row|
+          item = row.item
+          next item if item.is_a?(Spree::Product)
+
+          item.product if item.respond_to?(:product)
+        end.uniq
+
+        products.each do |product|
+          event = product.created_at >= started_at ? 'product.created' : 'product.updated'
+          product.publish_event(event)
+        end
+      end
+
       # Completion is row-state-derived so retry-induced over-increments of the counter
       # stay harmless. The counter pre-check just shortcuts the row scan for workers
       # that obviously can't be the last group to finish. `in_flight` excludes orphaned

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

@@ -39,6 +39,18 @@ module Spree
     included do
       class_attribute :publish_events, default: true
       class_attribute :lifecycle_events_enabled, default: false
+
+      after_update :mark_real_update_for_events
+    end
+
+    # A bare `touch` (variant → product, price → variant, asset → variants)
+    # writes no attribute changes — the resulting update event would carry
+    # nothing subscribers haven't already been told. Track it here so the
+    # commit callback can tell a touch-only commit from a real update;
+    # `saved_changes` can't (a touch replays the previous save's changeset).
+    def touch(*names, time: nil)
+      @_spree_touched_for_events = true
+      super
     end
 
     class_methods do
@@ -228,7 +240,21 @@ module Spree
     end
 
     def should_publish_events?
-      self.class.publish_events && Spree::Events.enabled?
+      self.class.publish_events && Spree::Events.lifecycle_enabled?
+    end
+
+    # True when this commit was caused only by `touch` — no real save ran
+    # (`after_update` fires for saves, never for touches). Flags reset every
+    # commit so a later genuine update publishes normally.
+    def touch_only_update?
+      touched = @_spree_touched_for_events
+      updated = @_spree_updated_for_events
+      @_spree_touched_for_events = @_spree_updated_for_events = nil
+      touched && !updated
+    end
+
+    def mark_real_update_for_events
+      @_spree_updated_for_events = true
     end
 
     def publish_create_event
@@ -236,6 +262,8 @@ module Spree
     end
 
     def publish_update_event
+      return if touch_only_update?
+
       publish_event("#{event_prefix}.updated")
     end
 

data/app/models/spree/address.rb

@@ -233,6 +233,7 @@ module Spree
       assign_new_default_address_to_user
 
       if can_be_deleted?
+        unassign_from_incomplete_orders
         super
       else
         update_column :deleted_at, Time.current
@@ -364,5 +365,11 @@ module Spree
     def assign_new_default_address_to_user_scope
       user.addresses.not_quick_checkout.reorder(created_at: :desc)
     end
+
+    def unassign_from_incomplete_orders
+      orders = Spree::Order.incomplete.where(user_id: user_id)
+      orders.where(ship_address_id: id).update_all(ship_address_id: nil, state: 'address', updated_at: Time.current)
+      orders.where(bill_address_id: id).update_all(bill_address_id: nil, state: 'address', updated_at: Time.current)
+    end
   end
 end

data/app/models/spree/calculator/default_tax.rb

@@ -24,11 +24,21 @@ module Spree
     end
 
     # When it comes to computing shipments or line items: same same.
+    #
+    # Both tax modes are computed from the item's live taxable basis, which
+    # follows every discount: item-level promotions and the item's share of
+    # whole-order promotions (see LineItem#taxable_basis). Included
+    # (VAT-style) tax intentionally does not read the stored pre_tax_amount
+    # column — that column is only refreshed by Spree::TaxRate.adjust on
+    # checkout transitions, so it goes stale the moment a promotion is
+    # applied or removed.
     def compute_shipment_or_line_item(item)
+      basis = item.taxable_basis
+
       if rate.included_in_price
-        deduced_total_by_rate(item.pre_tax_amount, rate)
+        deduced_total_by_rate(net_basis(item, basis), rate)
       else
-        round_to_two_places(item.discounted_amount * rate.amount)
+        round_to_two_places(basis * rate.amount)
       end
     end
 
@@ -54,5 +64,24 @@ module Spree
     def deduced_total_by_rate(pre_tax_amount, rate)
       round_to_two_places(pre_tax_amount * rate.amount)
     end
+
+    # Backs all included-in-price rates out of the gross basis, mirroring
+    # Spree::TaxRate.store_pre_tax_amount (several rates can share a tax
+    # category, e.g. MOSS VAT). Falls back to this rate's amount when no
+    # rate matches the item, e.g. in bare setups without matching zones.
+    def net_basis(item, basis)
+      included = included_rates_amount(item)
+      included = rate.amount if included.zero?
+
+      basis / (1 + included)
+    end
+
+    # Memoized per tax category: tax rate and zone rows are configuration,
+    # invariant within a recalculation pass.
+    def included_rates_amount(item)
+      @included_rates_amount ||= {}
+      @included_rates_amount[item.tax_category_id] ||=
+        Spree::TaxRate.included_tax_amount_for(tax_zone: rate.zone, tax_category: item.tax_category)
+    end
   end
 end

data/app/models/spree/line_item.rb

@@ -146,6 +146,29 @@ module Spree
     alias discounted_money display_discounted_amount
     alias discounted_amount taxable_amount
 
+    # Returns the amount this line item is taxed on: the discounted amount
+    # reduced further by the line item's proportional share of any
+    # whole-order promotions, which are adjustments on the order itself and
+    # therefore not part of +taxable_adjustment_total+. Never negative.
+    #
+    # @return [BigDecimal]
+    def taxable_basis
+      basis = taxable_amount
+      return basis if basis <= 0
+
+      order_discount = order.order_level_promo_total
+      return basis if order_discount.zero?
+
+      # summed in SQL so the allocation uses the persisted adjustment totals
+      # of all line items, not a possibly stale cached association
+      items_total = order.line_items.reorder(nil).pick(
+        Arel.sql('COALESCE(SUM(price * quantity + taxable_adjustment_total), 0)')
+      )
+      return basis if items_total <= 0
+
+      [basis + (order_discount * basis / items_total), BigDecimal(0)].max
+    end
+
     # Returns the final amount of the line item
     #
     # @return [BigDecimal]

data/app/models/spree/order.rb

@@ -360,6 +360,16 @@ module Spree
       line_items.sum(:pre_tax_amount)
     end
 
+    # Sum of the eligible promotion adjustments applied to the order itself
+    # (whole-order discounts created by Promotion::Actions::CreateAdjustment),
+    # as opposed to promotions applied to individual line items or shipments.
+    # Zero or negative.
+    #
+    # @return [BigDecimal]
+    def order_level_promo_total
+      adjustments.promotion.eligible.sum(:amount)
+    end
+
     # Sum of all line item and shipment pre-tax
     def pre_tax_total
       pre_tax_item_amount + shipments.sum(:pre_tax_amount)

data/app/models/spree/shipment.rb

@@ -207,6 +207,15 @@ module Spree
     end
     alias discounted_amount discounted_cost
 
+    # Returns the amount this shipment is taxed on: its discounted cost,
+    # never negative (stacked shipping promotions can push discounted_cost
+    # below zero). Whole-order promotions are not allocated to shipments.
+    #
+    # @return [BigDecimal]
+    def taxable_basis
+      [discounted_cost, BigDecimal(0)].max
+    end
+
     def final_price
       cost + adjustment_total
     end

data/app/models/spree/tax_rate.rb

@@ -54,6 +54,13 @@ module Spree
     # 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
+    #
+    # 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

data/app/services/spree/addresses/update.rb

@@ -7,7 +7,16 @@ module Spree
       attr_accessor :country
 
       def call(address:, address_params:, **opts)
-        order = opts[:order]
+        ApplicationRecord.transaction do
+          perform(address: address, address_params: address_params, **opts)
+        end
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotDestroyed => e
+        failure(e.record)
+      end
+
+      private
+
+      def perform(address:, address_params:, **opts)
         default_billing = address_params.key?(:is_default_billing) ? address_params.delete(:is_default_billing) : opts.fetch(:default_billing, false)
         default_shipping = address_params.key?(:is_default_shipping) ? address_params.delete(:is_default_shipping) : opts.fetch(:default_shipping, false)
         address_changes_except = opts.fetch(:address_changes_except, [])
@@ -35,24 +44,23 @@ module Spree
         return success(address) unless address_changed
 
         if address.editable?
-          if address.update(address_params)
-            if address.user.present?
-              assign_to_user_as_default(
-                user: address.user,
-                address_id: address.id,
-                default_billing: default_billing,
-                default_shipping: default_shipping
-              )
-            end
-
-            order.update(state: 'address') if order.present?
-
-            success(address)
-          else
-            failure(address)
+          address.update!(address_params)
+
+          if address.user.present?
+            assign_to_user_as_default(
+              user: address.user,
+              address_id: address.id,
+              default_billing: default_billing,
+              default_shipping: default_shipping
+            )
           end
+
+          reassign_incomplete_orders(address.id, address)
+
+          success(address)
         elsif new_address(address_params).valid?
-          address.destroy
+          old_address_id = address.id
+          address.destroy!
 
           if new_address.user.present?
             default_billing = address.user_default_billing? || default_billing
@@ -66,12 +74,7 @@ module Spree
             )
           end
 
-          if order.present?
-            order.ship_address = new_address if order.ship_address_id == address.id
-            order.bill_address = new_address if order.bill_address_id == address.id
-            order.state = 'address'
-            order.save
-          end
+          reassign_incomplete_orders(old_address_id, new_address)
 
           success(new_address)
         else
@@ -79,8 +82,6 @@ module Spree
         end
       end
 
-      private
-
       def prepare_address_params!(address, address_params)
         address_params[:user_id] = address&.user_id
         address_params[:country_id] ||= address.country_id
@@ -88,6 +89,12 @@ module Spree
         address_params.transform_values!(&:presence)
       end
 
+      def reassign_incomplete_orders(old_address_id, new_address)
+        orders = Spree::Order.incomplete.where(user_id: new_address.user_id)
+        orders.where(ship_address_id: old_address_id).update_all(ship_address_id: new_address.id, state: 'address', updated_at: Time.current)
+        orders.where(bill_address_id: old_address_id).update_all(bill_address_id: new_address.id, state: 'address', updated_at: Time.current)
+      end
+
       def defaults_changed?(address, default_billing, default_shipping)
         user = address.user
 

data/lib/generators/spree/dummy/templates/rails/database.yml

@@ -75,6 +75,7 @@ development:
 test:
   adapter: sqlite3
   database: db/spree_test<%%= ENV['TEST_ENV_NUMBER'] %>.sqlite3
+  timeout: 10000
 production:
   adapter: sqlite3
   database: db/spree_production.sqlite3

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '5.6.0.rc2'.freeze
+  VERSION = '5.6.0.rc3'.freeze
 
   def self.version
     VERSION

data/lib/spree/events.rb

@@ -187,7 +187,7 @@ module Spree
       #
       # @return [Boolean]
       def enabled?
-        !@globally_disabled && !Thread.current[:spree_events_disabled]
+        !@globally_disabled && !RequestStore.store[:spree_events_disabled]
       end
 
       # Temporarily disable events within a block
@@ -202,11 +202,35 @@ module Spree
       #   end
       #
       def disable
-        previous = Thread.current[:spree_events_disabled]
-        Thread.current[:spree_events_disabled] = true
+        previous = RequestStore.store[:spree_events_disabled]
+        RequestStore.store[:spree_events_disabled] = true
         yield
       ensure
-        Thread.current[:spree_events_disabled] = previous
+        RequestStore.store[:spree_events_disabled] = previous
+      end
+
+      # Check if automatic lifecycle events (*.created/updated/deleted) are enabled
+      #
+      # @return [Boolean]
+      def lifecycle_enabled?
+        enabled? && !RequestStore.store[:spree_lifecycle_events_disabled]
+      end
+
+      # Temporarily disable automatic lifecycle events within a block
+      #
+      # Unlike {disable}, explicitly published events (`publish_event`) still
+      # flow — only the per-record *.created/updated/deleted callbacks are
+      # suppressed. Used by bulk operations that emit their own coarser events
+      # afterwards (e.g. one product event per imported group).
+      #
+      # @yield Block during which lifecycle events are disabled
+      # @return [Object] Return value of the block
+      def disable_lifecycle
+        previous = RequestStore.store[:spree_lifecycle_events_disabled]
+        RequestStore.store[:spree_lifecycle_events_disabled] = true
+        yield
+      ensure
+        RequestStore.store[:spree_lifecycle_events_disabled] = previous
       end
 
       # Globally disable events
@@ -233,13 +257,13 @@ module Spree
       #
       def enable
         previous_global = @globally_disabled
-        previous_thread = Thread.current[:spree_events_disabled]
+        previous_thread = RequestStore.store[:spree_events_disabled]
         @globally_disabled = false
-        Thread.current[:spree_events_disabled] = false
+        RequestStore.store[:spree_events_disabled] = false
         yield
       ensure
         @globally_disabled = previous_global
-        Thread.current[:spree_events_disabled] = previous_thread
+        RequestStore.store[:spree_events_disabled] = previous_thread
       end
 
       # Globally enable events

data/lib/spree/testing_support/lifecycle_events.rb

@@ -21,6 +21,18 @@ shared_examples_for 'lifecycle events' do |factory: nil, event_prefix: nil|
         expect(record).to receive(:publish_event).with("#{lifecycle_event_prefix}.updated")
         allow(record).to receive(:publish_event).with(anything)
 
+        # update_attribute, not update!: Spree::Shipment#update! shadows the
+        # Active Record method with the legacy state-recalculation API.
+        Timecop.travel(1.minute.from_now) do
+          record.update_attribute(:updated_at, Time.current)
+        end
+      end
+
+      it 'does not publish updated event on a bare touch' do
+        record = create(lifecycle_factory)
+        expect(record).not_to receive(:publish_event).with("#{lifecycle_event_prefix}.updated")
+        allow(record).to receive(:publish_event).with(anything)
+
         record.touch
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_core
 version: !ruby/object:Gem::Version
-  version: 5.6.0.rc2
+  version: 5.6.0.rc3
 platform: ruby
 authors:
 - Sean Schofield
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-17 00:00:00.000000000 Z
+date: 2026-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n-tasks
@@ -849,6 +849,7 @@ files:
 - app/helpers/spree/locale_helper.rb
 - app/helpers/spree/localized_names_helper.rb
 - app/helpers/spree/products_helper.rb
+- app/helpers/spree/rich_text_helper.rb
 - app/helpers/spree/shipment_helper.rb
 - app/javascript/spree/core/controllers/address_autocomplete_controller.js
 - app/javascript/spree/core/controllers/address_form_controller.js
@@ -1860,9 +1861,9 @@ licenses:
 - BSD-3-Clause
 metadata:
   bug_tracker_uri: https://github.com/spree/spree/issues
-  changelog_uri: https://github.com/spree/spree/releases/tag/v5.6.0.rc2
+  changelog_uri: https://github.com/spree/spree/releases/tag/v5.6.0.rc3
   documentation_uri: https://docs.spreecommerce.org/
-  source_code_uri: https://github.com/spree/spree/tree/v5.6.0.rc2
+  source_code_uri: https://github.com/spree/spree/tree/v5.6.0.rc3
 post_install_message:
 rdoc_options: []
 require_paths: