solidus_core 3.2.5 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ca291cd7b979dea71a53e089ec1f5582fd29606135be6802668e6a249655295
-  data.tar.gz: 35c97c39d287f13bd2330fef96e59eefa5d82869e49563a32706b827087a936a
+  metadata.gz: 6b882356a483b6ec07df20020cfdf2429122ed885165c9626384017479b26442
+  data.tar.gz: a840c6d60aab4097f5159588a9b648ac5baac0fba6704ea21e1928eb7dc1dd88
 SHA512:
-  metadata.gz: dcd03d7fe00dade48a32ff5862579eed61115afe17e225e0378ea83fb1af3c502467dbef833619159742b2b7cef998e53d47cde357d6e2b57beb73daa80708f2
-  data.tar.gz: cea864acea70b4d18b208481ffa8d0587ce5bc721f2de5d83c653b2125e7dbf1e9da81ef0cb211180d48df93a53daaf813e5d8d7ecd9181c5c0f9de2efd239ba
+  metadata.gz: fdcc5ba0f68af828dd0d0908c55e4f69fdf14b7ca12ad80ad63d0083c73a49924a3d575ddc60ab3786c240faa120f1543aafbeed01c037e7246161d129d2bb0b
+  data.tar.gz: fae363d934fae8f8bbfcb26ce5f9187984c4e1094c11d43ad9e3f956f0682414d284195f13e390cda73bd4791dfe8ea8ab2e81ef71a8831300b0d5b39beaabe3

data/Rakefile

@@ -14,8 +14,12 @@ DummyApp::RakeTasks.new(
   lib_name: 'solidus_core'
 )
 
-require 'yard'
-YARD::Rake::YardocTask.new
+require 'yard/rake/yardoc_task'
+YARD::Rake::YardocTask.new(:yard)
+# The following workaround can be removed
+# once https://github.com/lsegal/yard/pull/1457 is merged.
+task('yard:require') { require 'yard' }
+task yard: 'yard:require'
 
 namespace :spec do
   task :isolated do

data/app/controllers/spree/base_controller.rb

@@ -4,7 +4,7 @@ require 'cancan'
 require_dependency 'spree/core/controller_helpers/strong_parameters'
 
 class Spree::BaseController < ApplicationController
-  include Spree::Core::ControllerHelpers::CurrentHost
+  include ActiveStorage::SetCurrent
   include Spree::Core::ControllerHelpers::Auth
   include Spree::Core::ControllerHelpers::Common
   include Spree::Core::ControllerHelpers::PaymentParameters

data/app/models/concerns/spree/active_storage_adapter/attachment.rb

@@ -59,6 +59,10 @@ module Spree
         analyze unless analyzed?
 
         @attachment.metadata
+      rescue ActiveStorage::FileNotFoundError => error
+        logger.error("#{error} - Image id: #{attachment.record.id} is corrupted or cannot be found")
+
+        { identified: nil, width: nil, height: nil, analyzed: true }
       end
 
       def styles_to_transformations(styles)

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

@@ -3,8 +3,28 @@
 module Spree::RansackableAttributes
   extend ActiveSupport::Concern
   included do
-    class_attribute :whitelisted_ransackable_associations
-    class_attribute :whitelisted_ransackable_attributes
+    class_attribute :allowed_ransackable_associations, default: []
+    class_attribute :allowed_ransackable_attributes, default: []
+
+    def self.whitelisted_ransackable_associations
+      Spree::Deprecation.deprecation_warning(:whitelisted_ransackable_associations, 'use allowed_ransackable_associations instead')
+      allowed_ransackable_associations
+    end
+
+    def self.whitelisted_ransackable_associations=(new_value)
+      Spree::Deprecation.deprecation_warning(:whitelisted_ransackable_associations=, 'use allowed_ransackable_associations= instead')
+      self.allowed_ransackable_associations = new_value
+    end
+
+    def self.whitelisted_ransackable_attributes
+      Spree::Deprecation.deprecation_warning(:whitelisted_ransackable_attributes, 'use allowed_ransackable_attributes instead')
+      allowed_ransackable_attributes
+    end
+
+    def self.whitelisted_ransackable_attributes=(new_value)
+      Spree::Deprecation.deprecation_warning(:whitelisted_ransackable_attributes=, 'use allowed_ransackable_attributes= instead')
+      self.allowed_ransackable_attributes = new_value
+    end
 
     class_attribute :default_ransackable_attributes
     self.default_ransackable_attributes = %w[id]
@@ -12,11 +32,11 @@ module Spree::RansackableAttributes
 
   class_methods do
     def ransackable_associations(*_args)
-      whitelisted_ransackable_associations || []
+      allowed_ransackable_associations
     end
 
     def ransackable_attributes(*_args)
