solidus_core 2.9.5 → 2.10.2

data/app/models/spree/return_item.rb

@@ -29,15 +29,15 @@ module Spree
     class_attribute :refund_amount_calculator
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
-    belongs_to :return_authorization, inverse_of: :return_items
-    belongs_to :inventory_unit, inverse_of: :return_items
-    belongs_to :exchange_variant, class_name: 'Spree::Variant'
-    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
-    belongs_to :customer_return, inverse_of: :return_items
-    belongs_to :reimbursement, inverse_of: :return_items
-    belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
-    belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
-    belongs_to :return_reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id
+    belongs_to :return_authorization, inverse_of: :return_items, optional: true
+    belongs_to :inventory_unit, inverse_of: :return_items, optional: true
+    belongs_to :exchange_variant, class_name: 'Spree::Variant', optional: true
+    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item, optional: true
+    belongs_to :customer_return, inverse_of: :return_items, optional: true
+    belongs_to :reimbursement, inverse_of: :return_items, optional: true
+    belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType', optional: true
+    belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType', optional: true
+    belongs_to :return_reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id, optional: true
 
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
@@ -77,22 +77,8 @@ module Spree
     before_create :set_default_amount, unless: :amount_changed?
     before_save :set_exchange_amount
 
-    state_machine :reception_status, initial: :awaiting do
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :attempt_accept
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :check_unexchange
-      after_transition to: :received, do: :process_inventory_unit!
-
-      event(:cancel) { transition to: :cancelled, from: :awaiting }
-
-      event(:receive) { transition to: :received, from: INTERMEDIATE_RECEPTION_STATUSES + [:awaiting] }
-      event(:unexchange) { transition to: :unexchanged, from: [:awaiting] }
-      event(:give) { transition to: :given_to_customer, from: :awaiting }
-      event(:lost) { transition to: :lost_in_transit, from: :awaiting }
-      event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
-      event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
-      event(:in_transit) { transition to: :in_transit, from: :awaiting }
-      event(:expired) { transition to: :expired, from: :awaiting }
-    end
+    include ::Spree::Config.state_machines.return_item_reception
+    include ::Spree::Config.state_machines.return_item_acceptance
 
     extend DisplayMoney
     money_methods :pre_tax_amount, :amount, :total, :total_excluding_vat
@@ -104,31 +90,6 @@ module Spree
       COMPLETED_RECEPTION_STATUSES.map(&:to_s).include?(reception_status.to_s)
     end
 
-    state_machine :acceptance_status, initial: :pending do
-      event :attempt_accept do
-        transition to: :accepted, from: :accepted
-        transition to: :accepted, from: :pending, if: ->(return_item) { return_item.eligible_for_return? }
-        transition to: :manual_intervention_required, from: :pending, if: ->(return_item) { return_item.requires_manual_intervention? }
-        transition to: :rejected, from: :pending
-      end
-
-      # bypasses eligibility checks
-      event :accept do
-        transition to: :accepted, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :reject do
-        transition to: :rejected, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :require_manual_intervention do
-        transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      after_transition any => any, do: :persist_acceptance_status_errors
-    end
 
     attr_accessor :skip_customer_return_processing
 
@@ -214,7 +175,7 @@ module Spree
       event_paths.delete(:expired)
       event_paths.delete(:unexchange)
 
-      status_paths.map{ |s| I18n.t("spree.reception_states.#{s}", default: s.to_s.humanize) }.zip(event_paths)
+      status_paths.map{ |status| I18n.t("spree.reception_states.#{status}", default: status.to_s.humanize) }.zip(event_paths)
     end
 
     def part_of_exchange?
@@ -226,7 +187,7 @@ module Spree
     private
 
     def persist_acceptance_status_errors
-      update_attributes(acceptance_status_errors: validator.errors)
+      update(acceptance_status_errors: validator.errors)
     end
 
     def currency

data/app/models/spree/return_item/eligibility_validator/default.rb

@@ -28,7 +28,7 @@ module Spree
         private
 
         def validators
-          @validators ||= permitted_eligibility_validators.map{ |v| v.new(@return_item) }
+          @validators ||= permitted_eligibility_validators.map{ |validator| validator.new(@return_item) }
         end
       end
     end

