spree_core 5.2.6 → 5.3.0.rc1

data/app/models/spree/subscriber.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Spree
+  # Base class for event subscribers.
+  #
+  # Subscribers handle events published through the Spree event system.
+  # They provide a clean DSL for declaring which events to subscribe to
+  # and are automatically registered during Rails initialization.
+  #
+  # @example Basic subscriber
+  #   class OrderCompletedNotifier < Spree::Subscriber
+  #     subscribes_to 'order.complete'
+  #
+  #     def call(event)
+  #       order_id = event.payload['id']
+  #       Spree::OrderMailer.confirm_email(order_id).deliver_later
+  #     end
+  #   end
+  #
+  # @example Multi-event subscriber
+  #   class OrderAuditLogger < Spree::Subscriber
+  #     subscribes_to 'order.complete', 'order.cancel', 'order.resume'
+  #
+  #     def call(event)
+  #       AuditLog.create!(
+  #         event_name: event.name,
+  #         payload: event.payload,
+  #         occurred_at: event.timestamp
+  #       )
+  #     end
+  #   end
+  #
+  # @example Pattern matching subscriber
+  #   class OrderEventLogger < Spree::Subscriber
+  #     subscribes_to 'order.*'
+  #
+  #     def call(event)
+  #       Rails.logger.info("Order event: #{event.name}")
+  #     end
+  #   end
+  #
+  # @example Subscriber with method routing
+  #   class PaymentSubscriber < Spree::Subscriber
+  #     subscribes_to 'payment.complete', 'payment.void', 'payment.refund'
+  #
+  #     on 'payment.complete', :handle_complete
+  #     on 'payment.void', :handle_void
+  #     on 'payment.refund', :handle_refund
+  #
+  #     private
+  #
+  #     def handle_complete(event)
+  #       # Handle payment completion
+  #     end
+  #
+  #     def handle_void(event)
+  #       # Handle payment void
+  #     end
+  #
+  #     def handle_refund(event)
+  #       # Handle payment refund
+  #     end
+  #   end
+  #
+  # @example Synchronous subscriber (runs immediately, not via ActiveJob)
+  #   class CriticalOrderHandler < Spree::Subscriber
+  #     subscribes_to 'order.complete', async: false
+  #
+  #     def call(event)
+  #       # This runs synchronously
+  #     end
+  #   end
+  #
+  class Subscriber
+    class << self
+      # DSL method to declare which events this subscriber handles
+      #
+      # @param patterns [Array<String>] Event patterns to subscribe to
+      # @param options [Hash] Subscription options
+      # @option options [Boolean] :async (true) Whether to run async via ActiveJob
+      # @return [void]
+      #
+      # @example
+      #   subscribes_to 'order.complete'
+      #   subscribes_to 'order.complete', 'order.cancel'
+      #   subscribes_to 'order.*'
+      #   subscribes_to 'order.complete', async: false
+      #
+      def subscribes_to(*patterns, **options)
+        @subscription_patterns ||= []
+        @subscription_options = options
+
+        patterns.flatten.each do |pattern|
+          @subscription_patterns << pattern.to_s
+        end
+      end
+
+      # DSL method to route specific events to specific methods
+      #
+      # @param pattern [String] Event pattern
+      # @param method_name [Symbol] Method to call for this event
+      # @return [void]
+      #
+      # @example
+      #   on 'payment.complete', :handle_complete
+      #   on 'payment.void', :handle_void
+      #
+      def on(pattern, method_name)
+        @event_handlers ||= {}
+        @event_handlers[pattern.to_s] = method_name
+      end
+
+      # Get all subscription patterns for this subscriber
+      #
+      # @return [Array<String>]
+      def subscription_patterns
+        @subscription_patterns ||= []
+      end
+
+      # Get subscription options
+      #
+      # @return [Hash]
+      def subscription_options
+        @subscription_options ||= {}
+      end
+
+      # Get event handlers mapping
+      #
+      # @return [Hash<String, Symbol>]
+      def event_handlers
+        @event_handlers ||= {}
+      end
+
+      # Class-level call method for when the class itself is used as subscriber
+      #
+      # @param event [Spree::Event]
+      def call(event)
+        new.call(event)
+      end
+    end
+
+    # Handle an event
+    #
+    # Override this method in subclasses to handle events.
+    # If you've defined event handlers with `on`, this method
+    # will route to the appropriate handler automatically.
+    #
+    # @param event [Spree::Event] The event to handle
+    # @return [void]
+    def call(event)
+      handler = find_handler(event)
+
+      if handler
+        send(handler, event)
+      else
+        # Default behavior - subclasses should override
+        handle(event)
+      end
+    end
+
+    # Default event handler
+    #
+    # Override this in subclasses if not using the `on` DSL
+    #
+    # @param event [Spree::Event]
+    def handle(event)
+      # Override in subclass
+    end
+
+    private
+
+    def find_handler(event)
+      handlers = self.class.event_handlers
+
+      # Try exact match first
+      return handlers[event.name] if handlers.key?(event.name)
+
+      # Try pattern matching
+      handlers.each do |pattern, method_name|
+        return method_name if event.matches?(pattern)
+      end
+
+      nil
+    end
+  end
+end

