spree_core 5.6.0.rc2 → 5.6.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df2eef5a82cf40bca9b5c518b663153584a72dc1dadf05880a5c2ce344766394
-  data.tar.gz: 48771116e279ccb8c5ed4f83896a60e8063b74cb8785ff51953c9d8446a804f2
+  metadata.gz: 81bf3080a8d43c9bc6a6d76561c9fae751c9282a1e8b30dfb388ca6abe2511d7
+  data.tar.gz: 423cf415d52c180297db3e26b581ea4078cfcf0e7816fc3084d12034b3d74a87
 SHA512:
-  metadata.gz: 3a27318377cb47ae53d0405a9a034642119446d4507f03c68966cd550cf41430dcdb0cc3ff7c67f8bf1435b695816c26f92b73e525f2ead42eaf83070c019f40
-  data.tar.gz: 1ac22bf54e39352eede750b630b7e2d6ca6a0d4713c776f0efd20e9cf552f3689b24b154c0694db3ae0edabba37a0bc1c7ad91aa5a0e84cca62aa5cc459d48f7
+  metadata.gz: 351598372ce3b7d938815929ac76d050a45679aad1a4734c07a5642f932b81e0e688e0903538e2446c30516545083d2c6d52963b82598650d6e998606aeb8341
+  data.tar.gz: 258324d4c6e23afbe5702782daf6e19811af60136b4f93bbd99d27824830ee7211426fde12f1330175132b4c82c281cfc6295ca0d7cd6f2cc400cce5e3f7e729

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/concerns/spree/webhook_payload_redaction.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Spree
+  # Keeps single-use credentials out of the persisted webhook delivery log.
+  #
+  # Some events must carry a live credential to their subscriber — a storefront
+  # that owns its transactional emails needs the real password reset token to
+  # build the email. Delivering it over TLS to a merchant-configured endpoint is
+  # intended; keeping a readable copy in `spree_webhook_deliveries.payload` is
+  # not, because that column is queryable and is served back through the Admin
+  # API delivery log.
+  #
+  # Sensitive values are therefore replaced with {REDACTION_PLACEHOLDER} before
+  # the record is written, and re-attached in memory at send time so the
+  # outgoing request body is unchanged.
+  module WebhookPayloadRedaction
+    extend ActiveSupport::Concern
+
+    # Payload keys under `data` whose values are live credentials.
+    SENSITIVE_PAYLOAD_KEYS = %w[reset_token unsubscribe_token].freeze
+
+    REDACTION_PLACEHOLDER = '[REDACTED]'
+
+    # Splits a payload into the version safe to persist and the secrets held
+    # back from it.
+    #
+    # @param payload [Hash] the full event payload
+    # @return [Array(Hash, Hash)] redacted payload, and the extracted secrets
+    #   keyed as they appeared under `data`
+    def self.split(payload)
+      secrets = {}
+
+      redacted = transform_data_hashes(payload) do |data|
+        data.to_h do |key, value|
+          if SENSITIVE_PAYLOAD_KEYS.include?(key.to_s) && value.present?
+            secrets[secret_key_for(key)] = value
+            [key, REDACTION_PLACEHOLDER]
+          else
+            [key, value]
+          end
+        end
+      end
+
+      secrets.empty? ? [payload, {}] : [redacted, secrets]
+    end
+
+    # Re-attaches previously extracted secrets to a redacted payload.
+    #
+    # @param payload [Hash] the redacted payload
+    # @param secrets [Hash] secrets returned by {split}
+    # @return [Hash] the payload as it should go over the wire
+    def self.merge(payload, secrets)
+      return payload if secrets.blank?
+
+      transform_data_hashes(payload) do |data|
+        data.to_h do |key, value|
+          secret = secrets[secret_key_for(key)]
+          [key, secret.presence || value]
+        end
+      end
+    end
+
+    # Applies +block+ to every `data` hash on the payload.
+    #
+    # Both key forms are visited rather than only the first match: a payload
+    # carrying `:data` *and* `'data'` would otherwise leave one of them
+    # unredacted.
+    def self.transform_data_hashes(payload)
+      return payload unless payload.is_a?(Hash)
+
+      [:data, 'data'].reduce(payload) do |result, data_key|
+        data = result[data_key]
+        next result unless data.is_a?(Hash)
+
+        result.merge(data_key => yield(data))
+      end
+    end
+    private_class_method :transform_data_hashes
+
+    # Secrets are keyed by name alone. They cross an ActiveJob serialization
+    # boundary, which coerces symbol keys to strings, so the key form at split
+    # time cannot be relied on to still match at merge time.
+    def self.secret_key_for(key)
+      key.to_s
+    end
+    private_class_method :secret_key_for
+  end
+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/api_key.rb

