solidus_core 4.6.2 → 4.7.0

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

@@ -8,11 +8,11 @@ module Spree
 
     def authorize(amount_in_cents, provided_store_credit, gateway_options = {})
       if provided_store_credit.nil?
-        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find'), {}, {})
+        ActiveMerchant::Billing::Response.new(false, I18n.t("spree.store_credit.unable_to_find"), {}, {})
       else
         action = ->(store_credit) {
           store_credit.authorize(
-            amount_in_cents / 100.0.to_d,
+            amount_in_cents / BigDecimal("100.0"),
             gateway_options[:currency],
             action_originator: gateway_options[:originator]
           )
@@ -24,7 +24,7 @@ module Spree
     def capture(amount_in_cents, auth_code, gateway_options = {})
       action = ->(store_credit) {
         store_credit.capture(
-          amount_in_cents / 100.0.to_d,
+          amount_in_cents / BigDecimal("100.0"),
           auth_code,
           gateway_options[:currency],
           action_originator: gateway_options[:originator]
@@ -35,14 +35,14 @@ module Spree
     end
 
     def purchase(amount_in_cents, store_credit, gateway_options = {})
-      eligible_events = store_credit.store_credit_events.where(amount: amount_in_cents / 100.0.to_d, action: Spree::StoreCredit::ELIGIBLE_ACTION)
+      eligible_events = store_credit.store_credit_events.where(amount: amount_in_cents / BigDecimal("100.0"), action: Spree::StoreCredit::ELIGIBLE_ACTION)
       event = eligible_events.find do |eligible_event|
         store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code)
-                                        .where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
+          .where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
       end
 
       if event.blank?
-        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find'), {}, {})
+        ActiveMerchant::Billing::Response.new(false, I18n.t("spree.store_credit.unable_to_find"), {}, {})
       else
         capture(amount_in_cents, event.authorization_code, gateway_options)
       end
@@ -60,7 +60,7 @@ module Spree
         currency = gateway_options[:currency] || store_credit.currency
         originator = gateway_options[:originator]
 
-        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+        store_credit.credit(amount_in_cents / BigDecimal("100.0"), auth_code, currency, action_originator: originator)
       end
 
       handle_action(action, :credit, auth_code)
@@ -73,13 +73,13 @@ module Spree
       store_credit = store_credit_event.try(:store_credit)
 
       if store_credit_event.nil? || store_credit.nil?
-        ActiveMerchant::Billing::Response.new(false, '', {}, {})
+        ActiveMerchant::Billing::Response.new(false, "", {}, {})
       elsif store_credit_event.capture_action?
         false # payment#cancel! handles the refund
       elsif store_credit_event.authorization_action?
         void(auth_code)
       else
-        ActiveMerchant::Billing::Response.new(false, '', {}, {})
+        ActiveMerchant::Billing::Response.new(false, "", {}, {})
       end
     end
 
@@ -91,11 +91,11 @@ module Spree
 
     def handle_action_call(store_credit, action, action_name, auth_code = nil)
       store_credit.with_lock do
-        if response = action.call(store_credit)
+        if (response = action.call(store_credit))
           # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
           ActiveMerchant::Billing::Response.new(true,
-                                                I18n.t('spree.store_credit.successful_action', action: action_name),
-                                                {}, { authorization: auth_code || response })
+            I18n.t("spree.store_credit.successful_action", action: action_name),
+            {}, {authorization: auth_code || response})
         else
           ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
         end
@@ -107,7 +107,7 @@ module Spree
       store_credit = Spree::StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
 
       if store_credit.nil?
-        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code:, action: action_name), {}, {})
+        ActiveMerchant::Billing::Response.new(false, I18n.t("spree.store_credit.unable_to_find_for_action", auth_code:, action: action_name), {}, {})
       else
         handle_action_call(store_credit, action, action_name, auth_code)
       end

data/app/models/spree/payment_method.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spree/preferences/statically_configurable'
+require "spree/preferences/statically_configurable"
 
 module Spree
   # A base class which is used for implementing payment methods.
