spree_core 5.6.0 → 6.0.0.beta1

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

@@ -1,50 +0,0 @@
-module Spree
-  module DisplayOn
-    extend ActiveSupport::Concern
-
-    DISPLAY = [:both, :front_end, :back_end]
-
-    included do
-      scope :available,              -> { where(display_on: [:both]) }
-      scope :available_on_front_end, -> { where(display_on: [:front_end, :both]) }
-      scope :available_on_back_end,  -> { where(display_on: [:back_end, :both]) }
-
-      # 5.5 → 6.0 bridge: see docs/plans/5.5-6.0-display-on-to-boolean.md.
-      # The tri-state `display_on` enum collapses to a single
-      # `storefront_visible` boolean in 6.0 — `back_end` becomes `false`,
-      # everything else becomes `true`. The legacy `front_end`-only value
-      # (visible to customers but hidden from staff) has no real use case
-      # and folds into `storefront_visible: true` on migration.
-      scope :storefront_visible, -> { where.not(display_on: 'back_end') }
-      scope :admin_only,         -> { where(display_on: 'back_end') }
-
-      # Expose `storefront_visible` to Ransack so admin clients can filter
-      # by it (e.g. `q[storefront_visible_eq]=true`) without knowing about
-      # the underlying tri-state `display_on` column.
-      ransacker :storefront_visible, type: :boolean do |parent|
-        # Wrap in `Grouping` so Postgres sees `(display_on != 'back_end') = TRUE`
-        # instead of the ambiguous `display_on != 'back_end' = TRUE`.
-        Arel::Nodes::Grouping.new(
-          Arel::Nodes::NotEqual.new(parent.table[:display_on], Arel::Nodes::Quoted.new('back_end'))
-        )
-      end
-
-      self.whitelisted_ransackable_attributes =
-        (whitelisted_ransackable_attributes || []) | %w[storefront_visible]
-
-      validates :display_on, presence: true, inclusion: { in: DISPLAY.map(&:to_s) }
-
-      def available_on_front_end?
-        display_on == 'front_end' || display_on == 'both'
-      end
-
-      def storefront_visible
-        display_on != 'back_end'
-      end
-
-      def storefront_visible=(value)
-        self.display_on = ActiveModel::Type::Boolean.new.cast(value) ? 'both' : 'back_end'
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Spree
-  module ImageMethods
-    extend ActiveSupport::Concern
-
-    def generate_url(size:, gravity: 'centre', quality: 80, background: [0, 0, 0])
-      Spree::Deprecation.warn("ImageMethods#generate_url is deprecated and will be removed in Spree 6.0. Please use active storage variants with cdn_image_url")
-
-      return if size.blank?
-
-      size = size.gsub(/\s+/, '')
-
-      return unless size.match(/(\d+)x(\d+)/)
-
-      width, height = size.split('x').map(&:to_i)
-      gravity = translate_gravity_for_mini_magick(gravity)
-
-      # FIXME: bring back support for background color
-
-      cdn_image_url(attachment.variant(resize_and_pad: [width, height, { gravity: gravity }], saver: { quality: quality }))
-    end
-
-    def original_url
-      Spree::Deprecation.warn("ImageMethods#original_url is deprecated and will be removed in Spree 6.0. Please use active storage variants with cdn_image_url")
-
-      cdn_image_url(attachment)
-    end
-
-    private
-
-    def translate_gravity_for_mini_magick(gravity)
-      variant_processor = Rails.application.config.active_storage.variant_processor
-
-      if gravity.downcase == 'centre' && [:mini_magick, nil].include?(variant_processor)
-        'center'
-      else
-        gravity
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module Spree
-  # Backwards-compatible shim for resources migrated from a many-to-many store
-  # relationship to a single-store +belongs_to :store+ FK (Spree::Product in 5.5,
-  # Spree::Promotion and Spree::PaymentMethod in 5.6). Maps the historic
-  # +stores+/+store_ids+ accessors onto the singular +store+/+store_id+, warning
-  # on use. The +spree_multi_store+ extension defines +SpreeMultiStore+ to
-  # suppress the include and restore the real +has_many :stores+ association.
-  module LegacyMultiStoreSupport
-    extend ActiveSupport::Concern
-
-    included do
-      # Legacy accessors for the many-to-many store relationship. These are deprecated
-      # and will be removed in Spree 6.0 once the models finish migrating to single-store ownership.
-      # @return [ActiveRecord::Relation<Spree::Store>] the single store wrapped in a relation, or an empty relation if no store is set
-      def stores
-        Spree::Deprecation.warn(
-          "#{self.class.base_class}#stores is deprecated. Please use #{self.class.base_class}#store instead. " \
-          'If you want to continue using multiple stores please install spree_multi_store gem'
-        )
-        store ? Spree::Store.where(id: store.id) : Spree::Store.none
-      end
-
-      def store_ids
-        Spree::Deprecation.warn(
-          "#{self.class.base_class}#store_ids is deprecated. Please use #{self.class.base_class}#store_id instead. " \
-          'If you want to continue using multiple stores please install spree_multi_store gem'
-        )
-        store_id ? [store_id] : []
-      end
-
-      def stores=(stores)
-        Spree::Deprecation.warn(
-          "#{self.class.base_class}#stores= is deprecated. Please use #{self.class.base_class}#store= instead. " \
-          'If you want to continue using multiple stores please install spree_multi_store gem'
-        )
-        self.store = Array(stores).compact.first
-      end
-
-      def store_ids=(store_ids)
-        Spree::Deprecation.warn(
-          "#{self.class.base_class}#store_ids= is deprecated. Please use #{self.class.base_class}#store_id= instead. " \
-          'If you want to continue using multiple stores please install spree_multi_store gem'
-        )
-        self.store_id = Array(store_ids).compact_blank.first
-      end
-    end
-  end
-end

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

