solidus_core 4.6.4 → 4.7.0

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

@@ -11,7 +11,7 @@ module Spree
         end
 
         def mark_default(user_address, address_type: :shipping)
-          column_for_default = address_type == :shipping ? :default : :default_billing
+          column_for_default = (address_type == :shipping) ? :default : :default_billing
           ActiveRecord::Base.transaction do
             (self - [user_address]).each do |address| # update_all would be nice, but it bypasses ActiveRecord callbacks
               if address.persisted?
@@ -33,9 +33,9 @@ module Spree
       has_many :addresses, through: :user_addresses
 
       has_one :default_user_bill_address,
-        ->{ default_billing },
-        class_name: 'Spree::UserAddress',
-        foreign_key: 'user_id',
+        -> { default_billing },
+        class_name: "Spree::UserAddress",
+        foreign_key: "user_id",
         inverse_of: false,
         dependent: false
       has_one :bill_address,
@@ -45,9 +45,9 @@ module Spree
         dependent: false
 
       has_one :default_user_ship_address,
-        ->{ default_shipping },
-        class_name: 'Spree::UserAddress',
-        foreign_key: 'user_id',
+        -> { default_shipping },
+        class_name: "Spree::UserAddress",
+        foreign_key: "user_id",
         inverse_of: false,
         dependent: false
       has_one :ship_address,
@@ -66,7 +66,7 @@ module Spree
     def ship_address=(address)
       if address
         save_in_address_book(address.attributes,
-                             Spree::Config.automatic_default_address)
+          Spree::Config.automatic_default_address)
       end
     end
 
@@ -77,8 +77,8 @@ module Spree
     def bill_address=(address)
       if address
         save_in_address_book(address.attributes,
-                             Spree::Config.automatic_default_address,
-                             :billing)
+          Spree::Config.automatic_default_address,
+          :billing)
       end
     end
 
@@ -185,8 +185,8 @@ module Spree
     end
 
     def remove_user_address_reference(address_id)
-      self.bill_address_id = bill_address_id == address_id.to_i ? nil : bill_address_id
-      self.ship_address_id = ship_address_id == address_id.to_i ? nil : ship_address_id
+      self.bill_address_id = (bill_address_id == address_id.to_i) ? nil : bill_address_id
+      self.ship_address_id = (ship_address_id == address_id.to_i) ? nil : ship_address_id
       save if changed?
     end
   end

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

@@ -59,15 +59,15 @@ module Spree
         inverse_of: :user
 
       has_many :wallet_payment_sources,
-        foreign_key: 'user_id',
-        class_name: 'Spree::WalletPaymentSource',
+        foreign_key: "user_id",
+        class_name: "Spree::WalletPaymentSource",
         inverse_of: :user,
         dependent: :destroy
 
       after_create :auto_generate_spree_api_key
       before_destroy :check_for_deletion
 
-      include Spree::RansackableAttributes unless included_modules.include?(Spree::RansackableAttributes)
+      include Spree::RansackableAttributes unless include?(Spree::RansackableAttributes)
 
       ransack_alias :name, :addresses_name
       self.allowed_ransackable_associations = %w[addresses spree_roles]
@@ -97,22 +97,22 @@ module Spree
       self_orders = orders
       self_orders = self_orders.where(frontend_viewable: true) if only_frontend_viewable
       self_orders = self_orders.where(store:) if store
