solidus_core 2.9.6 → 2.11.0

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

@@ -34,12 +34,13 @@ module Spree
 
       include Spree::RansackableAttributes unless included_modules.include?(Spree::RansackableAttributes)
 
+      ransack_alias :firstname_or_lastname, :addresses_firstname_or_addresses_lastname
       self.whitelisted_ransackable_associations = %w[addresses spree_roles]
-      self.whitelisted_ransackable_attributes = %w[id email created_at]
+      self.whitelisted_ransackable_attributes = %w[firstname_or_lastname id email created_at]
     end
 
     def wallet
-      Spree::Wallet.new(self)
+      @wallet ||= Spree::Wallet.new(self)
     end
 
     # has_spree_role? simply needs to return true or false whether a user has a role or not.
@@ -73,8 +74,8 @@ module Spree
     deprecate total_available_store_credit: :available_store_credit_total, deprecator: Spree::Deprecation
 
     def available_store_credit_total(currency:)
-      store_credits.reload.to_a.
-        select { |c| c.currency == currency }.
+      store_credits.to_a.
+        select { |credit| credit.currency == currency }.
         sum(&:amount_remaining)
     end
 

data/app/models/spree/ability.rb

@@ -14,6 +14,13 @@ module Spree
 
     attr_reader :user
 
+    CUSTOM_ALIASES_MAP = {
+      delete: :destroy,
+      display: :read,
+      new_action: :create,
+      read: :show
+    }.freeze
+
     # Allows us to go beyond the standard cancan initialize method which makes it difficult for engines to
     # modify the default +Ability+ of an application.  The +ability+ argument must be a class that includes
     # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
@@ -29,23 +36,40 @@ module Spree
     def initialize(current_user)
       @user = current_user || Spree.user_class.new
 
-      alias_actions
       activate_permission_sets
       register_extension_abilities
     end
 
+    def can?(action, *args)
+      super(normalize_action(action), *args)
+    end
+
+    def model_adapter(model_class, action)
+      super(model_class, normalize_action(action))
+    end
+
     private
 
-    def alias_actions
-      clear_aliased_actions
+    def normalize_action(action)
+      return action unless Spree::Config.use_custom_cancancan_actions
+
+      normalized_action = CUSTOM_ALIASES_MAP.fetch(action, action)
+
+      if action == :read
+        Spree::Deprecation.warn <<~WARN, caller(3)
+          The behavior of CanCanCan `:read` action alias will be changing in Solidus 3.0.
+          The current alias is: `:show, :to => :read`,
+          the new alias will be compliant with CanCanCan's default: `index, :show, :to => :read`
+        WARN
+      elsif CUSTOM_ALIASES_MAP.key? action
+        Spree::Deprecation.warn <<~WARN, caller(3)
+          Calling CanCanCan alias action #{action.inspect} is deprecated.
+          In Solidus 3.0 non-standard CanCanCan action aliases will be replaced with default ones,
+          please replace with #{normalized_action.inspect}.
+        WARN
+      end
 
-      # 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
+      normalized_action
     end
 
     # Before, this was the only way to extend this ability. Permission sets have been added since.

data/app/models/spree/address.rb

@@ -8,21 +8,39 @@ module Spree
   class Address < Spree::Base
     extend ActiveModel::ForbiddenAttributesProtection
 
-    belongs_to :country, class_name: "Spree::Country"
-    belongs_to :state, class_name: "Spree::State"
+    mattr_accessor :state_validator_class
+    self.state_validator_class = Spree::Address::StateValidator
 
-    validates :firstname, :address1, :city, :country_id, presence: true
+    belongs_to :country, class_name: "Spree::Country", optional: true
+    belongs_to :state, class_name: "Spree::State", optional: true
+
+    validates :address1, :city, :country_id, presence: true
     validates :zipcode, presence: true, if: :require_zipcode?
     validates :phone, presence: true, if: :require_phone?
 
