spree_core 6.0.0.beta3 → 6.0.0.rc1

data/app/models/spree/payment/gateway_options.rb

@@ -10,40 +10,19 @@ module Spree
 
       attr_reader :payment, :order
       delegate :currency, to: :payment
-      delegate :email, to: :order
-
-      def statement_descriptor_suffix
-        order.number
-      end
-
-      def customer
-        order.email
-      end
-
-      def customer_id
-        order.customer_id
-      end
-
-      def ip
-        order.last_ip_address
-      end
-
-      # The payment number already names its order (`R1001-P1`), so this is
-      # the payment number alone rather than the two concatenated.
-      def order_id
-        payment.number
-      end
-
-      def payment_id
-        payment.number
-      end
-
+      delegate :email, :customer_id, to: :order
       # Stable handle for a gateway to find its own payment back. The derived
       # number cannot be queried (its column is NULL on 6.0 rows) and shifts
       # if an earlier sibling is destroyed — nothing durable may key on it.
-      def payment_prefixed_id
-        payment.prefixed_id
-      end
+      delegate :prefixed_id, to: :payment, prefix: true
+
+      def statement_descriptor_suffix = order.number
+      def customer = order.email
+      def ip = order.last_ip_address
+      # The payment number already names its order (`R1001-P1`), so this is
+      # the payment number alone rather than the two concatenated.
+      def order_id = payment.number
+      def payment_id = payment.number
 
       # Built on the prefixed ID, not the number: a derived number shifts if
       # an earlier sibling payment is destroyed, and a shifted idempotency
@@ -53,7 +32,7 @@ module Spree
       end
 
       def shipping
-        order.ship_total * exchange_multiplier
+        order.delivery_total * exchange_multiplier
       end
 
       def tax
@@ -77,29 +56,12 @@ module Spree
       end
 
       def hash_methods
-        [
-          :email,
-          :customer,
-          :customer_id,
-          :ip,
-          :order_id,
-          :payment_id,
-          :payment_prefixed_id,
-          :idempotency_key,
-          :shipping,
-          :tax,
-          :subtotal,
-          :discount,
-          :currency,
-          :billing_address,
-          :shipping_address
-        ]
+        %i[email customer customer_id ip order_id payment_id payment_prefixed_id idempotency_key shipping tax
+           subtotal discount currency billing_address shipping_address]
       end
 
       def to_hash
-        Hash[hash_methods.map do |method|
-          [method, send(method)]
-        end]
+        hash_methods.index_with { |method| send(method) }
       end
 
       private

data/app/models/spree/payment/processing.rb

@@ -1,5 +1,3 @@
-require_dependency 'spree/payment/gateway_options'
-
 module Spree
   class Payment < Spree.base_class
     # Gateway mechanics shared by the payments workflows and the payment
@@ -144,11 +142,11 @@ module Spree
         text = if error.is_a? Spree::PaymentResponse
                  error.params['message'] || error.params['response_reason_text'] || error.message
                elsif error.is_a? Spree::PaymentConnectionError
-                 Spree.t(:unable_to_connect_to_gateway)
+                 I18n.t('spree.unable_to_connect_to_gateway')
                else
                  error.to_s
                end
-        Rails.logger.error(Spree.t(:gateway_error))
+        Rails.logger.error(I18n.t('spree.gateway_error'))
         Rails.logger.error("  #{error.to_yaml}")
         raise Core::GatewayError, text
       end

data/app/models/spree/payment.rb

@@ -1,5 +1,3 @@
-require_dependency 'spree/payment/processing'
-
 module Spree
   class Payment < Spree.base_class
     has_prefix_id :py  # Stripe: py_
@@ -18,6 +16,7 @@ module Spree
     include Spree::Payment::CustomEvents
 
     publishes_lifecycle_events
+    publishes_events :captured, :completed, :paid, :refunded, :voided
 
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
@@ -244,6 +243,9 @@ module Spree
       return amount if owner.nil?
 
       amount_from_order = owner.total - owner.payment_total
+      # A refund for returned goods settled what was owed for them; without
+      # this the order would accept a fresh charge for goods it took back.
+      amount_from_order -= owner.returned_items_refund_total if owner.respond_to?(:returned_items_refund_total)
 
       if payment_method&.store_credit?
         store_credits = owner.available_store_credits
@@ -263,6 +265,19 @@ module Spree
         end || amount
     end
 
+    # Resizes a store credit payment that has not been taken yet. Completion
+    # takes it against the eligibility event recorded for its amount, so the
+    # new amount needs one of its own.
+    #
+    # @param new_amount [BigDecimal]
+    # @return [void]
+    def update_store_credit_amount!(new_amount)
+      return if amount == new_amount
+
+      update_column(:amount, new_amount)
+      create_eligible_credit_event
+    end
+
     def offsets_total
       offsets.sum(:amount)
     end