-      default_ransackable_attributes | (whitelisted_ransackable_attributes || [])
+      default_ransackable_attributes | allowed_ransackable_attributes
     end
   end
 end

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

@@ -32,8 +32,8 @@ module Spree
       include Spree::RansackableAttributes unless included_modules.include?(Spree::RansackableAttributes)
 
       ransack_alias :name, :addresses_name
-      self.whitelisted_ransackable_associations = %w[addresses spree_roles]
-      self.whitelisted_ransackable_attributes = %w[name id email created_at]
+      self.allowed_ransackable_associations = %w[addresses spree_roles]
+      self.allowed_ransackable_attributes = %w[name id email created_at]
     end
 
     def wallet

data/app/models/spree/address.rb

@@ -26,7 +26,7 @@ module Spree
     DB_ONLY_ATTRS = %w(id updated_at created_at).freeze
     TAXATION_ATTRS = %w(state_id country_id zipcode).freeze
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     scope :with_values, ->(attributes) do
       where(value_attributes(attributes))

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  # Very simple tax rate calculator. Can be used to apply a flat fee to any
+  # type of item, including an order.
+  class Calculator::FlatFee < Calculator
+    alias_method :rate, :calculable
+
+    # Amount is fixed regardles of what it's being applied to.
+    def compute(_object)
+      rate.active? ? rate.amount : 0
+    end
+
+    alias_method :compute_order, :compute
+    alias_method :compute_shipment, :compute
+    alias_method :compute_line_item, :compute
+    alias_method :compute_shipping_rate, :compute
+  end
+end

data/app/models/spree/country.rb

@@ -8,7 +8,7 @@ module Spree
 
     validates :name, :iso_name, presence: true
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     def self.default
       find_by!(iso: Spree::Config.default_country_iso)

data/app/models/spree/credit_card.rb

@@ -97,7 +97,7 @@ module Spree
 
     # Sets the last digits field based on the assigned credit card number.
     def set_last_digits
-      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..)
     end
 
     # @return [String] the credit card type if it can be determined from the

data/app/models/spree/customer_return.rb

@@ -17,7 +17,7 @@ module Spree
 
     accepts_nested_attributes_for :return_items
 
-    self.whitelisted_ransackable_attributes = ['number']
+    self.allowed_ransackable_attributes = ['number']
 
     extend DisplayMoney
     money_methods :total, :total_excluding_vat, :amount

data/app/models/spree/line_item.rb

@@ -43,8 +43,8 @@ module Spree
 
     attr_accessor :target_shipment, :price_currency
 
-    self.whitelisted_ransackable_associations = ['variant']
-    self.whitelisted_ransackable_attributes = ['variant_id']
+    self.allowed_ransackable_associations = ['variant']
+    self.allowed_ransackable_attributes = ['variant_id']
 
     # @return [BigDecimal] the amount of this line item, which is the line
     #   item's price multiplied by its quantity.

data/app/models/spree/option_type.rb

@@ -25,7 +25,7 @@ module Spree
     after_touch :touch_all_products
     after_save :touch_all_products
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     def touch_all_products
       products.find_each(&:touch)

data/app/models/spree/option_value.rb

@@ -25,7 +25,7 @@ module Spree
     # TODO: Remove allow_nil once option_type is required on Solidus v4.0
     delegate :name, :presentation, to: :option_type, prefix: :option_type, allow_nil: true
 
-    self.whitelisted_ransackable_attributes = %w[name presentation]
+    self.allowed_ransackable_attributes = %w[name presentation]
 
     # Updates the updated_at column on all the variants associated with this
     # option value.

data/app/models/spree/order/number_generator.rb

@@ -35,11 +35,17 @@ module Spree
         # Use the random number if no other order exists with it.
         if Spree::Order.exists?(number: random)
           # If over half of all possible options are taken add another digit.
-          @length += 1 if Spree::Order.count > (10**@length / 2)
+          @length += 1 if order_count > (10**@length / 2)
         else
           break random
         end
       end
     end
+
+    private
+
+    def order_count
+      @order_count ||= Spree::Order.count
+    end
   end
 end

data/app/models/spree/order.rb

@@ -62,8 +62,8 @@ module Spree
       go_to_state :confirm
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
-    self.whitelisted_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
+    self.allowed_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
+    self.allowed_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address
@@ -596,8 +596,9 @@ module Spree
 
       if matching_store_credits.any?
         payment_method = Spree::PaymentMethod::StoreCredit.first
+        sorter = Spree::Config.store_credit_prioritizer_class.new(matching_store_credits, self)
 
-        matching_store_credits.order_by_priority.each do |credit|
+        sorter.call.each do |credit|
           break if remaining_total.zero?
           next if credit.amount_remaining.zero?
 

data/app/models/spree/order_promotion.rb