@@ -1,256 +0,0 @@
-module Spree
-  module Metafields
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def ensure_metafield_definition_exists!(key_with_namespace)
-        namespace, key = extract_namespace_and_key(key_with_namespace)
-        Spree::MetafieldDefinition.find_or_create_by!(namespace: namespace, key: key, resource_type: self.name)
-      end
-
-      def extract_namespace_and_key(key_with_namespace)
-        namespace = key_with_namespace.to_s.split('.').first
-        key = key_with_namespace.to_s.split('.').last
-        [namespace, key]
-      end
-    end
-
-    included do
-      has_many :metafields, -> { includes(:metafield_definition) }, as: :resource, class_name: 'Spree::Metafield', dependent: :destroy
-      has_many :public_metafields, -> { includes(:metafield_definition).available_on_front_end }, as: :resource, class_name: 'Spree::Metafield'
-      has_many :private_metafields, -> { includes(:metafield_definition).available_on_back_end }, as: :resource, class_name: 'Spree::Metafield'
-
-      accepts_nested_attributes_for :metafields, allow_destroy: true, reject_if: lambda { |mf|
-                                                                                     mf[:metafield_definition_id].blank? || (mf[:id].blank? && mf[:value].blank?)
-                                                                                   }
-
-      # Override metafields_attributes= to automatically mark existing metafields
-      # with empty values for destruction
-      def metafields_attributes=(attributes)
-        attributes = attributes.values if attributes.is_a?(Hash)
-
-        attributes.each do |attrs|
-          # If this is an existing metafield (has an id) and value is blank,
-          # mark it for destruction
-          if attrs[:id].present? && value_blank?(attrs[:value])
-            attrs[:_destroy] = true
-          end
-        end
-
-        super(attributes)
-      end
-
-      # API-facing alias for the 6.0 rename (`5.4-6.0-custom-fields-rename.md`):
-      # callers see "custom fields" everywhere even though the underlying
-      # tables/columns still use `metafield*`. Reached via flat params on the
-      # admin API v3 (`custom_fields: [...]`); also works through
-      # `Model.new(permitted_params)` since Rails routes the key to this writer.
-      #
-      # Upsert semantics by `custom_field_definition_id`: existing entries
-      # for the same definition are updated, missing entries are created.
-      # Partial: definitions NOT in the array are left untouched, so the
-      # client can patch one field at a time without resending the rest.
-      # Blank values on an existing metafield destroy it (mirrors the dedicated
-      # endpoint's behavior via `metafields_attributes=`).
-      def custom_fields=(attributes)
-        return if attributes.blank?
-        return super(attributes) if attributes.first.is_a?(Spree::Metafield)
-
-        assign_custom_field_attrs(attributes)
-      end
-
-      after_save :apply_pending_custom_fields, if: -> { @pending_custom_field_attrs.present? }
-
-      scope :with_metafield_key, ->(key_with_namespace) {
-        namespace, key = extract_namespace_and_key(key_with_namespace)
-        joins(metafields: :metafield_definition).where(spree_metafield_definitions: { namespace: namespace, key: key })
-      }
-      scope :with_metafield_key_value, ->(key_with_namespace, value) {
-        namespace, key = extract_namespace_and_key(key_with_namespace)
-
-        joins(metafields: :metafield_definition)
-          .where(spree_metafield_definitions: { namespace: namespace, key: key })
-          .where(spree_metafields: { value: value })
-      }
-
-      def extract_namespace_and_key(key_with_namespace)
-        self.class.extract_namespace_and_key(key_with_namespace)
-      end
-
-      # Upsert a single custom field value on this resource. The first
-      # argument locates the definition by any of:
-      #
-      # - `"namespace.key"` string — auto-creates the definition if missing
-      #   (backend-internal callers that don't know the id upfront).
-      # - {Spree::MetafieldDefinition} instance.
-      # - Integer / numeric String — raw definition id.
-      # - Prefixed-id String (`"cfdef_..."`) — decoded to the definition id.
-      #
-      # Blank values (nil or empty/whitespace string) destroy any existing
-      # metafield for the definition. Empty containers (`[]`, `{}`) and
-      # numeric / boolean falsy values are real values, not blanks.
-      #
-      # @param definition_or_key [String, Integer, Spree::MetafieldDefinition]
-      # @param value [Object] the value to persist; type is enforced by the
-      #   typed metafield subclass (Boolean, Number, Json, ShortText, …).
-      # @return [Spree::Metafield, nil] the persisted metafield, or nil when
-      #   the value was blank and any existing row was destroyed.
-      # @raise [ArgumentError] if `definition_or_key` doesn't resolve to a
-      #   known definition.
-      def set_metafield(definition_or_key, value)
-        definition_id = resolve_metafield_definition_id(definition_or_key)
-        metafield = metafields.find_or_initialize_by(metafield_definition_id: definition_id)
-        if value_blank?(value)
-          metafield.destroy if metafield.persisted?
-          return nil
-        end
-
-        # JSON metafields store canonical JSON in the underlying text column.
-        # Coerce Hash/Array values BEFORE assignment, since the STI subclass
-        # (`Spree::Metafields::Json`) isn't switched on until before_validation,
-        # so its custom `value=` writer doesn't run yet on a fresh
-        # `find_or_initialize_by` record.
-        if (value.is_a?(Hash) || value.is_a?(Array)) &&
-           metafield.metafield_definition&.metafield_type == 'Spree::Metafields::Json'
-          value = value.to_json
-        end
-
-        metafield.value = value
-        metafield.save!
-        metafield
-      end
-
-      def get_metafield(key_with_namespace)
-        namespace, key = extract_namespace_and_key(key_with_namespace)
-        metafields.with_key(namespace, key).first
-      end
-
-      def has_metafield?(key_with_namespace)
-        if key_with_namespace.is_a?(Spree::MetafieldDefinition)
-          namespace = key_with_namespace.namespace
-          key = key_with_namespace.key
-        elsif key_with_namespace.is_a?(String)
-          namespace, key = extract_namespace_and_key(key_with_namespace)
-        else
-          raise ArgumentError, "Invalid key_with_namespace: #{key_with_namespace.inspect}"
-        end
-
-        metafields.with_key(namespace, key).exists?
-      end
-
-      private
-
-      # Decide whether a metafield value should trigger the destroy-existing
-      # branch. Ruby's `blank?` reports `false`, `0`, `[]`, `{}` as blank, but
-      # for typed metafields those are real values:
-      #
-      # - Boolean `false` / Numeric `0` — real values, never destroy.
-      # - Empty Array / Hash — a JSON metafield storing `[]` or `{}` is a
-      #   meaningful value (an empty list / object), not a clear signal.
-      #
-      # Only `nil` and empty/whitespace strings count as "missing".
-      #
-      # @param value [Object]
-      # @return [Boolean]
-      def value_blank?(value)
-        return true if value.nil?
-        return value.strip.empty? if value.is_a?(String)
-
-        false
-      end
-
-      def assign_custom_field_attrs(attributes)
-        if new_record?
-          # Persisting metafields requires a persisted parent (resource_id NOT
-          # NULL). Stash the attrs and replay them after the parent is saved.
-          @pending_custom_field_attrs = attributes
-          return
-        end
-
-        apply_custom_field_attrs(attributes)
-      end
-
-      def apply_pending_custom_fields
-        attrs = @pending_custom_field_attrs
-        @pending_custom_field_attrs = nil
-        apply_custom_field_attrs(attrs)
-      end
-
-      def apply_custom_field_attrs(attributes)
-        attributes = attributes.values if attributes.is_a?(Hash)
-        attributes.each_with_index do |raw, index|
-          attrs = raw.respond_to?(:to_h) ? raw.to_h : raw
-          attrs = attrs.with_indifferent_access
-          definition_id = attrs[:metafield_definition_id] || attrs[:custom_field_definition_id]
-          next if definition_id.blank?
-
-          begin
-            set_metafield(definition_id, attrs[:value])
-          rescue ArgumentError => e
-            # Convert an unknown / malformed definition id into a field-level
-            # validation error so the controller returns 422 with structured
-            # `details`, instead of leaking ArgumentError as a 400/500.
-            errors.add("custom_fields[#{index}].custom_field_definition_id", e.message)
-            raise ActiveRecord::RecordInvalid, self
-          end
-        end
-      end
-
-      # Resolve any of the supported reference shapes to a raw definition id.
-      # See {#set_metafield} for the accepted shapes.
-      #
-      # @param definition_or_key [String, Integer, Spree::MetafieldDefinition]
-      # @return [Integer, String] the definition's primary key value (Integer
-      #   for legacy integer-id setups, String for UUID setups).
-      # @raise [ArgumentError] for unknown / malformed input.
-      def resolve_metafield_definition_id(definition_or_key)
-        case definition_or_key
-        when Spree::MetafieldDefinition
-          definition_or_key.id
-        when Integer
-          definition_or_key
-        when String
-          resolve_metafield_definition_id_from_string(definition_or_key)
-        else
-          raise ArgumentError, "Invalid definition_or_key: #{definition_or_key.inspect}"
-        end
-      end
-
-      # @param value [String] one of: `"namespace.key"`, a prefixed id
-      #   (`"cfdef_..."`), or a bare numeric id (`"42"`).
-      # @return [Integer, String] the resolved definition's primary key value.
-      # @raise [ArgumentError] if the string doesn't match any known shape.
-      def resolve_metafield_definition_id_from_string(value)
-        # `"namespace.key"` — backend-internal callers that don't know the id;
-        # auto-create the definition if missing.
-        if value.include?('.')
-          namespace, key = extract_namespace_and_key(value)
-          return Spree::MetafieldDefinition.find_or_create_by!(
-            namespace: namespace, key: key, resource_type: self.class.name
-          ).id
-        end
-
-        # Prefixed id (`"cfdef_..."`/`"mfd_..."`). Use the canonical predicate
-        # so single-segment names with underscores (e.g. `"product_specs"`)
-        # don't get mistaken for prefixed ids. We must verify the decoded id
-        # actually exists — Sqids will happily decode any all-lowercase
-        # alphanumeric string to a phantom integer; without the existence
-        # check `find_or_initialize_by(metafield_definition_id: phantom_id)`
-        # would later raise a confusing "Metafield definition must exist"
-        # 422 instead of an "unknown id" 422.
-        if Spree::PrefixedId.prefixed_id?(value)
-          decoded = Spree::MetafieldDefinition.decode_prefixed_id(value)
-          existing = decoded && Spree::MetafieldDefinition.find_by(id: decoded)
-          raise ArgumentError, "Unknown metafield definition id: #{value.inspect}" if existing.nil?
-
-          return existing.id
-        end
-
-        # Bare numeric id ("42"). Reject anything else outright.
-        raise ArgumentError, "Invalid metafield definition reference: #{value.inspect}" unless /\A\d+\z/.match?(value)
-
-        value.to_i
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Spree
-  module NumberAsParam
-    extend ActiveSupport::Concern
-
-    included do
-      Spree::Deprecation.warn(
-        'Spree::NumberAsParam is deprecated and will be removed in Spree 6.0. ' \
-        'Models now use Spree::PrefixedId with Sqids-based prefixed_id method instead. ' \
-        'This concern no longer provides any functionality and can be safely removed.'
-      )
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Spree
-  # @deprecated Use a single-store +belongs_to :store+ FK instead. This concern
-  #   modelled the historic many-to-many store relationship (Promotion,
-  #   PaymentMethod) and is removed in Spree 6.0 once those models finish
-  #   migrating to single-store ownership. See
-  #   docs/plans/5.6-6.0-single-store-promotions-payment-methods.md.
-  module StoreScopedResource
-    extend ActiveSupport::Concern
-
-    included do
-      Spree::Deprecation.warn(
-        "Spree::StoreScopedResource is deprecated and will be removed in Spree 6.0. " \
-        "Use a single-store `belongs_to :store` FK instead (see Spree::Promotion / Spree::PaymentMethod)."
-      )
-
-      scope :for_store, ->(store) { joins(:stores).where(Store.table_name => { id: store.id }) }
-
-      before_validation :set_default_store, if: :new_record?
-    end
-
-    protected
-
-    def set_default_store
-      return if disable_store_presence_validation?
-      # records built through a store's association (`store.payment_methods.build`)
-      # carry their link on the join association — `stores` can't see it until save
-      join_association = self.class.reflect_on_association(:stores).through_reflection.name
-      return if stores.any? || send(join_association).any?
-
-      stores << Spree::Store.default
-    end
-
-    def disable_store_presence_validation?
-      Spree::Config[:disable_store_presence_validation]
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-module Spree
-  module UniqueName
-    extend ActiveSupport::Concern
-
-    included do
-      normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
-
-      validates :name, presence: true,
-                       uniqueness: { case_sensitive: false, allow_blank: true, scope: spree_base_uniqueness_scope }
-    end
-  end
-end