data/app/models/spree/tax_category.rb

@@ -1,9 +1,5 @@
 module Spree
   class TaxCategory < Spree.base_class
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
-
     acts_as_paranoid
     validates :name, presence: true, uniqueness: { case_sensitive: false, scope: spree_base_uniqueness_scope + [:deleted_at] }
 

data/app/models/spree/tax_rate.rb

@@ -6,9 +6,6 @@ module Spree
     include Spree::AdjustmentSource
     include Spree::Metafields
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
 
     with_options inverse_of: :tax_rates do
       belongs_to :zone, class_name: 'Spree::Zone', optional: true

data/app/models/spree/taxon.rb

@@ -19,10 +19,6 @@ module Spree
     include Spree::Metafields
     include Spree::Metadata
     include Spree::MemoizedData
-    include Spree::Linkable
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
 
     MEMOIZED_METHODS = %w[cached_self_and_descendants_ids].freeze
 
@@ -31,7 +27,7 @@ module Spree
     #
     extend FriendlyId
     friendly_id :permalink, slug_column: :permalink, use: :history
-    acts_as_nested_set dependent: :destroy
+    acts_as_nested_set dependent: :destroy, counter_cache: :children_count
 
     #
     # Associations
@@ -85,10 +81,6 @@ module Spree
     after_move :regenerate_pretty_name_and_permalink
     after_move :regenerate_translations_pretty_name_and_permalink
 
-    after_commit :touch_featured_sections, on: [:update]
-    after_touch :touch_featured_sections
-    after_destroy :remove_featured_sections, if: -> { featured? }
-
     #
     # Scopes
     #
@@ -167,10 +159,6 @@ module Spree
       sort_order == 'manual'
     end
 
-    def page_builder_image
-      square_image.presence || image
-    end
-
     def active_products_with_descendants
       @active_products_with_descendants ||= store.products.
                                             joins(:classifications).
@@ -324,7 +312,7 @@ module Spree
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
     def applicable_filters
-      Spree::Deprecation.warn('applicable_filters is deprecated and will be removed in Spree 6.0')
+      Spree::Deprecation.warn('applicable_filters is deprecated and will be removed in Spree 5.5')
       fs = []
       # fs << ProductFilters.taxons_below(self)
       ## unless it's a root taxon? left open for demo purposes
@@ -366,6 +354,7 @@ module Spree
     end
 
     def active_products
+      Spree::Deprecation.warn('active_products is deprecated and will be removed in Spree 5.5. Please use taxon.products.active instead.')
       products.active
     end
 
@@ -401,20 +390,6 @@ module Spree
       move_to_child_with_index(parent, idx.to_i) unless new_record?
     end
 
-    def page_builder_url
-      return unless Spree::Core::Engine.routes.url_helpers.respond_to?(:nested_taxons_path)
-
-      Spree::Core::Engine.routes.url_helpers.nested_taxons_path(self)
-    end
-
-    def featured?
-      featured_sections.any?
-    end
-
-    def featured_sections
-      @featured_sections ||= Spree::PageSections::FeaturedTaxon.published.by_taxon_id(id)
-    end
-
     private
 
     def should_regenerate_pretty_name_and_permalink?
@@ -455,13 +430,5 @@ module Spree
     def regenerate_translations_pretty_name_and_permalink
       translations.each(&:regenerate_pretty_name_and_permalink)
     end