@@ -46,6 +46,11 @@ module Spree
     end
 
     belongs_to :store, class_name: 'Spree::Store'
+    # Optional single-channel binding for publishable keys. A bound key
+    # server-assigns the request's channel (see Api::V3::ChannelResolution),
+    # making channel identity unforgeable instead of client-asserted via the
+    # X-Spree-Channel header. See docs/plans/5.6-store-channel-context-and-key-binding.md.
+    belongs_to :channel, class_name: 'Spree::Channel', optional: true
     belongs_to :created_by, polymorphic: true, optional: true
     belongs_to :revoked_by, polymorphic: true, optional: true
 
@@ -64,6 +69,11 @@ module Spree
     # guard is at the model so every entry point (API, legacy admin, rake tasks)
     # is covered uniformly.
     validate :scopes_immutable, if: -> { secret? && persisted? && scopes_changed? }
+    validate :channel_binding_valid, if: -> { channel_id.present? }
+    # Like scopes, the binding is fixed for the life of the key — rebinding a
+    # live credential to a different channel would silently repoint every
+    # client holding it; mint a new key instead.
+    validate :channel_immutable, if: -> { persisted? && channel_id_changed? }
 
     before_validation :generate_token, on: :create
 
@@ -156,6 +166,18 @@ module Spree
       errors.add(:scopes, Spree.t(:api_key_scopes_immutable))
     end
 
+    def channel_binding_valid
+      if secret?
+        errors.add(:channel, Spree.t(:api_key_channel_publishable_only))
+      elsif channel && channel.store_id != store_id
+        errors.add(:channel, Spree.t(:api_key_channel_must_belong_to_store))
+      end
+    end
+
+    def channel_immutable
+      errors.add(:channel, Spree.t(:api_key_channel_immutable))
+    end
+
     # Generates the token on creation. For publishable keys, stores the raw token
     # in the +token+ column. For secret keys, computes an HMAC-SHA256 digest stored
     # in +token_digest+, saves the first 12 characters as +token_prefix+ for display,

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/channel.rb

@@ -22,6 +22,7 @@ module Spree
     has_many :order_routing_rules, class_name: 'Spree::OrderRoutingRule', dependent: :destroy
     has_many :publications, class_name: 'Spree::ProductPublication', dependent: :destroy
     has_many :products, through: :publications, class_name: 'Spree::Product'
+    has_many :api_keys, class_name: 'Spree::ApiKey', dependent: :nullify
 
     attribute :active, :boolean, default: true
 
@@ -40,6 +41,10 @@ module Spree
     # arrives at a single default without relying on DB constraints.
     before_save :demote_other_defaults, if: -> { default? && will_save_change_to_default? }
     before_destroy :ensure_not_default
+    # prepend: the +dependent: :nullify+ on +api_keys+ registers its own
+    # before_destroy at association-declaration time; without prepend it would
+    # clear every binding before this guard could see them.
+    before_destroy :ensure_no_active_bound_api_keys, prepend: true
     after_create :ensure_default_order_routing_rules
 
     scope :active, -> { where(active: true) }
@@ -115,19 +120,32 @@ module Spree
 
     # @return [Boolean]
     def can_be_deleted?
-      !default?
+      !default? && !api_keys.active.exists?
     end
 
     private
 
     def ensure_not_default
-      return if can_be_deleted?
+      return unless default?
       return if destroyed_by_association.present?
 
       errors.add(:base, Spree.t('errors.messages.cannot_delete_default_channel'))
       throw :abort
     end
 