data/app/models/spree/adjustable/adjuster/base.rb

@@ -1,25 +0,0 @@
-module Spree
-  module Adjustable
-    module Adjuster
-      class Base
-        def self.adjust(adjustable, totals)
-          new(adjustable, totals).update
-        end
-
-        def initialize(adjustable, totals)
-          @adjustable = adjustable
-          @totals = totals
-        end
-
-        def update
-          raise NotImplementedError, "Please implement 'update' in your adjuster: #{self.class.name}"
-        end
-
-        private
-
-        attr_reader :adjustable
-        delegate :adjustments, to: :adjustable
-      end
-    end
-  end
-end

data/app/models/spree/adjustable/adjuster/promotion.rb

@@ -1,41 +0,0 @@
-module Spree
-  module Adjustable
-    module Adjuster
-      class Promotion < Spree::Adjustable::Adjuster::Base
-        def update
-          promo_adjustments = adjustments.competing_promos.reload.map { |a| a.update!(adjustable) }
-          promos_total = promo_adjustments.compact.sum
-          choose_best_promo_adjustment unless promos_total == 0
-          promo_total = best_promo_adjustment.try(:amount).to_f if best_promo_adjustment.try(:promotion?)
-
-          update_totals(promo_total)
-        end
-
-        private
-
-        # Picks one (and only one) competing discount to be eligible for
-        # this order. This adjustment provides the most discount, and if
-        # two adjustments have the same amount, then it will pick the
-        # latest one.
-        def choose_best_promo_adjustment
-          if best_promo_adjustment
-            other_promotions = adjustments.competing_promos.where.not(id: best_promo_adjustment.id)
-            other_promotions.update_all(eligible: false)
-          end
-        end
-
-        def best_promo_adjustment
-          @best_promo_adjustment ||= begin
-            adjustments.competing_promos.eligible.reorder('amount ASC, created_at DESC, id DESC').first
-          end
-        end
-
-        def update_totals(promo_total)
-          promo_total ||= 0.0
-          @totals[:promo_total] = promo_total
-          @totals[:taxable_adjustment_total] += promo_total
-        end
-      end
-    end
-  end
-end

