spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/metafield_definition.rb

@@ -1,130 +1,13 @@
-module Spree
-  class MetafieldDefinition < Spree.base_class
-    has_prefix_id :cfdef
-
-    include Spree::DisplayOn
-    include Spree::MetafieldDefinition::SearchCapabilities
-
-    DISPLAY = [:both, :back_end]
-
-    #
-    # Associations
-    #
-    has_many :metafields, class_name: 'Spree::Metafield', dependent: :destroy
-
-    #
-    # Validations
-    #
-    validates :namespace, :key, :name, :resource_type, presence: true
-    validates :metafield_type, presence: true, inclusion: { in: :valid_available_types }
-    validates :resource_type, presence: true, inclusion: { in: :valid_available_resources }
-    validates :key, uniqueness: { scope: spree_base_uniqueness_scope + [:resource_type, :namespace] }
-    validate :field_type_input_must_be_recognized
-
-    #
-    # Scopes
-    #
-    scope :for_resource_type, ->(resource_type) { where(resource_type: resource_type) }
-    scope :search, ->(query) do
-      return all if query.blank?
-
-      search_term = "%#{query.downcase}%"
-      namespace_condition = arel_table[:namespace].lower.matches(search_term)
-      key_condition = arel_table[:key].lower.matches(search_term)
-      name_condition = arel_table[:name].lower.matches(search_term)
-
-      where(namespace_condition.or(key_condition).or(name_condition))
-    end
-
-    # Backward compatibility alias — remove in Spree 6.0
-    scope :multi_search, ->(*args) { search(*args) }
-
-    #
-    # Callbacks
-    #
-    normalizes :key, with: ->(value) { value.to_s.parameterize.underscore.strip }
-    normalizes :namespace, with: ->(value) { value.to_s.parameterize.underscore.strip }
-    before_validation :set_default_type, if: -> { metafield_type.blank? }, on: :create
-    before_validation :set_name_from_key, if: -> { name.blank? }, on: :create
-
-    #
-    # Ransack
-    #
-    self.whitelisted_ransackable_attributes = %w[key namespace name resource_type display_on searchable sortable]
-    self.whitelisted_ransackable_scopes = %w[search multi_search]
-
-    # API naming bridge — internal columns rename in 6.0. `label` matches
-    # OptionType/OptionValue conventions. (`storefront_visible` lives on
-    # the `Spree::DisplayOn` concern, shared with PaymentMethod + ShippingMethod —
-    # see docs/plans/5.5-6.0-display-on-to-boolean.md.)
-    alias_attribute :label, :name
-
-    # API-facing token for the STI subclass name stored in `metafield_type`.
-    # Reader returns the registered token (`short_text`); writer accepts either
-    # the token or the legacy class-name form for back-compat.
-    def field_type
-      Spree::Metafield::TYPE_CLASS_TO_TOKEN[metafield_type] || metafield_type
-    end
+# frozen_string_literal: true
 