@@ -502,7 +517,7 @@ module Spree
     end
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart, order_group].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart, order_group].compact.one?
     end
 
     def set_amount
@@ -532,8 +547,8 @@ module Spree
     end
 
     def add_source_error(field, message)
-      field_name = I18n.t("activerecord.attributes.#{source.class.to_s.underscore}.#{field}")
-      errors.add(Spree.t(source.class.to_s.demodulize.underscore), "#{field_name} #{message}")
+      field_name = source.class.human_attribute_name(field)
+      errors.add(source.class.model_name.human, "#{field_name} #{message}")
     end
 
 

data/app/models/spree/payment_method/session_instrumentation.rb

@@ -16,6 +16,7 @@ module Spree
         create_payment_session
         update_payment_session
         complete_payment_session
+        cancel_payment_session
         create_payment_setup_session
         complete_payment_setup_session
       ].freeze

data/app/models/spree/payment_method/store_credit.rb

@@ -22,7 +22,7 @@ module Spree
 
     def authorize(amount_in_cents, store_credit, gateway_options = {})
       if store_credit.nil?
-        Spree::PaymentResponse.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+        Spree::PaymentResponse.new(false, I18n.t('spree.store_credit_payment_method.unable_to_find'), {}, {})
       else
         action = lambda do |store_credit|
           store_credit.authorize(
@@ -58,7 +58,7 @@ module Spree
       end
 
       if event.blank?
-        Spree::PaymentResponse.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+        Spree::PaymentResponse.new(false, I18n.t('spree.store_credit_payment_method.unable_to_find'), {}, {})
       else
         capture(amount_in_cents, event.authorization_code, gateway_options)
       end
@@ -115,7 +115,7 @@ module Spree
           # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
           Spree::PaymentResponse.new(
             true,
-            Spree.t('store_credit_payment_method.successful_action', action: action_name),
+            I18n.t('spree.store_credit_payment_method.successful_action', action: action_name),
             {},
             authorization: auth_code || response
           )
@@ -132,7 +132,7 @@ module Spree
       if store_credit.nil?
         Spree::PaymentResponse.new(
           false,
-          Spree.t('store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
+          I18n.t('spree.store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
           {},
           {}
         )

data/app/models/spree/payment_method.rb

@@ -13,7 +13,9 @@ module Spree
     include Spree::StorePreferences
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::SecretPreferences
     include Spree::CaptureMethod
+    include Spree::ProviderListing
     if defined?(Spree::Security::PaymentMethods)
       include Spree::Security::PaymentMethods
     end
@@ -57,7 +59,6 @@ module Spree
     validates :storefront_visible, inclusion: { in: [true, false] }
     normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
 
-    belongs_to :store, class_name: 'Spree::Store'
 
     has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method, dependent: :nullify
     has_many :credit_cards, class_name: 'Spree::CreditCard', dependent: :destroy # CCs are soft deleted
@@ -74,6 +75,20 @@ module Spree
     # `providers`; declaring it keeps subclass resolution to a single rule.
     registers_subclasses_via { providers }
 
+    # Whether this method is backed by an external payment provider (Stripe,
+    # Adyen…) rather than handled by the store itself (check, store credit).
+    # Only third-party methods are listed under Settings → Integrations.
+    #
+    # @return [Boolean]
+    def self.third_party?
+      false
+    end
+
+    # @return [Hash] the listing attributes, plus whether the method is third-party
+    def self.provider_listing
+      super.merge(third_party: third_party?)
+    end
+
     def provider_class
       raise ::NotImplementedError, 'You must implement provider_class method for this gateway.'
     end
@@ -136,6 +151,25 @@ module Spree
       raise ::NotImplementedError, 'You must implement complete_payment_session method for this gateway.'
     end
 
+    # Cancels a session nobody is going to complete, so the provider can no
+    # longer take money against it. Called for the sessions left pending when
+    # an order is placed. The default leaves the session untouched: a
+    # gateway that cannot cancel at the provider must not report as canceled
+    # a session that can still be paid.
+    #
+    # Raise Spree::Core::GatewayError only for a refusal, such as a session
+    # that was already paid. A timeout, a rate limit, an outage, or rejected
+    # credentials is raised as itself. Callers that treat those as a refusal
+    # leave a session the buyer can still pay.
+    #
+    # @param payment_session [Spree::PaymentSession]
+    # @return [Boolean] whether the session was canceled
+    # @raise [Spree::Core::GatewayError] when the provider refuses, e.g. the
+    #   session has already been paid
+    def cancel_payment_session(payment_session:)
+      false
+    end
+
     # Parses an incoming webhook payload from the payment provider.
     # Override in gateway subclasses to implement provider-specific webhook parsing.
     #
@@ -284,9 +318,7 @@ module Spree
     end
 
     def public_preferences
-      public_preference_keys.each_with_object({}) do |key, hash|
-        hash[key] = preferences[key]
-      end
+      public_preference_keys.index_with { |key| get_preference(key) }
     end
 
     # @deprecated Use {#storefront_visible?}; removed in 6.1.

data/app/models/spree/payment_session.rb

@@ -9,6 +9,7 @@ module Spree
     self.event_prefix = 'payment_session'
 
     publishes_lifecycle_events
+    publishes_events :canceled, :completed, :expired, :failed, :processing
 
     belongs_to :order, class_name: 'Spree::Order', optional: true
     belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :payment_sessions
@@ -28,6 +29,9 @@ module Spree
 
     scope :not_expired, -> { where('expires_at IS NULL OR expires_at > ?', Time.current) }
     scope :active, -> { not_expired.where(status: %w[pending processing]) }
+    # A declined confirm marks the session failed while its intent can still
+    # be paid, so placement has to cancel those too.
+    scope :unused, -> { where(status: %w[pending failed]).where.missing(:payment) }
 
     before_validation :set_defaults_from_order, on: :create
 
@@ -195,7 +199,7 @@ module Spree
     end
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
 
     def publish_processing_event

data/app/models/spree/payment_setup_session.rb

@@ -9,6 +9,7 @@ module Spree
     self.event_prefix = 'payment_setup_session'
 
     publishes_lifecycle_events
+    publishes_events :canceled, :completed, :expired, :failed, :processing
 
     belongs_to :customer, class_name: Spree.customer_class.to_s, optional: true
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'

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

@@ -22,6 +22,8 @@ module Spree
     # delivery-rate providers are; anything request-specific arrives as an
     # argument.
     class Base
+      extend Spree::ApiTyped
+
       # The name a merchant sees when choosing how sellers are paid.
       #
       # @return [String]
@@ -57,7 +59,7 @@ module Spree
       # @return [Hash]
       def self.to_api_hash(store)
         {
-          id: name,
+          id: api_type,
           name: display_name,
           available: available_for_store?(store),
           requires_payout_account: requires_payout_account?,

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

@@ -10,6 +10,8 @@ module Spree
     # integrations) and +find_nearby+ gains +zipcode:+/+query:+ params.
     # Build third-party providers against 6.1, not this shape.
     class Base
+      extend Spree::ApiTyped
+
       # @return [Array<Spree::PickupPointOption>]
       def find_nearby(latitude:, longitude:, limit: 20)
         raise NotImplementedError, "Please implement 'find_nearby' in your pickup point provider: #{self.class.name}"

data/app/models/spree/price_list.rb

@@ -10,7 +10,6 @@ module Spree
 
     MATCH_POLICIES = %w[all any].freeze
 
-    belongs_to :store, class_name: 'Spree::Store'
     # The owning agreement, or nil for a standalone list. An owned list is
     # reached only through its catalog — generic rule matching skips it in
     # SQL (see .for_context) — so a deactivated catalog's list goes dormant
@@ -155,7 +154,7 @@ module Spree
     end
 
     def self.match_policies
-      MATCH_POLICIES.map { |key| [Spree.t(key), key] }
+      MATCH_POLICIES.map { |key| [I18n.t("spree.#{key}"), key] }
     end
 
     # Returns true if the price list is applicable to the context

data/app/models/spree/price_rules/channel_rule.rb

@@ -32,7 +32,7 @@ module Spree
       end
 
       def self.description
-        Spree.t('price_rules.channel_rule.description')
+        I18n.t('spree.price_rules.channel_rule.description')
       end
     end
   end

data/app/models/spree/price_rules/customer_group_rule.rb

@@ -33,7 +33,7 @@ module Spree
       end
 
       def self.description
-        Spree.t('price_rules.customer_group_rule.description')
+        I18n.t('spree.price_rules.customer_group_rule.description')
       end
 
       def self.superseded?

data/app/models/spree/product.rb

@@ -38,6 +38,7 @@ module Spree
     include Spree::StorePreferences
 
     publishes_lifecycle_events
+    publishes_events :activated, :approved, :archived, :back_in_stock, :drafted, :out_of_stock, :proposed, :rejected
 
     MEMOIZED_METHODS = %w[total_on_hand category_and_ancestors
                           default_variant_id tax_category default_variant variant_for_images
@@ -302,9 +303,6 @@ module Spree
       where(id: (product_ids + custom_field_ids).uniq.compact)
     }
 
-    # Backward compatibility alias — remove in Spree 6.0
-    scope :multi_search, ->(*args) { search(*args) }
-
     scope :archivable, -> { where(status: %w[active draft]) }
     scope :by_source, ->(source) { send(source) }
     scope :published, -> { where(status: 'active') }
@@ -375,7 +373,7 @@ module Spree
     self.storefront_ransackable_associations = %w[tags categories collections]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon in_category in_categories in_collection price_between
                                              price_lte price_gte
-                                             search multi_search in_stock out_of_stock with_option_value_ids
+                                             search in_stock out_of_stock with_option_value_ids
 
                                              ascend_by_price descend_by_price]
 
@@ -693,7 +691,7 @@ module Spree
     # variant), reading preloaded associations to avoid an N+1.
     # @return [ActiveSupport::TimeWithZone, nil]
     def preorder_ships_at
-      candidates = has_variants? ? variants : [master]
+      candidates = has_variants? ? variants : [default_variant]
       candidates.select(&:preorder?).filter_map(&:preorder_ships_at).max
     end
 
@@ -817,7 +815,13 @@ module Spree
       Spree::Products::AutoMatchCollectionsJob.set(wait: 30.seconds).perform_later(id)
     end
 
-    def to_csv(store = nil)
+    # @param seller [Spree::Seller, nil] the seller exporting their own
+    #   products, whose rows cover only their own locations; nil for the
+    #   operator, whose rows cover the marketplace's and the product's seller's
+    # @param default_stock_location [Spree::StockLocation, nil] the location
+    #   the full rows carry; further locations get stock-only rows. The
+    #   store's default when nil
+    def to_csv(store = nil, seller: nil, default_stock_location: nil)
       store ||= self.store
       properties_for_csv = if respond_to?(:product_properties) && Spree::Config.respond_to?(:product_properties_enabled) && Spree::Config[:product_properties_enabled]
                              Spree::Property.order(:position).flat_map do |property|
@@ -840,11 +844,12 @@ module Spree
       all_variants = variants.to_a
       default_currency = store.default_currency
       additional_currencies = store.supported_currencies_list.map(&:iso_code) - [default_currency]
+      default_stock_location ||= store.default_stock_location
 
       # Primary rows in the store's default currency
       all_variants.each_with_index do |variant, index|
         csv_lines << Spree::CSV::ProductVariantPresenter.new(self, variant, index, properties_for_csv, categories_for_csv, store,
-                                                             custom_field_values).call
+                                                             custom_field_values, default_stock_location: default_stock_location).call
       end
 
       # Price-only rows for each additional currency
@@ -857,6 +862,25 @@ module Spree
         end
       end
 
+      # Stock-only rows for every other location the importer can name back. A
+      # row the import cannot route to its variant is left out: with no SKU it
+      # would land on the default variant.
+      location_owner_ids = seller ? [seller.id] : [nil, seller_id].uniq
+      all_variants.each do |variant|
+        next unless variant.should_track_inventory?
+        next if variant.sku.blank? && variant != default_variant
+
+        variant.stock_levels.each do |stock_level|
+          location = stock_level.stock_location
+          next if location.nil? || location == default_stock_location
+          next unless location.store_id == store.id && location_owner_ids.include?(location.seller_id)
+          next if stock_level.count_on_hand.zero?
+
+          csv_lines << Spree::CSV::ProductVariantPresenter.new(self, variant, 0, [], [], store,
+                                                               stock_level: stock_level).call
+        end
+      end
+
       csv_lines
     end
 

data/app/models/spree/product_submission.rb

@@ -56,17 +56,5 @@ module Spree
     def store
       product&.store
     end
-
-    # Named explicitly rather than left to the `Spree::Api::V3::` convention:
-    # a serializer at that level is picked up by the Store API's generated
-    # types and OpenAPI document, and a review decision is not something the
-    # storefront has any business describing. The seller's own view is the
-    # right shape for an event — it already withholds who decided, which a
-    # webhook payload leaving the marketplace should not carry.
-    #
-    # @return [Class]
-    def event_serializer_class
-      Spree::Api::V3::Seller::ProductSubmissionSerializer
-    end
   end
 end

data/app/models/spree/product_type.rb

@@ -10,7 +10,6 @@ module Spree
     TRANSLATABLE_FIELDS = %i[name].freeze
     translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
-    belongs_to :store, class_name: 'Spree::Store'
     # Creation-time template only: stamped onto the product when it is
     # created with this type, never managed through it afterwards — the same
     # doctrine as every other type-driven attribute. Nil means the store's

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -104,6 +104,31 @@ module Spree
           quantifier.can_supply? quantity
         end
 
+        # Whether the promotion gives its gift on this order, judged with other
+        # promotions' gifts still counting toward its own rules — a single
+        # level, so two gift promotions measuring each other cannot loop.
+        #
+        # @param order [Spree::Order, Spree::Cart]
+        # @return [Boolean]
+        def gives_away?(order)
+          promotion.eligible?(order, own_gift_only: true) && qualifies_beyond_the_gift?(order, own_gift_only: true)
+        end
+
+        # How many units of this line the promotion pays for — never more than
+        # the line holds, so a shopper buying three of a variant gifted once
+        # still pays for two. `quantity` is nullable and written by `upsert_all`,
+        # which skips validation, so a missing or negative one gifts nothing
+        # rather than raising or turning the discount into a surcharge.
+        #
+        # @param line_item [Spree::LineItem]
+        # @return [Integer]
+        def gifted_quantity_of(line_item)
+          gifted = promotion_action_line_items.detect { |item| item.variant_id == line_item.variant_id }
+          return 0 if gifted.nil?
+
+          [[line_item.quantity, gifted.quantity.to_i].min, 0].max
+        end
+
         private
 
         # Whether this line holds a variant the promotion gives away.
@@ -117,30 +142,15 @@ module Spree
         # to hold a line the rules count with units this action is not already
         # covering. A promotion with no rules qualifies on anything, so there is
         # nothing for the gift to stand in for.
-        def qualifies_beyond_the_gift?(order)
+        def qualifies_beyond_the_gift?(order, options = {})
           return true if promotion.promotion_rules.empty?
 
           order.line_items.any? do |line_item|
-            promotion.line_item_actionable?(order, line_item) &&
+            promotion.line_item_actionable?(order, line_item, options) &&
               gifted_quantity_of(line_item) < line_item.quantity
           end
         end
 
-        # How many units of this line the promotion pays for — never more than
-        # the line holds, so a shopper buying three of a variant gifted once
-        # still pays for two. `quantity` is nullable and written by `upsert_all`,
-        # which skips validation, so a missing or negative one gifts nothing
-        # rather than raising or turning the discount into a surcharge.
-        #
-        # @param line_item [Spree::LineItem]
-        # @return [Integer]
-        def gifted_quantity_of(line_item)
-          gifted = promotion_action_line_items.detect { |item| item.variant_id == line_item.variant_id }
-          return 0 if gifted.nil?
-
-          [[line_item.quantity, gifted.quantity.to_i].min, 0].max
-        end
-
         def add_missing_line_items(order)
           added_results = promotion_action_line_items.map do |item|
             missing = item.quantity.to_i - order.quantity_of(item.variant)

data/app/models/spree/promotion/rules/category.rb

@@ -47,10 +47,6 @@ module Spree
         #
         after_save :add_categories
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible_category_ids
           @eligible_category_ids ||= promotion_rule_categories.pluck(:category_id)
         end

data/app/models/spree/promotion/rules/channel.rb

@@ -14,10 +14,6 @@ module Spree
                      scope: ->(rule) { rule.promotion.store.channels }
                    )
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def channels
           return Spree::Channel.none if preferred_channel_ids.blank?
 

data/app/models/spree/promotion/rules/country.rb

@@ -15,10 +15,6 @@ module Spree
         preference :country_id, :integer # legacy single-country shortcut
         preference :country_code, :string # legacy ISO-based shortcut
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def countries
           isos = configured_country_codes.presence || [configured_country_code].compact_blank
           isos = [legacy_country_code(preferred_country_id)].compact_blank if isos.blank? && preferred_country_id.present?

data/app/models/spree/promotion/rules/currency.rb

@@ -5,10 +5,6 @@ module Spree
       class Currency < Spree::PromotionRule
         preference :currency, :string
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, options = {})
           return true if order.currency == preferred_currency
 

data/app/models/spree/promotion/rules/customer_group.rb

@@ -15,10 +15,6 @@ module Spree
                      scope: ->(rule) { rule.promotion.store.customer_groups }
                    )
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def customer_groups
           return Spree::CustomerGroup.none if preferred_customer_group_ids.blank?
 

data/app/models/spree/promotion/rules/first_order.rb

@@ -4,10 +4,6 @@ module Spree
       class FirstOrder < Spree::PromotionRule
         attr_reader :user, :email, :store
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, options = {})
           @user = order.try(:customer) || options[:user]
           @email = if options[:email].present?