spree_core 5.6.0 → 6.0.0.beta1

data/app/models/spree/address.rb

@@ -4,7 +4,7 @@ module Spree
 
     require 'validates_zipcode'
 
-    include Spree::Metafields
+    include Spree::HasCustomFields
     include Spree::Metadata
 
     serialize :preferences, type: Hash, coder: YAML, default: {}
@@ -25,50 +25,84 @@ module Spree
 
     # we're not freezing this on purpose so developers can extend and manage
     # those attributes depending of the logic of their applications
-    ADDRESS_FIELDS = %w(firstname lastname company address1 address2 city state zipcode country phone)
-    EXCLUDED_KEYS_FOR_COMPARISON = %w(id updated_at created_at deleted_at label user_id public_metadata private_metadata)
+    ADDRESS_FIELDS = %w(first_name last_name company address1 address2 city state postal_code country phone)
+
+    # Beyond identity and ownership, three groups are excluded because they
+    # cannot tell two addresses apart. Latitude and longitude are derived from
+    # the address, so an entry whose geocoding has already run would otherwise
+    # never match the same address freshly typed in. country_id and state_id
+    # are the pre-6.0 foreign keys, which the upgrade task copies into codes
+    # and leaves populated: comparing them makes every migrated row differ
+    # from every new one. Both are handled the same way by .find_duplicate,
+    # which drops the legacy keys through .resolve_geo_params.
+    EXCLUDED_KEYS_FOR_COMPARISON = %w(
+      id updated_at created_at deleted_at label owner_type owner_id metadata
+      latitude longitude country_id state_id
+    )
     if defined?(Spree::Security::Addresses)
       include Spree::Security::Addresses
     end
 
     scope :not_deleted, -> { where(deleted_at: nil) }
 
+    # Matches a subdivision by code or by name. Only the code is stored, so a
+    # name is resolved to the codes it could mean before querying.
     scope :by_state_name_or_abbr, lambda { |state_name|
-      joins(:state).merge(Spree::State.where(name: state_name).or(Spree::State.where(abbr: state_name)))
+      codes = Spree::IsoData.countries.filter_map do |country|
+        Spree::IsoData.subdivision_code(country.alpha2, state_name)
+      end.uniq
+
+      where(state_code: ([state_name] + codes).uniq)
     }
 
     scope :not_quick_checkout, -> { where(quick_checkout: false) }
 
-    belongs_to :country, class_name: 'Spree::Country'
-    belongs_to :state, class_name: 'Spree::State', optional: true
-    # we need a safe operator here as Address is added to metafield_enabled_resources in Engine
-    belongs_to :user, class_name: Spree.user_class&.name, optional: true, touch: true
+    has_iso_geography
+
+    # @deprecated The canonical names are +country_code+ and +state_code+,
+    #   matching the tax tables. Kept because the Store API shipped
+    #   +country_iso+ and +state_abbr+; both are removed in 6.1.
+    alias_attribute :state_abbr, :state_code
+    alias_attribute :country_iso, :country_code
+
+    # Who the address belongs to: a customer's address book, a company node's,
+    # or a seller's billing address. One relationship with three cardinalities,
+    # so a further owner costs no schema change — and what the row requires
+    # follows from the owner rather than from a subclass.
+    #
+    # Order and cart addresses have no owner: completion copies the attributes
+    # onto a fresh row, and that snapshot belongs to the order, not to anyone's
+    # book.
+    belongs_to :owner, polymorphic: true, optional: true, touch: true
+
 
-    has_many :shipments, inverse_of: :address
+    has_many :fulfillments, class_name: 'Spree::Fulfillment', inverse_of: :address
+    has_many :shipments, class_name: 'Spree::Fulfillment', foreign_key: :address_id, deprecated: true
 
-    after_initialize :set_default_values, if: -> { new_record? && user.present? }
+    after_initialize :set_default_values, if: -> { new_record? && customer_owned? }
 
     before_validation :normalize_country
     before_validation :normalize_state
     before_validation :clear_invalid_state_entities, if: -> { country.present? }, on: :update
 