-    def field_type=(value)
-      v = value.to_s
-      mapped = Spree::Metafield::TYPE_TOKENS[v]
-      # An input is "recognized" when it's either a known token (mapped to a
-      # class) or already a known class name. Anything else gets surfaced as
-      # an error on `field_type` so API clients get a token-vocabulary
-      # message instead of the raw class-name inclusion error on
-      # `metafield_type`.
-      @field_type_input_recognized = !mapped.nil? || Spree::Metafield::TYPE_CLASS_TO_TOKEN.key?(v)
-      self.metafield_type = mapped || value
-    end
-
-    # Returns the full key with namespace
-    # @return [String] eg. custom.id
-    def full_key
-      "#{namespace}.#{key}"
-    end
-
-    # Returns the CSV header name for this metafield
-    # @return [String] eg. metafield.custom.id
-    def csv_header_name
-      "metafield.#{full_key}"
-    end
-
-    # Returns the available types
-    # @return [Array<Class>]
-    def self.available_types
-      Spree.metafields.types
-    end
-
-    # Returns the available resources
-    # @return [Array<Class>]
-    def self.available_resources
-      Spree.metafields.enabled_resources
-    end
-
-    private
-
-    def valid_available_types
-      self.class.available_types.map(&:to_s)
-    end
-
-    def field_type_input_must_be_recognized
-      return if @field_type_input_recognized.nil? || @field_type_input_recognized
-
-      tokens = Spree::Metafield::TYPE_TOKENS.keys.join(', ')
-      errors.add(:field_type, "is not a known custom field type (expected one of: #{tokens})")
-    end
-
-    def valid_available_resources
-      self.class.available_resources.map(&:to_s)
-    end
-
-    def set_default_type
-      self.metafield_type ||= Spree.metafields.types.first.to_s
-    end
-
-    def set_name_from_key
-      self.name ||= key.titleize
-    end
-  end
+module Spree
+  # Deprecation alias for Spree::CustomFieldDefinition, renamed from
+  # Spree::MetafieldDefinition in 6.0. Retained for one release; removed in 6.1.
+  # A plain constant alias for the same reason as {Spree::Metafield}.
+  #
+  # Note the columns renamed alongside the class: `name` is now `label`,
+  # `metafield_type` is now `field_type` (which reads back an API token such as
+  # `short_text` rather than the STI class name), and the tri-state `display_on`
+  # collapsed into the `storefront_visible` boolean.
+  MetafieldDefinition = CustomFieldDefinition
 end

data/app/models/spree/metafields.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  # Deprecation bridge for the 6.0 custom-fields rename. Serves the two roles
+  # the old `Spree::Metafields` name had, and is removed in 6.1:
+  #
+  # 1. The concern — `include Spree::Metafields` still works and gives a model
+  #    the full custom-fields surface via {Spree::HasCustomFields}.
+  # 2. The STI namespace — `Spree::Metafields::ShortText` and friends are
+  #    constant aliases for `Spree::CustomFields::*`. The `type` column stores
+  #    the new class names, so these resolve to the very same classes and
+  #    existing rows keep loading.
+  module Metafields
+    extend ActiveSupport::Concern
+
+    ShortText = CustomFields::ShortText
+    LongText = CustomFields::LongText
+    RichText = CustomFields::RichText
+    Number = CustomFields::Number
+    Boolean = CustomFields::Boolean
+    Json = CustomFields::Json
+
+    included do
+      Spree::Deprecation.warn(
+        "include Spree::Metafields is deprecated and will be removed in Spree 6.1. " \
+        "Use include Spree::HasCustomFields instead (#{name})."
+      )
+
+      include Spree::HasCustomFields
+    end
+  end
+end

data/app/models/spree/newsletter_subscriber.rb

@@ -2,7 +2,7 @@ module Spree
   class NewsletterSubscriber < Spree.base_class
     has_prefix_id :sub
 
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::SingleStoreResource
 
     publishes_lifecycle_events
@@ -16,8 +16,9 @@ module Spree
     #
     # Associations
     #
-    belongs_to :user, optional: true, class_name: Spree.user_class&.name
-    belongs_to :store, class_name: 'Spree::Store', required: true
+    belongs_to :customer, optional: true, class_name: Spree.customer_class&.name
+
+    include Spree::DeprecatedCustomerAlias
 
     #
     # Validations
@@ -44,9 +45,9 @@ module Spree
     #
     self.whitelisted_ransackable_attributes = %w[email verified_at]
     self.whitelisted_ransackable_scopes = %w[verified unverified]
-    
+
     def accepts_email_marketing
-      return user.accepts_email_marketing if user.present?
+      return customer.accepts_email_marketing if customer.present?
 
       verified?
     end
@@ -55,16 +56,16 @@ module Spree
       verified_at.present?
     end
 
-    def to_csv(_store = nil)
-      Spree::CSV::NewsletterSubscriberPresenter.new(self).call
+    def to_csv(store = nil)
+      Spree::CSV::NewsletterSubscriberPresenter.new(self, store || self.store).call
     end
 
-    def self.subscribe(email:, user: nil, store: nil, redirect_url: nil)
+    def self.subscribe(email:, customer: nil, store: nil, redirect_url: nil)
       store ||= Spree::Current.store
 
       Spree::Newsletter::Subscribe.new(
         email: email,
-        current_user: user,
+        current_user: customer,
         current_store: store,
         redirect_url: redirect_url
       ).call

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

