solidus_core 4.1.6 → 4.5.1

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

@@ -25,7 +25,7 @@ module Spree
           Spree::InventoryUnit.new(
             pending: true,
             variant: line_item.variant,
-            line_item: line_item
+            line_item:
           )
         end
       end

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

@@ -124,8 +124,8 @@ module Spree
         contents.each { |content_item| content_item.inventory_unit.state = content_item.state.to_s }
 
         Spree::Shipment.new(
-          order: order,
-          stock_location: stock_location,
+          order:,
+          stock_location:,
           inventory_units: contents.map(&:inventory_unit)
         )
       end

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

@@ -22,39 +22,65 @@ module Spree
     class SimpleCoordinator
       attr_reader :order
 
+      # @api private
+      attr_reader :inventory_units, :splitters, :stock_locations,
+        :filtered_stock_locations, :inventory_units_by_variant, :desired,
+        :availability, :allocator, :packages
+
       def initialize(order, inventory_units = nil)
         @order = order
         @inventory_units =
           inventory_units || Spree::Config.stock.inventory_unit_builder_class.new(order).units
         @splitters = Spree::Config.environment.stock_splitters
 
-        filtered_stock_locations = Spree::Config.stock.location_filter_class.new(Spree::StockLocation.all, @order).filter
+        @filtered_stock_locations = Spree::Config.stock.location_filter_class.new(load_stock_locations, order).filter
         sorted_stock_locations = Spree::Config.stock.location_sorter_class.new(filtered_stock_locations).sort
         @stock_locations = sorted_stock_locations
 
         @inventory_units_by_variant = @inventory_units.group_by(&:variant)
-        @desired = Spree::StockQuantities.new(@inventory_units_by_variant.transform_values(&:count))
+        @desired = Spree::StockQuantities.new(inventory_units_by_variant.transform_values(&:count))
         @availability = Spree::Stock::Availability.new(
-          variants: @desired.variants,
-          stock_locations: @stock_locations
+          variants: desired.variants,
+          stock_locations:
         )
 
-        @allocator = Spree::Config.stock.allocator_class.new(@availability)
+        @allocator = Spree::Config.stock.allocator_class.new(availability)
       end
 
       def shipments
-        @shipments ||= build_shipments
+        @shipments ||= begin
+          @packages = build_packages
+          shipments = build_shipments
+
+          # Make sure we don't add the proposed shipments to the order
+          order.shipments = order.shipments - shipments
+
+          shipments
+        end
       end
 
       private
 
+      def load_stock_locations
+        Spree::StockLocation.all
+      end
+
       def build_shipments
+        # Turn the Stock::Packages into a Shipment with rates
+        packages.map do |package|
+          shipment = package.shipment = package.to_shipment
+          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
+          shipment
+        end
+      end
+
+      def build_packages
         # Allocate any available on hand inventory and remaining desired inventory from backorders
-        on_hand_packages, backordered_packages, leftover = @allocator.allocate_inventory(@desired)
+        on_hand_packages, backordered_packages, leftover = allocator.allocate_inventory(desired)
 
         raise Spree::Order::InsufficientStock.new(items: leftover.quantities) unless leftover.empty?
 
-        packages = @stock_locations.map do |stock_location|
+        packages = stock_locations.map do |stock_location|
           # Combine on_hand and backorders into a single package per-location
           on_hand = on_hand_packages[stock_location.id] || Spree::StockQuantities.new
           backordered = backordered_packages[stock_location.id] || Spree::StockQuantities.new
@@ -71,19 +97,7 @@ module Spree
         end.compact
 
         # Split the packages
-        packages = split_packages(packages)
-
-        # Turn the Stock::Packages into a Shipment with rates
-        shipments = packages.map do |package|
-          shipment = package.shipment = package.to_shipment
-          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
-          shipment
-        end
-
-        # Make sure we don't add the proposed shipments to the order
-        order.shipments = order.shipments - shipments
-
-        shipments
+        split_packages(packages)
       end
 
       def split_packages(initial_packages)
@@ -96,7 +110,7 @@ module Spree
       def get_units(quantities)
         # Change our raw quantities back into inventory units
         quantities.flat_map do |variant, quantity|
-          @inventory_units_by_variant[variant].shift(quantity)
+          inventory_units_by_variant[variant].shift(quantity)
         end
       end
     end

