spree_core 5.6.1 → 6.0.0.beta2

data/app/presenters/spree/csv/order_line_item_presenter.rb

@@ -28,7 +28,7 @@ module Spree
         'Item Total Price',
         'Item requires shipping',
         'Item taxbale',
-        'Item Vendor',
+        'Item Seller',
         'Category lvl0',
         'Category lvl1',
         'Category lvl2',
@@ -59,32 +59,54 @@ module Spree
         'Notes'
       ].freeze
 
-      def initialize(order, line_item, index, metafields = [])
+      # Columns a caller may leave out, and the headers naming them.
+      #
+      # Filtering both the header list and the row through the same names is
+      # what keeps them aligned: dropping a cell by hand would silently shift
+      # every value after it into the wrong column.
+      #
+      # @param order [Spree::Order]
+      # @param line_item [Spree::LineItem]
+      # @param index [Integer] position within the order's line items; only
+      #   the first row carries the order-level values
+      # @param custom_fields [Array]
+      # @param omit_headers [Array<String>] headers to leave out of this row
+      def initialize(order, line_item, index, custom_fields = [], omit_headers: [])
         @order = order
         @line_item = line_item
         @index = index
-        @metafields = metafields
+        @custom_fields = custom_fields
+        @omit_headers = Array(omit_headers)
       end
 
-      attr_accessor :order, :line_item, :index, :metafields
+      attr_accessor :order, :line_item, :index, :custom_fields
+      attr_reader :omit_headers
+
+      # The headers this presenter emits, minus the omitted ones.
+      #
+      # @param omit_headers [Array<String>]
+      # @return [Array<String>]
+      def self.headers(omit_headers: [])
+        HEADERS - Array(omit_headers)
+      end
 
       def call
         csv = [
           order.number,
           index.zero? ? order.email : nil,
-          index.zero? ? order.state : nil,
+          index.zero? ? order.status : nil,
           index.zero? ? order.currency : nil,
           index.zero? ? order.item_total.to_f : nil,
           index.zero? ? order.shipment_total.to_f : nil,
           index.zero? ? order.tax_total.to_f : nil,
           index.zero? ? order.included_tax_total.positive? : nil,
-          index.zero? ? (order.promo_total.negative? || line_item.promo_total.negative?) : nil,
+          index.zero? ? (order.discount_total.negative? || line_item.discount_total.negative?) : nil,
           index.zero? ? order.has_free_shipping? : nil,
-          index.zero? ? order.promo_total.abs : nil,
+          index.zero? ? order.discount_total.abs : nil,
           index.zero? ? order.promo_code : nil,
           index.zero? ? order.payments.store_credits.sum(:amount).abs : nil,
           index.zero? ? order.total.to_f : nil,
-          index.zero? ? order.shipping_method&.name : nil,
+          index.zero? ? order.delivery_method&.name : nil,
           index.zero? ? order.total_weight.to_f : nil,
           index.zero? ? order.payments.valid&.first&.display_source_name : nil,
           line_item.product_id,
@@ -92,22 +114,22 @@ module Spree
           line_item.sku,
           line_item.name,
           line_item.price,
-          line_item.promo_total.abs,
+          line_item.discount_total.abs,
           line_item.total,
-          !line_item.product.digital?,
+          !line_item.variant.digital?,
           line_item.product.tax_category_id.present?,
-          line_item.product.try(:vendor_name),
-          taxon_dict(line_item.product.main_taxon)[0],
-          taxon_dict(line_item.product.main_taxon)[1],
-          taxon_dict(line_item.product.main_taxon)[2],
-          taxon_dict(line_item.product.main_taxon)[3],
-          taxon_dict(line_item.product.main_taxon)[4],
+          line_item.product.try(:seller_name),
+          taxon_dict(line_item.product.primary_category)[0],
+          taxon_dict(line_item.product.primary_category)[1],
+          taxon_dict(line_item.product.primary_category)[2],
+          taxon_dict(line_item.product.primary_category)[3],
+          taxon_dict(line_item.product.primary_category)[4],
           index.zero? ? order.bill_address&.full_name : nil,
           index.zero? ? order.bill_address&.address1 : nil,
           index.zero? ? order.bill_address&.address2 : nil,
           index.zero? ? order.bill_address&.company : nil,
           index.zero? ? order.bill_address&.city : nil,
-          index.zero? ? order.bill_address&.zipcode : nil,
+          index.zero? ? order.bill_address&.postal_code : nil,
           index.zero? ? order.bill_address&.state_name : nil,
           index.zero? ? order.bill_address&.country&.name : nil,
           index.zero? ? order.bill_address&.phone : nil,
@@ -116,19 +138,21 @@ module Spree
           index.zero? ? order.ship_address&.address2 : nil,
           index.zero? ? order.ship_address&.company : nil,
           index.zero? ? order.ship_address&.city : nil,
-          index.zero? ? order.ship_address&.zipcode : nil,
+          index.zero? ? order.ship_address&.postal_code : nil,
           index.zero? ? order.ship_address&.state_name : nil,
           index.zero? ? order.ship_address&.country&.name : nil,
           index.zero? ? order.ship_address&.phone : nil,
           index.zero? ? format_date(order.completed_at) : nil,
-          format_date(line_item.order.shipments.first&.shipped_at),
+          format_date(line_item.order.fulfillments.first&.fulfilled_at),
           index.zero? ? format_date(order.canceled_at) : nil,
           index.zero? ? order.canceler&.email : nil,
-          index.zero? ? order.special_instructions : nil
+          index.zero? ? order.customer_note : nil
         ]
 
