solidus_core 2.9.5 → 2.10.2

data/app/models/spree/product_option_type.rb

@@ -2,8 +2,8 @@
 
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true, optional: true
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types, optional: true
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_promotion_rule.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ProductPromotionRule < Spree::Base
-    belongs_to :product
-    belongs_to :promotion_rule
+    belongs_to :product, optional: true
+    belongs_to :promotion_rule, optional: true
   end
 end

data/app/models/spree/product_property.rb

@@ -6,8 +6,8 @@ module Spree
 
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties, optional: true
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties, optional: true
 
     self.whitelisted_ransackable_attributes = ['value']
   end

data/app/models/spree/promotion.rb

@@ -7,7 +7,7 @@ module Spree
 
     attr_reader :eligibility_errors
 
-    belongs_to :promotion_category
+    belongs_to :promotion_category, optional: true
 
     has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :rules, :promotion_rules
@@ -126,9 +126,12 @@ module Spree
     # called anytime order.recalculate happens
     def eligible?(promotable, promotion_code: nil)
       return false if inactive?
-      return false if usage_limit_exceeded?
-      return false if promotion_code && promotion_code.usage_limit_exceeded?
       return false if blacklisted?(promotable)
+
+      excluded_orders = eligibility_excluded_orders(promotable)
+      return false if usage_limit_exceeded?(excluded_orders: excluded_orders)
+      return false if promotion_code&.usage_limit_exceeded?(excluded_orders: excluded_orders)
+
       !!eligible_rules(promotable, {})
     end
 
@@ -138,7 +141,8 @@ module Spree
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
       return [] if rules.none?
-      eligible = lambda { |r| r.eligible?(promotable, options) }
+
+      eligible = lambda { |rule| rule.eligible?(promotable, options) }
       specific_rules = rules.for(promotable)
       return [] if specific_rules.none?
 
@@ -165,23 +169,23 @@ module Spree
 
     # Whether the promotion has exceeded it's usage restrictions.
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
     # @return true or false
-    def usage_limit_exceeded?
+    def usage_limit_exceeded?(excluded_orders: [])
       if usage_limit
-        usage_count >= usage_limit
+        usage_count(excluded_orders: excluded_orders) >= usage_limit
       end
     end
 
     # Number of times the code has been used overall
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
-    def usage_count
-      Spree::Adjustment.eligible.
-        promotion.
-        where(source_id: actions.map(&:id)).
-        joins(:order).
-        merge(Spree::Order.complete).
-        distinct.
+    def usage_count(excluded_orders: [])
+      Spree::Adjustment.promotion.
+        eligible.
+        in_completed_orders(excluded_orders: excluded_orders).
+        where(source_id: actions).
         count(:order_id)
     end
 
@@ -255,8 +259,19 @@ module Spree
 
     def apply_automatically_disallowed_with_codes_or_paths
       return unless apply_automatically
+
       errors.add(:apply_automatically, :disallowed_with_code) if codes.any?
       errors.add(:apply_automatically, :disallowed_with_path) if path.present?
     end
+
+    def eligibility_excluded_orders(promotable)
+      if promotable.is_a?(Spree::Order)
+        [promotable]
+      elsif promotable.respond_to?(:order)
+        [promotable.order]
+      else
+        []
+      end
+    end
   end
 end

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

@@ -67,7 +67,7 @@ module Spree
           line_items = actionable_line_items(order)
 
           actioned_line_items = order.line_item_adjustments.reload.
-            select { |a| a.source == self && a.amount < 0 }.
+            select { |adjustment| adjustment.source == self && adjustment.amount < 0 }.
             map(&:adjustable)
           other_line_items = actioned_line_items - [line_item]
 

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

@@ -21,7 +21,7 @@ module Spree
           end
           # Did we actually end up applying any adjustments?
           # If so, then this action should be classed as 'successful'
-          results.any? { |r| r == true }
+          results.any? { |result| result == true }
         end
 
         def label

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

@@ -29,8 +29,8 @@ module Spree
         def preferred_eligible_values
           values = preferences[:eligible_values] || {}
           Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            values.values.map do |value|
+              (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
             end
           )]
         end

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

@@ -32,15 +32,15 @@ module Spree
 
           case preferred_match_policy
           when 'all'