@@ -12,9 +12,10 @@ module Spree
   #
   class PaymentMethod < Spree::Base
     include Spree::Preferences::Persistable
+
     class UnsupportedPaymentMethod < StandardError; end
 
-    preference :server, :string, default: 'test'
+    preference :server, :string, default: "test"
     preference :test_mode, :boolean, default: true
 
     include Spree::SoftDeletable
@@ -53,7 +54,7 @@ module Spree
           options[:default],
           @human
         ].compact
-        options = { scope: [:activerecord, :models], count: 1, default: defaults }.merge!(options.except(:default))
+        options = {scope: [:activerecord, :models], count: 1, default: defaults}.merge!(options.except(:default))
         I18n.translate(defaults.shift, **options)
       end
     end
@@ -64,12 +65,12 @@ module Spree
       end
 
       def find_sti_class(type_name)
-        super(type_name)
+        super
       rescue ActiveRecord::SubclassNotFound
-        raise UnsupportedPaymentMethod, "Found invalid payment type '#{type_name}'.\n"\
-          "This may happen after switching payment service provider, when payment methods "\
-          "reference old types that are not supported any more.\n"\
-          "If that is the case, consider running 'rake payment_method:deactivate_unsupported_payment_methods' "\
+        raise UnsupportedPaymentMethod, "Found invalid payment type '#{type_name}'.\n" \
+          "This may happen after switching payment service provider, when payment methods " \
+          "reference old types that are not supported any more.\n" \
+          "If that is the case, consider running 'rake payment_method:deactivate_unsupported_payment_methods' " \
           "to fix the issue."
       end
     end
@@ -91,7 +92,7 @@ module Spree
       gateway_options.delete :login if gateway_options.key?(:login) && gateway_options[:login].nil?
 
       # All environments except production considered to be test
-      test_server = gateway_options[:server] != 'production'
+      test_server = gateway_options[:server] != "production"
       test_mode = gateway_options[:test_mode]
 
       gateway_options[:test] = (test_server || test_mode)
@@ -182,9 +183,9 @@ module Spree
     # @return [ActiveMerchant::Billing::Response|FalseClass]
     def try_void(payment)
       void_attempt = if payment.payment_method.payment_profiles_supported?
-        void(payment.transaction_id, payment.source, { originator: payment })
+        void(payment.transaction_id, payment.source, {originator: payment})
       else
-        void(payment.transaction_id, { originator: payment })
+        void(payment.transaction_id, {originator: payment})
       end
 
       return void_attempt if void_attempt.success?

data/app/models/spree/payment_source.rb

@@ -8,7 +8,7 @@ module Spree
 
     has_many :payments, as: :source
     has_many :wallet_payment_sources,
-      class_name: 'Spree::WalletPaymentSource',
+      class_name: "Spree::WalletPaymentSource",
       as: :payment_source,
       inverse_of: :payment_source,
       dependent: :destroy
@@ -17,7 +17,7 @@ module Spree
 
     # @return [Array<String>] the actions available on this payment source
     def actions
-      %w(capture void credit)
+      %w[capture void credit]
     end
 
     # @param payment [Spree::Payment] the payment we want to know if can be captured

data/app/models/spree/permission_sets/dashboard_display.rb

@@ -19,9 +19,9 @@ module Spree
       end
 
       def activate!
-          Spree.deprecator.warn "The #{self.class.name} module is deprecated. " \
-            "If you still use dashboards, please copy all controllers and views from #{self.class.name} to your application."
-          can [:admin, :home], :dashboards
+        Spree.deprecator.warn "The #{self.class.name} module is deprecated. " \
+          "If you still use dashboards, please copy all controllers and views from #{self.class.name} to your application."
+        can [:admin, :home], :dashboards
       end
     end
   end

data/app/models/spree/permission_sets/default_customer.rb

@@ -70,7 +70,7 @@ module Spree
         can :create, Spree.user_class
         can [:show, :update, :update_email], Spree.user_class, id: user.id
         can :read, State
-        can :read, StockItem, stock_location: { active: true }
+        can :read, StockItem, stock_location: {active: true}
         can :read, StockLocation, active: true
         can :read, Taxon
         can :read, Taxonomy

