solidus_core 2.10.5 → 3.0.8

data/app/models/spree/ability.rb

@@ -29,25 +29,12 @@ module Spree
     def initialize(current_user)
       @user = current_user || Spree.user_class.new
 
-      alias_actions
       activate_permission_sets
       register_extension_abilities
     end
 
     private
 
-    def alias_actions
-      clear_aliased_actions
-
-      # override cancan default aliasing (we don't want to differentiate between read and index)
-      alias_action :delete, to: :destroy
-      alias_action :edit, to: :update
-      alias_action :new, to: :create
-      alias_action :new_action, to: :create
-      alias_action :show, to: :read
-      alias_action :index, :read, to: :display
-    end
-
     # Before, this was the only way to extend this ability. Permission sets have been added since.
     # It is recommended to use them instead for extension purposes if possible.
     def register_extension_abilities

data/app/models/spree/address/name.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Spree
+  class Address
+    # Provides a value object to help splitting and joining
+    # name fields
+    class Name
+      attr_reader :first_name, :last_name, :value
+
+      def initialize(*components)
+        @value = components.join(' ').strip
+        initialize_name_components(components)
+      end
+
+      def to_s
+        @value
+      end
+
+      private
+
+      def initialize_name_components(components)
+        if components.size == 2
+          @first_name = components[0].to_s
+          @last_name = components[1].to_s
+        else
+          @first_name, @last_name = @value.split(/[[:space:]]/, 2)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/address/state_validator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Spree
+  class Address::StateValidator
+    attr_reader :address
+    delegate :state, :state_name, :country, to: :address
+
+    def initialize(address)
+      @address = address
+    end
+
+    def perform
+      return unless state_required?
+
+      if country.present?
+        normalize_state if state.present?
+        normalize_state_name if state_name.present?
+      end
+
+      validate_not_blank
+      validate_matches_country
+    end
+
+    private
+
+    def normalize_state
+      # discard the 'state' attribute when having a country with no states
+      address.state = nil if country.states.blank?
+    end
+
+    def normalize_state_name
+      # discard the 'state_name' when having a valid 'state' and country combo
+      if state.present? && state.country == country
+        address.state_name = nil
+        return
+      end
+
+      # set the state from the state name if the country contains one with that name
+      states_from_name = country.states.with_name_or_abbr(state_name)
+      if states_from_name.size == 1
+        address.state = states_from_name.first
+        address.state_name = nil
+      end
+    end
+
+    def validate_not_blank
+      if state.blank? && state_name.blank?
+        address.errors.add(:state, :blank)
+      end
+    end
+
+    def validate_matches_country
+      if state.present? && state.country != country
+        address.errors.add(:state, :does_not_match_country)
+      end
+    end
+
+    # Don't require a state if disabled at config level or
+    # the associated country doesn't require states
+    def state_required?
+      Spree::Config.address_requires_state && country_requires_states?
+    end
+
+    def country_requires_states?
+      # default to `true` if country not present
+      return true if country.blank?
+
+      country.states_required
+    end
+  end
+end

data/app/models/spree/address.rb

@@ -8,23 +8,25 @@ module Spree
   class Address < Spree::Base
     extend ActiveModel::ForbiddenAttributesProtection
 
+    mattr_accessor :state_validator_class
+    self.state_validator_class = Spree::Address::StateValidator
+
     belongs_to :country, class_name: "Spree::Country", optional: true
     belongs_to :state, class_name: "Spree::State", optional: true
 
-    validates :firstname, :address1, :city, :country_id, presence: true
+    validates :address1, :city, :country_id, :name, presence: true
     validates :zipcode, presence: true, if: :require_zipcode?
     validates :phone, presence: true, if: :require_phone?
 
-    validate :state_validate
-    validate :validate_state_matches_country
-
-    alias_attribute :first_name, :firstname
-    alias_attribute :last_name, :lastname
+    validate do
+      self.class.state_validator_class.new(self).perform
+    end
 
-    DB_ONLY_ATTRS = %w(id updated_at created_at)
-    TAXATION_ATTRS = %w(state_id country_id zipcode)
+    self.ignored_columns = %w(firstname lastname)
+    DB_ONLY_ATTRS = %w(id updated_at created_at).freeze
+    TAXATION_ATTRS = %w(state_id country_id zipcode).freeze
 
