solidus_core 2.10.5 → 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.

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
 
+    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, 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,6 +48,11 @@ module Spree
       where(value_attributes(attributes))
     end
 
+    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)
@@ -62,10 +85,13 @@ module Spree
     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')
-
+      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)
 
       base.except(*excluded_attributes)
@@ -80,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
@@ -130,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,
@@ -143,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
@@ -172,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]
@@ -210,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

@@ -159,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

data/app/models/spree/base.rb

@@ -2,6 +2,7 @@
 
 class Spree::Base < ActiveRecord::Base
   include Spree::Preferences::Preferable
+  include Spree::Core::Permalinks
   serialize :preferences, Hash
 
   include Spree::RansackableAttributes

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

@@ -16,9 +16,9 @@ module Spree
 
     def compute(object = nil)
       return 0 if object.nil?
-      object.line_items.map { |line_item|
+      object.line_items.sum { |line_item|
         value_for_line_item(line_item)
-      }.sum
+      }
     end
 
     private
@@ -28,9 +28,9 @@ module Spree
     # Copied from per_item.rb
     def matching_products
       if compute_on_promotion?
-        calculable.promotion.rules.map do |rule|
+        calculable.promotion.rules.flat_map do |rule|
           rule.respond_to?(:products) ? rule.products : []
-        end.flatten
+        end
       end
     end
 

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

@@ -12,7 +12,7 @@ module Spree
     # as object we always get line items, as calculable we have Coupon, ShippingMethod
     def compute(object)
       if object.is_a?(Array)
-        base = object.map { |element| element.respond_to?(:amount) ? element.amount : BigDecimal(element.to_s) }.sum
+        base = object.sum { |element| element.respond_to?(:amount) ? element.amount : BigDecimal(element.to_s) }
       else
         base = object.respond_to?(:amount) ? object.amount : BigDecimal(object.to_s)
       end