+        csv = reject_omitted(csv)
+
         if index.zero?
-          csv += metafields
+          csv += custom_fields
         end
 
         csv
@@ -136,6 +160,14 @@ module Spree
 
       private
 
+      # Drops the cells whose headers were omitted, matching each value to its
+      # header by position so the row and the header list stay aligned.
+      def reject_omitted(csv)
+        return csv if omit_headers.empty?
+
+        csv.reject.with_index { |_value, position| omit_headers.include?(HEADERS[position]) }
+      end
+
       def taxon_dict(taxon)
         return [] if taxon.blank?
 

data/app/presenters/spree/csv/price_list_price_presenter.rb

@@ -0,0 +1,41 @@
+module Spree
+  module CSV
+    # One rung of a price list as a CSV line. The headers are exactly the
+    # import schema's fields, so an exported file maps onto the import without
+    # anyone renaming a column, and every column in it means something on the
+    # way back (docs/plans/6.0-volume-pricing.md).
+    class PriceListPricePresenter
+      HEADERS = Spree::ImportSchemas::PriceListPrices.new.headers.freeze
+
+      def initialize(price)
+        @price = price
+      end
+
+      attr_reader :price
+
+      # @return [Array<String, Integer, nil>]
+      def call
+        [
+          price.variant.sku,
+          price.currency,
+          price.min_quantity,
+          amount_string(price.amount),
+          amount_string(price.compare_at_amount)
+        ]
+      end
+
+      private
+
+      # The currency's own precision, a dot for the decimal mark and nothing
+      # else — "18.00", never "$18.00", "18.0" or "18,00". Fixed rather than
+      # localized because the file is read back by the import under the
+      # store's locale, not the exporting admin's, and a comma written here
+      # would re-import as a hundred times the price.
+      def amount_string(amount)
+        return nil if amount.nil?
+
+        format("%.#{Spree::Money::Rounding.precision(price.currency)}f", amount)
+      end
+    end
+  end
+end

data/app/presenters/spree/csv/product_variant_presenter.rb

@@ -9,8 +9,7 @@ module Spree
         'name',
         'slug',
         'status',
-        'vendor_name',
-        'brand_name',
+        'seller_name',
         'description',
         'meta_title',
         'meta_description',