-    after_create :set_user_attributes, if: -> { user.present? }
+    after_create :set_user_attributes, if: -> { customer_owned? }
 
     after_commit :async_geocode
 
     with_options presence: true do
-      validates :firstname, :lastname, if: :require_name?
+      validates :first_name, :last_name, if: :require_name?
       validates :address1, if: :require_street?
       validates :city, :country
-      validates :zipcode, if: :require_zipcode?
+      validates :postal_code, if: :require_postal_code?
       validates :phone, if: :require_phone?
+      validates :company, if: :require_company?
     end
 
     validate :state_validate, :postal_code_validate
     validate :address_validators, on: [:create, :update]
 
     validates :label, uniqueness: { conditions: -> { where(deleted_at: nil) },
-                                    scope: :user_id,
+                                    scope: [:owner_type, :owner_id],
                                     case_sensitive: false,
                                     allow_blank: true,
                                     allow_nil: true }
@@ -79,25 +113,97 @@ module Spree
       end
     end
 
-    delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true, allow_nil: true
-    delegate :abbr, to: :state, prefix: true, allow_nil: true
-
-    alias_attribute :postal_code, :zipcode
-    alias_attribute :first_name, :firstname
-    alias_attribute :last_name, :lastname
+    delegate :name, :iso3, :iso_name, to: :country, prefix: true, allow_nil: true
+
+    # Standardized column names (renamed in 6.0); the legacy readers stay one
+    # release.
+    alias_attribute :zipcode, :postal_code
+    alias_attribute :firstname, :first_name
+    alias_attribute :lastname, :last_name
+
+    # The single home for postal-code normalization (delivery-zone matching) —
+    # don't scatter postal-code munging elsewhere.
+    # @param value [String, nil]
+    # @return [String] value with spaces/dashes stripped, upcased
+    def self.normalize_postal_code(value)
+      value.to_s.gsub(/[\s-]/, '').upcase
+    end
+
+    # @deprecated Use {.normalize_postal_code}; removed in 6.1.
+    def self.normalize_zipcode(value)
+      Spree::Deprecation.warn('Spree::Address.normalize_zipcode is deprecated and will be removed in Spree 6.1. Use .normalize_postal_code instead.')
+      normalize_postal_code(value)
+    end
+
+    # @return [String] this address's postal code, normalized via {.normalize_postal_code}
+    def normalized_postal_code
+      self.class.normalize_postal_code(postal_code)
+    end
+
+    # @deprecated Use {#normalized_postal_code}; removed in 6.1.
+    def normalized_zipcode
+      Spree::Deprecation.warn('Spree::Address#normalized_zipcode is deprecated and will be removed in Spree 6.1. Use #normalized_postal_code instead.')
+      normalized_postal_code
+    end
+
+    # Normalizes a params hash for query builders like +find_or_create_by+,
+    # which match on exactly the keys they are given. Codes are upcased so a
+    # lookup finds the row a save would have written, the redundant foreign
+    # keys are dropped, and a +state_name+ that names a real subdivision
+    # becomes the code that a saved address would hold.
+    #
+    # Assignment does not need this — the writers and their +before_validation+
+    # callbacks resolve both halves.
+    #
+    # @param params [Hash]
+    # @return [Hash]
+    def self.resolve_geo_params(params)
+      params = params.to_h.symbolize_keys
+      params.delete(:country_id)
+      params.delete(:state_id)
+
+      # Legacy write names accepted until 6.1; the columns are country_code
+      # and state_code. The renamed name and postal-code columns need no entry
+      # here — alias_attribute resolves those inside `where` too, while these
+      # two are not attribute aliases.
+      params[:state_code] = params.delete(:state_abbr) if params.key?(:state_abbr)
+      params[:country_code] = params.delete(:country_iso) if params.key?(:country_iso)
+
+      country_code = params[:country_code].presence&.to_s&.upcase
+      params[:country_code] = country_code if country_code
+
+      if params[:state_code].present?
+        params[:state_code] = params[:state_code].to_s.upcase
+      elsif country_code && params[:state_name].present?
+        matched = Spree::IsoData.subdivision_code(country_code, params[:state_name])
+
+        if matched
+          params[:state_code] = matched
+          params.delete(:state_name)
+        end
+      end
 