@@ -0,0 +1,56 @@
+module Spree
+  module NumberGenerators
+    # Produces candidate document numbers for models including
+    # {Spree::HasNumber}. Uniqueness is the concern's job, not the
+    # generator's — a generator only has to propose.
+    #
+    # Subclass and register to take over numbering for one resource or all of
+    # them (docs/plans/6.0-document-numbers.md):
+    #
+    #   class MyApp::BranchOrderNumbers < Spree::NumberGenerators::Base
+    #     def generate(record)
+    #       "#{record.number_store.code}-#{record.created_at.year}-#{...}"
+    #     end
+    #   end
+    #
+    #   Spree.number_generators[:order] = 'MyApp::BranchOrderNumbers'
+    class Base
+      # @param record [ActiveRecord::Base] the record being numbered; reaches
+      #   its store through `#number_store` and its prefix through
+      #   `.number_prefix`
+      # @return [String] a candidate number
+      def generate(record)
+        raise NotImplementedError, "#{self.class.name} must implement #generate"
+      end
+
+      protected
+
+      # The prefix a merchant configured for this resource, falling back to
+      # the model's code-level default. Only orders are configurable in 6.0.
+      #
+      # @return [String]
+      def prefix_for(record)
+        return record.class.number_prefix unless record.number_key == :order
+
+        store_preference(record, :order_number_prefix) || record.class.number_prefix
+      end
+
+      # @return [String]
+      def suffix_for(record)
+        return '' unless record.number_key == :order
+
+        store_preference(record, :order_number_suffix).to_s
+      end
+
+      # @return [Object, nil] nil when there is no store to read, so callers
+      #   fall back to their own defaults rather than to a store's blank
+      def store_preference(record, name)
+        store = record.number_store
+        return if store.nil?
+
+        value = store.public_send(:"preferred_#{name}")
+        value.presence
+      end
+    end
+  end
+end

data/app/models/spree/number_generators/random.rb

@@ -0,0 +1,23 @@
+module Spree
+  module NumberGenerators
+    # Pre-6.0 behaviour, kept as an opt-in: prefix + a fixed-width run of
+    # random digits. Merchants choose this when they would rather not tell a
+    # repeat customer how many orders the store took in between their two
+    # purchases, and accept numbers that are harder to read back over a
+    # phone.
+    class Random < Base
+      DEFAULT_LENGTH = 9
+
+      # @param length [Integer] digits after the prefix
+      def initialize(length: DEFAULT_LENGTH)
+        @length = length
+      end
+
+      def generate(record)
+        digits = SecureRandom.random_number(10**@length).to_s.rjust(@length, '0')
+
+        "#{prefix_for(record)}#{digits}#{suffix_for(record)}"
+      end
+    end
+  end
+end

data/app/models/spree/number_generators/sequential.rb