@@ -32,7 +31,7 @@ module Spree
         'inventory_count',
         'inventory_backorderable',
         'tax_category',
-        'shipping_category',
+        'product_type',
         'image1_src',
         'image2_src',
         'image3_src',
@@ -47,29 +46,29 @@ module Spree
         'category3',
       ].freeze
 
-      def initialize(product, variant, index = 0, properties = [], taxons = [], store = nil, metafields = [], currency = nil)
+      def initialize(product, variant, index = 0, properties = [], categories = [], store = nil, custom_fields = [], currency = nil)
         @product = product
         @variant = variant
         @index = index
         @properties = properties
-        @taxons = taxons
+        @categories = categories
         @store = store || product.store
         @currency = currency || @store.default_currency
         @price_only = @currency != @store.default_currency
-        @metafields = metafields
+        @custom_fields = custom_fields
       end
 
-      attr_accessor :product, :variant, :index, :properties, :taxons, :store, :currency, :price_only, :metafields
+      attr_accessor :product, :variant, :index, :properties, :categories, :store, :currency, :price_only, :custom_fields
 
       ##
       # Generates an array representing a CSV row of product variant data.
       #
       # For the primary variant row (when the index is zero), product-level details such as name,
-      # slug, status, vendor and brand names, description, meta tags, and tag/label lists are included.
+      # slug, status, seller name, description, meta tags, and tag/label lists are included.
       # In all cases, variant-specific attributes (e.g., id, SKU, pricing, dimensions, weight,
       # availability dates, inventory count, shipping category, tax category, image URLs via original_url,
       # and the first three option types and corresponding option values) are appended.
-      # Additionally, when the index is zero, associated taxons and properties are added.
+      # Additionally, when the index is zero, associated categories and properties are added.
       #
       # @return [Array] An array containing the combined product and variant CSV data.
       def call
@@ -83,9 +82,8 @@ module Spree
           index.zero? ? product.name : nil,
           product.slug,
           index.zero? ? product.status : nil,
-          index.zero? ? product.try(:vendor_name) : nil,
-          index.zero? ? product.try(:brand_name) : nil,
-          index.zero? ? product.description&.html_safe : nil,
+          index.zero? ? product.try(:seller_name) : nil,
+          index.zero? ? product.description : nil,
           index.zero? ? product.meta_title : nil,
           index.zero? ? product.meta_description : nil,
           index.zero? ? product.meta_keywords : nil,
@@ -97,31 +95,34 @@ module Spree
           variant.width,
           variant.height,
           variant.depth,
-          variant.dimensions_unit,
+          # The stored columns, not the resolved readers: importing this file
+          # into a store on another unit system must not silently write this
+          # store's units onto every variant.
+          variant[:dimensions_unit],
           variant.weight,
-          variant.weight_unit,
+          variant[:weight_unit],
           publication_available_on&.strftime('%Y-%m-%d %H:%M:%S'),
           (variant.discontinue_on || publication_discontinue_on)&.strftime('%Y-%m-%d %H:%M:%S'),
           variant.track_inventory?,
           total_on_hand == BigDecimal::INFINITY ? '∞' : total_on_hand,
           variant.backorderable?,
           variant.tax_category&.name,
-          product.shipping_category&.name,
+          product.product_type&.name,
           spree_image_url(variant.images[0], image_url_options),
           spree_image_url(variant.images[1], image_url_options),
           spree_image_url(variant.images[2], image_url_options),
-          index.positive? ? option_type(0)&.presentation : nil,
+          index.positive? ? option_type(0)&.label : nil,
           index.positive? ? option_value(option_type(0)) : nil,
-          index.positive? ? option_type(1)&.presentation : nil,
+          index.positive? ? option_type(1)&.label : nil,
           index.positive? ? option_value(option_type(1)) : nil,