-    # Writer methods for API convenience - these set country/state from ISO/abbr codes
-    # The reader methods (country_iso, state_abbr) are delegates to country.iso and state.abbr
-    def country_iso=(value)
-      @country_iso_input = value
+      params
     end
 
-    def state_abbr=(value)
-      @state_abbr_input = value
+    # Finds an existing, undeleted address matching the given attributes, so a
+    # customer re-entering an address they already have reuses that row rather
+    # than accumulating duplicates. Geography is matched by code, and a state
+    # given by name is resolved to the codes it could mean.
+    #
+    # @param attributes [Hash]
+    # @return [Spree::Address, nil]
+    def self.find_duplicate(attributes)
+      attributes = resolve_geo_params(attributes.except(:id, :updated_at, :created_at))
+      state_name = attributes[:state_name]
+
+      scope = not_deleted.where(attributes.except(:state_name))
+      scope = scope.by_state_name_or_abbr(state_name) if state_name.present?
+      scope.first
     end
 
-    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS
-    self.whitelisted_ransackable_associations = %w[country state user]
+    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS + %w[country_code state_code]
+    self.whitelisted_ransackable_associations = %w[owner]
 
     def self.required_fields
       Spree::Address.validators.map do |v|
@@ -105,36 +211,89 @@ module Spree
       end.flatten
     end
 
-    def user_default_billing?
-      Spree::Deprecation.warn('Spree::Address#user_default_billing? is deprecated and will be removed in Spree 6.0. Use #is_default_billing? instead.')
-      is_default_billing?
+    # The owner when it is a customer, so customer-specific behaviour (the
+    # address book defaults, the profile back-fill) reads nil for a company's
+    # or a seller's row and simply does not apply.
+    #
+    # @return [Object, nil]
+    def customer_owner
+      owner if customer_owned?
+    end
+
+    # @return [Boolean]
+    def customer_owned?
+      owner_type == Spree.customer_class.to_s
+    end
+
+    # @param kind [Symbol] :bill or :ship
+    # @return [Integer, nil] the owner's chosen address of that kind
+    def default_address_id(kind)
+      return nil unless owner.respond_to?(:default_address_id)
+
+      owner.default_address_id(kind)
+    end
+
+    # @deprecated The address's owner may be a customer, a company node or a
+    #   seller, so {#owner} replaces the customer-only association. Removed in
+    #   Spree 6.1.
+    def user
+      Spree::Deprecation.warn('Spree::Address#user is deprecated and will be removed in Spree 6.1. Use #owner instead.') if defined?(Spree::Deprecation)
+      customer_owner
+    end
+
+    def user=(value)
+      Spree::Deprecation.warn('Spree::Address#user= is deprecated and will be removed in Spree 6.1. Use #owner= instead.') if defined?(Spree::Deprecation)
+      self.owner = value
+    end
+
+    def user_id
+      Spree::Deprecation.warn('Spree::Address#user_id is deprecated and will be removed in Spree 6.1. Use #owner_id instead.') if defined?(Spree::Deprecation)
+      owner_id if customer_owned?
+    end
+
+    # A company node's or a seller's address: nobody is named on it, and the
+    # business is the part that cannot be left out.
+    #
+    # @return [Boolean]
+    def business_owned?
+      owner_type == 'Spree::Company' || owner_type == 'Spree::Seller'
     end
 