data/app/models/spree/adjustable/adjuster/tax.rb

@@ -1,26 +0,0 @@
-module Spree
-  module Adjustable
-    module Adjuster
-      class Tax < Spree::Adjustable::Adjuster::Base
-        def update
-          tax = adjustments.tax
-          included_tax_total = tax.find_all(&:included?).map(&:update!).compact.sum || 0
-          additional_tax_total = tax.find_all(&:additional?).map(&:update!).compact.sum || 0
-
-          update_totals(included_tax_total, additional_tax_total)
-        end
-
-        private
-
-        def adjustments
-          adjustable.try(:all_adjustments) || adjustable.adjustments
-        end
-
-        def update_totals(included_tax_total, additional_tax_total)
-          @totals[:included_tax_total] = included_tax_total
-          @totals[:additional_tax_total] = additional_tax_total
-        end
-      end
-    end
-  end
-end

data/app/models/spree/adjustable/adjustments_updater.rb

@@ -1,74 +0,0 @@
-module Spree
-  module Adjustable
-    class AdjustmentsUpdater
-      def self.update(adjustable)
-        new(adjustable).update
-      end
-
-      def initialize(adjustable)
-        @adjustable = adjustable
-        adjustable.reload if shipment? && adjustable && adjustable.persisted?
-      end
-
-      def update
-        return unless adjustable_still_exists?
-
-        totals = {
-          non_taxable_adjustment_total: 0,
-          taxable_adjustment_total: 0
-        }
-        non_tax_adjusters.each do |klass|
-          klass.adjust(@adjustable, totals)
-        end
-
-        if tax_adjuster.present?
-          # Other adjustments can change the taxable amount so we need to update it first
-          update_adjustable_attributes(totals)
-          tax_adjuster.adjust(@adjustable, totals)
-        end
-
-        persist_totals totals
-      end
-
-      private
-
-      def persist_totals(totals)
-        attributes = totals
-        attributes[:adjustment_total] = totals[:non_taxable_adjustment_total] +
-          totals[:taxable_adjustment_total] +
-          totals.fetch(:additional_tax_total, 0)
-
-        update_adjustable_attributes(attributes)
-      end
-
-      def update_adjustable_attributes(attributes)
-        # Only update if attributes have changed
-        current_attributes = @adjustable.attributes.slice(*attributes.keys.map(&:to_s))
-        return if attributes.all? { |key, value| current_attributes[key.to_s] == value }
-
-        attributes[:updated_at] = Time.current
-        @adjustable.update_columns(attributes)
-      end
-
-      def shipment?
-        @adjustable.is_a?(Shipment)
-      end
-
-      def adjusters
-        Spree.adjusters
-      end
-
-      def tax_adjuster
-        @tax_adjuster ||= adjusters.find { |adjuster| adjuster.name == 'Spree::Adjustable::Adjuster::Tax' }
-      end
-
-      def non_tax_adjusters
-        adjusters - [tax_adjuster].compact
-      end
-
-      def adjustable_still_exists?
-        @adjustable&.class&.exists?(@adjustable.id)
-      end
-    end
-  end
-end