-    self.whitelisted_ransackable_attributes = %w[firstname lastname]
+    self.whitelisted_ransackable_attributes = %w[name]
 
     scope :with_values, ->(attributes) do
       where(value_attributes(attributes))
@@ -61,14 +63,7 @@ module Spree
     # @return [Hash] hash of attributes contributing to value equality with optional merge
     def self.value_attributes(base_attributes, merge_attributes = {})
       base = base_attributes.stringify_keys.merge(merge_attributes.stringify_keys)
-
-      # TODO: Deprecate these aliased attributes
-      base['firstname'] = base['first_name'] if base.key?('first_name')
-      base['lastname'] = base['last_name'] if base.key?('last_name')
-
-      excluded_attributes = DB_ONLY_ATTRS + %w(first_name last_name)
-
-      base.except(*excluded_attributes)
+      base.except(*DB_ONLY_ATTRS)
     end
 
     # @return [Hash] hash of attributes contributing to value equality
@@ -80,18 +75,13 @@ module Spree
       self.class.value_attributes(attributes.slice(*TAXATION_ATTRS))
     end
 
-    # @return [String] the full name on this address
-    def full_name
-      "#{firstname} #{lastname}".strip
-    end
-
     # @return [String] a string representation of this state
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
     end
 
     def to_s
-      "#{full_name}: #{address1}"
+      "#{name}: #{address1}"
     end
 
     # @note This compares the addresses based on only the fields that make up
@@ -102,35 +92,10 @@ module Spree
       value_attributes == other_address.value_attributes
     end
 