-    def user_default_shipping?
-      Spree::Deprecation.warn('Spree::Address#user_default_shipping? is deprecated and will be removed in Spree 6.0. Use #is_default_shipping? instead.')
-      is_default_shipping?
+    # The company line. A stored value wins, so an order's copied address keeps
+    # what it was sent with even after the node is renamed, and a member can
+    # override the line for one site. An owned book entry with nothing stored
+    # tracks its node's current name.
+    #
+    # @return [String, nil]
+    def company
+      stored = read_attribute(:company)
+      return stored if stored.present?
+
+      owner.name if owner.is_a?(Spree::Company)
     end
 
-    # In 6.0 these become real columns on Address, replacing User#bill_address_id / ship_address_id.
-    # For now they delegate to the User FK so the API shape is stable.
+    # Whether the owner prefills with this address. Every owner keeps the
+    # pointer itself — a customer on bill_address_id / ship_address_id, a
+    # company node on its own two columns — so the answer is the same question
+    # asked of whichever one owns the row.
     def is_default_billing?
-      user.present? && id == user.bill_address_id
+      default_address_id(:bill) == id
     end
     alias_method :is_default_billing, :is_default_billing?
 
     def is_default_shipping?
-      user.present? && id == user.ship_address_id
+      default_address_id(:ship) == id
     end
     alias_method :is_default_shipping, :is_default_shipping?
 
     # first_name / last_name aliases are defined via alias_attribute above
 
     def full_name
-      "#{firstname} #{lastname}".strip
+      "#{first_name} #{last_name}".strip
     end
 
     def state_text
-      state.try(:abbr) || state.try(:name) || state_name
+      state_code.presence || state.try(:name) || state_name
     end
 
     def state_name_text
@@ -151,15 +310,65 @@ module Spree
         company,
         address1,
         address2,
-        "#{city}, #{state_text} #{zipcode}",
+        "#{city}, #{state_text} #{postal_code}",
         country.to_s
       ].reject(&:blank?).map { |attribute| ERB::Util.html_escape(attribute) }.join('<br/>')
     end
 
+    # @deprecated Overriding Ruby's +Object#clone+ was a mistake: this returns
+    #   a value copy with the owner, label and metadata stripped, which is not
+    #   what +clone+ means anywhere else in Ruby. The override is removed in
+    #   Spree 6.1 and +clone+ becomes the standard shallow copy. Use
+    #   {#snapshot} for the ownerless copy a purchase keeps.
     def clone
+      Spree::Deprecation.warn(
+        'Spree::Address#clone is deprecated. From Spree 6.1 it behaves as the standard Ruby Object#clone — a shallow copy keeping the owner and every other attribute. Use #snapshot for the ownerless copy a purchase keeps.'
+      )
+
       self.class.new(value_attributes)
     end
 
+    # A copy of this address for a purchase to keep. An order's address records
+    # where the parcel actually went, so it belongs to the order and not to
+    # anyone's address book — a copy that kept the owner would file a second
+    # entry in the buyer's book on every order they place. Having no owner it
+    # carries no label either: a label is unique within one book, so every
+    # ownerless snapshot would compete for the same one.
+    #
+    # @return [Spree::Address]
+    def snapshot
+      dup.tap do |copy|
+        copy.owner = nil
+        copy.label = nil
+        copy.deleted_at = nil
+      end
+    end
+
+    # The entry the owner's book already holds for this, if there is one, so
+    # someone re-entering an address they already saved gets the entry they
+    # have back instead of a near-copy filed beside it.
+    #
+    # An entry is more than a place. Two rows match only when they mean the
+    # same place ({#==}) *and* agree on the things the owner attached to the
+    # entry itself — its label and its metadata. A company filing "Dock A" and
+    # "Dock B" at one site keeps two entries, and neither request silently
+    # loses the name it was filed under.
+    #
+    # Owners that keep no book, including no owner at all, have nothing to
+    # match against.
+    #
+    # @return [Spree::Address, nil]
+    def duplicate_in_address_book
+      return nil unless owner.respond_to?(:addresses)
+
+      owner.addresses.not_deleted.detect do |existing|
+        existing.id != id &&
+          existing == self &&
+          existing.label == label &&
+          existing.metadata.to_h == metadata.to_h
+      end
+    end
+
     def ==(other)
       return false unless other&.respond_to?(:value_attributes)
 
