solidus_core 3.0.0 → 4.5.1

data/app/mailers/spree/base_mailer.rb

@@ -11,7 +11,7 @@ module Spree
     end
 
     def money(amount, currency = Spree::Config[:currency])
-      Spree::Money.new(amount, currency: currency).to_s
+      Spree::Money.new(amount, currency:).to_s
     end
     helper_method :money
 

data/app/mailers/spree/carton_mailer.rb

@@ -19,7 +19,7 @@ module Spree
       @store = @order.store
       subject = (options[:resend] ? "[#{t('spree.resend').upcase}] " : '')
       subject += "#{@store.name} #{t('spree.shipment_mailer.shipped_email.subject')} ##{@order.number}"
-      mail(to: @order.email, from: from_address(@store), subject: subject)
+      mail(to: @order.email, from: from_address(@store), subject:)
     end
   end
 end

data/app/mailers/spree/order_mailer.rb

@@ -7,7 +7,7 @@ module Spree
       @store = @order.store
       subject = build_subject(t('.subject'), resend)
 
-      mail(to: @order.email, bcc: bcc_address(@store), from: from_address(@store), subject: subject)
+      mail(to: @order.email, bcc: bcc_address(@store), from: from_address(@store), subject:)
     end
 
     def cancel_email(order, resend = false)
@@ -15,7 +15,7 @@ module Spree
       @store = @order.store
       subject = build_subject(t('.subject'), resend)
 
-      mail(to: @order.email, from: from_address(@store), subject: subject)
+      mail(to: @order.email, from: from_address(@store), subject:)
     end
 
     def inventory_cancellation_email(order, inventory_units, resend = false)
@@ -23,7 +23,7 @@ module Spree
       @store = @order.store
       subject = build_subject(t('spree.order_mailer.inventory_cancellation.subject'), resend)
 
-      mail(to: @order.email, from: from_address(@store), subject: subject)
+      mail(to: @order.email, from: from_address(@store), subject:)
     end
 
     private

data/app/mailers/spree/reimbursement_mailer.rb

@@ -7,7 +7,7 @@ module Spree
       store = @reimbursement.order.store
       subject = (resend ? "[#{t('spree.resend').upcase}] " : '')
       subject += "#{store.name} #{t('.subject')} ##{@reimbursement.order.number}"
-      mail(to: @reimbursement.order.email, from: from_address(store), subject: subject)
+      mail(to: @reimbursement.order.email, from: from_address(store), subject:)
     end
   end
 end

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

@@ -4,14 +4,16 @@ require 'mini_magick'
 
 module Spree
   module ActiveStorageAdapter
-    # Decorares AtiveStorage attachment to add methods exptected by Solidus'
+    # Decorates ActiveStorage attachment to add methods expected by Solidus'
     # Paperclip-oriented attachment support.
     class Attachment
       delegate_missing_to :@attachment
 
+      attr_reader :attachment
+
       def initialize(attachment, styles: {})
         @attachment = attachment
-        @styles = normalize_styles(styles)
+        @transformations = styles_to_transformations(styles)
       end
 
       def exists?
@@ -27,11 +29,13 @@ module Spree
       end
 
       def variant(style = nil)
-        size = style_to_size(style)
-        @attachment.variant(
-          resize_to_limit: size,
-          strip: true
-        ).processed
+        transformation = @transformations[style] || default_transformation(width, height)
+
+        @attachment.variant({
+          saver: {
+            strip: true
+          }
+        }.merge(transformation)).processed
       end
 
       def height
@@ -55,14 +59,29 @@ 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 normalize_styles(styles)
-        styles.transform_values { |v| v.split('x') }
+      def styles_to_transformations(styles)
+        styles.transform_values(&method(:imagemagick_to_image_processing_definition))
+      end
+
+      def imagemagick_to_image_processing_definition(definition)
+        width_height = definition.split('x').map(&:to_i)
+
+        case definition[-1].to_sym
+        when :^
+          { resize_to_fill: width_height }
+        else
+          default_transformation(*width_height)
+        end
       end
 
-      def style_to_size(style)
-        @styles.fetch(style&.to_sym) { [width, height] }
+      def default_transformation(width, height)
+        { resize_to_limit: [width, height] }
       end
     end
   end

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

@@ -32,7 +32,7 @@ module Spree
                    end
         attachable.rewind
 
-        { io: attachable, filename: filename }
+        { io: attachable, filename: }
       end
     end
   end

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