data/app/models/spree/preference.rb

@@ -3,5 +3,5 @@
 class Spree::Preference < Spree::Base
   serialize :value, coder: YAML
 
-  validates :key, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
+  validates :key, presence: true, uniqueness: {allow_blank: true, case_sensitive: true}
 end

data/app/models/spree/price.rb

@@ -4,9 +4,9 @@ module Spree
   class Price < Spree::Base
     include Spree::SoftDeletable
 
-    MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
+    MAXIMUM_AMOUNT = BigDecimal("99_999_999.99")
 
-    belongs_to :variant, -> { with_discarded }, class_name: 'Spree::Variant', touch: true, optional: true
+    belongs_to :variant, -> { with_discarded }, class_name: "Spree::Variant", touch: true, optional: true
     belongs_to :country, class_name: "Spree::Country", foreign_key: "country_iso", primary_key: "iso", optional: true
 
     delegate :product, to: :variant
@@ -17,20 +17,21 @@ module Spree
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
-    validates :currency, inclusion: { in: ::Money::Currency.all.map(&:iso_code), message: :invalid_code }
+    validates :currency, inclusion: {in: ::Money::Currency.all.map(&:iso_code), message: :invalid_code}
     validates :country, presence: true, unless: -> { for_any_country? }
 
     scope :currently_valid, -> { order(Arel.sql("country_iso IS NULL")).order(updated_at: :DESC, id: :DESC) }
-    scope :for_master, -> { joins(:variant).where(spree_variants: { is_master: true }) }
-    scope :for_variant, -> { joins(:variant).where(spree_variants: { is_master: false }) }
+    scope :for_master, -> { joins(:variant).where(spree_variants: {is_master: true}) }
+    scope :for_variant, -> { joins(:variant).where(spree_variants: {is_master: false}) }
     scope :for_any_country, -> { where(country: nil) }
     scope :with_default_attributes, -> { where(Spree::Config.default_pricing_options.desired_attributes) }
 
     extend DisplayMoney
+
     money_methods :amount, :price
     alias_method :money, :display_amount
 
-    self.allowed_ransackable_attributes = %w(amount variant_id currency country_iso)
+    self.allowed_ransackable_attributes = %w[amount variant_id currency country_iso]
 
     # An alias for #amount
     def price

data/app/models/spree/product/scopes.rb

@@ -17,9 +17,9 @@ module Spree
           def self.property_conditions(property)
             properties = Property.table_name
             case property
-            when String   then { "#{properties}.name" => property }
-            when Property then { "#{properties}.id" => property.id }
-            else { "#{properties}.id" => property.to_i }
+            when String then {"#{properties}.name" => property}
+            when Property then {"#{properties}.id" => property.id}
+            else {"#{properties}.id" => property.to_i}
             end
           end
 
@@ -29,17 +29,17 @@ module Spree
           scope :descend_by_name, -> { order(name: :desc) }
 
           add_search_scope :ascend_by_master_price do
-            joins(master: :prices).select('spree_products.* , spree_prices.amount')
-                                         .order(Spree::Price.arel_table[:amount].asc)
+            joins(master: :prices).select("spree_products.* , spree_prices.amount")
+              .order(Spree::Price.arel_table[:amount].asc)
           end
 
           add_search_scope :descend_by_master_price do
-            joins(master: :prices).select('spree_products.* , spree_prices.amount')
-                                         .order(Spree::Price.arel_table[:amount].desc)
+            joins(master: :prices).select("spree_products.* , spree_prices.amount")
+              .order(Spree::Price.arel_table[:amount].desc)
           end
 
           add_search_scope :price_between do |low, high|
-            joins(master: :prices).where(Price.table_name => { amount: low..high })
+            joins(master: :prices).where(Price.table_name => {amount: low..high})
           end
 
           add_search_scope :master_price_lte do |price|
@@ -69,7 +69,7 @@ module Spree
           #   SELECT COUNT(*) ...
           add_search_scope :in_taxon do |taxon|
             includes(:classifications)