-    # @deprecated Do not use this. Use Address.== instead.
-    def same_as?(other_address)
-      Spree::Deprecation.warn("Address#same_as? is deprecated. It's equivalent to Address.==", caller)
-      self == other_address
-    end
-
-    # @deprecated Do not use this. Use Address.== instead.
-    def same_as(other_address)
-      Spree::Deprecation.warn("Address#same_as is deprecated. It's equivalent to Address.==", caller)
-      self == other_address
-    end
-
-    # @deprecated Do not use this
-    def empty?
-      Spree::Deprecation.warn("Address#empty? is deprecated.", caller)
-      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, value| value.nil? }
-    end
-
-    # This exists because the default Object#blank?, checks empty? if it is
-    # defined, and we have defined empty.
-    # This should be removed once empty? is removed
-    def blank?
-      false
-    end
-
     # @return [Hash] an ActiveMerchant compatible address hash
     def active_merchant_hash
       {
-        name: full_name,
+        name: name,
         address1: address1,
         address2: address2,
         city: city,
@@ -143,13 +108,13 @@ module Spree
 
     # @todo Remove this from the public API if possible.
     # @return [true] whether or not the address requires a phone number to be
-    #   valid
+    #   present
     def require_phone?
-      true
+      Spree::Config[:address_requires_phone]
     end
 
     # @todo Remove this from the public API if possible.
-    # @return [true] whether or not the address requires a zipcode to be valid
+    # @return [true] whether or not the address requires a zipcode to be present
     def require_zipcode?
       true
     end
@@ -171,48 +136,5 @@ module Spree
     def country_iso
       country && country.iso
     end
-
-    private
-
-    def state_validate
-      # Skip state validation without country (also required)
-      # or when disabled by preference
-      return if country.blank? || !Spree::Config[:address_requires_state]
-      return unless country.states_required
-
-      # ensure associated state belongs to country
-      if state.present?
-        if state.country == country
-          self.state_name = nil # not required as we have a valid state and country combo
-        elsif state_name.present?
-          self.state = nil
-        else
-          errors.add(:state, :invalid)
-        end
-      end
-
-      # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
-      if state_name.present?
-        if country.states.present?
-          states = country.states.with_name_or_abbr(state_name)
-
-          if states.size == 1
-            self.state = states.first
-            self.state_name = nil
-          else
-            errors.add(:state, :invalid)
-          end
-        end
-      end
-
-      # ensure at least one state field is populated
-      errors.add :state, :blank if state.blank? && state_name.blank?
-    end
-
-    def validate_state_matches_country
-      if state && state.country != country
-        errors.add(:state, :does_not_match_country)
-      end
-    end
   end
 end

data/app/models/spree/adjustment.rb

@@ -28,11 +28,6 @@ module Spree
     validates :amount, numericality: true
     validates :promotion_code, presence: true, if: :require_promotion_code?
 
-    # We need to use `after_commit` here because otherwise it's too early to
-    # tell if any repair is needed.
-    after_commit :repair_adjustments_associations_on_create, on: [:create]
-    after_commit :repair_adjustments_associations_on_destroy, on: [:destroy]
-
     scope :not_finalized, -> { where(finalized: false) }
     scope :finalized, -> { where(finalized: true) }
     scope :cancellation, -> { where(source_type: 'Spree::UnitCancel') }
@@ -135,15 +130,6 @@ module Spree
       amount
     end
 
-    def update!(*args)
-      if args.empty?
-        Spree::Deprecation.warn "Calling adjustment.update! with no arguments to recalculate amounts and eligibility is deprecated, since it conflicts with AR::Base#update! Please use adjustment.recalculate instead"
-        recalculate
-      else
-        super
-      end
-    end
-
     # Calculates based on attached promotion (if this is a promotion
     # adjustment) whether this promotion is still eligible.
     # @api private
@@ -159,21 +145,7 @@ module Spree
     private
 
     def require_promotion_code?
-      promotion? && source.promotion.codes.any?
-    end
-
-    def repair_adjustments_associations_on_create
-      if adjustable.adjustments.loaded? && !adjustable.adjustments.include?(self) && !destroyed?
-        Spree::Deprecation.warn("Adjustment #{id} was not added to #{adjustable.class} #{adjustable.id}. Add adjustments via `adjustable.adjustments.create!`. Partial call stack: #{caller.select { |line| line =~ %r(/(app|spec)/) }}.", caller)
-        adjustable.adjustments.proxy_association.add_to_target(self)
-      end
-    end
-
-    def repair_adjustments_associations_on_destroy
-      if adjustable.adjustments.loaded? && adjustable.adjustments.include?(self)
-        Spree::Deprecation.warn("Adjustment #{id} was not removed from #{adjustable.class} #{adjustable.id}. Remove adjustments via `adjustable.adjustments.destroy`. Partial call stack: #{caller.select { |line| line =~ %r(/(app|spec)/) }}.", caller)
-        adjustable.adjustments.proxy_association.target.delete(self)
-      end
+      promotion? && !source.promotion.apply_automatically && source.promotion.codes.any?
     end
   end
 end

data/app/models/spree/base.rb

@@ -1,36 +1,9 @@
 # frozen_string_literal: true
 
 class Spree::Base < ActiveRecord::Base
-  include Spree::Preferences::Preferable
-  serialize :preferences, Hash
-
+  include Spree::Core::Permalinks
   include Spree::RansackableAttributes
 
-  def initialize_preference_defaults
-    if has_attribute?(:preferences)
-      self.preferences = default_preferences.merge(preferences)
-    end
-  end
-
-  # Only run preference initialization on models which requires it. Improves
-  # performance of record initialization slightly.
-  def self.preference(*args)
-    # after_initialize can be called multiple times with the same symbol, it
-    # will only be called once on initialization.
-    after_initialize :initialize_preference_defaults
-    super
-  end
-
-  if Kaminari.config.page_method_name != :page
-    def self.page(num)
-      Spree::Deprecation.warn \
-        "Redefining Spree::Base.page for a different kaminari page name is better done inside " \
-        "your own app. This will be removed from future versions of solidus."
-
-      send Kaminari.config.page_method_name, num
-    end
-  end
-
   self.abstract_class = true
 
   # Provides a scope that should be included any time products

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

@@ -54,7 +54,7 @@ module Spree
     end
 
     def sum_of_included_tax_rates(item)
-      rates_for_item(item).map(&:amount).sum
+      rates_for_item(item).sum(&:amount)
     end
   end
 end

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

@@ -9,11 +9,6 @@ module Spree
     preference :max_items,       :integer, default: 0
     preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
 
-    def self.available?(_object)
-      Spree::Deprecation.warn('Spree::Calculator::FlexiRate::available is DEPRECATED. Use the instance method instead.')
-      true
-    end
-
     def compute(object)
       items_count = object.quantity
       items_count = [items_count, preferred_max_items].min unless preferred_max_items.zero?

data/app/models/spree/calculator.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'spree/preferences/persistable'
+
 module Spree
   class Calculator < Spree::Base
+    include Spree::Preferences::Persistable
+
     belongs_to :calculable, polymorphic: true, optional: true
 
     # This method calls a compute_<computable> method. must be overriden in concrete calculator.
@@ -10,12 +14,12 @@ module Spree
     def compute(computable)
       # Spree::LineItem -> :compute_line_item
       computable_name = computable.class.name.demodulize.underscore
-      method = "compute_#{computable_name}".to_sym
+      method_name = "compute_#{computable_name}".to_sym
       calculator_class = self.class
-      if respond_to?(method)
-        send(method, computable)
+      if respond_to?(method_name)
+        send(method_name, computable)
       else
-        raise NotImplementedError, "Please implement '#{method}(#{computable_name})' in your calculator: #{calculator_class.name}"
+        raise NotImplementedError, "Please implement '#{method_name}(#{computable_name})' in your calculator: #{calculator_class.name}"
       end
     end
 
@@ -27,13 +31,6 @@ module Spree
 
     ###################################################################
 
-    # Returns all calculators applicable for kind of work
-    def self.calculators
-      Spree::Deprecation.warn("Calling .calculators is deprecated. Please access through Rails.application.config.spree.calculators")
-
-      Spree::Config.environment.calculators
-    end
-
     def to_s
       self.class.name.titleize.gsub("Calculator\/", "")
     end

data/app/models/spree/country.rb

@@ -11,12 +11,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name]
 
     def self.default