@@ -7,23 +7,6 @@ module Spree
     extend ActiveSupport::Concern
     include Spree::ActiveStorageAdapter::Normalization
 
-    included do
-      next if Rails.gem_version >= Gem::Version.new('6.1.0.alpha')
-
-      abort <<~MESSAGE
-        Configuration Error: Solidus ActiveStorage attachment adpater requires Rails >= 6.1.0.
-
-        Spree::Config.image_attachment_module preference is set to #{Spree::Config.image_attachment_module}
-        Spree::Config.taxon_attachment_module preference is set to #{Spree::Config.taxon_attachment_module}
-        Rails version is #{Rails.gem_version}
-
-        To solve the problem you can upgrade to a Rails version greater than or equal to 6.1.0
-        or use legacy Paperclip attachment adapter by editing `config/initialiers/spree/rb`:
-        config.image_attachment_module = 'Spree::Image::PaperclipAttachment'
-        config.taxon_attachment_module = 'Spree::Taxon::PaperclipAttachment'
-      MESSAGE
-    end
-
     class_methods do
       attr_reader :attachment_name
       attr_reader :attachment_definition
@@ -51,7 +34,7 @@ module Spree
         method_name = attachment_name
         override = Module.new do
           define_method method_name do |*args|
-            attachment = Attachment.new(super(), styles: styles)
+            attachment = Attachment.new(super(), styles:)
             if args.empty?
               attachment
             else

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

@@ -5,20 +5,40 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_one :default_price,
-        -> { with_discarded.currently_valid.with_default_attributes },
-        class_name: 'Spree::Price',
-        inverse_of: :variant,
-        dependent: :destroy,
-        autosave: true
+      delegate :display_price, :display_amount, :price, to: :default_price, allow_nil: true
+      delegate :price=, to: :default_price_or_build
+
+      # @see Spree::Variant::PricingOptions.default_price_attributes
+      def self.default_price_attributes
+        Spree::Config.default_pricing_options.desired_attributes
+      end
     end
 
-    def find_or_build_default_price
-      default_price || build_default_price(Spree::Config.default_pricing_options.desired_attributes)
+    # Returns {#default_price} or builds it from {Spree::Variant.default_price_attributes}
+    #
+    # @return [Spree::Price, nil]
+    # @see Spree::Variant.default_price_attributes
+    def default_price_or_build
+      default_price ||
+        prices.build(self.class.default_price_attributes)
     end
 
-    delegate :display_price, :display_amount, :price, to: :find_or_build_default_price
-    delegate :price=, to: :find_or_build_default_price
+    # Select from {#prices} the one to be considered as the default
+    #
+    # This method works with the in-memory association, so non-persisted prices
+    # are taken into account.
+    #
+    # A price is a candidate to be considered as the default when it meets
+    # {Spree::Variant.default_price_attributes} criteria. When more than one candidate is
+    # found, non-persisted records take preference. When more than one persisted
+    # candidate exists, the one most recently updated is taken or, in case of
+    # race condition, the one with higher id.
+    #
+    # @return [Spree::Price, nil]
+    # @see Spree::Variant.default_price_attributes
+    def default_price
+      price_selector.price_for_options(Spree::Config.default_pricing_options)
+    end
 
     def has_default_price?
       default_price.present? && !default_price.discarded?

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

@@ -24,7 +24,7 @@ module Spree
         money_method = { money_method => {} } unless money_method.is_a? Hash
         money_method.each do |method_name, opts|
           define_method("display_#{method_name}") do
-            default_opts = respond_to?(:currency) ? { currency: currency } : {}
+            default_opts = respond_to?(:currency) ? { currency: } : {}
             Spree::Money.new(send(method_name), default_opts.merge(opts))
           end
         end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Spree