@@ -16,7 +16,7 @@ module Spree
     validates :promotion, presence: true
     validates :promotion_code, presence: true, if: :require_promotion_code?
 
-    self.whitelisted_ransackable_associations = %w[promotion_code]
+    self.allowed_ransackable_associations = %w[promotion_code]
 
     private
 

data/app/models/spree/order_updater.rb

@@ -110,8 +110,7 @@ module Spree
       # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
       # It also fits the criteria for sales tax as outlined here:
       # http://www.boe.ca.gov/formspubs/pub113/
-      update_item_promotions
-      update_order_promotions
+      update_promotions
       update_taxes
       update_cancellations
       update_item_totals
@@ -163,6 +162,7 @@ module Spree
       order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
       order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
 
+      # TODO: Delete this line in Solidus 4.0, when it is run in `update_promotions`.
       order.promo_total = all_items.sum(&:promo_total) + adjustments.select(&:eligible?).select(&:promotion?).sum(&:amount)
 
       update_order_total
@@ -196,6 +196,11 @@ module Spree
       end
     end
 
+    def update_promotions
+      Spree::Config.promotion_adjuster_class.new(order).call
+    end
+
+    # DEPRECATED; this functionality is handled in #update_promotions
     def update_item_promotions
       [*line_items, *shipments].each do |item|
         promotion_adjustments = item.adjustments.select(&:promotion?)
@@ -206,16 +211,20 @@ module Spree
         item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
       end
     end
+    deprecate update_item_promotions: :update_promotions, deprecator: Spree::Deprecation
 
     # Update and select the best promotion adjustment for the order.
     # We don't update the order.promo_total yet. Order totals are updated later
     # in #update_adjustment_total since they include the totals from the order's
     # line items and/or shipments.
+    #
+    # DEPRECATED; this functionality is handled in #update_promotions
     def update_order_promotions
       promotion_adjustments = order.adjustments.select(&:promotion?)
       promotion_adjustments.each(&:recalculate)
       Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
     end
+    deprecate update_order_promotions: :update_promotions, deprecator: Spree::Deprecation
 
     def update_taxes
       Spree::Config.tax_adjuster_class.new(order).adjust!

data/app/models/spree/payment/processing.rb

@@ -35,12 +35,36 @@ module Spree
       end
 
       def authorize!
-        handle_payment_preconditions { process_authorization }
+        return unless check_payment_preconditions!
+
+        started_processing!
+
+        protect_from_connection_error do
+          response = payment_method.authorize(
+            money.money.cents,
+            source,
+            gateway_options,
+          )
+          pend! if handle_response(response)
+        end
       end
 
       # Captures the entire amount of a payment.
       def purchase!
-        handle_payment_preconditions { process_purchase }
+        return unless check_payment_preconditions!
+
+        started_processing!
+
+        protect_from_connection_error do
+          response = payment_method.purchase(
+            money.money.cents,
+            source,
+            gateway_options,
+          )
+          complete! if handle_response(response)
+        end
+
+        capture_events.create!(amount: amount)
       end
 
       # Takes the amount in cents to capture.
@@ -62,7 +86,7 @@ module Spree
           money = ::Money.new(capture_amount, currency)
           capture_events.create!(amount: money.to_d)
           update!(amount: captured_amount)
-          handle_response(response, :complete, :failure)
+          complete! if handle_response(response)
         end
       end
 
@@ -139,67 +163,46 @@ module Spree
 
       private
 
-      def process_authorization
-        started_processing!
-        gateway_action(source, :authorize, :pend)
-      end
+      # @raises Spree::Core::GatewayError
+      def check_payment_preconditions!
+        return if processing?
+        return unless payment_method
+        return unless payment_method.source_required?
 
-      def process_purchase
-        started_processing!
-        gateway_action(source, :purchase, :complete)
-        # This won't be called if gateway_action raises a GatewayError
-        capture_events.create!(amount: amount)
-      end
-
-      def handle_payment_preconditions(&_block)
-        unless block_given?
-          raise ArgumentError.new("handle_payment_preconditions must be called with a block")
+        unless source
+          gateway_error(I18n.t('spree.payment_processing_failed'))
         end
 
-        return if payment_method.nil?
-        return if !payment_method.source_required?
-
-        if source
-          if !processing?
-            if payment_method.supports?(source)
-              yield
-            else
-              invalidate!
-              raise Core::GatewayError.new(I18n.t('spree.payment_method_not_supported'))
-            end
-          end
-        else
-          raise Core::GatewayError.new(I18n.t('spree.payment_processing_failed'))
+        unless payment_method.supports?(source)
+          invalidate!
+          gateway_error(I18n.t('spree.payment_method_not_supported'))
         end
-      end
 
