spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/concerns/spree/purchase/deprecated_aliases.rb

@@ -0,0 +1,87 @@
+module Spree
+  module Purchase
+    # One-release bridges for the names renamed in 6.0, shared by
+    # {Spree::Cart} and {Spree::Order}. Before 6.0 a cart was an incomplete
+    # order, so extensions written against 5.x (payment gateways, checkout
+    # plugins) call the legacy names on carts too. Every legacy name warns and
+    # forwards to its replacement. Removed in 6.1.
+    #
+    # Renamed columns are also registered with +alias_attribute+, so the legacy
+    # name keeps working in +where+ / +find_by+ (those paths do not warn).
+    module DeprecatedAliases
+      extend ActiveSupport::Concern
+
+      RENAMED_ATTRIBUTES = {
+        promo_total: :discount_total,
+        item_count: :total_quantity,
+        shipment_total: :delivery_total,
+        ship_total: :delivery_total,
+        special_instructions: :customer_note
+      }.freeze
+
+      RENAMED_METHODS = {
+        display_promo_total: :display_discount_total,
+        display_shipment_total: :display_delivery_total,
+        display_ship_total: :display_delivery_total,
+        shipping_discount: :fulfillment_discount,
+        delivery_required?: :delivery_step_required?,
+        requires_ship_address?: :shipping_address_required?,
+        set_shipments_cost: :set_fulfillments_cost,
+        ensure_updated_shipments: :ensure_updated_fulfillments,
+        create_proposed_fulfillments: :rebuild_fulfillments!,
+        create_proposed_shipments: :rebuild_fulfillments!,
+        associate_user!: :associate_customer!,
+        update_with_updater!: :recalculate_totals!,
+        all_line_items: :line_items
+      }.freeze
+
+      # 5.x took a store argument; payment methods now always come from the
+      # purchase's own store.
+      RENAMED_PAYMENT_METHOD_READERS = %i[
+        available_payment_methods
+        collect_payment_methods
+        collect_frontend_payment_methods
+      ].freeze
+
+      included do
+        include Spree::DeprecatedCustomerAlias
+
+        RENAMED_ATTRIBUTES.each do |legacy_name, current_name|
+          alias_attribute legacy_name, current_name
+        end
+      end
+
+      RENAMED_ATTRIBUTES.each do |legacy_name, current_name|
+        define_method(legacy_name) do
+          warn_deprecated_name(legacy_name, current_name)
+          public_send(current_name)
+        end
+
+        define_method(:"#{legacy_name}=") do |value|
+          warn_deprecated_name(:"#{legacy_name}=", :"#{current_name}=")
+          public_send(:"#{current_name}=", value)
+        end
+      end
+
+      RENAMED_METHODS.each do |legacy_name, current_name|
+        define_method(legacy_name) do |*args, **options, &block|
+          warn_deprecated_name(legacy_name, current_name)
+          public_send(current_name, *args, **options, &block)
+        end
+      end
+
+      RENAMED_PAYMENT_METHOD_READERS.each do |legacy_name|
+        define_method(legacy_name) do |*|
+          warn_deprecated_name(legacy_name, :payment_methods)
+          payment_methods
+        end
+      end
+
+      private
+
+      def warn_deprecated_name(legacy_name, current_name)
+        Spree::Deprecation.warn("#{self.class.name}##{legacy_name} is deprecated and will be removed in Spree 6.1. Use ##{current_name} instead.")
+      end
+    end
+  end
+end

data/app/models/concerns/spree/purchase/gift_cards.rb

@@ -51,16 +51,22 @@ module Spree
 
         payment = payments.checkout.store_credits.where(source: gift_card.store_credits).first
         return unless payment
+        # Nothing is left for the card to pay, and a store credit cannot hold
+        # a zero amount, so the card is released rather than resized.
+        return remove_gift_card unless total.positive?
 
         gift_card.with_lock do
-          new_amount = [gift_card.amount_remaining + payment.amount, total].min
+          # A locking read: a plain reload can return the transaction's older
+          # snapshot, and a resize committed since would be applied again.
+          payment.lock!
+          new_amount = [gift_card.spendable_amount + payment.amount, total].min
           next if payment.amount == new_amount
 
           difference = new_amount - payment.amount
-          # update_column bypasses Payment#max_amount validation which can
-          # fail on stale in-memory state; bounds enforced via min() above.
-          payment.update_column(:amount, new_amount)
           payment.source.update_column(:amount, new_amount)