-            unless eligible_products.all? { |p| order.products.include?(p) }
+            unless eligible_products.all? { |product| order.products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
           when 'any'
-            unless order.products.any? { |p| eligible_products.include?(p) }
+            unless order.products.any? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
             end
           when 'none'
-            unless order.products.none? { |p| eligible_products.include?(p) }
+            unless order.products.none? { |product| eligible_products.include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
             end
           else

data/app/models/spree/promotion_action.rb

@@ -14,9 +14,9 @@ module Spree
     include Discard::Model
     self.discard_column = :deleted_at
 
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
-    scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
     # Updates the state of the order or performs some other action depending on

data/app/models/spree/promotion_chooser.rb

@@ -26,8 +26,8 @@ module Spree
 
     # @return The best promotion from this set of adjustments.
     def best_promotion_adjustment
-      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
-        [a.amount, -a.id]
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |adjustment|
+        [adjustment.amount, -adjustment.id]
       end
     end
   end

data/app/models/spree/promotion_code.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Spree::PromotionCode < Spree::Base
-  belongs_to :promotion, inverse_of: :codes
-  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
+  belongs_to :promotion, inverse_of: :codes, optional: true
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch", optional: true
   has_many :adjustments
 
   validates :value, presence: true, uniqueness: { allow_blank: true }
@@ -14,22 +14,23 @@ class Spree::PromotionCode < Spree::Base
 
   # Whether the promotion code has exceeded its usage restrictions
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
   # @return true or false
-  def usage_limit_exceeded?
+  def usage_limit_exceeded?(excluded_orders: [])
     if usage_limit
-      usage_count >= usage_limit
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
     end
   end
 
   # Number of times the code has been used overall
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
-  def usage_count
-    adjustments.eligible.
-      joins(:order).
-      merge(Spree::Order.complete).
-      distinct.
-      count(:order_id)
+  def usage_count(excluded_orders: [])
+    adjustments.
+    eligible.
+    in_completed_orders(excluded_orders: excluded_orders).
+    count(:order_id)
   end
 
   def usage_limit

data/app/models/spree/promotion_code/batch_builder.rb

@@ -33,12 +33,12 @@ class ::Spree::PromotionCode::BatchBuilder
   def build_promotion_codes
     generate_random_codes
     promotion_code_batch.update!(state: "completed")
-  rescue StandardError => e
+  rescue StandardError => error
     promotion_code_batch.update!(
-      error: e.inspect,
+      error: error.inspect,
       state: "failed"
     )
-    raise e
+    raise error
   end
 
   private

data/app/models/spree/promotion_code_batch.rb

@@ -5,7 +5,7 @@ module Spree
     class CantProcessStartedBatch < StandardError
     end
 
-    belongs_to :promotion, class_name: "Spree::Promotion"
+    belongs_to :promotion, class_name: "Spree::Promotion", optional: true
     has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
 
     validates :number_of_codes, numericality: { greater_than: 0 }

data/app/models/spree/promotion_rule.rb

@@ -3,9 +3,9 @@
 module Spree
   # Base class for all promotion rules
   class PromotionRule < Spree::Base
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
-    scope :of_type, ->(t) { where(type: t) }
+    scope :of_type, ->(type) { where(type: type) }
 
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create

data/app/models/spree/promotion_rule_role.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleRole < ActiveRecord::Base
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :role, class_name: 'Spree::Role'
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :role, class_name: 'Spree::Role', optional: true
   end
 end

data/app/models/spree/promotion_rule_store.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleStore < Spree::Base
     self.table_name = "spree_promotion_rules_stores"
 
-    belongs_to :promotion_rule, class_name: "Spree::PromotionRule"
-    belongs_to :store, class_name: "Spree::Store"
+    belongs_to :promotion_rule, class_name: "Spree::PromotionRule", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
   end
 end

data/app/models/spree/promotion_rule_taxon.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleTaxon < Spree::Base
-    belongs_to :promotion_rule
-    belongs_to :taxon
+    belongs_to :promotion_rule, optional: true
+    belongs_to :taxon, optional: true
   end
 end

data/app/models/spree/promotion_rule_user.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleUser < Spree::Base
     self.table_name = 'spree_promotion_rules_users'
 
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
   end
 end

data/app/models/spree/refund.rb

@@ -2,9 +2,9 @@
 
 module Spree
   class Refund < Spree::Base
-    belongs_to :payment, inverse_of: :refunds
-    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
-    belongs_to :reimbursement, inverse_of: :refunds
+    belongs_to :payment, inverse_of: :refunds, optional: true
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id, optional: true
+    belongs_to :reimbursement, inverse_of: :refunds, optional: true
 
     has_many :log_entries, as: :source
 
@@ -68,8 +68,8 @@ module Spree
       end
 
       response
-    rescue ActiveMerchant::ConnectionError => e
-      logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+    rescue ActiveMerchant::ConnectionError => error
+      logger.error(I18n.t('spree.gateway_error') + "  #{error.inspect}")
       raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
     end
 

data/app/models/spree/reimbursement.rb

@@ -4,8 +4,8 @@ module Spree
   class Reimbursement < Spree::Base
     class IncompleteReimbursementError < StandardError; end
 
-    belongs_to :order, inverse_of: :reimbursements
-    belongs_to :customer_return, inverse_of: :reimbursements, touch: true
+    belongs_to :order, inverse_of: :reimbursements, optional: true
+    belongs_to :customer_return, inverse_of: :reimbursements, touch: true, optional: true
 
     has_many :refunds, inverse_of: :reimbursement
     has_many :credits, inverse_of: :reimbursement, class_name: 'Spree::Reimbursement::Credit'
@@ -59,15 +59,7 @@ module Spree
     class_attribute :reimbursement_failure_hooks
     self.reimbursement_failure_hooks = []
 
-    state_machine :reimbursement_status, initial: :pending do
-      event :errored do
-        transition to: :errored, from: [:pending, :errored]
-      end
-
-      event :reimbursed do
-        transition to: :reimbursed, from: [:pending, :errored]
-      end
-    end
+    include ::Spree::Config.state_machines.reimbursement
 
     class << self
       def build_from_customer_return(customer_return)
@@ -112,11 +104,11 @@ module Spree
       if unpaid_amount_within_tolerance?
         reimbursed!
         Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
-        reimbursement_success_hooks.each { |h| h.call self }
+        reimbursement_success_hooks.each { |hook| hook.call self }
       else
         errored!
         Spree::Event.fire 'reimbursement_errored', reimbursement: self
-        reimbursement_failure_hooks.each { |h| h.call self }
+        reimbursement_failure_hooks.each { |hook| hook.call self }
       end
 
       if errored?

data/app/models/spree/reimbursement/credit.rb

@@ -6,8 +6,8 @@ module Spree
       class_attribute :default_creditable_class
       self.default_creditable_class = Spree::StoreCredit
 
-      belongs_to :reimbursement, inverse_of: :credits
-      belongs_to :creditable, polymorphic: true
+      belongs_to :reimbursement, inverse_of: :credits, optional: true
+      belongs_to :creditable, polymorphic: true, optional: true
 
       validates :creditable, presence: true
 

data/app/models/spree/reimbursement/reimbursement_type_engine.rb

@@ -18,7 +18,7 @@ module Spree
 
     def initialize(return_items)
       @return_items = return_items
-      @reimbursement_type_hash = Hash.new { |h, k| h[k] = [] }
+      @reimbursement_type_hash = Hash.new { |hash, key| hash[key] = [] }
     end
 
     def calculate_reimbursement_types

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -25,7 +25,7 @@ module Spree
         additional_tax_total = percent_of_tax * return_item.inventory_unit.additional_tax_total
         included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
 
-        return_item.update_attributes!({
+        return_item.update!({
           additional_tax_total: additional_tax_total,
           included_tax_total:   included_tax_total
         })

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -63,8 +63,8 @@ module Spree
 
     def sorted_eligible_refund_payments(payments)
       if eligible_refund_methods = self.eligible_refund_methods
-        payments = payments.select { |p| eligible_refund_methods.include? p.payment_method.class }
-        payments = payments.sort_by { |p| eligible_refund_methods.index(p.payment_method.class) }
+        payments = payments.select { |payment| eligible_refund_methods.include? payment.payment_method.class }
+        payments = payments.sort_by { |payment| eligible_refund_methods.index(payment.payment_method.class) }
       end
       payments
     end

data/app/models/spree/return_authorization.rb

@@ -4,14 +4,14 @@ module Spree
   # Models the return of Inventory Units to a Stock Location for an Order.
   #
   class ReturnAuthorization < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations, optional: true
 
     has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
     has_many :inventory_units, through: :return_items, dependent: :nullify
     has_many :customer_returns, through: :return_items
 
-    belongs_to :stock_location
-    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id
+    belongs_to :stock_location, optional: true
+    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id, optional: true
 
     before_create :generate_number
 
@@ -22,13 +22,7 @@ module Spree
     validate :must_have_shipped_units, on: :create
     validate :no_previously_exchanged_inventory_units, on: :create
 
-    state_machine initial: :authorized do
-      before_transition to: :canceled, do: :cancel_return_items
-
-      event :cancel do
-        transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
-      end
-    end
+    include ::Spree::Config.state_machines.return_authorization
 
     extend DisplayMoney
     money_methods :pre_tax_total, :amount, :total_excluding_vat