-          index.positive? ? option_type(2)&.presentation : nil,
+          index.positive? ? option_type(2)&.label : nil,
           index.positive? ? option_value(option_type(2)) : nil
         ]
 
         if index.zero?
-          csv += taxons
+          csv += categories
           csv += properties
-          csv += metafields
+          csv += custom_fields
         end
 
         csv
@@ -132,7 +133,7 @@ module Spree
       end
 
       def option_value(option_type)
-        variant.option_values.find { |ov| ov.option_type == option_type }&.presentation
+        variant.option_values.find { |ov| ov.option_type == option_type }&.label
       end
 
       private

data/app/presenters/spree/csv/purchase_order_item_presenter.rb

@@ -0,0 +1,50 @@
+module Spree
+  module CSV
+    # One purchase order line as a CSV row: the order it belongs to, then the
+    # line, then what has happened to it. Every import-schema column is here
+    # under its own name, so an exported file re-imports as it stands.
+    class PurchaseOrderItemPresenter
+      HEADERS = %w[
+        number status reference supplier destination
+        sku product_name quantity received rejected unit_cost currency
+        expected_at cancel_by notes
+      ].freeze
+
+      def initialize(item)
+        @item = item
+      end
+
+      attr_reader :item
+
+      def call
+        order = item.purchase_order
+
+        [
+          order.number,
+          order.status,
+          order.reference,
+          order.supplier&.name,
+          order.destination_location&.name,
+          item.variant&.sku,
+          item.variant&.product&.name,
+          item.quantity_ordered,
+          item.quantity_received,
+          item.quantity_rejected,
+          amount_string(item.unit_cost, order.currency),
+          order.currency,
+          order.expected_at&.iso8601,
+          order.cancel_by&.iso8601,
+          order.notes
+        ]
+      end
+
+      private
+
+      def amount_string(amount, currency)
+        return nil if amount.nil?
+
+        format("%.#{Spree::Money::Rounding.precision(currency)}f", amount)
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Spree
   module DataFeeds
     class GooglePresenter < BasePresenter
       # Optional Google Merchant Center product attributes sourced from
-      # metafields. See https://support.google.com/merchants/answer/7052112
+      # custom_fields. 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
@@ -42,15 +42,21 @@ module Spree
       end
 
       def build_items(xml)
-        products.includes(:primary_media, public_metafields: :metafield_definition, variants_including_master: [:primary_media, option_values: :option_type]).find_each do |product|
-          product.variants_including_master.active.each do |variant|
-            next if variant.is_master? && product.has_variants?
-
+        products.includes(:primary_media, storefront_custom_fields: :custom_field_definition, variants: [:primary_media, option_values: :option_type]).find_each do |product|
+          product.variants.active(feed_currency).each do |variant|
             build_item(xml, product, variant)
           end
         end
       end
 
+      # The feed quotes every item in the store's currency, so variants are
+      # both selected and priced against it — a variant's own +cost_currency+
+      # may differ and carry no price here.
+      # @return [String]
+      def feed_currency
+        store.default_currency
+      end
+
       def build_item(xml, product, variant)
         image_url = image_link(variant, product)
         return if image_url.nil?
@@ -65,20 +71,20 @@ module Spree
         xml['g'].id variant.id
         xml['g'].item_group_id product.id
         xml['g'].title format_title(product, variant)
-        xml['g'].description product.description || format_title(product, variant)
+        xml['g'].description plain_description(product).presence || format_title(product, variant)
         xml['g'].link "#{store.storefront_url}/products/#{product.slug}"
         xml['g'].image_link image_url
-        xml['g'].price "#{variant.price} #{variant.cost_currency}"
+        xml['g'].price "#{variant.amount_in(feed_currency)} #{feed_currency}"
         xml['g'].availability availability(product)
         xml['g'].availability_date product.available_on.xmlschema if product.available_on.present?
       end
 
       def build_optional_attributes(xml, product)