@@ -0,0 +1,88 @@
+module Spree
+  module NumberGenerators
+    # The 6.0 default: prefix + a counter that advances by one per document,
+    # producing the invoice-like numbers merchants expect (`R1001`, `R1002`).
+    #
+    # The counter lives in {Spree::NumberSequence} rather than being derived
+    # from the `number` column, because the column cannot answer "what comes
+    # next": upgraded stores are full of 5.x random values that poison any
+    # MAX-and-parse, string columns sort `R999` above `R1000`, concurrent
+    # writers computing MAX+1 collide by construction, and a merchant-chosen
+    # starting value is not a fact about any existing row.
+    #
+    # Numbering is mostly-gapless, never guaranteed gapless — a collision or
+    # a rolled-back transaction consumes a value. Never present this as legal
+    # invoice numbering.
+    class Sequential < Base
+      # Candidate values checked per query when jumping a stretch of numbers
+      # another store already owns.
+      SCAN_BATCH_SIZE = 100
+
+      def generate(record)
+        store = record.number_store
+        raise_missing_store(record) if store.nil?
+
+        resource_type = record.number_key.to_s
+        value = Spree::NumberSequence.next_value(
+          store: store,
+          resource_type: resource_type,
+          start_at: start_at_for(record)
+        )
+
+        candidate = compose(record, value)
+        return candidate unless taken?(record, candidate)
+
+        # The unique index is global, so a sibling store with the same format
+        # can own a whole stretch of numbers — and stepping through it one
+        # save attempt at a time would exhaust the concern's retry budget and
+        # fail the save. Find the first free value in batches and jump the
+        # counter past the stretch in one move instead.
+        free_value = next_free_value(record, value)
+        Spree::NumberSequence.advance_to(store: store, resource_type: resource_type, value: free_value)
+
+        compose(record, free_value)
+      end
+
+      private
+
+      def compose(record, value)
+        "#{prefix_for(record)}#{value}#{suffix_for(record)}"
+      end
+
+      def taken?(record, candidate)
+        record.class.unscoped.exists?(number: candidate)
+      end
+
+      def next_free_value(record, from)
+        value = from
+
+        loop do
+          candidates = (value + 1..value + SCAN_BATCH_SIZE).index_by { |v| compose(record, v) }
+          taken = record.class.unscoped.where(number: candidates.keys).pluck(:number)
+          free = (candidates.keys - taken).first
+
+          return candidates.fetch(free) if free
+
+          value += SCAN_BATCH_SIZE
+        end
+      end
+
+      # Says which setting is missing rather than letting the concern report
+      # ten failed attempts and blame collisions.
+      def raise_missing_store(record)
+        raise Spree::HasNumber::GenerationError,
+              "#{record.class.name} has no store to read numbering settings from — " \
+              'define #number_store on the model or set Spree::Current.store'
+      end
+
+      # The starting value is part of the order-numbers settings card, so only
+      # orders honour it; every other document type counts from the default.
+      def start_at_for(record)
+        return Spree::NumberSequence::DEFAULT_START unless record.number_key == :order
+
+        store_preference(record, :order_number_sequence_start).to_i.nonzero? ||
+          Spree::NumberSequence::DEFAULT_START
+      end
+    end
+  end
+end

data/app/models/spree/number_sequence.rb

@@ -0,0 +1,86 @@
+module Spree
+  # Per-store, per-resource counter behind sequential document numbering
+  # (docs/plans/6.0-document-numbers.md). One row per numbered resource type
+  # a store actually uses; nothing outside {Spree::NumberGenerators::Sequential}
+  # reads them.
+  #
+  # This exists because the `number` column cannot say what comes next — see
+  # the generator for why deriving it from data is not an option. Postgres
+  # has native sequences, MySQL and SQLite do not, so a locked counter row is
+  # the portable equivalent.
+  class NumberSequence < Spree.base_class
+    DEFAULT_START = 1001
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    validates :resource_type, presence: true,
+                              uniqueness: { scope: :store_id, case_sensitive: false }
+    validates :value, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+    class << self
+      # Advances the counter and returns the value to use. The row is locked
+      # for the increment, so concurrent checkouts hand out distinct numbers
+      # instead of racing on the same one.
+      #
+      # @param store [Spree::Store]
+      # @param resource_type [String] e.g. 'order'
+      # @param start_at [Integer] first value handed out for a fresh counter
+      # @return [Integer]
+      # Whether a counter has already handed out a number, which is what makes
+      # the store's starting-value setting inert from then on. The dashboard
+      # reads this to say so rather than letting a merchant set a value that
+      # silently does nothing.
+      #
+      # @param store [Spree::Store]
+      # @param resource_type [String]
+      # @return [Boolean]
+      def started?(store:, resource_type: 'order')
+        return false if store.nil?
+
+        exists?(store: store, resource_type: resource_type)
+      end
+
+      # Moves the counter forward to +value+ — never backward — so numbering
+      # continues past a stretch of numbers that turned out to be taken.
+      #
+      # @param store [Spree::Store]
+      # @param resource_type [String]
+      # @param value [Integer] the value the counter should stand at
+      def advance_to(store:, resource_type:, value:)
+        sequence = find_or_create_sequence(store, resource_type, value)
+
+        sequence.with_lock do
+          sequence.update!(value: value) if sequence.value < value
+        end
+      end
+
+      def next_value(store:, resource_type:, start_at: DEFAULT_START)
+        sequence = find_or_create_sequence(store, resource_type, start_at)
+
+        sequence.with_lock do
+          sequence.increment!(:value)
+          sequence.value
+        end
+      end
+
+      private
+
+      # A fresh counter is seeded one below the configured start so the first
+      # increment hands out `start_at` itself.
+      #
+      # Two writers can reach the insert together — the loser sees either the
+      # unique index (RecordNotUnique) or the uniqueness validation reading
+      # the winner's committed row (RecordInvalid). Both mean the same thing:
+      # the row now exists, so read it.
+      def find_or_create_sequence(store, resource_type, start_at)
+        seed = [start_at.to_i - 1, 0].max
+
+        find_or_create_by!(store: store, resource_type: resource_type) do |sequence|
+          sequence.value = seed
+        end
+      rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid
+        find_by!(store: store, resource_type: resource_type)
+      end
+    end
+  end
+end