data/app/models/spree/stock_item.rb

@@ -21,6 +21,7 @@ module Spree
     after_touch { variant.touch }
 
     self.allowed_ransackable_attributes = ['count_on_hand', 'stock_location_id']
+    self.allowed_ransackable_associations = %w[variant]
 
     # @return [Array<Spree::InventoryUnit>] the backordered inventory units
     #   associated with this stock item

data/app/models/spree/stock_location.rb

@@ -39,7 +39,7 @@ module Spree
 
     # Wrapper for creating a new stock item respecting the backorderable config
     def propagate_variant(variant)
-      stock_items.create!(variant: variant, backorderable: backorderable_default)
+      stock_items.create!(variant:, backorderable: backorderable_default)
     end
 
     # Return either an existing stock item or create a new one. Useful in
@@ -55,7 +55,7 @@ module Spree
     #
     # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
     def stock_item(variant_id)
-      stock_items.where(variant_id: variant_id).order(:id).first
+      stock_items.where(variant_id:).order(:id).first
     end
 
     # Attempts to look up StockItem for the variant, and creates one if not found.
@@ -101,8 +101,8 @@ module Spree
       if quantity < 1 && !stock_item(variant)
         raise InvalidMovementError.new(I18n.t('spree.negative_movement_absent_item'))
       end
-      stock_item_or_create(variant).stock_movements.create!(quantity: quantity,
-                                                            originator: originator)
+      stock_item_or_create(variant).stock_movements.create!(quantity:,
+                                                            originator:)
     end
 
     def fill_status(variant, quantity)
@@ -121,7 +121,7 @@ module Spree
 
     def ensure_one_default
       if default
-        Spree::StockLocation.where(default: true).where.not(id: id).find_each do |stock_location|
+        Spree::StockLocation.where(default: true).where.not(id:).find_each do |stock_location|
           stock_location.default = false
           stock_location.save!
         end

data/app/models/spree/store.rb

@@ -22,6 +22,8 @@ module Spree
     validates :url, presence: true
     validates :mail_from_address, presence: true
 
+    self.allowed_ransackable_attributes = %w[name url code]
+
     before_save :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
@@ -56,7 +58,7 @@ module Spree
 
     def ensure_default_exists_and_is_unique
       if default
-        Spree::Store.where.not(id: id).update_all(default: false)
+        Spree::Store.where.not(id:).update_all(default: false)
       elsif Spree::Store.where(default: true).count == 0
         self.default = true
       end

data/app/models/spree/store_credit.rb

@@ -40,6 +40,8 @@ class Spree::StoreCredit < Spree::PaymentSource
   extend Spree::DisplayMoney
   money_methods :amount, :amount_used, :amount_authorized
 
+  alias_method :display_number, :category_name
+
   # Sets this store credit's amount to a new value,
   # parsing it as a localized number if the new value is a string.
   #
@@ -56,7 +58,7 @@ class Spree::StoreCredit < Spree::PaymentSource
   def authorize(amount, order_currency, options = {})
     authorization_code = options[:action_authorization_code]
     if authorization_code
-      if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+      if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code:)
         # Don't authorize again on capture
         return true
       end
@@ -90,7 +92,7 @@ class Spree::StoreCredit < Spree::PaymentSource
 
   def capture(amount, authorization_code, order_currency, options = {})
     return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