-      self_orders = self_orders.where('updated_at > ?', Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
-      self_orders = self_orders.where('created_at > ?', Spree::Config.completable_order_created_cutoff_days.days.ago) if Spree::Config.completable_order_created_cutoff_days
+      self_orders = self_orders.where("updated_at > ?", Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
+      self_orders = self_orders.where("created_at > ?", Spree::Config.completable_order_created_cutoff_days.days.ago) if Spree::Config.completable_order_created_cutoff_days
       last_order = self_orders.order(:created_at).last
       last_order unless last_order.try!(:completed?)
     end
 
     def available_store_credit_total(currency:)
-      store_credits.to_a.
-        select { |credit| credit.currency == currency }.
-        sum(&:amount_remaining)
+      store_credits.to_a
+        .select { |credit| credit.currency == currency }
+        .sum(&:amount_remaining)
     end
 
     def display_available_store_credit_total(currency:)
       Spree::Money.new(
         available_store_credit_total(currency:),
-        currency:,
+        currency:
       )
     end
 
@@ -130,14 +130,14 @@ module Spree
 
     # Updates the roles in keeping with the given ability's permissions
     #
-    # Roles that the given ability cannot manage will be ignored. It also
-    # ensure not to remove non manageable roles when assigning new manageable
-    # ones.
+    # Roles that are not accessible to the given ability will be ignored. It
+    # also ensure not to remove non accessible roles when assigning new
+    # accessible ones.
     #
     # @param given_roles [Spree::Role]
     # @param ability [Spree::Ability]
     def update_spree_roles(given_roles, ability:)
-      accessible_roles = Spree::Role.accessible_by(ability, :manage)
+      accessible_roles = Spree::Role.accessible_by(ability)
       non_accessible_roles = Spree::Role.all - accessible_roles
       new_accessible_roles = given_roles - non_accessible_roles
       self.spree_roles = spree_roles - accessible_roles + new_accessible_roles

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

@@ -3,6 +3,7 @@
 module Spree
   module UserReporting
     extend DisplayMoney
+
     money_methods :lifetime_value, :average_order_value
 
     def lifetime_value

data/app/models/spree/ability.rb

@@ -4,7 +4,7 @@
 # using the special +register_ability+ method which allows extensions to add their own abilities.
 #
 # See http://github.com/ryanb/cancan for more details on cancan.
-require 'cancan'
+require "cancan"
 module Spree
   class Ability
     include CanCan::Ability

data/app/models/spree/address/name.rb

@@ -8,7 +8,7 @@ module Spree
       attr_reader :first_name, :last_name, :value
 
       def initialize(*components)
-        @value = components.join(' ').strip
+        @value = components.join(" ").strip
         initialize_name_components(components)
       end
 

data/app/models/spree/address.rb

@@ -22,9 +22,9 @@ module Spree
       self.class.state_validator_class.new(self).perform
     end
 
-    self.ignored_columns = %w(firstname lastname)
-    DB_ONLY_ATTRS = %w(id updated_at created_at).freeze
-    TAXATION_ATTRS = %w(state_id country_id zipcode).freeze
+    self.ignored_columns = %w[firstname lastname]
+    DB_ONLY_ATTRS = %w[id updated_at created_at].freeze
+    TAXATION_ATTRS = %w[state_id country_id zipcode].freeze
 
     self.allowed_ransackable_attributes = %w[name]
 
@@ -95,9 +95,9 @@ module Spree
     # @note This compares the addresses based on only the fields that make up
     #   the logical "address" and excludes the database specific fields (id, created_at, updated_at).
     # @return [Boolean] true if the two addresses have the same address fields
-    def ==(other_address)
-      return false unless other_address && other_address.respond_to?(:value_attributes)
-      value_attributes == other_address.value_attributes
+    def ==(other)
+      return false unless other&.respond_to?(:value_attributes)
+      value_attributes == other.value_attributes
     end
 
     # @return [Hash] an ActiveMerchant compatible address hash
@@ -142,7 +142,7 @@ module Spree
     end
 
     def country_iso
-      country && country.iso
+      country&.iso
     end
   end
 end

data/app/models/spree/adjustment.rb

@@ -9,8 +9,8 @@ module Spree
   class Adjustment < Spree::Base
     belongs_to :adjustable, polymorphic: true, touch: true, optional: true
     belongs_to :source, polymorphic: true, optional: true
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments, optional: true
-    belongs_to :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments, optional: true
+    belongs_to :order, class_name: "Spree::Order", inverse_of: false, optional: true
+    belongs_to :adjustment_reason, class_name: "Spree::AdjustmentReason", inverse_of: :adjustments, optional: true
 
     validates :adjustable, presence: true
     validates :order, presence: true
@@ -19,14 +19,14 @@ module Spree
 
     scope :not_finalized, -> { where(finalized: false) }
     scope :finalized, -> { where(finalized: true) }
-    scope :cancellation, -> { where(source_type: 'Spree::UnitCancel') }
-    scope :tax, -> { where(source_type: 'Spree::TaxRate') }
+    scope :cancellation, -> { where(source_type: "Spree::UnitCancel") }
+    scope :tax, -> { where(source_type: "Spree::TaxRate") }
     scope :non_tax, -> do
       source_type = arel_table[:source_type]
-      where(source_type.not_eq('Spree::TaxRate').or(source_type.eq(nil)))
+      where(source_type.not_eq("Spree::TaxRate").or(source_type.eq(nil)))
     end
-    scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
-    scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
+    scope :price, -> { where(adjustable_type: "Spree::LineItem") }
+    scope :shipping, -> { where(adjustable_type: "Spree::Shipment") }
     scope :eligible, -> { all }
     class << self
       deprecate :eligible, deprecator: Spree.deprecator
@@ -42,9 +42,10 @@ module Spree
 
     singleton_class.deprecate :return_authorization, deprecator: Spree.deprecator
 
-    allowed_ransackable_attributes << 'label'
+    allowed_ransackable_attributes << "label"
 
     extend DisplayMoney
+
     money_methods :amount
 
     def finalize!
@@ -74,12 +75,12 @@ module Spree
 
     # @return [Boolean] true when this is a tax adjustment (Tax adjustments have a {TaxRate} source)
     def tax?
-      source_type == 'Spree::TaxRate'
+      source_type == "Spree::TaxRate"
     end
 
     # @return [Boolean] true when this is a cancellation adjustment (Cancellation adjustments have a {UnitCancel} source)
     def cancellation?
-      source_type == 'Spree::UnitCancel'
+      source_type == "Spree::UnitCancel"
     end
 
     def eligible?

data/app/models/spree/adjustment_reason.rb

@@ -4,8 +4,8 @@ module Spree
   class AdjustmentReason < Spree::Base
     has_many :adjustments, inverse_of: :adjustment_reason, dependent: :restrict_with_error
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
-    validates :code, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
+    validates :code, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
 
     scope :active, -> { where(active: true) }
 

data/app/models/spree/billing_integration.rb

@@ -4,14 +4,14 @@ module Spree
   class BillingIntegration < PaymentMethod
     validates :name, presence: true
 
-    preference :server, :string, default: 'test'
+    preference :server, :string, default: "test"
     preference :test_mode, :boolean, default: true
 
     def gateway
       integration_options = options
 
       # All environments except production considered to be test
-      test_server = integration_options[:server] != 'production'
+      test_server = integration_options[:server] != "production"
       test_mode = integration_options[:test_mode]
 
       integration_options[:test] = (test_server || test_mode)

data/app/models/spree/calculator/default_tax.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
+require_dependency "spree/calculator"
 
 module Spree
   class Calculator::DefaultTax < Calculator
@@ -17,7 +17,7 @@ module Spree
 
       line_items_total = matched_line_items.sum(&:total_before_tax)
       if rate.included_in_price
-        round_to_two_places(line_items_total - ( line_items_total / (1 + rate.amount) ) )
+        round_to_two_places(line_items_total - (line_items_total / (1 + rate.amount)))
       else
         round_to_two_places(line_items_total * rate.amount)
       end

data/app/models/spree/calculator/flat_fee.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
+require_dependency "spree/calculator"
 
 module Spree
   # Very simple tax rate calculator. Can be used to apply a flat fee to any

data/app/models/spree/calculator/flat_rate.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
+require_dependency "spree/calculator"
 
 module Spree
   class Calculator::FlatRate < Calculator
     preference :amount, :decimal, default: 0
-    preference :currency, :string, default: ->{ Spree::Config[:currency] }
+    preference :currency, :string, default: -> { Spree::Config[:currency] }
 
     def compute(object = nil)
       if object && preferred_currency.casecmp(object.currency).zero?

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/returns_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/returns_calculator"
 
 module Spree
   module Calculator::Returns
     class DefaultRefundAmount < ReturnsCalculator
       def compute(return_item)
-        return 0.0.to_d if return_item.part_of_exchange?
+        return BigDecimal("0.0") if return_item.part_of_exchange?
         weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_amount(return_item.inventory_unit)
       end
 

data/app/models/spree/calculator/shipping/flat_percent_item_total.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/shipping_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/shipping_calculator"
 
 module Spree
   module Calculator::Shipping

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/shipping_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/shipping_calculator"
 
 module Spree
   module Calculator::Shipping
     class FlatRate < ShippingCalculator
       preference :amount, :decimal, default: 0
-      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       def compute_package(_package)
         preferred_amount

data/app/models/spree/calculator/shipping/flexi_rate.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/shipping_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/shipping_calculator"
 
 module Spree
   module Calculator::Shipping
     class FlexiRate < ShippingCalculator
-      preference :first_item,      :decimal, default: 0.0
+      preference :first_item, :decimal, default: 0.0
       preference :additional_item, :decimal, default: 0.0
-      preference :max_items,       :integer, default: 0
-      preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
+      preference :max_items, :integer, default: 0
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       def compute_package(package)
         compute_from_quantity(package.contents.sum(&:quantity))
@@ -20,10 +20,10 @@ module Spree
         max = preferred_max_items.to_i
         quantity.times do |index|
           # check max value to avoid divide by 0 errors
-          if (max == 0 && index == 0) || (max > 0) && (index % max == 0)
-            sum += preferred_first_item.to_f
+          sum += if (max == 0 && index == 0) || (max > 0) && (index % max == 0)
+            preferred_first_item.to_f
           else
-            sum += preferred_additional_item.to_f
+            preferred_additional_item.to_f
           end
         end
 

data/app/models/spree/calculator/shipping/per_item.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/shipping_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/shipping_calculator"
 
 module Spree
   module Calculator::Shipping
     class PerItem < ShippingCalculator
       preference :amount, :decimal, default: 0
-      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       def compute_package(package)
         compute_from_quantity(package.contents.sum(&:quantity))

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_dependency 'spree/calculator'
-require_dependency 'spree/shipping_calculator'
+require_dependency "spree/calculator"
+require_dependency "spree/shipping_calculator"
 
 module Spree
   module Calculator::Shipping
@@ -9,7 +9,7 @@ module Spree
       preference :minimal_amount, :decimal, default: 0
       preference :normal_amount, :decimal, default: 0
       preference :discount_amount, :decimal, default: 0
-      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+      preference :currency, :string, default: -> { Spree::Config[:currency] }
 
       def compute_package(package)
         compute_from_price(total(package.contents))

data/app/models/spree/calculator.rb

@@ -6,16 +6,41 @@ module Spree
 
     belongs_to :calculable, polymorphic: true, optional: true
 
-    # This method calls a compute_<computable> method. must be overriden in concrete calculator.
+    # Computes an amount based on the calculable and the computable parameter.
     #
-    # It should return amount computed based on #calculable and the computable parameter
-    def compute(computable)
+    # This method dynamically calls a compute_<computable> method based on the class
+    # of the computable parameter. Concrete calculator classes must implement the
+    # appropriate compute method for each computable type they support.
+    #
+    # For example, if the computable is a Spree::LineItem, this will call
+    # compute_line_item(computable, ...). If the computable is a Spree::Order,
+    # it will call compute_order(computable, ...).
+    #
+    # @param computable [Object] The object to compute the amount for (e.g.,
+    #                            Spree::LineItem, Spree::Order, Spree::Shipment,
+    #                            Spree::ShippingRate)
+    # @param ... [args, kwargs] Additional arguments passed to the specific compute method
+    #
+    # @return [BigDecimal, Numeric] The computed amount
+    #
+    # @raise [NotImplementedError] If the calculator doesn't implement the required compute method
+    #
+    # @example Implementing a calculator for line items
+    #   class MyCalculator < Spree::Calculator
+    #     def compute_line_item(line_item)
+    #       line_item.amount * 0.1 # 10% of line item amount
+    #     end
+    #   end
+    #
+    # @see Spree::CalculatedAdjustments for how calculators connect to calculables, such as
+    #      Spree::TaxRate, Spree::ShippingRate, SolidusPromotions::Benefit, or Spree::PromotionAction
+    def compute(computable, ...)
       # Spree::LineItem -> :compute_line_item
       computable_name = computable.class.name.demodulize.underscore
-      method_name = "compute_#{computable_name}".to_sym
+      method_name = :"compute_#{computable_name}"
       calculator_class = self.class
       if respond_to?(method_name)
-        send(method_name, computable)
+        send(method_name, computable, ...)
       else
         raise NotImplementedError, "Please implement '#{method_name}(#{computable_name})' in your calculator: #{calculator_class.name}"
       end
@@ -30,7 +55,7 @@ module Spree
     ###################################################################
 
     def to_s
-      self.class.name.titleize.gsub("Calculator\/", "")
+      self.class.name.titleize.gsub("Calculator/", "")
     end
 
     def description

data/app/models/spree/carton.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 class Spree::Carton < Spree::Base
-  belongs_to :address, class_name: 'Spree::Address', optional: true
-  belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :cartons, optional: true
-  belongs_to :shipping_method, -> { with_discarded }, class_name: 'Spree::ShippingMethod', inverse_of: :cartons, optional: true
+  belongs_to :address, class_name: "Spree::Address", optional: true
+  belongs_to :stock_location, class_name: "Spree::StockLocation", inverse_of: :cartons, optional: true
+  belongs_to :shipping_method, -> { with_discarded }, class_name: "Spree::ShippingMethod", inverse_of: :cartons, optional: true
 
   has_many :inventory_units, class_name: "Spree::InventoryUnit", inverse_of: :carton, dependent: :nullify
   has_many :orders, -> { distinct }, through: :inventory_units
@@ -22,7 +22,7 @@ class Spree::Carton < Spree::Base
   # @return [boolean, NilClass] Whether the email should be suppressed.
   attr_accessor :suppress_email
 
-  make_permalink field: :number, length: 11, prefix: 'C'
+  make_permalink field: :number, length: 11, prefix: "C"
 
   scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
   # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.

data/app/models/spree/classification.rb

@@ -2,12 +2,12 @@
 
 module Spree
   class Classification < Spree::Base
-    self.table_name = 'spree_products_taxons'
+    self.table_name = "spree_products_taxons"
     acts_as_list scope: :taxon
     belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications, touch: true
     belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
 
     # For https://github.com/spree/spree/issues/3494
-    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked }
+    validates :taxon_id, uniqueness: {scope: :product_id, message: :already_linked}
   end
 end

data/app/models/spree/core/state_machines/order/class_methods.rb

@@ -101,7 +101,7 @@ module Spree
               end
 
               after_transition to: :complete, do: :finalize
-              after_transition to: :resumed,  do: :after_resume
+              after_transition to: :resumed, do: :after_resume
               after_transition to: :canceled, do: :after_cancel
 
               after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
@@ -121,7 +121,7 @@ module Spree
           def go_to_state(name, options = {})
             checkout_steps[name] = options
             previous_states.each do |state|
-              add_transition({ from: state, to: name }.merge(options))
+              add_transition({from: state, to: name}.merge(options))
             end
             if options[:if]
               previous_states << name
@@ -188,7 +188,7 @@ module Spree
           end
 
           def add_transition(options)
-            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+            next_event_transitions << {options.delete(:from) => options.delete(:to)}.merge(options)
           end
 
           def removed_transitions

data/app/models/spree/core/state_machines/return_item/acceptance_status.rb

@@ -41,7 +41,7 @@ module Spree
                 transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
               end
 
-              after_transition any => any, do: :persist_acceptance_status_errors
+              after_transition any => any, :do => :persist_acceptance_status_errors
             end
           end
         end

data/app/models/spree/country.rb

@@ -28,7 +28,7 @@ module Spree
     def self.available(restrict_to_zone: Spree::Config[:checkout_zone])
       checkout_zone = Zone.find_by(name: restrict_to_zone)
 
-      return checkout_zone.country_list if checkout_zone.try(:kind) == 'country'
+      return checkout_zone.country_list if checkout_zone.try(:kind) == "country"
 
       all
     end