solidus_core 3.0.0 → 4.5.1

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,16 @@ 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.
+  #
+  # @param number [String, #to_d] a new amount
+  def amount=(number)
+    self[:amount] = Spree::LocalizedNumber.parse(number)
+  end
+
   def amount_remaining
     return 0.0.to_d if invalidated?
     amount - amount_used - amount_authorized
@@ -48,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
@@ -82,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
@@ -107,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,
@@ -125,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'))
@@ -150,7 +160,12 @@ class Spree::StoreCredit < Spree::PaymentSource
   end
 
   def generate_authorization_code
-    "#{id}-SC-#{Time.current.utc.strftime('%Y%m%d%H%M%S%6N')}"
+    [
+      id,
+      'SC',
+      Time.current.utc.strftime('%Y%m%d%H%M%S%6N'),
+      SecureRandom.uuid
+    ].join('-')
   end
 
   def editable?
@@ -206,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
@@ -232,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_prioritizer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  class StoreCreditPrioritizer
+    def initialize(credits, _order)
+      @credits = credits
+    end
+
+    def call
+      credits.order_by_priority
+    end
+
+    private
+
+    attr_reader :credits
+  end
+end

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/item_tax.rb

@@ -5,9 +5,10 @@ module Spree
     # Simple object used to hold tax data for an item.
     #
     # This generic object will hold the amount of tax that should be applied to
-    # an item. (Either a {Spree::LineItem} or a {Spree::Shipment}.)
+    # an item. (Either a {Spree::Order}, a {Spree::LineItem} or a {Spree::Shipment}.)
     #
-    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID
+    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID.
+    #   Or blank if an order-level tax.
     # @attr_reader [String] label information about the taxes
     # @attr_reader [Spree::TaxRate] tax_rate will be used as the source for tax
     #   adjustments

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

@@ -8,13 +8,15 @@ module Spree
     # adjustments on an order.
     #
     # @attr_reader [Integer] order_id the {Spree::Order} these taxes apply to
+    # @attr_reader [Array<Spree::Tax::ItemTax>] order_taxes an array of tax
+    #   data for the order
     # @attr_reader [Array<Spree::Tax::ItemTax>] line_item_taxes an array of
     #   tax data for order's line items
     # @attr_reader [Array<Spree::Tax::ItemTax>] shipment_taxes an array of
     #   tax data for the order's shipments
     class OrderTax
       include ActiveModel::Model
-      attr_accessor :order_id, :line_item_taxes, :shipment_taxes
+      attr_accessor :order_id, :order_taxes, :line_item_taxes, :shipment_taxes
     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_order ||= Spree::TaxRate.for_address(item.order.tax_address)
+        @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_order.select do |rate|
-          rate.active? && rate.tax_categories.map(&:id).include?(item.tax_category_id)
+        @rates_for_item.select do |rate|
+          rate.active? && rate.tax_categories.map(&:id).include?(tax_category_id)
         end
       end
     end

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

@@ -8,7 +8,7 @@ module Spree
     # @attr_reader [Integer] country_id the ID of a Spree::Country object
     # @attr_reader [Integer] state_id the ID of a Spree::State object
     class TaxLocation
-      attr_reader :country_id, :state_id
+      attr_reader :country, :state
 
       # Create a new TaxLocation object
       #
@@ -19,18 +19,15 @@ module Spree
       #
       # @return [Spree::Tax::TaxLocation] a Spree::Tax::TaxLocation object
       def initialize(country: nil, state: nil)
-        @country_id = country && country.id
-        @state_id = state && state.id
+        @country, @state = country, state
       end
+      delegate :id, to: :state, prefix: true, allow_nil: true
+      delegate :id, to: :country, prefix: true, allow_nil: true
 
       def ==(other)
         state_id == other.state_id && country_id == other.country_id
       end
 
-      def country
-        Spree::Country.find_by(id: country_id)
-      end
-
       def empty?
         country_id.nil? && state_id.nil?
       end

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

@@ -25,6 +25,7 @@ module Spree
       def calculate
         Spree::Tax::OrderTax.new(
           order_id: order.id,
+          order_taxes: order_rates,
           line_item_taxes: line_item_rates,
           shipment_taxes: shipment_rates
         )
@@ -34,6 +35,23 @@ module Spree
 
       attr_reader :order
 
+      # Calculate the order-level taxes.
+      #
+      # @private
+      # @return [Array<Spree::Tax::ItemTax>] calculated taxes for the order
+      def order_rates
+        rates_for_order.map do |rate|
+          amount = rate.compute_amount(order)
+
+          Spree::Tax::ItemTax.new(
+            label: rate.adjustment_label(amount),
+            tax_rate: rate,
+            amount:,
+            included_in_price: rate.included_in_price
+          )
+        end
+      end
+
       # Calculate the taxes for line items.
       #
       # @private