-    auth_event = store_credit_events.find_by!(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+    auth_event = store_credit_events.find_by!(action: AUTHORIZE_ACTION, authorization_code:)
 
     if amount <= auth_event.amount
       if currency != order_currency
@@ -115,7 +117,7 @@ class Spree::StoreCredit < Spree::PaymentSource
   end
 
   def void(authorization_code, options = {})
-    if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+    if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code:)
       update!({
         action: VOID_ACTION,
         action_amount: auth_event.amount,
@@ -133,7 +135,7 @@ class Spree::StoreCredit < Spree::PaymentSource
 
   def credit(amount, authorization_code, order_currency, options = {})
     # Find the amount related to this authorization_code in order to add the store credit back
-    capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
+    capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code:)
 
     if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
       errors.add(:base, I18n.t('spree.store_credit.currency_mismatch'))
@@ -219,25 +221,25 @@ class Spree::StoreCredit < Spree::PaymentSource
 
   def create_credit_record_params(amount)
     {
-      amount: amount,
-      user_id: user_id,
-      category_id: category_id,
-      created_by_id: created_by_id,
-      currency: currency,
-      type_id: type_id,
+      amount:,
+      user_id:,
+      category_id:,
+      created_by_id:,
+      currency:,
+      type_id:,
       memo: credit_allocation_memo
     }
   end
 
   def credit_allocation_memo
-    I18n.t("spree.store_credit.credit_allocation_memo", id: id)
+    I18n.t("spree.store_credit.credit_allocation_memo", id:)
   end
 
   def store_event
     return unless saved_change_to_amount? || saved_change_to_amount_used? || saved_change_to_amount_authorized? || [ELIGIBLE_ACTION, INVALIDATE_ACTION].include?(action)
 
     event = if action
-      store_credit_events.build(action: action)
+      store_credit_events.build(action:)
     else
       store_credit_events.where(action: ALLOCATION_ACTION).first_or_initialize
     end
@@ -245,10 +247,10 @@ class Spree::StoreCredit < Spree::PaymentSource
     event.update!({
       amount: action_amount || amount,
       authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
-      amount_remaining: amount_remaining,
-      user_total_amount: user.available_store_credit_total(currency: currency),
+      amount_remaining:,
+      user_total_amount: user.available_store_credit_total(currency:),
       originator: action_originator,
-      store_credit_reason: store_credit_reason
+      store_credit_reason:
     })
   end
 

data/app/models/spree/store_credit_event.rb

@@ -3,6 +3,7 @@
 module Spree
   class StoreCreditEvent < Spree::Base
     include Spree::SoftDeletable
+    include Metadata
 
     belongs_to :store_credit, optional: true
     belongs_to :originator, polymorphic: true, optional: true
@@ -33,15 +34,15 @@ module Spree
     end
 
     def display_amount
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, { currency: })
     end
 
     def display_user_total_amount
-      Spree::Money.new(user_total_amount, { currency: currency })
+      Spree::Money.new(user_total_amount, { currency: })
     end
 
     def display_remaining_amount
-      Spree::Money.new(amount_remaining, { currency: currency })
+      Spree::Money.new(amount_remaining, { currency: })
     end
 
     def display_event_date

data/app/models/spree/store_credit_reason.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
 class Spree::StoreCreditReason < Spree::Base
-  include Spree::NamedType
+  scope :active, -> { where(active: true) }
+  default_scope -> { order(arel_table[:name].lower) }
+
+  validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
   has_many :store_credit_events, inverse_of: :store_credit_reason
+
+  self.allowed_ransackable_attributes = %w[name]
 end

data/app/models/spree/store_selector/by_server_name.rb

@@ -25,7 +25,7 @@ module Spree
         store = Spree::Store.where(url: server_name).or(Store.where(default: true)).order(default: :asc).first
 
         # Provide a fallback, mostly for legacy/testing purposes
-        store || Spree::Store.new
+        store || Spree::Store.new(url: server_name)
       end
     end
   end

data/app/models/spree/tax/tax_helpers.rb

@@ -5,11 +5,22 @@ module Spree
     module TaxHelpers
       private
 
+      # Select active rates matching tax category and address
+      #
+      # @private
+      # @param [Spree::LineItem, Spree::Shipment, Spree::ShippingRate] item
+      #   the line item, shipment, or shipping rate to select rates for
+      # @return [Array<Spree::TaxRate>] the active Tax Rates that match both
+      #   Tax Category and the item's order's tax address
       def rates_for_item(item)
         @rates_for_item ||= Spree::TaxRate.item_level.for_address(item.order.tax_address)
+        # try is used here to ensure that a LineItem has rates selected for the
+        # currently configured Tax Category. Shipments and ShippingRates do not
+        # implement variant_tax_category_id, so try is necessary instead of .&
+        tax_category_id = item.try(:variant_tax_category_id) || item.tax_category_id
 
         @rates_for_item.select do |rate|
-          rate.active? && rate.tax_categories.map(&:id).include?(item.tax_category_id)
+          rate.active? && rate.tax_categories.map(&:id).include?(tax_category_id)
         end
       end
     end

data/app/models/spree/tax_calculator/default.rb