data/app/models/spree/option_type.rb

@@ -2,17 +2,15 @@ module Spree
   class OptionType < Spree.base_class
     has_prefix_id :opt  # Spree-specific: option type
 
-    COLOR_NAMES = %w[color colour].freeze
     KINDS = %w[dropdown color_swatch buttons].freeze
 
     include Spree::ParameterizableName
-    include Spree::UniqueName
-    include Spree::Metafields
+    include Spree::SingleStoreResource
+    include Spree::HasCustomFields
     include Spree::Metadata
-    # presentation column, exposed publicly as `label` + translated via Mobility.
-    include Spree::PresentationTranslatable
+    include Spree::LabelTranslatable
 
-    TRANSLATABLE_FIELDS = Spree::PresentationTranslatable::TRANSLATABLE_FIELDS
+    TRANSLATABLE_FIELDS = Spree::LabelTranslatable::TRANSLATABLE_FIELDS
 
     # Option values are translated alongside their type — the translations
     # endpoint nests their matrices so the editor fetches both in one read.
@@ -20,15 +18,19 @@ module Spree
       :option_values
     end
 
-    self::Translation.class_eval do
-      normalizes :presentation, with: ->(value) { value&.to_s&.squish&.presence }
-    end
-
     #
     # Magic methods
     #
     self.whitelisted_ransackable_scopes = %w[search_by_name]
-    acts_as_list
+    # `label` is what admin surfaces display, so it has to be filterable —
+    # matching Spree::OptionValue, which already allows it.
+    self.whitelisted_ransackable_attributes = %w[label name]
+
+    normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
+
+    validates :name, presence: true
+    validates_store_uniqueness :name
+    acts_as_list scope: :store_id
 
     #
     # Associations
@@ -44,55 +46,39 @@ module Spree
       has_many :product_option_types
     end
     has_many :products, through: :product_option_types
-    has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
-    has_many :prototypes, through: :option_type_prototypes, class_name: 'Spree::Prototype'
-
-    # 5.5 API naming bridge (`label` → `presentation`) lives in
-    # Spree::PresentationTranslatable.
+    has_many :option_type_product_types, class_name: 'Spree::OptionTypeProductType', dependent: :destroy
+    has_many :product_types, through: :option_type_product_types, class_name: 'Spree::ProductType'
 
     #
     # Validations
     #
-    validates :presentation, presence: true
+    validates :label, presence: true
     validates :kind, presence: true, inclusion: { in: KINDS }
 
     #
     # Scopes
     #
     default_scope { order(:position) }
-    scope :colors, -> { where(name: COLOR_NAMES) }
-    scope :color_swatches, -> { where(kind: 'color_swatch') }
     scope :filterable, -> { where(filterable: true) }
 
     #
     # Attributes
     #
     accepts_nested_attributes_for :option_values, reject_if: lambda { |ov|
-      ov[:id].blank? && (ov[:name].blank? || ov[:presentation].blank?)
+      ov[:id].blank? && (ov[:name].blank? || ov[:label].blank?)
     }, allow_destroy: true
 
     #
     # Callbacks
     #
     after_touch :touch_all_products