-        product.public_metafields.each do |metafield|
-          key = metafield.metafield_definition.key.parameterize.underscore
+        product.storefront_custom_fields.each do |custom_field|
+          key = custom_field.custom_field_definition.key.parameterize.underscore
           next unless OPTIONAL_ATTRIBUTES.include?(key)
 
-          append_g_element(xml, key, metafield.value)
+          append_g_element(xml, key, custom_field.value)
         end
       end
 
@@ -90,6 +96,14 @@ module Spree
         parent << node
       end
 
+      # Google expects plain text in g:description, not markup. Memoized per
+      # product: this is called once per variant, and stripping the markup
+      # parses the whole description each time.
+      def plain_description(product)
+        @plain_descriptions ||= {}
+        @plain_descriptions[product.id] ||= Spree::RichTextHelper.to_plain_text(product.description)
+      end
+
       def format_title(product, variant)
         parts = [product.name]
         variant.option_values.each do |option_value|

data/app/presenters/spree/filters/options_presenter.rb

@@ -8,7 +8,7 @@ module Spree
           {
             id: option_type.id,
             name: option_type.name,
-            presentation: option_type.presentation,
+            presentation: option_type.label,
             option_values: option_values.map { |e| option_value_hash(e) }
           }
         end
@@ -19,7 +19,7 @@ module Spree
           {
             id: option_value.id,
             name: option_value.name,
-            presentation: option_value.presentation,
+            presentation: option_value.label,
             position: option_value.position
           }
         end

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

@@ -4,45 +4,88 @@ module Spree
       prepend Spree::ServiceModule::Base
       include Spree::Addresses::Helper
 
-      attr_accessor :country
-
-      def call(address_params: {}, user: nil, **opts)
+      # @param owner [Object, nil] who keeps the address — a customer, a
+      #   company node, anything with an address book. +user:+ is the older
+      #   name for the same thing, from when only customers had one.
+      def call(address_params: {}, owner: nil, user: nil, **opts)
+        owner ||= user
         order = opts[:order]
-        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_params = fill_country_and_state_ids(address_params)
+        # nil, not false — the same three-state contract Update keeps, so
+        # silence means the same thing on both.
+        default_billing = address_params.key?(:is_default_billing) ? address_params.delete(:is_default_billing) : opts.fetch(:default_billing, nil)
+        default_shipping = address_params.key?(:is_default_shipping) ? address_params.delete(:is_default_shipping) : opts.fetch(:default_shipping, nil)
 
         address = Spree::Address.new(address_params)
-        address.user = user if user.present?
+        address.owner = owner if owner.present?
 
         ApplicationRecord.transaction do
-          if address.save
-            if user.present?
-              if user.addresses.pluck(:id) == [address.id]
-                user.update(bill_address_id: address.id, ship_address_id: address.id)
-              else
-                assign_to_user_as_default(
-                  user: user,
-                  address_id: address.id,
-                  default_billing: default_billing,
-                  default_shipping: default_shipping
-                )
-              end
-            end
+          arguments = { order: order, default_billing: default_billing, default_shipping: default_shipping }
+          next write(address, **arguments) if owner.nil?
 
-            assign_to_order(order: order, address_id: address.id) if order.present?
-            success(address)
-          else
-            failure(address)
-          end
+          # One writer per book at a time. Looking for an entry and then filing
+          # one when there is none is a read the write depends on, and no
+          # unique index stands behind it, so two requests arriving together
+          # would each find nothing and file an entry each — the very duplicate
+          # the lookup exists to prevent.
+          owner.with_lock { write(address, **arguments) }
         end
       end
 
       private
 