-      def gateway_action(source, action, success_state)
-        protect_from_connection_error do
-          response = payment_method.send(action, money.money.cents,
-                                         source,
-                                         gateway_options)
-          handle_response(response, success_state, :failure)
-        end
+        true
       end
 
-      def handle_response(response, success_state, failure_state)
+      # @returns true if the response is successful
+      # @returns false (and calls #failure) if the response is not successful
+      def handle_response(response)
         record_response(response)
 
-        if response.success?
-          unless response.authorization.nil?
-            self.response_code = response.authorization
-            self.avs_response = response.avs_result['code']
-
-            if response.cvv_result
-              self.cvv_response_code = response.cvv_result['code']
-              self.cvv_response_message = response.cvv_result['message']
-            end
-          end
-          send("#{success_state}!")
-        else
-          send(failure_state)
+        unless response.success?
+          failure
           gateway_error(response)
+          return false
+        end
+
+        unless response.authorization.nil?
+          self.response_code = response.authorization
+          self.avs_response = response.avs_result['code']
+
+          if response.cvv_result
+            self.cvv_response_code = response.cvv_result['code']
+            self.cvv_response_message = response.cvv_result['message']
+          end
         end
+
+        true
       end
 
       def record_response(response)
@@ -207,9 +210,9 @@ module Spree
       end
 
       def protect_from_connection_error
-          yield
+        yield
       rescue ActiveMerchant::ConnectionError => error
-          gateway_error(error)
+        gateway_error(error)
       end
 
       def gateway_error(error)

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

@@ -57,13 +57,12 @@ module Spree
       end
     end
 
-    def void(_response_code, _credit_card, _options = {})
-      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
-    end
-
-    # @see Spree::PaymentMethod#try_void
-    def try_void(_payment)
-      ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+    def void(_response_code, _credit_card, options = {})
+      if options[:originator].completed?
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+      else
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+      end
     end
 
     def test?

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

@@ -22,5 +22,13 @@ module Spree
         ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, message: FAILURE_MESSAGE, test: true)
       end
     end
+
+    def void(_response_code, options = {})
+      if options[:originator].completed?
+        ActiveMerchant::Billing::Response.new(false, FAILURE_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+      else
+        ActiveMerchant::Billing::Response.new(true, SUCCESS_MESSAGE, {}, test: true, authorization: AUTHORIZATION_CODE)
+      end
+    end
   end
 end

data/app/models/spree/payment_method.rb

@@ -173,16 +173,22 @@ module Spree
     # Return +false+ or +nil+ if the void is not possible anymore - because it was already processed by the bank.
     # Solidus will refund the amount of the payment in this case.
     #
-    # @return [ActiveMerchant::Billing::Response] with +true+ if the void succeeded
-    # @return [ActiveMerchant::Billing::Response] with +false+ if the void failed
-    # @return [false] if it can't be voided at this time
-    #
-    def try_void(_payment)
-      raise ::NotImplementedError,
-        "You need to implement `try_void` for #{self.class.name}. In that " \
-        'return a ActiveMerchant::Billing::Response object if the void succeeds '\
-        'or `false|nil` if the void is not possible anymore. ' \
-        'Solidus will refund the amount of the payment then.'
+    # This default implementation will void the payment if void succeeds,
+    # otherwise it returns false.
+    #
+    # @api public
+    # @param payment [Spree::Payment] the payment to void
+    # @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 })
+      else
+        void(payment.transaction_id, { originator: payment })
+      end
+
+      return void_attempt if void_attempt.success?
+
+      false
     end
 
     def store_credit?

data/app/models/spree/price.rb

@@ -30,7 +30,7 @@ module Spree
     money_methods :amount, :price
     alias_method :money, :display_amount
 
-    self.whitelisted_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.rb

@@ -131,11 +131,11 @@ module Spree
 
     alias :options :product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[name slug]
+    self.allowed_ransackable_associations = %w[stores variants_including_master master variants]
+    self.allowed_ransackable_attributes = %w[name slug]
 
     def self.ransackable_scopes(_auth_object = nil)
-      %i(with_discarded with_variant_sku_cont with_all_variant_sku_cont with_kept_variant_sku_cont)
+      %i(available with_discarded with_variant_sku_cont with_all_variant_sku_cont with_kept_variant_sku_cont)
     end
 
     # @return [Boolean] true if there are any variants

data/app/models/spree/product_property.rb

@@ -9,6 +9,6 @@ module Spree
     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']
+    self.allowed_ransackable_attributes = ['value']
   end
 end

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

@@ -7,6 +7,7 @@ module Spree
         def perform(payload = {})
           order = payload[:order]
           promotion_code = payload[:promotion_code]
+          return false unless promotion.eligible? order
 
           created_adjustments = order.shipments.map do |shipment|
             next if promotion_credit_exists?(shipment)