data/app/models/spree/role_user.rb

@@ -3,8 +3,8 @@
 module Spree
   class RoleUser < Spree::Base
     self.table_name = "spree_roles_users"
-    belongs_to :role, class_name: "Spree::Role"
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :role, class_name: "Spree::Role", optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
 
     after_create :auto_generate_spree_api_key
 

data/app/models/spree/shipment.rb

@@ -4,8 +4,8 @@ module Spree
   # An order's planned shipments including tracking and cost.
   #
   class Shipment < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
-    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments, optional: true
+    belongs_to :stock_location, class_name: 'Spree::StockLocation', optional: true
 
     has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :delete_all
     has_many :inventory_units, dependent: :destroy, inverse_of: :shipment
@@ -31,7 +31,7 @@ module Spree
     scope :ready,   -> { with_state('ready') }
     scope :shipped, -> { with_state('shipped') }
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
-    scope :with_state, ->(*s) { where(state: s) }
+    scope :with_state, ->(*state) { where(state: state) }
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
     scope :reverse_chronological, -> {
       order(Arel.sql("coalesce(#{Spree::Shipment.table_name}.shipped_at, #{Spree::Shipment.table_name}.created_at) desc"), id: :desc)
@@ -39,41 +39,7 @@ module Spree
 
     scope :by_store, ->(store) { joins(:order).merge(Spree::Order.by_store(store)) }
 
-    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine initial: :pending, use_transactions: false do
-      event :ready do
-        transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
-        transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
-      end
-
-      event :pend do
-        transition from: :ready, to: :pending
-      end
-
-      event :ship do
-        transition from: [:ready, :canceled], to: :shipped
-      end
-      after_transition to: :shipped, do: :after_ship
-
-      event :cancel do
-        transition to: :canceled, from: [:pending, :ready]
-      end
-      after_transition to: :canceled, do: :after_cancel
-
-      event :resume do
-        transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
-        transition from: :canceled, to: :pending
-      end
-      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
-
-      after_transition do |shipment, transition|
-        shipment.state_changes.create!(
-          previous_state: transition.from,
-          next_state:     transition.to,
-          name:           'shipment'
-        )
-      end
-    end
+    include ::Spree::Config.state_machines.shipment
 
     self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
@@ -142,7 +108,7 @@ module Spree
     # @return [BigDecimal] the amount of this item, taking into consideration
     #   all non-tax adjustments.
     def total_before_tax
-      amount + adjustments.select { |a| !a.tax? && a.eligible? }.sum(&:amount)
+      amount + adjustments.select { |adjustment| !adjustment.tax? && adjustment.eligible? }.sum(&:amount)
     end
 
     # @return [BigDecimal] the amount of this shipment before VAT tax
@@ -219,7 +185,7 @@ module Spree
     def select_shipping_method(shipping_method)
       estimator = Spree::Config.stock.estimator_class.new
       rates = estimator.shipping_rates(to_package, false)
-      rate = rates.detect { |r| r.shipping_method_id == shipping_method.id }
+      rate = rates.detect { |detected| detected.shipping_method_id == shipping_method.id }
       rate.selected = true
       self.shipping_rates = [rate]
     end
@@ -326,7 +292,7 @@ module Spree
 
     # Update Shipment and make sure Order states follow the shipment changes
     def update_attributes_and_order(params = {})
-      if update_attributes params
+      if update(params)
         if params.key? :selected_shipping_rate_id
           # Changing the selected Shipping Rate won't update the cost (for now)
           # so we persist the Shipment#cost before running `order.recalculate`

data/app/models/spree/shipping_calculator.rb

@@ -2,10 +2,6 @@
 
 module Spree
   class ShippingCalculator < Calculator
-    def compute_shipment(_shipment)
-      raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
-    end
-
     def compute_package(_package)
       raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
     end

data/app/models/spree/shipping_manifest.rb

@@ -21,9 +21,9 @@ class Spree::ShippingManifest
         states = {}
         units.group_by(&:state).each { |state, iu| states[state] = iu.count }
 
-        line_item = units.first.line_item
-        variant = units.first.variant
-        ManifestItem.new(line_item, variant, units.length, states)
+        first_unit = units.first
+
+        ManifestItem.new(first_unit.line_item, first_unit.variant, units.length, states)
       end
     end.flatten
   end

data/app/models/spree/shipping_method.rb

@@ -28,7 +28,7 @@ module Spree
     has_many :shipping_method_zones, dependent: :destroy
     has_many :zones, through: :shipping_method_zones
 
-    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory'
+    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory', optional: true
     has_many :shipping_method_stock_locations, dependent: :destroy, class_name: "Spree::ShippingMethodStockLocation"
     has_many :stock_locations, through: :shipping_method_stock_locations
 
@@ -41,7 +41,7 @@ module Spree
 
     scope :available_to_store, ->(store) do
       raise ArgumentError, "You must provide a store" if store.nil?
-      store.shipping_methods.empty? ? all : where(id: store.shipping_method_ids)
+      store.shipping_methods.empty? ? all : where(id: store.shipping_methods.ids)
     end
 
     # @param shipping_category_ids [Array<Integer>] ids of desired shipping categories

data/app/models/spree/shipping_method_category.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ShippingMethodCategory < Spree::Base
-    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', optional: true
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories, optional: true
   end
 end

data/app/models/spree/shipping_method_stock_location.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 class Spree::ShippingMethodStockLocation < Spree::Base
-  belongs_to :shipping_method
-  belongs_to :stock_location
+  belongs_to :shipping_method, optional: true
+  belongs_to :stock_location, optional: true
 end

data/app/models/spree/shipping_method_zone.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ShippingMethodZone < Spree::Base
-    belongs_to :zone
-    belongs_to :shipping_method
+    belongs_to :zone, optional: true
+    belongs_to :shipping_method, optional: true
   end
 end

data/app/models/spree/shipping_rate.rb

@@ -5,8 +5,8 @@ module Spree
   # method has been selected to deliver the shipment.
   #
   class ShippingRate < Spree::Base
-    belongs_to :shipment, class_name: 'Spree::Shipment', touch: true
-    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+    belongs_to :shipment, class_name: 'Spree::Shipment', touch: true, optional: true
+    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates, optional: true
 
     has_many :taxes,
              class_name: "Spree::ShippingRateTax",

data/app/models/spree/shipping_rate_tax.rb

@@ -7,8 +7,8 @@ module Spree
   # @since 1.3.0
   # @see Spree::Tax::ShippingRateTaxer
   class ShippingRateTax < ActiveRecord::Base
-    belongs_to :shipping_rate, class_name: "Spree::ShippingRate"
-    belongs_to :tax_rate, class_name: "Spree::TaxRate"
+    belongs_to :shipping_rate, class_name: "Spree::ShippingRate", optional: true
+    belongs_to :tax_rate, class_name: "Spree::TaxRate", optional: true
 
     extend DisplayMoney
     money_methods :absolute_amount

data/app/models/spree/state.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class State < Spree::Base
-    belongs_to :country, class_name: 'Spree::Country'
+    belongs_to :country, class_name: 'Spree::Country', optional: true
     has_many :addresses, dependent: :nullify
 
     validates :country, :name, presence: true
@@ -24,7 +24,7 @@ module Spree
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
-      state_info = Hash.new { |h, k| h[k] = [] }
+      state_info = Hash.new { |hash, key| hash[key] = [] }
       order(:name).each { |state|
         state_info[state.country_id.to_s].push [state.id, state.name]
       }

data/app/models/spree/state_change.rb

@@ -2,8 +2,8 @@
 
 module Spree
   class StateChange < Spree::Base
-    belongs_to :user
-    belongs_to :stateful, polymorphic: true
+    belongs_to :user, optional: true
+    belongs_to :stateful, polymorphic: true, optional: true
     before_create :assign_user
 
     def <=>(other)

data/app/models/spree/stock/differentiator.rb

@@ -14,7 +14,7 @@ module Spree
       end
 
       def missing?
-        missing.values.any? { |v| v > 0 }
+        missing.values.any? { |value| value > 0 }
       end
 
       private

data/app/models/spree/stock/package.rb

@@ -85,7 +85,7 @@ module Spree
       # @return [Fixnum] the number of inventory units in the package,
       #   counting only those in the given state if it was specified
       def quantity(state = nil)
-        matched_contents = state.nil? ? contents : contents.select { |c| c.state.to_s == state.to_s }
+        matched_contents = state.nil? ? contents : contents.select { |content| content.state.to_s == state.to_s }
         matched_contents.map(&:quantity).sum
       end
 

data/app/models/spree/stock_item.rb

@@ -10,8 +10,8 @@ module Spree
     include Discard::Model
     self.discard_column = :deleted_at
 
-    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
-    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :stock_items
+    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items, optional: true
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :stock_items, optional: true
     has_many :stock_movements, inverse_of: :stock_item
 
     validates :stock_location, :variant, presence: true
@@ -111,7 +111,7 @@ module Spree
     def should_touch_variant?
       # the variant_id changes from nil when a new stock location is added
       inventory_cache_threshold &&
-        (saved_change_to_count_on_hand && saved_change_to_count_on_hand.any? { |c| c < inventory_cache_threshold }) ||
+        (saved_change_to_count_on_hand&.any? { |cache| cache < inventory_cache_threshold }) ||
         saved_change_to_variant_id?
     end
 

data/app/models/spree/stock_location.rb

@@ -16,8 +16,8 @@ module Spree
     has_many :user_stock_locations, dependent: :delete_all
     has_many :users, through: :user_stock_locations
 
-    belongs_to :state, class_name: 'Spree::State'
-    belongs_to :country, class_name: 'Spree::Country'
+    belongs_to :state, class_name: 'Spree::State', optional: true
+    belongs_to :country, class_name: 'Spree::Country', optional: true
 
     has_many :shipping_method_stock_locations, dependent: :destroy
     has_many :shipping_methods, through: :shipping_method_stock_locations

data/app/models/spree/stock_movement.rb

@@ -2,8 +2,8 @@
 
 module Spree
   class StockMovement < Spree::Base
-    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
-    belongs_to :originator, polymorphic: true
+    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements, optional: true
+    belongs_to :originator, polymorphic: true, optional: true
 
     after_create :update_stock_item_quantity
 

data/app/models/spree/stock_quantities.rb

@@ -8,8 +8,8 @@ module Spree
 
     # @param quantities [Hash<Spree::Variant=>Numeric>]
     def initialize(quantities = {})
-      raise ArgumentError unless quantities.keys.all?{ |v| v.is_a?(Spree::Variant) }
-      raise ArgumentError unless quantities.values.all?{ |v| v.is_a?(Numeric) }
+      raise ArgumentError unless quantities.keys.all?{ |value| value.is_a?(Spree::Variant) }
+      raise ArgumentError unless quantities.values.all?{ |value| value.is_a?(Numeric) }
 
       @quantities = quantities
     end
@@ -33,16 +33,16 @@ module Spree
     # Adds two StockQuantities together
     # @return [Spree::StockQuantities]
     def +(other)
-      combine_with(other) do |_variant, a, b|
-        (a || 0) + (b || 0)
+      combine_with(other) do |_variant, first, second|
+        (first || 0) + (second || 0)
       end
     end
 
     # Subtracts another StockQuantities from this one
     # @return [Spree::StockQuantities]
     def -(other)
-      combine_with(other) do |_variant, a, b|
-        (a || 0) - (b || 0)
+      combine_with(other) do |_variant, first, second|
+        (first || 0) - (second || 0)
       end
     end
 
@@ -50,9 +50,10 @@ module Spree
     # stock which exists in both StockQuantities.
     # @return [Spree::StockQuantities]
     def &(other)
-      combine_with(other) do |_variant, a, b|
-        next unless a && b
-        [a, b].min
+      combine_with(other) do |_variant, first, second|
+        next unless first && second
+
+        [first, second].min
       end
     end
 
@@ -72,9 +73,9 @@ module Spree
     def combine_with(other)
       self.class.new(
         (variants | other.variants).map do |variant|
-          a = self[variant]
-          b = other[variant]
-          value = yield variant, a, b
+          self_v = self[variant]
+          other_v = other[variant]
+          value = yield variant, self_v, other_v
           [variant, value]
         end.to_h.compact
       )