+          # Skips Payment#max_amount, which can fail on stale in-memory state;
+          # min() above bounds the amount.
+          payment.update_store_credit_amount!(new_amount)
           gift_card.amount_used += difference
           gift_card.save!
         end

data/app/models/concerns/spree/purchase/locale.rb

@@ -22,7 +22,7 @@ module Spree
         return if locale.blank? || store.blank?
 
         unless store.supported_locales_list.include?(locale)
-          errors.add(:locale, :locale_not_supported_by_store, message: Spree.t(:locale_not_supported_by_store))
+          errors.add(:locale, :locale_not_supported_by_store, message: I18n.t('spree.locale_not_supported_by_store'))
         end
       end
     end

data/app/models/concerns/spree/purchase/payment_processing.rb

@@ -31,18 +31,22 @@ module Spree
         payments.pending
       end
 
-      # Active front-end payment methods available for this record.
+      # Active front-end payment methods available for this record. Store
+      # credit is never one of them: it is applied through its own endpoint
+      # before the buyer chooses how to pay the rest.
       #
       # @return [Array<Spree::PaymentMethod>]
       def payment_methods
-        store.payment_methods.active.storefront_visible.select { |payment_method| payment_method.available_for_order?(self) }
+        store.payment_methods.active.storefront_visible.select do |payment_method|
+          !payment_method.store_credit? && payment_method.available_for_order?(self)
+        end
       end
 
       # Free checkouts have no money to collect.
       #
       # @return [Boolean]
       def payment_required?
-        total.to_f > 0.0
+        total.to_d.positive?
       end
 
       # Whether a confirm/review pass is expected before completion —
@@ -71,7 +75,7 @@ module Spree
         # Don't run if there are authorized payments
         return if pending_payments.any? && unprocessed_payments.empty?
         # Never complete without a successfully processed payment.
-        raise Spree::Core::GatewayError, Spree.t(:no_payment_found) if unprocessed_payments.empty?
+        raise Spree::Core::GatewayError, I18n.t('spree.no_payment_found') if unprocessed_payments.empty?
 
         unprocessed_payments.each do |payment|
           break if settled_payment_total >= total

data/app/models/concerns/spree/purchase/purchase_order.rb

@@ -17,8 +17,8 @@ module Spree
       MAX_PO_DOCUMENT_SIZE = 10.megabytes
 
       # What a purchase order plausibly arrives as: an export from the buyer's
-      # procurement system, a scan, or a photo of one. Matches the list the
-      # seller document requirement accepts — the same kinds of paperwork.
+      # procurement system (often a spreadsheet or CSV), a scan, or a photo of
+      # one.
       PO_DOCUMENT_CONTENT_TYPES = %w[
         application/pdf
         image/jpeg
@@ -27,6 +27,10 @@ module Spree
         image/webp
         application/msword
         application/vnd.openxmlformats-officedocument.wordprocessingml.document
+        application/vnd.ms-excel
+        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+        application/vnd.oasis.opendocument.spreadsheet
+        text/csv
       ].freeze
 
       included do
@@ -36,6 +40,7 @@ module Spree
         # internal cost codes, and is served only through an authenticated
         # download action.
         has_one_attached :po_document, service: Spree.private_storage_service_name
+        signed_id_attachments :po_document
 
         validates :po_document,
                   size: { less_than_or_equal_to: MAX_PO_DOCUMENT_SIZE },