+  module Metadata
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :customer_metadata, :json, default: {}
+      attribute :admin_metadata, :json, default: {}
+
+      validate :validate_metadata_limits, if: :validate_metadata_enabled?
+    end
+
+    class_methods do
+      def meta_data_columns
+        %i[customer_metadata admin_metadata]
+      end
+    end
+
+    private
+
+    def validate_metadata_enabled?
+      Spree::Config.meta_data_validation_enabled
+    end
+
+    def validate_metadata_limits
+      self.class.meta_data_columns.each { |column| validate_metadata_column(column) }
+    end
+
+    def validate_metadata_column(column)
+      config = Spree::Config
+      metadata = send(column)
+
+      return if metadata.nil?
+
+      # Check for maximum number of keys
+      validate_metadata_keys_count(metadata, column, config.meta_data_max_keys)
+
+      # Check for maximum key and value size
+      metadata.each do |key, value|
+        validate_metadata_key(key, column, config.meta_data_max_key_length)
+        validate_metadata_value(key, value, column, config.meta_data_max_value_length)
+      end
+    end
+
+    def validate_metadata_keys_count(metadata, column, max_keys)
+      return unless metadata.keys.count > max_keys
+
+      errors.add(column, "must not have more than #{max_keys} keys")
+    end
+
+    def validate_metadata_key(key, column, max_key_length)
+      return unless key.to_s.length > max_key_length
+
+      errors.add(column, "key '#{key}' exceeds #{max_key_length} characters")
+    end
+
+    def validate_metadata_value(key, value, column, max_value_length)
+      return unless value.to_s.length > max_value_length
+
+      errors.add(column, "value for key '#{key}' exceeds #{max_value_length} characters")
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
+      Spree.deprecator.warn "Spree::NamedType is deprecated. Please set scopes and validations locally instead.", caller
+
       scope :active, -> { where(active: true) }
       default_scope -> { order(arel_table[:name].lower) }
 

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

@@ -18,8 +18,8 @@ module Spree
 
     def property_name=(name)
       unless name.blank?
-        unless property = Spree::Property.find_by(name: name)
-          property = Spree::Property.create(name: name, presentation: name)
+        unless property = Spree::Property.find_by(name:)
+          property = Spree::Property.create(name:, presentation: name)
         end
         self.property = property
       end

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

@@ -3,20 +3,24 @@
 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: []
+    class_attribute :allowed_ransackable_scopes, default: []
     class_attribute :default_ransackable_attributes
     self.default_ransackable_attributes = %w[id]
   end
 
   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
+
+    def ransackable_scopes(*_args)
+      allowed_ransackable_scopes
     end
   end
 end

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

@@ -5,7 +5,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :user_addresses, -> { active }, foreign_key: "user_id", class_name: "Spree::UserAddress" do
+      has_many :user_addresses, foreign_key: "user_id", class_name: "Spree::UserAddress" do
         def find_first_by_address_values(address_attrs)
           detect { |ua| ua.address == Spree::Address.new(address_attrs) }
         end
@@ -22,7 +22,7 @@ module Spree
             end
 
             if user_address.persisted?
-              user_address.update!(column_for_default => true, archived: false)
+              user_address.update!(column_for_default => true)
             else
               user_address.write_attribute(column_for_default, true)
             end
@@ -37,6 +37,9 @@ module Spree
 
       has_one :default_user_ship_address, ->{ default_shipping }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
       has_one :ship_address, through: :default_user_ship_address, source: :address
+
+      accepts_nested_attributes_for :ship_address
+      accepts_nested_attributes_for :bill_address
     end
 
     # saves address in address book
@@ -104,13 +107,20 @@ module Spree
       return new_address unless new_address.valid?
 
       first_one = user_addresses.empty?
+      user_address = prepare_user_address(new_address)
 
       if address_attributes[:id].present? && new_address.id != address_attributes[:id]
+        if ship_address&.id == address_attributes[:id].to_i
+          user_addresses.mark_default(user_address, address_type: :shipping)
+        end
+
+        if bill_address&.id == address_attributes[:id].to_i
+          user_addresses.mark_default(user_address, address_type: :billing)
+        end
         remove_from_address_book(address_attributes[:id])
       end
 
-      user_address = prepare_user_address(new_address)
-      user_addresses.mark_default(user_address, address_type: address_type) if default || first_one
+      user_addresses.mark_default(user_address, address_type:) if default || first_one
 
       if persisted?
         user_address.save!
@@ -130,18 +140,18 @@ module Spree
     end
 
     def mark_default_ship_address(address)
-      user_addresses.mark_default(user_addresses.find_by(address: address))
+      user_addresses.mark_default(user_addresses.find_by(address:))
     end
 
     def mark_default_bill_address(address)
-      user_addresses.mark_default(user_addresses.find_by(address: address), address_type: :billing)
+      user_addresses.mark_default(user_addresses.find_by(address:), address_type: :billing)
     end
 
     def remove_from_address_book(address_id)
-      user_address = user_addresses.find_by(address_id: address_id)
+      user_address = user_addresses.find_by(address_id:)
       if user_address
         remove_user_address_reference(address_id)