@@ -46,7 +46,7 @@ module Spree
           Spree::Tax::ItemTax.new(
             label: rate.adjustment_label(amount),
             tax_rate: rate,
-            amount: amount,
+            amount:,
             included_in_price: rate.included_in_price
           )
         end
@@ -89,7 +89,7 @@ module Spree
             item_id: item.id,
             label: rate.adjustment_label(amount),
             tax_rate: rate,
-            amount: amount,
+            amount:,
             included_in_price: rate.included_in_price
           )
         end
@@ -99,7 +99,7 @@ module Spree
       # @return [Array<Spree::TaxRate>] rates that apply to an order
       def rates_for_order
         tax_category_ids = Set[
-          *@order.line_items.map(&:tax_category_id),
+          *@order.line_items.map(&:variant_tax_category_id),
           *@order.shipments.map(&:tax_category_id)
         ]
         rates = Spree::TaxRate.active.order_level.for_address(@order.tax_address)

data/app/models/spree/tax_calculator/shipping_rate.rb

@@ -35,7 +35,7 @@ module Spree
             item_id: shipping_rate.id,
             label: rate.adjustment_label(amount),
             tax_rate: rate,
-            amount: amount
+            amount:
           )
         end
       end

data/app/models/spree/tax_category.rb

@@ -4,6 +4,8 @@ module Spree
   class TaxCategory < Spree::Base
     include Spree::SoftDeletable
 
+    self.allowed_ransackable_attributes = %w[name description]
+
     after_discard do
       self.tax_rate_tax_categories = []
     end
@@ -28,7 +30,7 @@ module Spree
 
     def ensure_one_default
       if is_default
-        Spree::TaxCategory.where(is_default: true).where.not(id: id).update_all(is_default: false, updated_at: Time.current)
+        Spree::TaxCategory.where(is_default: true).where.not(id:).update_all(is_default: false, updated_at: Time.current)
       end
     end
   end

data/app/models/spree/tax_rate.rb

@@ -11,10 +11,10 @@ module Spree
     include Spree::CalculatedAdjustments
     include Spree::AdjustmentSource
 
-    enum level: {
+    enum :level, {
       item: 0,
       order: 1
-    }, _suffix: true
+    }, suffix: true
 
     belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates, optional: true
 
@@ -37,7 +37,7 @@ module Spree
     # Finds all tax rates whose zones match a given address
     scope :for_address, ->(address) { joins(:zone).merge(Spree::Zone.for_address(address)) }
     scope :for_country,
-          ->(country) { for_address(Spree::Tax::TaxLocation.new(country: country)) }
+          ->(country) { for_address(Spree::Tax::TaxLocation.new(country:)) }
     scope :active, -> do
       table = arel_table
       time = Time.current
@@ -113,6 +113,10 @@ module Spree
       )
     end
 
+    def display_amount
+      amount_for_adjustment_label
+    end
+
     private
 
     def amount_for_adjustment_label

data/app/models/spree/taxon.rb

@@ -4,6 +4,9 @@ require 'spree/core/product_filters'
 
 module Spree
   class Taxon < Spree::Base
+    extend FriendlyId
+    friendly_id :permalink, use: :history, slug_column: :permalink
+
     acts_as_nested_set dependent: :destroy
 
     belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
@@ -13,8 +16,7 @@ module Spree
     has_many :promotion_rule_taxons
     has_many :promotion_rules, through: :promotion_rule_taxons
 
-    before_create :set_permalink
-    before_update :set_permalink
+    before_save :set_permalink
     after_update :update_child_permalinks, if: :saved_change_to_permalink?
 
     validates :name, presence: true
@@ -121,6 +123,24 @@ module Spree
       end
     end
 
+    # override for {FriendlyId::Slugged#should_generate_new_friendly_id?} method,
+    # to control exactly when new friendly ids are set or updated
+    def should_generate_new_friendly_id?
+      permalink_changed? || super
+    end
+
+    # override for {FriendlyId::Slugged#normalize_friendly_id} method,
+    # to control over the slug format
+    def normalize_friendly_id(value)
+      return '' if value.blank?
+
+      parts = value.to_s.split('/')
+      last_word = parts.pop
+      corrected_last_word = Spree::Config.taxon_url_parametizer_class.parameterize(last_word)
+
+      (parts << corrected_last_word).join('/')
+    end
+
     private
 
     def touch_ancestors_and_taxonomy