@@ -83,8 +88,8 @@ module Spree
         return if stored_size <= MAX_PO_DOCUMENT_SIZE
 
         errors.add(
-          :po_document, :po_document_too_large, message: Spree.t(
-            :po_document_too_large,
+          :po_document, :po_document_too_large, message: I18n.t(
+            'spree.po_document_too_large',
             size: ActiveSupport::NumberHelper.number_to_human_size(MAX_PO_DOCUMENT_SIZE)
           )
         )

data/app/models/concerns/spree/purchase/store_credits.rb

@@ -58,7 +58,7 @@ module Spree
 
       # @return [BigDecimal]
       def total_applied_store_credit
-        if payments.loaded?
+        if read_association_in_memory?(:payments)
           payments.
             find_all(&:store_credit?).
             reject(&:has_invalid_status?).
@@ -68,10 +68,32 @@ module Spree
         end
       end
 
+      # Balance still to collect, never negative. Store credit already applied
+      # but not yet captured is taken off; captured credit is a completed
+      # payment, so the balance has counted it already.
+      #
+      # @return [BigDecimal]
+      def amount_due
+        [outstanding_balance - uncaptured_store_credit, 0].max
+      end
+
+      # What store credit paid, apart from gift cards. A gift card is redeemed
+      # as store credit, but it is reported on its own as +gift_card_total+, so
+      # a summary showing both rows deducts each amount once.
+      #
+      # @return [BigDecimal]
+      def store_credit_total
+        total_applied_store_credit - gift_card_total
+      end
+
       def using_store_credit?
         total_applied_store_credit > 0
       end
 
+      def display_store_credit_total
+        Spree::Money.new(-store_credit_total, currency: currency)
+      end
+
       def display_total_applicable_store_credit
         Spree::Money.new(-total_applicable_store_credit, currency: currency)
       end
@@ -95,6 +117,19 @@ module Spree
       def display_total_minus_store_credits
         Spree::Money.new(total_minus_store_credits, currency: currency)
       end
+
+      private
+
+      # @return [BigDecimal]
+      def uncaptured_store_credit
+        if read_association_in_memory?(:payments)
+          payments.
+            select { |payment| payment.store_credit? && !payment.has_invalid_status? && !payment.completed? }.
+            sum(BigDecimal('0'), &:amount)
+        else
+          payments.store_credits.valid.where.not(status: 'completed').sum(:amount)
+        end
+      end
     end
   end
 end

data/app/models/concerns/spree/purchase/totals.rb

@@ -10,9 +10,37 @@ module Spree
         line_items.sum(:quantity)
       end
 
+      # What promotion calculators take a share of: the line amounts less the
+      # free gifts, so a gift never enlarges a percentage off the order.
+      #
       # @return [BigDecimal]
       def amount
-        line_items.sum(BigDecimal('0'), &:amount)
+        line_items.sum(BigDecimal('0'), &:amount) - gift_amount
+      end
+
+      # The list price of the units gift promotions give away. The gift keeps
+      # its price on its line and is paid for by a discount, so anything
+      # measuring what the shopper spends has to take it out.
+      #
+      # @param promotion [Spree::Promotion, nil] the promotion doing the
+      #   measuring; its own gifts are always taken out, since a gift cannot
+      #   be what qualifies the promotion giving it away
+      # @param own_gift_only [Boolean] true while deciding whether another
+      #   promotion gives its gift, so two gift promotions with spend
+      #   thresholds do not each wait on the other
+      # @return [BigDecimal]
+      def gift_amount(promotion: nil, own_gift_only: false)
+        return BigDecimal('0') if line_items.empty?
+
+        excluded_gift_promo_actions = gift_promo_actions(promotion, own_gift_only).select do |action|
+          action.promotion_id == promotion&.id || action.gives_away?(self)
+        end
+        return BigDecimal('0') if excluded_gift_promo_actions.empty?
+
+        line_items.sum(BigDecimal('0')) do |line_item|
+          gifted_quantity = excluded_gift_promo_actions.sum { |action| action.gifted_quantity_of(line_item) }
+          Spree::Money::Rounding.to_currency(line_item.price * [gifted_quantity, line_item.quantity].min, line_item.currency)
+        end
       end
 
       # Re-sums what the customer has actually paid, and nothing else. A
@@ -47,13 +75,6 @@ module Spree
         outstanding_balance != 0
       end
 
-      # Balance still to collect after applied store credit, never negative.
-      #
-      # @return [BigDecimal]
-      def amount_due
-        [outstanding_balance - total_applied_store_credit, 0].max
-      end
-
       # @return [Boolean]
       def paid?
         total.positive? && payment_total >= total
@@ -78,6 +99,26 @@ module Spree
 
       private
 
+      # Other promotions' gifts are looked for among the promotions a
+      # recalculation writes discounts for, so a gift leaves the measure
+      # exactly when its discount can be written.
+      def gift_promo_actions(promotion, own_gift_only)
+        own = promotion ? promotion.actions.grep(Spree::Promotion::Actions::CreateLineItems) : []
+        return own if own_gift_only
+
+        discounting_ids = promotion_ids + Spree::Promotion.held_by_saved_coupon_code(self).map(&:id)
+        return own if discounting_ids.empty?
+
+        gifting_cart_variants = Spree::PromotionActionLineItem.
+                                where(variant_id: line_items.map(&:variant_id)).
+                                select(:promotion_action_id)
+        others = Spree::Promotion::Actions::CreateLineItems.
+                 where(promotion_id: discounting_ids, id: gifting_cart_variants).
+                 includes(:promotion, :promotion_action_line_items)
+
+        (own + others.to_a).uniq(&:id)
+      end
+
       # Completed payments less their refunds, as a scalar subquery so the
       # sum and the write are one statement.
       #

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

@@ -11,6 +11,12 @@ module Spree::RansackableAttributes
     class_attribute :whitelisted_ransackable_attributes
     class_attribute :whitelisted_ransackable_scopes
 
+    # `{ 'price_between' => %w[decimal decimal], 'in_categories' => { list: 'id' } }`
+    # — the arguments a ransackable scope takes, which Ruby cannot report for
+    # a `scope` lambda. A scope taking none is `'boolean'`; an undeclared one
+    # is published as taking one text value.
+    class_attribute :ransackable_scope_types, default: {}
+
     # Associations the Store API may filter through. Empty by default: every
     # hop is a join into data the storefront was never meant to query, and a
     # join back to the model it came from lets one filter chain them forever.
@@ -21,6 +27,9 @@ module Spree::RansackableAttributes
     class_attribute :private_ransackable_attributes, default: {}
     class_attribute :private_ransackable_scopes, default: {}
 
+    # Attributes the `search` filter matches, set with {.search_by}.
+    class_attribute :search_attributes, default: [], instance_accessor: false
+
     class_attribute :default_ransackable_attributes
     # `position` is included so any `acts_as_list` model is sortable by it
     # without each subclass having to opt in. Ransack ignores attributes
@@ -48,10 +57,47 @@ module Spree::RansackableAttributes
     def self.ransackable_scopes(auth_object = nil)
       base = (whitelisted_ransackable_scopes || []).map(&:to_s)
       base |= Spree.ransack.custom_scopes_for(self).map(&:to_s)
+      base |= %w[search] if search_attributes.any? && search_attributes.all? { |path| ransackable_path?(path, auth_object) }
       return base unless Spree::RansackableAttributes.restricted_audience?(auth_object)
 
       base - Array(private_ransackable_scopes[auth_object.to_sym])
     end
+
+    # Declares the `search` filter (`q[search]=term`): a case-insensitive
+    # partial match on any of the given attributes, which may reach through
+    # associations (`variant_sku`). It runs as Ransack's `_cont` on those
+    # attributes, so translated names match in the current locale. An
+    # audience that may not filter on every one of them does not get it.
+    #
+    #   search_by :name, :code
+    #
+    # @param attributes [Array<Symbol, String>]
+    def self.search_by(*attributes)
+      self.search_attributes = attributes.map(&:to_s).freeze
+      scope :search, ->(query) {
+        query.blank? ? all : ransack("#{search_attributes.join('_or_')}_cont" => query.to_s.strip).result
+      }
+    end
+
+    # Whether an attribute, or one reached through associations
+    # (`variant_product_name`), is filterable by this audience.
+    #
+    # @param path [String]
+    # @param auth_object [Symbol, nil]
+    # @return [Boolean]
+    def self.ransackable_path?(path, auth_object = nil, depth = 0)
+      return true if ransackable_attributes(auth_object).include?(path)
+      return false if depth >= 2
+
+      ransackable_associations(auth_object).any? do |name|
+        next false unless path.start_with?("#{name}_")
+
+        reflection = reflect_on_association(name.to_sym)
+        next false if reflection.nil? || reflection.polymorphic? || !reflection.klass.respond_to?(:ransackable_path?)
+
+        reflection.klass.ransackable_path?(path.delete_prefix("#{name}_"), auth_object, depth + 1)
+      end
+    end
   end
 
   # @param auth_object [Symbol, nil] the Ransack auth object a search ran with

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

@@ -97,7 +97,7 @@ module Spree
       variant_ids = items.reject(&:marked_for_destruction?).filter_map(&:variant_id)
       return if variant_ids.uniq.size == variant_ids.size
 
-      errors.add(:items, :duplicate_variant, message: Spree.t('errors.messages.duplicate_variant'))
+      errors.add(:items, :duplicate_variant, message: I18n.t('spree.errors.messages.duplicate_variant'))
     end
   end
 end

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

@@ -25,10 +25,6 @@ module Spree
           model_class.arel_table[attribute.to_sym].lower.matches("%#{escaped}%", '\\')
         end
       end
-
-      # Backward compatibility aliases — remove in Spree 6.0
-      def self.sanitize_query_for_multi_search(query) = sanitize_query_for_search(query)
-      def self.multi_search_condition(model_class, attribute, query) = search_condition(model_class, attribute, query)
     end
   end
 end

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

@@ -0,0 +1,59 @@
+module Spree
+  # Stores a model's `:password` preferences in a separate `secret_preferences`
+  # text column, encrypted with Active Record encryption whenever keys are
+  # configured, so the `preferences` column never holds a secret. Declarations
+  # are unchanged: `preference :secret_key, :password` and
+  # `preferred_secret_key` read and write the encrypted column.
+  #
+  # Values written before encryption was enabled stay readable and are
+  # encrypted on the next save, or at once by
+  # `spree:upgrade:encrypt_secret_preferences`.
+  module SecretPreferences
+    extend ActiveSupport::Concern
+
+    included do
+      serialize :secret_preferences, coder: TextHashSerializer
+
+      if ActiveRecord::Encryption.config.has_primary_key?
+        encrypts :secret_preferences, support_unencrypted_data: true
+      end
+
+      before_save :move_secret_preferences
+    end
+
+    # The column is `text`, since ciphertext cannot live in a JSON column. An
+    # empty column stays nil rather than `{}`: encrypted attributes compare the
+    # stored value with the loaded one, so `{}` would mark every record without
+    # secrets as changed.
+    class TextHashSerializer
+      def self.dump(hash)
+        ActiveSupport::JSON.encode(hash) unless hash.nil?
+      end
+
+      def self.load(json)
+        Spree::Metadata::HashSerializer.load(ActiveSupport::JSON.decode(json)) unless json.nil?
+      end
+    end
+
+    # Both columns as they should be stored, when `preferences` holds a secret
+    # — one assigned as part of a whole hash, or one the upgrade has not moved
+    # yet. A secret found there is the newer value and wins.
+    #
+    # @return [Hash{Symbol => Hash}, nil] `preferences:` and `secret_preferences:`, or nil when there is nothing to move
+    def separated_secret_preferences
+      secrets = (preferences || {}).slice(*self.class.secret_preference_names)
+      return if secrets.empty?
+
+      { preferences: preferences.except(*secrets.keys), secret_preferences: (secret_preferences || {}).merge(secrets) }
+    end
+
+    private
+
+    # Keeps a secret out of the plain `preferences` column when the record is
+    # saved.
+    def move_secret_preferences
+      separated = separated_secret_preferences
+      assign_attributes(separated) if separated
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Spree
+  # Gives attachment slots their API write name, `<slot>_signed_id`
+  # (docs/plans/6.0-uploads-and-file-ownership.md).
+  #
+  #   signed_id_attachments :logo, :mailer_logo
+  #   store.update(logo_signed_id: upload.signed_id) # attaches
+  #   store.update(logo_signed_id: nil)              # removes
+  #
+  # A declared slot also refuses a file stored with the other visibility:
+  # attaching never moves a file between storage services, so a public upload
+  # attached to a private slot would stay readable at a public URL.
+  module SignedIdAttachments
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :signed_id_attachment_slots, instance_writer: false, default: []
+    end
+
+    class_methods do
+      # @param slots [Array<Symbol>] `has_one_attached` slot names
+      # @return [void]
+      def signed_id_attachments(*slots)
+        validate :signed_id_attachments_on_their_storage if signed_id_attachment_slots.empty?
+        self.signed_id_attachment_slots += slots
+
+        slots.each do |slot|
+          define_method(:"#{slot}_signed_id=") { |signed_id| public_send(:"#{slot}=", signed_id) }
+        end
+      end
+
+      # The name the API reports +attribute+'s errors under: `logo_signed_id`
+      # for the `logo` slot, so a client reads them back under the field it sent.
+      #
+      # @param attribute [Symbol, String]
+      # @return [String, nil] nil when +attribute+ is not a declared slot
+      def signed_id_attribute_for(attribute)
+        "#{attribute}_signed_id" if signed_id_attachment_slots.include?(attribute.to_sym)
+      end
+    end
+
+    private
+
+    def signed_id_attachments_on_their_storage
+      signed_id_attachment_slots.each do |slot|
+        blob = attachment_changes[slot.to_s].try(:blob)
+        expected_service = self.class.reflect_on_attachment(slot)&.options&.dig(:service_name)
+        next if blob.nil? || expected_service.nil? || blob.service_name.to_s == expected_service.to_s
+
+        visibility = expected_service.to_s == Spree.private_storage_service_name.to_s ? 'private' : 'public'
+        errors.add(slot, :wrong_visibility, message: I18n.t('spree.upload_wrong_visibility', visibility: visibility))
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Spree
 
     def ensure_store_association_is_not_changed
       if store_id_changed? && persisted?
-        errors.add(:store, :store_association_can_not_be_changed, message: Spree.t('errors.messages.store_association_can_not_be_changed'))
+        errors.add(:store, :store_association_can_not_be_changed, message: I18n.t('spree.errors.messages.store_association_can_not_be_changed'))
       end
     end
   end

data/app/models/concerns/spree/stores/email_branding.rb

@@ -0,0 +1,32 @@
+module Spree
+  module Stores
+    # The colors and font of a store's customer emails (see Spree::Emails::Branding).
+    # All optional: a blank one keeps the shipped design.
+    module EmailBranding
+      extend ActiveSupport::Concern
+
+      included do
+        Spree::Emails::Branding::COLORS.each { |name| preference :"email_#{name}", :string, format: :color }
+        preference :email_font, :string, choices: -> { Spree::Emails::Branding::FONTS.keys }
+
+        validate :email_branding_valid
+      end
+
+      # @param overrides [Hash] unsaved values, e.g. to preview them
+      # @return [Spree::Emails::Branding]
+      def email_branding(overrides = {})
+        saved = Spree::Emails::Branding.attribute_names.to_h { |name| [name, public_send(:"preferred_email_#{name}")] }
+        Spree::Emails::Branding.new(saved.merge(overrides.to_h.stringify_keys.slice(*saved.keys)))
+      end
+
+      private
+
+      def email_branding_valid
+        branding = email_branding
+        return if branding.valid?
+
+        branding.errors.each { |error| errors.add(:"preferred_email_#{error.attribute}", error.type) }
+      end
+    end
+  end
+end

data/app/models/concerns/spree/stores/markets.rb

@@ -7,6 +7,9 @@ module Spree
         has_many :markets, class_name: 'Spree::Market', dependent: :destroy
         has_one :default_market, -> { default }, class_name: 'Spree::Market'
 
+        normalizes :default_locale, with: ->(value) { value.to_s.strip.presence }
+        validates_with Spree::LocaleCodesValidator, attributes: %i[default_locale supported_locales]
+
         after_create :ensure_default_market
         after_update :sync_default_market_settings
       end
@@ -145,7 +148,7 @@ module Spree
           markets.create!(
             name: country.name,
             currency: read_attribute(:default_currency) || iso_country&.currency_code || 'USD',
-            default_locale: read_attribute(:default_locale) || iso_country&.languages_official&.first || 'en',
+            default_locale: read_attribute(:default_locale) || Spree::Locales.listed(iso_country&.languages_official&.first) || 'en',
             supported_locales: read_attribute(:supported_locales),
             default: true,
             bootstrap_default: true,
@@ -190,7 +193,7 @@ module Spree
       end
 
       def legacy_supported_locales_list
-        (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
+        (read_attribute(:supported_locales).to_s.split(',').map(&:strip) << default_locale).compact_blank.uniq.sort
       end
     end
   end

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

@@ -0,0 +1,38 @@
+module Spree
+  # Names and describes each kind in a family of typed subclasses (promotion
+  # rules, collection rules, …) from one translation scope keyed by
+  # +api_type+, so the `/types` endpoints and dashboard pickers label
+  # extension kinds the same way as built-in ones.
+  #
+  #   class Spree::PromotionRule < Spree.base_class
+  #     include Spree::TypeLabels
+  #     self.type_labels_scope = 'spree.promotion_rule_types'
+  #   end
+  #
+  #   Spree::Promotion::Rules::Currency.human_name # => spree.promotion_rule_types.currency.name
+  module TypeLabels
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :type_labels_scope, instance_writer: false
+    end
+
+    class_methods do
+      # @return [String] the kind's name, falling back to its humanized +api_type+
+      def human_name
+        I18n.t("#{type_labels_scope}.#{api_type}.name", default: api_type.titleize)
+      end
+
+      # @return [String] what the kind does, empty when it has no translation
+      def human_description
+        I18n.t("#{type_labels_scope}.#{api_type}.description", default: '')
+      end
+    end
+
+    # @return [String]
+    def human_name = self.class.human_name
+
+    # @return [String]
+    def human_description = self.class.human_description
+  end
+end