-    validate :state_validate
-    validate :validate_state_matches_country
+    validate :validate_name
+
+    validate do
+      if Spree::Config.use_legacy_address_state_validator
+        begin
+          @silence_state_deprecations = true
+          state_validate
+          validate_state_matches_country
+        ensure
+          @silence_state_deprecations = false
+        end
+      else
+        self.class.state_validator_class.new(self).perform
+      end
+    end
 
     alias_attribute :first_name, :firstname
     alias_attribute :last_name, :lastname
+    alias_attribute :full_name, :name
 
     DB_ONLY_ATTRS = %w(id updated_at created_at)
     TAXATION_ATTRS = %w(state_id country_id zipcode)
+    LEGACY_NAME_ATTRS = %w(firstname lastname full_name)
 
     self.whitelisted_ransackable_attributes = %w[firstname lastname]
 
@@ -30,8 +48,14 @@ module Spree
       where(value_attributes(attributes))
     end
 
-    def self.build_default
-      new(country: Spree::Country.default)
+    Spree::Deprecation.deprecate_methods(
+      Spree::Address,
+      LEGACY_NAME_ATTRS.product([:name]).to_h
+    )
+
+    # @return [Address] an address with default attributes
+    def self.build_default(*args, &block)
+      where(country: Spree::Country.default).build(*args, &block)
     end
 
     # @return [Address] an equal address already in the database or a newly created one
@@ -58,21 +82,19 @@ module Spree
     end
 
     # @return [Hash] hash of attributes contributing to value equality with optional merge
-    def self.value_attributes(base_attributes, merge_attributes = nil)
-      # dup because we may modify firstname/lastname.
-      base = base_attributes.dup
+    def self.value_attributes(base_attributes, merge_attributes = {})
+      base = base_attributes.stringify_keys.merge(merge_attributes.stringify_keys)
 
-      base.stringify_keys!
-
-      if merge_attributes
-        base.merge!(merge_attributes.stringify_keys)
+      name_from_attributes = Spree::Address::Name.from_attributes(base)
+      if base['firstname'].presence || base['first_name'].presence
+        base['firstname'] = name_from_attributes.first_name
       end
+      if base['lastname'].presence || base['last_name'].presence
+        base['lastname'] = name_from_attributes.last_name
+      end
+      excluded_attributes = DB_ONLY_ATTRS + %w(first_name last_name)
 
-      # TODO: Deprecate these aliased attributes
-      base['firstname'] = base.delete('first_name') if base.key?('first_name')
-      base['lastname'] = base.delete('last_name') if base.key?('last_name')
-
-      base.except!(*DB_ONLY_ATTRS)
+      base.except(*excluded_attributes)
     end
 
     # @return [Hash] hash of attributes contributing to value equality
@@ -84,18 +106,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
@@ -121,7 +138,7 @@ module Spree
     # @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? { |_, v| v.nil? }