@@ -170,8 +379,10 @@ module Spree
       attributes.except(*EXCLUDED_KEYS_FOR_COMPARISON)
     end
 
+    # A country alone doesn't make an address — a new one is pre-filled with the
+    # store's default, so both the code and the association are ignored here.
     def empty?
-      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, v| v.nil? }
+      attributes.except('id', 'created_at', 'updated_at', 'country_id', 'country_code').all? { |_, v| v.nil? }
     end
 
     # Generates an address hash for payment gateway options
@@ -182,7 +393,7 @@ module Spree
         address2: address2,
         city: city,
         state: state_text,
-        zip: zipcode,
+        zip: postal_code,
         country: country.try(:iso),
         phone: phone
       }
@@ -192,19 +403,40 @@ module Spree
     def require_phone?
       # We want to collect phone number for quick checkout but not to validate it
       # as it's not available before payment by browser.
-      !quick_checkout && Spree::Config[:address_requires_phone]
+      !quick_checkout && store_preference(:address_requires_phone, false)
+    end
+
+    # A host app that overrode the pre-6.0 +require_zipcode?+ still decides:
+    # its override sits ahead of this class in the ancestry, so the shell below
+    # never runs and the answer comes from the decorator. Without the
+    # indirection that override would stop being called silently, and addresses
+    # that used to save would start failing validation with nothing in the log.
+    def require_postal_code?
+      require_zipcode?
     end
 
+    # @deprecated Override {#require_postal_code?}; removed in 6.1.
     def require_zipcode?
       !quick_checkout && (country ? country.zipcode_required? : true)
     end
 
+    # A business address names no person: a company site or a seller's billing
+    # address has no contact to insist on, which is why the owner decides this
+    # rather than a subclass.
     def require_name?
-      !quick_checkout
+      !quick_checkout && !business_owned?
     end
 
     def require_company?
-      false
+      return false if quick_checkout
+      # A company node names itself, so the line is always answerable; a
+      # seller's billing address is what a commission invoice is addressed to,
+      # and that is the part which cannot be left out.
+      return true if business_owned?
+
+      # Only meaningful when the field is on the form at all — requiring a
+      # value the customer is never shown would make checkout unfinishable.
+      show_company_address_field? && store_preference(:address_requires_company, false)
     end
 
     def require_street?
@@ -212,7 +444,9 @@ module Spree
     end
 
     def show_company_address_field?
-      Spree::Store.current.prefers_company_field_enabled?
+      return true if business_owned?
+
+      store_preference(:company_field_enabled, false)
     end
 
     def editable?
@@ -223,12 +457,6 @@ module Spree
       shipments.empty? && Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).none?
     end
 
-    def check
-      attrs = attributes.except('id', 'updated_at', 'created_at')
-      the_same_address = user&.addresses&.find_by(attrs)
-      the_same_address || self
-    end
-
     def destroy
       assign_new_default_address_to_user
 
@@ -250,36 +478,75 @@ module Spree
 
     private
 
+    # Addresses carry no store association, so store-scoped settings resolve
+    # through the ambient store. Outside a request (console, seeds, a job that
+    # forgets to set the store) there may be none, so callers pass the
+    # preference default explicitly.
+    def store_preference(name, fallback)
+      store = Spree::Current.store
+      return fallback if store.nil?
+
+      store.get_preference(name)
+    end
+
     def should_geocode?
       Spree::Config[:geocode_addresses] && (
-        saved_changes.key?(:address1) || saved_changes.key?(:city) || saved_changes.key?(:state_id) || saved_changes.key?(:country_id)
+        saved_changes.key?(:address1) || saved_changes.key?(:city) ||
+        saved_changes.key?(:state_code) || saved_changes.key?(:country_code)
       )
     end
 
     def set_default_values