+      def write(address, order:, default_billing:, default_shipping:)
+        owner = address.owner
+        existing = existing_entry(address)
+
+        if existing.present?
+          assign_owner_default(
+            owner: owner,
+            address_id: existing.id,
+            default_billing: default_billing,
+            default_shipping: default_shipping
+          )
+
+          assign_to_order(order: order, address_id: existing.id) if order.present?
+          success(existing)
+        elsif address.save
+          if owner.present?
+            # The first address a book gets is its default of both kinds —
+            # there is nothing for it to displace.
+            if owner.addresses.pluck(:id) == [address.id]
+              assign_owner_default(owner: owner, address_id: address.id)
+            else
+              assign_owner_default(
+                owner: owner,
+                address_id: address.id,
+                default_billing: default_billing,
+                default_shipping: default_shipping
+              )
+            end
+          end
+
+          assign_to_order(order: order, address_id: address.id) if order.present?
+          success(address)
+        else
+          failure(address)
+        end
+      end
+
+      # The entry the book already holds for this, so a book that has it gets
+      # that entry back rather than a second copy of it.
+      #
+      # Validation runs first only to resolve the country and state codes, and
+      # its verdict is deliberately ignored: a resubmission carrying the label
+      # it was filed under is invalid precisely because that entry already
+      # exists, and answering it with "name has already been taken" instead of
+      # the entry itself would be absurd. A genuinely invalid address matches
+      # nothing and fails on the save that follows.
+      def existing_entry(address)
+        address.validate
+        address.duplicate_in_address_book
+      end
+
       def assign_to_order(order:, address_id:)
-        order.update(ship_address_id: address_id, state: 'address')
+        order.update(ship_address_id: address_id)
       end
     end
   end

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

@@ -3,60 +3,23 @@ module Spree
     module Helper
       private
 
-      attr_accessor :country
-
-      def fill_country_and_state_ids(params)
-        replace_country_iso_with_id(params)
-        fill_state_id(params)
-      end
-
-      def replace_country_iso_with_id(params)
-        iso = params[:country_iso]
-        return params unless iso.present?
-
-        country = Spree::Country.by_iso(iso)
-        params[:country_id] = country&.id
-        params.delete(:country_iso)
-        params
-      end
-
-      def fill_state_id(params)
-        # Always extract state_abbr - it's not a model attribute
-        state_abbr = params.delete(:state_abbr)
-
-        country ||= Spree::Country.find(params[:country_id]) if params[:country_id].present?
-        return params unless country
-
-        # Support state_abbr (state abbreviation code, e.g., "CA", "NY")
-        if state_abbr.present?
-          params[:state_id] = country.states.find_by(abbr: state_abbr)&.id
-          return params
-        end
-
-        # Support state_name - try to find matching state
-        if params[:state_name].present?
-          state = country.states.find_by(name: params[:state_name])
-          if state
-            # Found a matching state, use state_id
-            params[:state_id] = state.id
-            params.delete(:state_name)
-          elsif country.states_required?
-            # States required but not found - clear state_name so validation fails
-            params.delete(:state_name)
-          end
-          # If states not required and no match found, keep state_name as-is
-        end
-
-        params
-      end
-
-      def assign_to_user_as_default(user:, address_id:, default_billing: true, default_shipping: true)
-        attributes_to_update = {
-          ship_address_id: (address_id if default_shipping),
-          bill_address_id: (address_id if default_billing),
-        }.compact_blank
-
-        user.update_columns(**attributes_to_update, updated_at: Time.current) if attributes_to_update.present?
+      # Points an owner's default billing/shipping slots at an address.
+      #
+      # Which columns those are is the owner's business — a customer and a
+      # company node name them differently — so the owner is asked rather
+      # than assumed. The checkout path promotes defaults by plain assignment
+      # instead, because there the address ownership is exactly what is still
+      # in question.
+      #
+      # @param owner [Object, nil] anything including Spree::HasAddressBook
+      def assign_owner_default(owner:, address_id:, default_billing: true, default_shipping: true)
+        return if owner.nil? || !owner.respond_to?(:assign_default_address)
+
+        owner.assign_default_address(
+          address_id: address_id,
+          billing: default_billing,
+          shipping: default_shipping
+        )
       end
     end
   end