+    # Fail closed: deleting a channel must not silently convert its bound
+    # publishable keys into unbound (store-wide) credentials via the
+    # +dependent: :nullify+ above. Active keys block deletion — revoke or
+    # rebind them first; revoked keys are historical and nullify freely.
+    # Store-cascade deletes skip the guard (the keys die with the store).
+    def ensure_no_active_bound_api_keys
+      return unless api_keys.active.exists?
+      return if destroyed_by_association.present?
+
+      errors.add(:base, Spree.t('errors.messages.cannot_delete_channel_with_active_api_keys'))
+      throw :abort
+    end
+
     def backfill_code_from_name
       self.code = name
     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/models/spree/webhook_delivery.rb

@@ -7,6 +7,11 @@ module Spree
     belongs_to :webhook_endpoint, class_name: 'Spree::WebhookEndpoint'
     delegate :url, to: :webhook_endpoint
 
+    # Credentials stripped from the persisted payload. Never written to the
+    # database — held in memory on a single delivery instance, assigned by
+    # WebhookDeliveryJob when it runs. See {Spree::WebhookPayloadRedaction}.
+    attr_accessor :payload_secrets
+
     validates :event_name, presence: true
     validates :payload, presence: true
 
@@ -64,6 +69,23 @@ module Spree
       webhook_endpoint.check_auto_disable! unless is_success
     end
 
+    # Payload as it should be sent over the wire.
+    #
+    # Re-attaches any credentials withheld from the persisted column. Once this
+    # record has been reloaded from the database those secrets are gone for
+    # good, so a redelivery sends the redacted placeholder — single-use tokens
+    # are not replayable anyway.
+    #
+    # This is deliberate: keeping a recoverable copy would put the credential
+    # back at rest, which is what redaction exists to prevent. If a delivery is
+    # lost (worker crash between creation and delivery), the customer requests
+    # a new reset, which mints a fresh token.
+    #
+    # @return [Hash]
+    def deliverable_payload
+      Spree::WebhookPayloadRedaction.merge(payload, payload_secrets)
+    end
+
     # Create a new delivery with the same payload and queue it.
     # Used to retry failed deliveries manually.
     #

data/app/presenters/spree/data_feeds/google_presenter.rb

@@ -3,6 +3,22 @@ require 'nokogiri'
 module Spree
   module DataFeeds
     class GooglePresenter < BasePresenter
+      # Optional Google Merchant Center product attributes sourced from
+      # metafields. See https://support.google.com/merchants/answer/7052112
+      OPTIONAL_ATTRIBUTES = %w[
+        brand gtin mpn identifier_exists condition adult multipack is_bundle
+        age_group color gender material pattern size size_type size_system
+        product_length product_width product_height product_weight
+        google_product_category product_type sale_price sale_price_effective_date
+        cost_of_goods_sold unit_pricing_measure unit_pricing_base_measure
+        shipping shipping_label shipping_weight shipping_length shipping_width
+        shipping_height ships_from_country transit_time_label max_handling_time
+        min_handling_time tax tax_category energy_efficiency_class
+        min_energy_efficiency_class max_energy_efficiency_class
+        gtin_source expiration_date custom_label_0 custom_label_1 custom_label_2
+        custom_label_3 custom_label_4 mobile_link additional_image_link
+      ].freeze
+
       # @return [String] RSS XML feed for Google Merchant Center
       def call
         builder = Nokogiri::XML::Builder.new do |xml|
@@ -59,10 +75,21 @@ module Spree
 
       def build_optional_attributes(xml, product)
         product.public_metafields.each do |metafield|
-          xml['g'].send(metafield.metafield_definition.key.parameterize.underscore, metafield.value)
+          key = metafield.metafield_definition.key.parameterize.underscore
+          next unless OPTIONAL_ATTRIBUTES.include?(key)
+
+          append_g_element(xml, key, metafield.value)
         end
       end
 
+      def append_g_element(xml, name, value)
+        parent = xml.parent
+        node = Nokogiri::XML::Node.new(name, parent.document)
+        node.namespace = parent.namespace_scopes.find { |ns| ns.prefix == 'g' }
+        node.content = value
+        parent << node
+      end
+
       def format_title(product, variant)
         parts = [product.name]
         variant.option_values.each do |option_value|