-      self.firstname ||= user.first_name
-      self.lastname ||= user.last_name
-      self.phone ||= user.phone
+      self.first_name ||= customer_owner.first_name
+      self.last_name ||= customer_owner.last_name
+      self.phone ||= customer_owner.phone
     end
 
+    # The ISO code is what the address stores; the association is kept in step
+    # with it for the one release it still exists. Assigning +country+ directly
+    # is equally supported — whichever half was set fills in the other.
     def normalize_country
-      iso = @country_iso_input
-      return if iso.blank?
+      submitted_iso = self[:country_code].presence
+      return if submitted_iso.blank?
 
-      self.country = Spree::Country.by_iso(iso)
-      @country_iso_input = nil
+      resolved = Spree::Country.by_iso(submitted_iso)
+      # Alpha-3 codes arrive here too; the column stores alpha-2. An
+      # unrecognised code is left in place — the presence validation on
+      # +country+ reports it.
+      self[:country_code] = resolved.iso if resolved
     end
 
+    # Resolves the subdivision code from whichever handle the caller supplied:
+    # +state_code+ (which may be a retired code), or a +state_name+ that names
+    # a real subdivision of this country. A name matching nothing is left
+    # alone — countries without subdivisions keep it as free text, and
+    # +state_validate+ decides whether that is acceptable.
     def normalize_state
-      abbr = @state_abbr_input
-      return if abbr.blank? || country.blank?
+      return if country_code.blank?
+
+      submitted_abbr = self[:state_code].presence
+
+      if submitted_abbr.present?
+        resolved = Spree::IsoData.subdivision_code(country_code, submitted_abbr)
 
-      self.state = country.states.find_by(abbr: abbr)
-      @state_abbr_input = nil
+        # A code that means nothing in this country is stale — it came from the
+        # country the address just moved off — so drop it and let the other
+        # handles (a state_name, or nothing) decide.
+        self[:state_code] = resolved
+        return if resolved
+      end
+
+      return if state_name.blank?
+
+      matched = Spree::IsoData.subdivision_code(country_code, state_name)
+      return if matched.blank?
+
+      self[:state_code] = matched
+      self.state_name = nil
     end
 
     def clear_state
-      self.state = nil
+      self[:state_code] = nil
     end
 
     def clear_state_name
@@ -287,89 +554,91 @@ module Spree
     end
 
     def clear_invalid_state_entities
-      if state.present? && (state.country != country)
-        clear_state
-      elsif state_name.present? && !country.states_required? && country.states.empty?
-        clear_state_name
-      end
+      # A subdivision that means nothing in this country was already dropped by
+      # normalize_state; what is left is free text on a country that has no
+      # subdivisions to match it against.
+      return unless state_name.present? && !country.states_required? && country.states.empty?
+
+      clear_state_name
     end
 
     def set_user_attributes
-      if user.name.blank?
-        user.first_name = firstname
-        user.last_name = lastname
+      customer = customer_owner
+      if customer.name.blank?
+        customer.first_name = first_name
+        customer.last_name = last_name
       end
-      user.phone = user.phone.presence || phone.presence
+      customer.phone = customer.phone.presence || phone.presence
 
-      user.save! if user.changed?
+      customer.save! if customer.changed?
     end
 
+    # normalize_state has already resolved the code, so what is left to check
+    # is whether a country that requires a subdivision actually got one.
     def state_validate
-      # Skip state validation without country (also required)
-      # or when disabled by preference
-      return if country.blank? || !Spree::Config[:address_requires_state]
+      # Skip state validation without country (also required).
+      # Whether a state is required is the country's call.
+      return if country.blank?
       return unless country.states_required
 