-
-    def touch_featured_sections
-      Spree::Taxons::TouchFeaturedSections.call(taxon_ids: [id])
-    end
-
-    def remove_featured_sections
-      featured_sections.destroy_all
-    end
   end
 end

data/app/models/spree/taxonomy.rb

@@ -4,9 +4,6 @@ module Spree
     include Spree::Metafields
     include Spree::Metadata
     include Spree::SingleStoreResource
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
 
     TRANSLATABLE_FIELDS = %i[name].freeze
     translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)

data/app/models/spree/variant.rb

@@ -8,6 +8,8 @@ module Spree
     include Spree::Metadata
     include Spree::Variant::Webhooks
 
+    publishes_lifecycle_events
+
     MEMOIZED_METHODS = %w(purchasable in_stock on_sale backorderable tax_category options_text compare_at_price)
 
     DIMENSION_UNITS = %w[mm cm in ft]
@@ -19,7 +21,7 @@ module Spree
     delegate :name, :name=, :description, :slug, :available_on, :make_active_at, :shipping_category_id,
              :meta_description, :meta_keywords, :shipping_category, to: :product
 
-    auto_strip_attributes :sku, nullify: false
+    normalizes :sku, with: ->(value) { value&.to_s&.strip }
 
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
@@ -80,6 +82,8 @@ module Spree
 
     after_commit :remove_prices_from_master_variant, on: [:create, :update], unless: :is_master?
     after_commit :remove_stock_items_from_master_variant, on: :create, unless: :is_master?
+    after_create :increment_product_variant_count, unless: :is_master?
+    after_destroy :decrement_product_variant_count, unless: :is_master?
 
     after_touch :clear_in_stock_cache
 
@@ -208,6 +212,8 @@ module Spree
       product_name_or_sku_cont(query)
     end
 
+    # Returns the human name of the variant.
+    # @return [String] the human name of the variant
     def human_name
       @human_name ||= option_values.
                       joins(option_type: :product_option_types).
@@ -216,10 +222,14 @@ module Spree
                       pluck(:presentation).join('/')
     end
 
+    # Returns true if the variant is available.
+    # @return [Boolean] true if the variant is available
     def available?
       !discontinued? && product.available?
     end
 
+    # Returns true if the variant is in stock or backorderable.
+    # @return [Boolean] true if the variant is in stock or backorderable
     def in_stock_or_backorderable?
       self.class.in_stock_or_backorderable.exists?(id: id)
     end
@@ -244,6 +254,8 @@ module Spree
                            end
     end
 
+    # Returns the options text of the variant.
+    # @return [String] the options text of the variant
     def options_text
       @options_text ||= if option_values.loaded?
                           option_values.sort_by { |ov| ov.option_type.position }.map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence(words_connector: ', ', two_words_connector: ', ')
@@ -252,11 +264,14 @@ module Spree
                         end
     end
 
-    # Default to master name
+    # Returns the exchange name of the variant.
+    # @return [String] the exchange name of the variant
     def exchange_name
       is_master? ? name : options_text
     end
 
+    # Returns the descriptive name of the variant.
+    # @return [String] the descriptive name of the variant
     def descriptive_name
       is_master? ? name + ' - Master' : name + ' - ' + options_text
     end
@@ -264,34 +279,42 @@ module Spree
     # use deleted? rather than checking the attribute directly. this
     # allows extensions to override deleted? if they want to provide
     # their own definition.
+    # @return [Boolean] true if the variant is deleted.
     def deleted?
       !!deleted_at
     end
 
-    # Returns default Image for Variant
-    # @return [Spree::Image]
+    # Returns true if the variant has images.
+    # Uses loaded association when available, otherwise falls back to counter cache.
+    # @return [Boolean]
+    def has_images?
+      return images.any? if images.loaded?
+
+      image_count.positive?
+    end
+
+    # Returns default Image for Variant, falling back to product's default image.
+    # @return [Spree::Image, nil]
     def default_image
-      @default_image ||= if images.any?
-                           images.first
-                         else
-                           product.default_image
-                         end
+      @default_image ||= has_images? ? images.first : product.default_image
+    end
+
+    # Returns first Image for Variant.
+    # @return [Spree::Image, nil]
+    def primary_image
+      images.first
     end
 
-    # Returns secondary Image for Variant
-    # @return [Spree::Image]
+    # Returns second Image for Variant (for hover effects).
+    # @return [Spree::Image, nil]
     def secondary_image