-              .where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id))
+              .where("spree_products_taxons.taxon_id" => taxon.self_and_descendants.pluck(:id))
               .order(Spree::Classification.arel_table[:position].asc)
           end
 
@@ -98,9 +98,9 @@ module Spree
           add_search_scope :with_option do |option|
             option_types = Spree::OptionType.table_name
             conditions = case option
-                         when String     then { "#{option_types}.name" => option }
-                         when OptionType then { "#{option_types}.id" => option.id }
-                         else { "#{option_types}.id" => option.to_i }
+            when String then {"#{option_types}.name" => option}
+            when OptionType then {"#{option_types}.id" => option.id}
+            else {"#{option_types}.id" => option.to_i}
             end
 
             joins(:option_types).where(conditions)
@@ -109,22 +109,22 @@ module Spree
           add_search_scope :with_option_value do |option, value|
             option_values = Spree::OptionValue.table_name
             option_type_id = case option
-                             when String then Spree::OptionType.find_by(name: option) || option.to_i
-                             when Spree::OptionType then option.id
-                             else option.to_i
+            when String then Spree::OptionType.find_by(name: option) || option.to_i
+            when Spree::OptionType then option.id
+            else option.to_i
             end
 
             conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
-            group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
+            group("spree_products.id").joins(variants_including_master: :option_values).where(conditions)
           end
 
           # Finds all products which have either:
           # 1) have an option value with the name matching the one given
           # 2) have a product property with a value matching the one given
           add_search_scope :with do |value|
-            includes(variants_including_master: :option_values).
-              includes(:product_properties).
-              where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
+            includes(variants_including_master: :option_values)
+              .includes(:product_properties)
+              .where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
           end
 
           # Finds all products that have a name containing the given words.
@@ -157,8 +157,8 @@ module Spree
           # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
           # order: 'COALESCE(cnt, 0) DESC'
           add_search_scope :descend_by_popularity do