-      # ensure associated state belongs to country
-      if state.present?
-        if state.country == country
-          clear_state_name # not required as we have a valid state and country combo
-        elsif state_name.present?
-          clear_state
-        else
-          errors.add(:state, :invalid)
-        end
+      if state_code.present?
+        clear_state_name
+        return
       end
 
-      # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
-      if state_name.present? && country.states.present?
-        states = country.states.find_all_by_name_or_abbr(state_name)
-
-        if states.size == 1
-          self.state = states.first
-          clear_state_name
-        else
-          errors.add(:state, :invalid)
-        end
+      # A name is only acceptable when it names nothing the country knows —
+      # otherwise normalize_state would have turned it into a code.
+      if state_name.present?
+        errors.add(:state, :invalid) if country.states.any?
+        return
       end
 
-      # ensure at least one state field is populated
-      errors.add :state, :blank if state.blank? && state_name.blank?
+      errors.add :state, :blank
     end
 
     def postal_code_validate
-      return if country.blank? || country_iso.blank? || !require_zipcode? || zipcode.blank?
-      return unless ::ValidatesZipcode::CldrRegexpCollection::ZIPCODES_REGEX.keys.include?(country_iso.upcase.to_sym)
-
-      formatted_zip = ::ValidatesZipcode::Formatter.new(
-        zipcode: zipcode.to_s.strip,
-        country_alpha2: country_iso.upcase
-      ).format
+      return if country.blank? || country_code.blank? || !require_postal_code? || postal_code.blank?
+      return unless ::ValidatesZipcode::CldrRegexpCollection::ZIPCODES_REGEX.keys.include?(country_code.upcase.to_sym)
+
+      # The formatter indexes backwards into the string to insert a separator,
+      # so anything shorter than the country's format raises rather than
+      # returning something invalid. A stored value can be short — erasure
+      # truncates a postcode to the part that establishes the tax jurisdiction
+      # — and a save of that row must fail validation, not crash.
+      formatted_zip = begin
+        ::ValidatesZipcode::Formatter.new(
+          zipcode: postal_code.to_s.strip,
+          country_alpha2: country_code.upcase
+        ).format
+      rescue IndexError
+        postal_code.to_s.strip
+      end
 
-      errors.add(:zipcode, :invalid) unless ::ValidatesZipcode.valid?(formatted_zip, country_iso.upcase)
+      errors.add(:postal_code, :invalid) unless ::ValidatesZipcode.valid?(formatted_zip, country_code.upcase)
     end
 
     def assign_new_default_address_to_user
-      return unless user
+      customer = customer_owner
+      return unless customer
 
-      user.reload
-      return if user.bill_address != self && user.ship_address != self
+      customer.reload
+      return if customer.bill_address != self && customer.ship_address != self
 
       last_address = assign_new_default_address_to_user_scope.find { |address| address.id != id && address.valid? }
 
-      user.bill_address = last_address if user.bill_address == self
-      user.ship_address = last_address if user.ship_address == self
-      user.save!
+      customer.bill_address = last_address if customer.bill_address == self
+      customer.ship_address = last_address if customer.ship_address == self
+      customer.save!
     end
 
     def assign_new_default_address_to_user_scope
-      user.addresses.not_quick_checkout.reorder(created_at: :desc)
+      customer_owner.addresses.not_quick_checkout.reorder(created_at: :desc)
     end
 
     def unassign_from_incomplete_orders
-      orders = Spree::Order.incomplete.where(user_id: user_id)
-      orders.where(ship_address_id: id).update_all(ship_address_id: nil, state: 'address', updated_at: Time.current)
-      orders.where(bill_address_id: id).update_all(bill_address_id: nil, state: 'address', updated_at: Time.current)
+      orders = Spree::Order.incomplete.where(customer_id: owner_id)
+      orders.where(ship_address_id: id).update_all(ship_address_id: nil, updated_at: Time.current)
+      orders.where(bill_address_id: id).update_all(bill_address_id: nil, updated_at: Time.current)
     end
   end
 end