-        user_address.update(archived: true, default: false)
+        user_address.destroy!
       else
         false
       end
@@ -150,10 +160,9 @@ module Spree
     private
 
     def prepare_user_address(new_address)
-      user_address = user_addresses.all_historical.find_first_by_address_values(new_address.attributes)
+      user_address = user_addresses.find_first_by_address_values(new_address.attributes)
       user_address ||= user_addresses.build
       user_address.address = new_address
-      user_address.archived = false
       user_address
     end
 

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

@@ -18,7 +18,7 @@ module Spree
       has_many :stock_locations, through: :user_stock_locations
 
       has_many :spree_orders, foreign_key: "user_id", class_name: "Spree::Order"
-      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order", dependent: :restrict_with_exception
+      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order"
 
       has_many :store_credits, -> { includes(:credit_type) }, foreign_key: "user_id", class_name: "Spree::StoreCredit"
       has_many :store_credit_events, through: :store_credits
@@ -27,12 +27,13 @@ module Spree
       has_many :wallet_payment_sources, foreign_key: 'user_id', class_name: 'Spree::WalletPaymentSource', inverse_of: :user
 
       after_create :auto_generate_spree_api_key
+      before_destroy :check_for_deletion
 
       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
@@ -57,7 +58,7 @@ module Spree
     def last_incomplete_spree_order(store: nil, only_frontend_viewable: true)
       self_orders = orders
       self_orders = self_orders.where(frontend_viewable: true) if only_frontend_viewable
-      self_orders = self_orders.where(store: store) if store
+      self_orders = self_orders.where(store:) if store
       self_orders = self_orders.where('updated_at > ?', Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
       self_orders = self_orders.where('created_at > ?', Spree::Config.completable_order_created_cutoff_days.days.ago) if Spree::Config.completable_order_created_cutoff_days
       last_order = self_orders.order(:created_at).last
@@ -72,9 +73,42 @@ module Spree
 
     def display_available_store_credit_total(currency:)
       Spree::Money.new(
-        available_store_credit_total(currency: currency),
-        currency: currency,
+        available_store_credit_total(currency:),
+        currency:,
       )
     end
+
+    # Restrict to delete users with existing orders
+    #
+    # Override this in your user model class to add another logic.
+    #
+    # Ie. to allow to delete users with incomplete orders add:
+    #
+    #   orders.complete.none?
+    #
+    def can_be_deleted?
+      orders.none?
+    end
+
+    # Updates the roles in keeping with the given ability's permissions
+    #
+    # Roles that are not accessible to the given ability will be ignored. It
+    # also ensure not to remove non accessible roles when assigning new
+    # accessible ones.
+    #
+    # @param given_roles [Spree::Role]
+    # @param ability [Spree::Ability]
+    def update_spree_roles(given_roles, ability:)
+      accessible_roles = Spree::Role.accessible_by(ability)
+      non_accessible_roles = Spree::Role.all - accessible_roles
+      new_accessible_roles = given_roles - non_accessible_roles
+      self.spree_roles = spree_roles - accessible_roles + new_accessible_roles
+    end
+
+    private
+
+    def check_for_deletion
+      raise ActiveRecord::DeleteRestrictionError unless can_be_deleted?
+    end
   end
 end

data/app/models/spree/address.rb

@@ -26,10 +26,12 @@ 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))
+    unless ActiveRecord::Relation.method_defined? :with_values # Rails 7.1+
+      scope :with_values, ->(attributes) do
+        where(value_attributes(attributes))
+      end
     end
 
     # @return [Address] an address with default attributes
@@ -95,14 +97,14 @@ module Spree
     # @return [Hash] an ActiveMerchant compatible address hash
     def active_merchant_hash
       {
-        name: name,
-        address1: address1,
-        address2: address2,
-        city: city,
+        name:,
+        address1:,
+        address2:,
+        city:,
         state: state_text,
         zip: zipcode,
         country: country.try(:iso),
-        phone: phone
+        phone:
       }
     end
 
@@ -130,7 +132,7 @@ module Spree
     # @return [Country] setter that sets self.country to the Country with a matching 2 letter iso
     # @raise [ActiveRecord::RecordNotFound] if country with the iso doesn't exist
     def country_iso=(iso)
-      self.country = Spree::Country.find_by!(iso: iso)
+      self.country = Spree::Country.find_by!(iso:)
     end
 
     def country_iso