-      @secondary_image ||= if images.size > 1
-                             images.second
-                           else
-                             product.secondary_image
-                           end
+      images.second
     end
 
-    # Returns additional Images for Variant
+    # Returns all images except the default image, combining variant and product images.
     # @return [Array<Spree::Image>]
     def additional_images
-      @additional_images ||= (images + product.images).uniq.find_all { |image| image.id != default_image&.id }
+      @additional_images ||= (images + product.images).uniq.reject { |image| image.id == default_image&.id }
     end
 
     # Returns an array of hashes with the option type name, value and presentation
@@ -310,6 +333,9 @@ module Spree
                    end
     end
 
+    # Sets the option values for the variant
+    # @param options [Array<Hash>] the options to set
+    # @return [void]
     def options=(options = {})
       options.each do |option|
         next if option[:name].blank? || option[:value].blank?
@@ -318,6 +344,11 @@ module Spree
       end
     end
 
+    # Sets the option value for the given option name.
+    # @param opt_name [String] the option name to set the option value for
+    # @param opt_value [String] the option value to set
+    # @param opt_type_position [Integer] the position of the option type
+    # @return [void]
     def set_option_value(opt_name, opt_value, opt_type_position = nil)
       # no option values on master
       return if is_master
@@ -354,10 +385,16 @@ module Spree
       save
     end
 
+    # Returns the option value for the given option name.
+    # @param opt_name [String] the option name to get the option value for
+    # @return [Spree::OptionValue] the option value for the given option name
     def find_option_value(opt_name)
       option_values.includes(:option_type).detect { |o| o.option_type.name.parameterize == opt_name.parameterize }
     end
 
+    # Returns the presentation of the option value for the given option type.
+    # @param option_type [Spree::OptionType] the option type to get the option value for
+    # @return [String] the presentation of the option value for the given option type
     def option_value(option_type)
       if option_type.is_a?(Spree::OptionType)
         option_values.detect { |o| o.option_type_id == option_type.id }.try(:presentation)
@@ -366,13 +403,17 @@ module Spree
       end
     end
 
+    # Returns the base price (global price, not from a price list) for the given currency.
+    # Use price_for(context) when you need to resolve prices including price lists.
+    # @param currency [String] the currency to get the price for
+    # @return [Spree::Price] the base price for the given currency
     def price_in(currency)
       currency = currency&.upcase
 
       price = if prices.loaded? && prices.any?
-                prices.detect { |p| p.currency == currency }
+                prices.detect { |p| p.currency == currency && p.price_list_id.nil? }
               else
-                prices.find_by(currency: currency)
+                prices.base_prices.find_by(currency: currency)
               end
 
       if price.nil?
@@ -390,21 +431,52 @@ module Spree
       )
     end
 
+    # Returns the amount for the given currency.
+    # @param currency [String] the currency to get the amount for
+    # @return [BigDecimal] the amount for the given currency
     def amount_in(currency)
       price_in(currency).try(:amount)
     end
 
+    # Returns the compare at amount for the given currency.
+    # @param currency [String] the currency to get the compare at amount for
+    # @return [BigDecimal] the compare at amount for the given currency
     def compare_at_amount_in(currency)
       price_in(currency).try(:compare_at_amount)
     end
 
+    # Sets the base price (global price, not for a price list) for the given currency.
+    # @param currency [String] the currency to set the price for
+    # @param amount [BigDecimal] the amount to set
+    # @param compare_at_amount [BigDecimal] the compare at amount to set
+    # @return [void]
     def set_price(currency, amount, compare_at_amount = nil)
-      price = prices.find_or_initialize_by(currency: currency)
+      price = prices.base_prices.find_or_initialize_by(currency: currency)
       price.amount = amount
       price.compare_at_amount = compare_at_amount if compare_at_amount.present?
       price.save!
     end
 