@@ -71,11 +89,24 @@ 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
       end
+
+      # @private
+      # @return [Array<Spree::TaxRate>] rates that apply to an order
+      def rates_for_order
+        tax_category_ids = Set[
+          *@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)
+        rates.select do |rate|
+          tax_category_ids.intersect?(rate.tax_category_ids.to_set)
+        end
+      end
     end
   end
 end

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

@@ -9,7 +9,7 @@ module Spree
     # looking to provide their own calculator should adhere to the API of this
     # class.
     #
-    # @see Spree::Tax::ShippingRateTaxer
+    # @see Spree::Stock::Estimator
     class ShippingRate
       include Spree::Tax::TaxHelpers
 
@@ -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,6 +11,11 @@ module Spree
     include Spree::CalculatedAdjustments
     include Spree::AdjustmentSource
 
+    enum :level, {
+      item: 0,
+      order: 1
+    }, suffix: true
+
     belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates, optional: true
 
     has_many :tax_rate_tax_categories,
@@ -27,10 +32,12 @@ module Spree
 
     validates :amount, presence: true, numericality: true
 
+    self.allowed_ransackable_associations = %w[tax_categories zone]
+
     # 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
@@ -106,6 +113,10 @@ module Spree
       )
     end
 
+    def display_amount
+      amount_for_adjustment_label
+    end
+
     private
 
     def amount_for_adjustment_label
@@ -116,6 +127,8 @@ module Spree
     end
 
     def translation_key(_amount)
+      return "flat_fee" if calculator.is_a?(Spree::Calculator::FlatFee)
+
       key = included_in_price? ? "vat" : "sales_tax"
       key += "_with_rate" if show_rate_in_label?
       key.to_sym

data/app/models/spree/taxon/active_storage_attachment.rb

@@ -6,8 +6,8 @@ module Spree::Taxon::ActiveStorageAttachment
 
   included do
     has_attachment :icon,
-                   styles: { mini: '32x32>', normal: '128x128>' },
-                   default_style: :mini
+                   styles: Spree::Config.taxon_image_styles,
+                   default_style: Spree::Config.taxon_image_style_default
     validate :icon_is_an_image
   end
 end

data/app/models/spree/taxon/paperclip_attachment.rb

@@ -5,14 +5,14 @@ module Spree::Taxon::PaperclipAttachment
 
   included do
     has_attached_file :icon,
-      styles: { mini: '32x32>', normal: '128x128>' },
-      default_style: :mini,
+      styles: Spree::Config.taxon_image_styles,
+      default_style: Spree::Config.taxon_image_style_default,
       url: '/spree/taxons/:id/:style/:basename.:extension',
       path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
       default_url: '/assets/default_taxon.png'
 
     validates_attachment :icon,
-      content_type: { content_type: %w[image/jpg image/jpeg image/png image/gif] }
+      content_type: { content_type: Spree::Config.allowed_image_mime_types }
   end
 
   def icon_present?
@@ -25,6 +25,6 @@ module Spree::Taxon::PaperclipAttachment
     attached_file = send(definition)
     return false unless attached_file.exists?
 
-    attached_file.destroy
+    attached_file.destroy && save
   end
 end

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,21 +16,22 @@ 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
+    validates :name, uniqueness: { scope: :parent_id, message: :must_be_unique_under_same_parent }
     validates :meta_keywords, length: { maximum: 255 }
     validates :meta_description, length: { maximum: 255 }
     validates :meta_title, length: { maximum: 255 }
+    validates :taxonomy_id, uniqueness: { scope: :parent_id, message: :can_have_only_one_root }, if: -> { root? }
 
     after_save :touch_ancestors_and_taxonomy
     after_touch :touch_ancestors_and_taxonomy
 
     include ::Spree::Config.taxon_attachment_module
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     # @return [String] meta_title if set otherwise a string containing the
     #   root name and taxon name
@@ -119,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

@@ -5,6 +5,7 @@ module Spree
     acts_as_list
 
     validates :name, presence: true
+    validates :name, uniqueness: true
 
     has_many :taxons, inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
@@ -13,18 +14,18 @@ module Spree
 
     default_scope -> { order(position: :asc) }
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     private
 
     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/user_last_url_storer/rules/authentication_rule.rb

@@ -4,7 +4,7 @@ module Spree
   class UserLastUrlStorer
     module Rules
       # This is the basic rule that ships with Solidus that avoids storing in
-      # session the current path for login/loout/signup routes, avoiding possibly
+      # session the current path for login/logout/signup routes, avoiding possibly
       # infinte redirects.
       module AuthenticationRule
         AUTHENTICATION_ROUTES = %w[spree_signup_path spree_login_path spree_logout_path]