data/app/models/spree/taxon_brand_selector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  class TaxonBrandSelector
+    BRANDS_TAXONOMY_NAME = "Brands"
+
+    def initialize(product)
+      @product = product
+    end
+
+    def call
+      product.taxons
+             .joins(:taxonomy)
+             .where(spree_taxonomies: { name: BRANDS_TAXONOMY_NAME })
+             .first
+    end
+
+    private
+
+    attr_reader :product
+  end
+end

data/app/models/spree/taxonomy.rb

@@ -21,11 +21,11 @@ module Spree
     def set_name
       if root
         root.update_columns(
-          name: name,
+          name:,
           updated_at: Time.current
         )
       else
-        self.root = Spree::Taxon.create!(taxonomy_id: id, name: name)
+        self.root = Spree::Taxon.create!(taxonomy_id: id, name:)
       end
     end
   end

data/app/models/spree/unauthorized_redirect_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  # This service object is responsible for handling unauthorized redirects
+  class UnauthorizedRedirectHandler
+    # @param controller [ApplicationController] an instance of ApplicationController
+    #  or its subclasses.
+    def initialize(controller)
+      @controller = controller
+    end
+
+    # This method is responsible for handling unauthorized redirects
+    def call
+      flash[:error] = I18n.t('spree.authorization_failure')
+      redirect_back(fallback_location: "/unauthorized")
+    end
+
+    private
+
+    attr_reader :controller
+
+    delegate :flash, :redirect_back, to: :controller
+  end
+end

data/app/models/spree/unit_cancel.rb

@@ -20,10 +20,9 @@ class Spree::UnitCancel < Spree::Base
 
     self.adjustment = inventory_unit.line_item.adjustments.create!(
       source: self,
-      amount: amount,
+      amount:,
       order: inventory_unit.order,
       label: "#{I18n.t('spree.cancellation')} - #{reason}",
-      eligible: true,
       finalized: true
     )
 

data/app/models/spree/user_address.rb

@@ -6,7 +6,7 @@ module Spree
     belongs_to :address, class_name: "Spree::Address", optional: true
 
     validates_uniqueness_of :address_id, scope: :user_id
-    validates_uniqueness_of :user_id, conditions: -> { active.default_shipping }, message: :default_address_exists, if: :default?
+    validates_uniqueness_of :user_id, conditions: -> { default_shipping }, message: :default_address_exists, if: :default?
 
     scope :with_address_values, ->(address_attributes) do
       joins(:address).merge(
@@ -14,10 +14,16 @@ module Spree
       )
     end
 
-    scope :all_historical, -> { unscope(where: :archived) }
+    scope :all_historical, -> {
+      Spree.deprecator.warn("The 'Spree::UserAddress.all_historical` scope does not do anything and will be removed from Solidus 5.")
+      all
+    }
     scope :default_shipping, -> { where(default: true) }
     scope :default_billing, -> { where(default_billing: true) }
-    scope :active, -> { where(archived: false) }
+    scope :active, -> {
+      Spree.deprecator.warn("The 'Spree::UserAddress.active` scope does not do anything and will be removed from Solidus 5.")
+      all
+    }
 
     default_scope -> { order([default: :desc, updated_at: :desc]) }
   end

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

@@ -10,6 +10,10 @@ module Spree
             order(Arel.sql("COALESCE((SELECT COUNT(*) FROM  #{Spree::LineItem.quoted_table_name} GROUP BY #{Spree::LineItem.quoted_table_name}.variant_id HAVING #{Spree::LineItem.quoted_table_name}.variant_id = #{Spree::Variant.quoted_table_name}.id), 0) DESC"))
           }
 
+          scope :by_stock_location, ->(stock_location_id) {
+            joins(:stock_locations).where(spree_stock_locations: { id: stock_location_id })
+          }
+
           class << self
             # Returns variants that match a given option value
             #

data/app/models/spree/variant/vat_price_generator.rb

@@ -41,7 +41,7 @@ module Spree
       def find_or_initialize_price_by(country_iso, currency)
         variant.prices.detect do |price|
           price.country_iso == country_iso && price.currency == currency
-        end || variant.prices.build(country_iso: country_iso, currency: currency)
+        end || variant.prices.build(country_iso:, currency:)
       end
 
       # nil is added to the array so we always have an export price.