+      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
@@ -134,7 +151,7 @@ module Spree
     # @return [Hash] an ActiveMerchant compatible address hash
     def active_merchant_hash
       {
-        name: full_name,
+        name: name,
         address1: address1,
         address2: address2,
         city: city,
@@ -147,13 +164,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
@@ -176,9 +193,54 @@ module Spree
       country && country.iso
     end
 
+    # @return [String] the full name on this address
+    def name
+      Spree::Address::Name.new(
+        read_attribute(:firstname),
+        read_attribute(:lastname)
+      ).value
+    end
+
+    def name=(value)
+      return if value.nil?
+
+      name_from_value = Spree::Address::Name.new(value)
+      write_attribute(:firstname, name_from_value.first_name)
+      write_attribute(:lastname, name_from_value.last_name)
+    end
+
+    def as_json(options = {})
+      if Spree::Config.use_combined_first_and_last_name_in_address
+        super(options.merge(except: LEGACY_NAME_ATTRS)).tap do |hash|
+          hash['name'] = name
+        end
+      else
+        super
+      end
+    end
+
     private
 
+    def validate_name
+      return if name.present?
+
+      name_attribute = if Spree::Config.use_combined_first_and_last_name_in_address
+        :name
+      else
+        :firstname
+      end
+      errors.add(name_attribute, :blank)
+    end
+
     def state_validate
+      unless @silence_state_deprecations
+        Spree::Deprecation.warn \
+          "#{self.class}#state_validate private method has been deprecated" \
+          " and will be removed in Solidus v3." \
+          " Check https://github.com/solidusio/solidus/pull/3129 for more details.",
+          caller
+      end
+
       # Skip state validation without country (also required)
       # or when disabled by preference
       return if country.blank? || !Spree::Config[:address_requires_state]
@@ -214,6 +276,17 @@ module Spree
     end
 
     def validate_state_matches_country
+      unless @silence_state_deprecations
+        Spree::Deprecation.warn \
+          "#{self.class}#validate_state_matches_country private method has been deprecated" \
+          " and will be removed in Solidus v3." \
+          " Check https://github.com/solidusio/solidus/pull/3129 for more details.",
+          caller
+      end
+
+      return unless country
+
+      self.state = nil if country.states.empty?
       if state && state.country != country
         errors.add(:state, :does_not_match_country)
       end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Spree
+  class Address
+    # Provides a value object to help transitioning from legacy
+    # firstname and lastname fields to a unified name field.
+    class Name
+      attr_reader :first_name, :last_name, :value
+
+      # Creates an instance of Spree::Address::Name parsing input attributes.
+      # @param attributes [Hash] an hash possibly containing name-related
+      #   attributes (name, firstname, lastname, first_name, last_name)
+      # @return [Spree::Address::Name] the object created
+      def self.from_attributes(attributes)
+        params = attributes.with_indifferent_access
+
+        if params[:name].present?
+          Spree::Address::Name.new(params[:name])
+        elsif params[:firstname].present?
+          Spree::Address::Name.new(params[:firstname], params[:lastname])
+        elsif params[:first_name].present?
+          Spree::Address::Name.new(params[:first_name], params[:last_name])
+        else
+          Spree::Address::Name.new
+        end
+      end
+
+      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/adjustment.rb

@@ -16,11 +16,11 @@ module Spree
   #    order's adjustment total. This allows an adjustment to be preserved if
   #    it becomes ineligible so it might be reinstated.
   class Adjustment < Spree::Base
-    belongs_to :adjustable, polymorphic: true, touch: true
-    belongs_to :source, polymorphic: true
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
-    belongs_to :promotion_code, class_name: 'Spree::PromotionCode'
-    belongs_to :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments
+    belongs_to :adjustable, polymorphic: true, touch: true, optional: true
+    belongs_to :source, polymorphic: true, optional: true
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments, optional: true
+    belongs_to :promotion_code, class_name: 'Spree::PromotionCode', optional: true
+    belongs_to :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments, optional: true
 
     validates :adjustable, presence: true
     validates :order, presence: true
@@ -56,20 +56,31 @@ module Spree
     extend DisplayMoney
     money_methods :amount
 
+    # Returns Adjustments of completed Orders.
+    #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from query
+    # @return [ActiveRecord::Relation] Scoped Adjustments
+    def self.in_completed_orders(excluded_orders: [])
+      joins(:order).
+      merge(Spree::Order.complete).
+      where.not(spree_orders: { id: excluded_orders }).
+      distinct
+    end
+
     def finalize!
-      update_attributes!(finalized: true)
+      update!(finalized: true)
     end
 
     def unfinalize!
-      update_attributes!(finalized: false)
+      update!(finalized: false)
     end
 
     def finalize
-      update_attributes(finalized: true)
+      update(finalized: true)
     end
 
     def unfinalize
-      update_attributes(finalized: false)
+      update(finalized: false)
     end
 
     def currency
@@ -148,7 +159,7 @@ module Spree
     private
 
     def require_promotion_code?
-      promotion? && source.promotion.codes.any?
+      promotion? && !source.promotion.apply_automatically && source.promotion.codes.any?
     end
 
     def repair_adjustments_associations_on_create