+    # Returns the price for the given context or options.
+    # @param context_or_options [Spree::Pricing::Context|Hash] the context or options to get the price for
+    # @return [Spree::Price] the price for the given context or options
+    def price_for(context_or_options)
+      context = if context_or_options.is_a?(Spree::Pricing::Context)
+                  context_or_options
+                elsif context_or_options.is_a?(Hash)
+                  Spree::Pricing::Context.new(**context_or_options.merge(variant: self))
+                else
+                  raise ArgumentError, 'Must provide a Pricing::Context or options hash'
+                end
+
+      Spree::Pricing::Resolver.new(context).resolve
+    end
+
+    # Sets the stock for the variant
+    # @param count_on_hand [Integer] the count on hand
+    # @param backorderable [Boolean] the backorderable flag
+    # @param stock_location [Spree::StockLocation] the stock location to set the stock for
+    # @return [void]
     def set_stock(count_on_hand, backorderable = nil, stock_location = nil)
       stock_location ||= Spree::Store.current.default_stock_location
       stock_item = stock_items.find_or_initialize_by(stock_location: stock_location)
@@ -426,6 +498,9 @@ module Spree
       end.sum
     end
 
+    # Returns the price modifier amount of the variant.
+    # @param options [Hash] the options to get the price modifier amount for
+    # @return [BigDecimal] the price modifier amount of the variant
     def price_modifier_amount(options = {})
       return 0 unless options.present?
 
@@ -439,18 +514,26 @@ module Spree
       end.sum
     end
 
+    # Returns the compare at price of the variant.
+    # @return [BigDecimal] the compare at price of the variant
     def compare_at_price
       @compare_at_price ||= price_in(cost_currency).try(:compare_at_amount)
     end
 
+    # Returns the name and sku of the variant.
+    # @return [String] the name and sku of the variant
     def name_and_sku
       "#{name} - #{sku}"
     end
 
+    # Returns the sku and options text of the variant.
+    # @return [String] the sku and options text of the variant
     def sku_and_options_text
       "#{sku} #{options_text}".strip
     end
 
+    # Returns true if the variant is in stock.
+    # @return [Boolean] true if the variant is in stock
     def in_stock?
       @in_stock ||= if association(:stock_items).loaded? && association(:stock_locations).loaded?
                       total_on_hand.positive?
@@ -461,6 +544,8 @@ module Spree
                     end
     end
 
+    # Returns true if the variant is backorderable.
+    # @return [Boolean] true if the variant is backorderable
     def backorderable?
       @backorderable ||= Rails.cache.fetch(['variant-backorderable', cache_key_with_version]) do
         quantifier.backorderable?
@@ -609,5 +694,13 @@ module Spree
     def remove_stock_items_from_master_variant
       product.master.stock_items.delete_all
     end
+
+    def increment_product_variant_count
+      Spree::Product.increment_counter(:variant_count, product_id)
+    end
+
+    def decrement_product_variant_count
+      Spree::Product.decrement_counter(:variant_count, product_id)
+    end
   end
 end

data/app/models/spree/webhook_delivery.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Spree
+  class WebhookDelivery < Spree.base_class
+    belongs_to :webhook_endpoint, class_name: 'Spree::WebhookEndpoint'
+    delegate :url, to: :webhook_endpoint
+
+    validates :event_name, presence: true
+    validates :payload, presence: true
+
+    ERROR_TYPES = %w[timeout connection_error].freeze
+
+    scope :successful, -> { where(success: true) }
+    scope :failed, -> { where(success: false) }
+    scope :pending, -> { where(delivered_at: nil) }
+    scope :recent, -> { order(created_at: :desc) }
+    scope :for_event, ->(event_name) { where(event_name: event_name) }
+
+    # Ransack configuration
+    self.whitelisted_ransackable_attributes = %w[event_name response_code execution_time success delivered_at]
+
+    # Check if the delivery was successful
+    #
+    # @return [Boolean]
+    def successful?
+      success == true
+    end
+
+    # Check if the delivery failed
+    #
+    # @return [Boolean]
+    def failed?
+      success == false
+    end
+
+    # Check if the delivery is pending
+    #
+    # @return [Boolean]
+    def pending?
+      delivered_at.nil?
+    end
+
+    # Mark delivery as completed with HTTP response
+    #
+    # @param response_code [Integer] HTTP response code
+    # @param execution_time [Integer] time in milliseconds
+    # @param response_body [String] response body from the webhook endpoint
+    def complete!(response_code: nil, execution_time:, error_type: nil, request_errors: nil, response_body: nil)
+      update!(
+        response_code: response_code,
+        execution_time: execution_time,
+        error_type: error_type,
+        request_errors: request_errors,
+        response_body: response_body,
+        success: response_code.present? && response_code.to_s.start_with?('2'),
+        delivered_at: Time.current
+      )
+    end
+  end
+end