-      if Spree::Config.default_country_id
-        Spree::Deprecation.warn("Setting your default country via its ID is deprecated. Please set your default country via the `default_country_iso` setting.", caller)
-        find_by(id: Spree::Config.default_country_id) || find_by!(iso: Spree::Config.default_country_iso)
-      else
-        find_by!(iso: Spree::Config.default_country_iso)
-      end
+      find_by!(iso: Spree::Config.default_country_iso)
     end
 
     def self.available(restrict_to_zone: Spree::Config[:checkout_zone])

data/app/models/spree/credit_card.rb

@@ -21,11 +21,6 @@ module Spree
 
     scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
 
-    def self.default
-      Spree::Deprecation.warn("CreditCard.default is deprecated. Please use Spree::Wallet instead.")
-      joins(:wallet_payment_sources).where(spree_wallet_payment_sources: { default: true })
-    end
-
     # needed for some of the ActiveMerchant gateways (eg. SagePay)
     alias_attribute :brand, :cc_type
 
@@ -46,28 +41,6 @@ module Spree
       'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
     }.freeze
 
-    def default
-      Spree::Deprecation.warn("CreditCard#default is deprecated. Please use user.wallet.default_wallet_payment_source instead.", caller)
-      return false if user.nil?
-      user.wallet.default_wallet_payment_source.try!(:payment_source) == self
-    end
-
-    def default=(set_as_default)
-      Spree::Deprecation.warn("CreditCard#default= is deprecated. Please use user.wallet.default_wallet_payment_source= instead.", caller)
-      if user.nil?
-        raise "Cannot set 'default' on a credit card without a user"
-      elsif set_as_default # setting this card as default
-        wallet_payment_source = user.wallet.add(self)
-        user.wallet.default_wallet_payment_source = wallet_payment_source
-        true
-      else # removing this card as default
-        if user.wallet.default_wallet_payment_source.try!(:payment_source) == self
-          user.wallet.default_wallet_payment_source = nil
-        end
-        false
-      end
-    end
-
     def address_attributes=(attributes)
       self.address = Spree::Address.immutable_merge(address, attributes)
     end
@@ -163,7 +136,7 @@ module Spree
     #   the object to ActiveMerchant.
     # @return [String] the first name on this credit card
     def first_name
-      name.to_s.split(/[[:space:]]/, 2)[0]
+      Spree::Address::Name.new(name).first_name
     end
 
     # @note ActiveMerchant needs first_name/last_name because we pass it a
@@ -172,7 +145,7 @@ module Spree
     #   the object to ActiveMerchant.
     # @return [String] the last name on this credit card
     def last_name
-      name.to_s.split(/[[:space:]]/, 2)[1]
+      Spree::Address::Name.new(name).last_name
     end
 
     # @return [ActiveMerchant::Billing::CreditCard] an ActiveMerchant credit

data/app/models/spree/customer_return.rb

@@ -17,22 +17,21 @@ module Spree
 
     accepts_nested_attributes_for :return_items
 