-            joins(:master).
-              order(Arel.sql(%{
+            joins(:master)
+              .order(Arel.sql(%{
            COALESCE((
              SELECT
                COUNT(#{Spree::LineItem.quoted_table_name}.id)
@@ -230,10 +230,10 @@ module Spree
             # Produce an array of keywords for use in scopes.
             # Always return array with at least an empty string to avoid SQL errors
             def prepare_words(words)
-              return [''] if words.blank?
+              return [""] if words.blank?
 
               splitted = words.split(/[,\s]/).map(&:strip)
-              splitted.any? ? splitted : ['']
+              splitted.any? ? splitted : [""]
             end
 
             def get_taxons(*ids_or_records_or_names)

data/app/models/spree/product.rb

@@ -7,6 +7,7 @@ module Spree
   # variant.
   class Product < Spree::Base
     extend FriendlyId
+
     friendly_id :slug_candidates, use: :history
 
     include Spree::SoftDeletable
@@ -15,7 +16,7 @@ module Spree
       variants_including_master.discard_all
       self.product_option_types = []
       self.product_properties = []
-      self.classifications.destroy_all
+      classifications.destroy_all
     end
 
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
@@ -30,27 +31,27 @@ module Spree
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
 
-    belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
-    belongs_to :primary_taxon, class_name: 'Spree::Taxon', optional: true
+    belongs_to :tax_category, class_name: "Spree::TaxCategory", optional: true
+    belongs_to :shipping_category, class_name: "Spree::ShippingCategory", inverse_of: :products
+    belongs_to :primary_taxon, class_name: "Spree::Taxon", optional: true
 
     has_one :master,
       -> { where(is_master: true).with_discarded },
       inverse_of: :product,
-      class_name: 'Spree::Variant',
+      class_name: "Spree::Variant",
       autosave: true,
       dependent: false
 
     has_many :variants,
       -> { where(is_master: false).order(:position) },
       inverse_of: :product,
-      class_name: 'Spree::Variant',
+      class_name: "Spree::Variant",
       dependent: false
 
     has_many :variants_including_master,
       -> { order(:position) },
       inverse_of: :product,
-      class_name: 'Spree::Variant',
+      class_name: "Spree::Variant",
       dependent: :destroy
 
     has_many :prices, -> { order(Spree::Variant.arel_table[:position].asc, Spree::Variant.arel_table[:id].asc, :currency) }, through: :variants_including_master
@@ -63,14 +64,14 @@ module Spree
     has_many :option_values, -> { distinct }, through: :variants_including_master
 
     scope :sort_by_master_default_price_amount_asc, -> {
-      with_default_price.order('spree_prices.amount ASC')
+      with_default_price.order("spree_prices.amount ASC")
     }
     scope :sort_by_master_default_price_amount_desc, -> {
-      with_default_price.order('spree_prices.amount DESC')
+      with_default_price.order("spree_prices.amount DESC")
     }
     scope :with_default_price, -> {
       left_joins(master: :prices)
-        .where(master: { spree_prices: Spree::Config.default_pricing_options.desired_attributes })
+        .where(master: {spree_prices: Spree::Config.default_pricing_options.desired_attributes})
     }
 
     def find_or_build_master
@@ -95,13 +96,13 @@ module Spree
     end
 
     delegate :amount_in,
-             :display_amount,
-             :display_price,
-             :has_default_price?,
-             :images,
-             :price_for_options,
-             :rebuild_vat_prices=,
-             to: :find_or_build_master
+      :display_amount,
+      :display_price,
+      :has_default_price?,
+      :images,
+      :price_for_options,
+      :rebuild_vat_prices=,
+      to: :find_or_build_master
 
     alias_method :master_images, :images
 
@@ -120,18 +121,18 @@ module Spree
     before_validation :normalize_slug, on: :update
     before_validation :validate_master
 
-    validates :meta_keywords, length: { maximum: 255 }
-    validates :meta_title, length: { maximum: 255 }
+    validates :meta_keywords, length: {maximum: 255}
+    validates :meta_title, length: {maximum: 255}
     validates :name, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
-    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
+    validates :slug, presence: true, uniqueness: {allow_blank: true, case_sensitive: true}
 
     attr_accessor :option_values_hash
 
     accepts_nested_attributes_for :variant_property_rules, allow_destroy: true
     accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
 
-    alias :options :product_option_types
+    alias_method :options, :product_option_types
 
     self.allowed_ransackable_associations = %w[stores variants_including_master master variants option_values]
     self.allowed_ransackable_attributes = %w[name slug]
@@ -147,6 +148,11 @@ module Spree
       super || Spree::TaxCategory.find_by(is_default: true)
     end
 
+    # @return [Integer] tax category id for this product, or the default tax category id
+    def tax_category_id
+      super || tax_category&.id
+    end
+
     # Ensures option_types and product_option_types exist for keys in
     # option_values_hash.
     #
@@ -225,24 +231,24 @@ module Spree
     # associated with the products variants grouped by option type
     def variant_option_values_by_option_type(variant_scope = nil)
       option_value_scope = Spree::OptionValuesVariant.joins(:variant)
-        .where(spree_variants: { product_id: id })
+        .where(spree_variants: {product_id: id})
       option_value_scope = option_value_scope.merge(variant_scope) if variant_scope
       option_value_ids = option_value_scope.distinct.pluck(:option_value_id)
-      Spree::OptionValue.where(id: option_value_ids).
-        includes(:option_type).
-        order("#{Spree::OptionType.table_name}.position, #{Spree::OptionValue.table_name}.position").
-        group_by(&:option_type)
+      Spree::OptionValue.where(id: option_value_ids)
+        .includes(:option_type)
+        .order("#{Spree::OptionType.table_name}.position, #{Spree::OptionValue.table_name}.position")
+        .group_by(&:option_type)
     end
 
     # @return [Boolean] true if there are no option values
     def empty_option_values?
-      options.empty? || !option_types.left_joins(:option_values).where('spree_option_values.id IS NULL').empty?
+      options.empty? || !option_types.left_joins(:option_values).where("spree_option_values.id IS NULL").empty?
     end
 
     # @param property_name [String] the name of the property to find
     # @return [String] the value of the given property. nil if property is undefined on this product
     def property(property_name)
-      return nil unless prop = properties.find_by(name: property_name)
+      return nil unless (prop = properties.find_by(name: property_name))
       product_properties.find_by(property: prop).try(:value)
     end
 
@@ -270,10 +276,8 @@ module Spree
     #
     # @return [Fixnum, Infinity]
     def total_on_hand
-      if any_variants_not_track_inventory?
-        Float::INFINITY
-      else
-        stock_items.sum(:count_on_hand)
+      variants_including_master.sum do |variant|
+        Spree::Config.stock.quantifier_class.new(variant).total_on_hand
       end
     end
 
@@ -301,14 +305,6 @@ module Spree
 
     private
 
-    def any_variants_not_track_inventory?
-      if variants_including_master.loaded?
-        variants_including_master.any? { |variant| !variant.should_track_inventory? }
-      else
-        !Spree::Config.track_inventory_levels || variants_including_master.where(track_inventory: false).exists?
-      end
-    end
-
     # Builds variants from a hash of option types & values
     def build_variants_from_option_values_hash
       ensure_option_types_exist_for_values_hash
@@ -377,4 +373,4 @@ module Spree
   end
 end
 
-require_dependency 'spree/product/scopes'
+require_dependency "spree/product/scopes"

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
+    belongs_to :option_type, class_name: "Spree::OptionType", inverse_of: :product_option_types
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_property.rb

@@ -6,9 +6,9 @@ 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
+    belongs_to :property, class_name: "Spree::Property", inverse_of: :product_properties
 
-    self.allowed_ransackable_attributes = ['value']
+    self.allowed_ransackable_attributes = ["value"]
   end
 end

data/app/models/spree/refund.rb

@@ -5,14 +5,14 @@ module Spree
     include Metadata
 
     belongs_to :payment, inverse_of: :refunds, optional: true
-    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id, 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
 
     validates :payment, presence: true
     validates :reason, presence: true
-    validates :amount, presence: true, numericality: { greater_than: 0 }
+    validates :amount, presence: true, numericality: {greater_than: 0}
 
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
@@ -23,9 +23,9 @@ module Spree
     delegate :currency, to: :payment
 
     def money
-      Spree::Money.new(amount, { currency: })
+      Spree::Money.new(amount, {currency:})
     end
-    alias display_amount money
+    alias_method :display_amount, :money
 
     class << self
       def total_amount_reimbursed_for(reimbursement)
@@ -68,21 +68,21 @@ module Spree
     # return an activemerchant response object if successful or else raise an error
     def process!(credit_cents)
       response = if payment.payment_method.payment_profiles_supported?
-        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, { originator: self })
+        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, {originator: self})
       else
-        payment.payment_method.credit(credit_cents, payment.transaction_id, { originator: self })
+        payment.payment_method.credit(credit_cents, payment.transaction_id, {originator: self})
       end
 
       if !response.success?
-        logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
-        text = response.params['message'] || response.params['response_reason_text'] || response.message
+        logger.error(I18n.t("spree.gateway_error") + "  #{response.to_yaml}")
+        text = response.params["message"] || response.params["response_reason_text"] || response.message
         raise Core::GatewayError.new(text)
       end
 
       response
     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'))
+      logger.error(I18n.t("spree.gateway_error") + "  #{error.inspect}")
+      raise Core::GatewayError.new(I18n.t("spree.unable_to_connect_to_gateway"))
     end
 
     def amount_is_less_than_or_equal_to_allowed_amount

data/app/models/spree/refund_reason.rb

@@ -5,9 +5,9 @@ module Spree
     scope :active, -> { where(active: true) }
     default_scope -> { order(arel_table[:name].lower) }
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
 
-    RETURN_PROCESSING_REASON = 'Return processing'
+    RETURN_PROCESSING_REASON = "Return processing"
 
     has_many :refunds
 

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

@@ -22,7 +22,7 @@ module Spree
       end
 
       def display_amount
-        Spree::Money.new(amount, { currency: creditable.try(:currency) || "USD" })
+        Spree::Money.new(amount, {currency: creditable.try(:currency) || "USD"})
       end
     end
   end