-    after_update :touch_all_products, if: -> { saved_changes.key?(:presentation) }
+    after_update :touch_all_products, if: -> { saved_changes.key?(:label) }
     after_destroy :touch_all_products
 
-    def self.color
-      colors.first
-    end
-
     def color_swatch?
       kind == 'color_swatch'
     end
 
-    def color?
-      Spree::Deprecation.warn(
-        'Spree::OptionType#color? is deprecated. Use #color_swatch? instead. Will be removed in Spree 6.0.'
-      )
-      color_swatch?
-    end
-
     # Syncs option values from an array of hashes by mutating the in-memory
     # `option_values` association — built/assigned children get persisted by
     # `autosave: true` when the parent saves, and absent IDs get destroyed

data/app/models/spree/option_type_product_type.rb

@@ -0,0 +1,8 @@
+module Spree
+  class OptionTypeProductType < Spree.base_class
+    belongs_to :option_type, class_name: 'Spree::OptionType'
+    belongs_to :product_type, class_name: 'Spree::ProductType'
+
+    validates :product_type_id, uniqueness: { scope: :option_type_id }
+  end
+end

data/app/models/spree/option_value.rb

@@ -3,18 +3,17 @@ module Spree
     has_prefix_id :optval  # Spree-specific: option value
 
     include Spree::ParameterizableName
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::Metadata
-    # presentation column, exposed publicly as `label` + translated via Mobility.
-    include Spree::PresentationTranslatable
+    include Spree::LabelTranslatable
 
-    TRANSLATABLE_FIELDS = Spree::PresentationTranslatable::TRANSLATABLE_FIELDS
+    TRANSLATABLE_FIELDS = Spree::LabelTranslatable::TRANSLATABLE_FIELDS
 
     #
     # Magic methods
     #
     acts_as_list scope: :option_type
-    self.whitelisted_ransackable_attributes = ['presentation']
+    self.whitelisted_ransackable_attributes = ['label']
 
     #
     # Attachments
@@ -29,15 +28,12 @@ module Spree
     has_many :variants, through: :option_value_variants, class_name: 'Spree::Variant'
     has_many :products, through: :variants, class_name: 'Spree::Product'
 
-    # 5.5 API naming bridge (`label` → `presentation`) lives in
-    # Spree::PresentationTranslatable.
-
     #
     # Validations
     #
     with_options presence: true do
       validates :name, uniqueness: { scope: :option_type_id, case_sensitive: false }
-      validates :presentation
+      validates :label
     end
 
     validates :color_code, format: { with: /\A#[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?\z/, message: 'must be a valid hex color (e.g. #FF0000)' },
@@ -61,26 +57,36 @@ module Spree
     # Callbacks
     #
     after_touch :touch_all_variants
-    after_update :touch_all_products, if: -> { saved_changes.key?(:presentation) }
+    after_update :touch_all_products, if: -> { saved_changes.key?(:label) }
     after_touch :touch_all_products
 
-    delegate :name, :presentation, to: :option_type, prefix: true, allow_nil: true
+    delegate :name, :label, to: :option_type, prefix: true, allow_nil: true
+
+    # @deprecated The delegated name follows the renamed column since 6.0;
+    #   removed in 6.1.
+    alias option_type_presentation option_type_label
 
     # Using map here instead of pluck, as these values are translatable via Mobility gem
+    # @deprecated Legacy Tom Select helper for the removed Rails admin. No replacement.
     # @return [Array<Hash>]
     def self.to_tom_select_json
+      Spree::Deprecation.warn('Spree::OptionValue.to_tom_select_json is deprecated and will be removed in Spree 6.1.')
+
       all.map do |ov|
         {
           id: ov.name,
-          name: ov.presentation
+          name: ov.label
         }
       end
     end
 
     # Returns the presentation with the option type presentation, eg. "Color: Red"
+    # @deprecated No replacement, build the label in the presentation layer instead.
     # @return [String]
     def display_presentation
-      @display_presentation ||= "#{option_type.presentation}: #{presentation}"
+      Spree::Deprecation.warn('Spree::OptionValue#display_presentation is deprecated and will be removed in Spree 6.1.')
+
+      @display_presentation ||= "#{option_type.label}: #{label}"
     end
 
     private