+    self.whitelisted_ransackable_attributes = ['number']
+
     extend DisplayMoney
-    money_methods :pre_tax_total, :total, :total_excluding_vat, :amount
-    deprecate display_pre_tax_total: :display_total_excluding_vat, deprecator: Spree::Deprecation
+    money_methods :total, :total_excluding_vat, :amount
 
     delegate :currency, to: :order
     delegate :id, to: :order, prefix: true, allow_nil: true
 
     def total
-      return_items.map(&:total).sum
+      return_items.sum(&:total)
     end
 
     def total_excluding_vat
-      return_items.map(&:total_excluding_vat).sum
+      return_items.sum(&:total_excluding_vat)
     end
-    alias pre_tax_total total_excluding_vat
-    deprecate pre_tax_total: :total_excluding_vat, deprecator: Spree::Deprecation
 
     def amount
       return_items.sum(:amount)

data/app/models/spree/exchange.rb

@@ -17,7 +17,7 @@ module Spree
     end
 
     def display_amount
-      Spree::Money.new @reimbursement_objects.map(&:total).sum
+      Spree::Money.new @reimbursement_objects.sum(&:total)
     end
 
     def perform!

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spree::Image::ActiveStorageAttachment
+  extend ActiveSupport::Concern
+  include Spree::ActiveStorageAdapter
+
+  delegate :width, :height, to: :attachment, prefix: true
+
+  included do
+    validates :attachment, presence: true
+    validate :attachment_is_an_image
+    validate :supported_content_type
+
+    has_attachment :attachment,
+                   styles: {
+                   mini: '48x48>',
+                   small: '400x400>',
+                   product: '680x680>',
+                   large: '1200x1200>'
+                 },
+                 default_style: :product
+
+    def supported_content_type
+      unless attachment.content_type.in?(Spree::Config.allowed_image_mime_types)
+        errors.add(:attachment, :content_type_not_supported)
+      end
+    end
+  end
+end

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

@@ -15,7 +15,7 @@ module Spree::Image::PaperclipAttachment
                       convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
     validates_attachment :attachment,
       presence: true,
-      content_type: { content_type: %w[image/jpeg image/jpg image/png image/gif] }
+      content_type: { content_type: Spree::Config.allowed_image_mime_types }
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet

data/app/models/spree/image.rb

@@ -3,12 +3,5 @@
 module Spree
   class Image < Asset
     include ::Spree::Config.image_attachment_module
-
-    def mini_url
-      Spree::Deprecation.warn(
-        'Spree::Image#mini_url is DEPRECATED. Use Spree::Image#url(:mini) instead.'
-      )
-      url(:mini)
-    end
   end
 end

data/app/models/spree/inventory_unit.rb

@@ -8,7 +8,7 @@ module Spree
     POST_SHIPMENT_STATES = %w(returned)
     CANCELABLE_STATES = ['on_hand', 'backordered', 'shipped']
 
-    belongs_to :variant, -> { with_deleted }, class_name: "Spree::Variant", inverse_of: :inventory_units, optional: true
+    belongs_to :variant, -> { with_discarded }, class_name: "Spree::Variant", inverse_of: :inventory_units, optional: true
     belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units, optional: true
     belongs_to :carton, class_name: "Spree::Carton", inverse_of: :inventory_units, optional: true
     belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units, optional: true
@@ -60,27 +60,6 @@ module Spree
 
     include ::Spree::Config.state_machines.inventory_unit
 
-    # Updates the given inventory units to not be pending.
-    #
-    # @deprecated do not use this, use
-    #   Spree::Stock::InventoryUnitsFinalizer.new(inventory_units).run!
-    # @param inventory_units [<Spree::InventoryUnit>] the inventory to be
-    #   finalized
-    def self.finalize_units!(inventory_units)
-      Spree::Deprecation.warn(
-        "inventory_units.finalize_units!(inventory_units) is deprecated. Please
-        use Spree::Stock::InventoryUnitsFinalizer.new(inventory_units).run!",
-        caller
-      )
-
-      inventory_units.map do |iu|
-        iu.update_columns(
-          pending: false,
-          updated_at: Time.current
-        )
-      end
-    end
-
     # @return [Spree::StockItem] the first stock item from this shipment's
     #   stock location that is associated with this inventory unit's variant
     def find_stock_item