worldwide 0.10.3 → 0.11.0

data/lib/worldwide/address.rb

@@ -300,7 +300,7 @@ module Worldwide
     end
 
     def normalize_city
-      Worldwide.region(code: @country_code)&.field(key: :city)&.autofill || @city
+      Worldwide.region(code: @country_code)&.autofill_city || @city
     end
 
     def normalize_country_code(autocorrect_level:)

data/lib/worldwide/address_validator.rb

@@ -73,7 +73,7 @@ module Worldwide
 
       return [] if country.nil?
       return [] if country.zones.nil?
-      return [] if country.zones.select(&:province?).empty?
+      return [] if country.zones.none?(&:province?)
       return [] if country.hide_provinces_from_addresses
 
       if Util.blank?(address.province_code)

data/lib/worldwide/currencies.rb

@@ -45,7 +45,7 @@ module Worldwide
     end
 
     def currency_codes
-      @currency_codes ||= YAML.safe_load(File.read(CURRENCY_CODES_FILE_PATH))
+      @currency_codes ||= YAML.safe_load_file(CURRENCY_CODES_FILE_PATH)
     end
 
     def map_alpha_three_to_numeric_three

data/lib/worldwide/currency.rb

@@ -12,15 +12,11 @@ module Worldwide
 
     class << self
       def digits_and_rounding
-        @digits_and_rounding ||= YAML.safe_load(
-          File.read(File.join(Worldwide::Paths::OTHER_DATA_ROOT, "currency", "digits.yml")),
-        ).freeze
+        @digits_and_rounding ||= YAML.safe_load_file(File.join(Worldwide::Paths::OTHER_DATA_ROOT, "currency", "digits.yml")).freeze
       end
 
       def minor_symbols
-        @minor_symbols ||= YAML.safe_load(
-          File.read(File.join(Worldwide::Paths::OTHER_DATA_ROOT, "currency", "minor_symbols.yml")),
-        ).freeze
+        @minor_symbols ||= YAML.safe_load_file(File.join(Worldwide::Paths::OTHER_DATA_ROOT, "currency", "minor_symbols.yml")).freeze
       end
     end
 
@@ -170,7 +166,7 @@ module Worldwide
 
       if prefix?(locale)
         if formatted.include?("-")
-          "-#{symbol}#{space}#{formatted.sub(/\-/, "")}"
+          "-#{symbol}#{space}#{formatted.sub("-", "")}"
         else
           "#{symbol}#{space}#{formatted}"
         end

data/lib/worldwide/extant_outcodes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "singleton"
+require "yaml"
+
+module Worldwide
+  class ExtantOutcodes
+    include Singleton
+
+    class << self
+      extend Forwardable
+      def_delegators :instance, :for_country
+    end
+
+    def for_country(code:)
+      extant[code.to_s.downcase]
+    end
+
+    private
+
+    def initialize
+      @extant = nil
+    end
+
+    def extant
+      @extant ||= YAML.safe_load_file("#{::Worldwide::Paths::GEM_ROOT}/db/extant_outcodes.yml").dig("extant_outcodes")&.map do |key, value|
+        [key, value.to_set]
+      end&.to_h || {}
+    end
+  end
+end

data/lib/worldwide/phone.rb

@@ -48,6 +48,11 @@ module Worldwide
       @parsed_number.valid?
     end
 
+    # Returns the country prefix for the phone number
+    def country_prefix
+      @parsed_number.country_code
+    end
+
     private
 
     # For various reasons, Worldwide considers these territories to be zones inside the USA

data/lib/worldwide/region.rb

@@ -291,9 +291,14 @@ module Worldwide
       zip_example if @zip_autofill_enabled
     end
 
+    # The value with which to autofill the city, if this region has a default city; otherwise, nil.
+    def autofill_city(locale: I18n.locale)
+      field(key: :city).autofill(locale: locale)
+    end
+
     # Does this region require cities to be specified?
     def city_required?
-      field(key: :city).autofill(locale: :en).nil?
+      autofill_city(locale: :en).nil?
     end
 
     # Is this Region a continent?
@@ -386,7 +391,7 @@ module Worldwide
     # If the Region has an autofill zip, return the value that will be autofilled
     # Otherwise, return nil
     def zip_autofill
-      return zip_example if zip_autofill_enabled
+      zip_example if zip_autofill_enabled
     end
 
     # is a postal code required for this region?
@@ -511,7 +516,7 @@ module Worldwide
       return iso_code if iso_code.nil? || iso_code.length < 3
 
       country_code, subdivision_code = iso_code.split("-")
-      return subdivision_code if country_code.casecmp(associated_country.iso_code).zero?
+      subdivision_code if country_code.casecmp(associated_country.iso_code).zero?
     end
 
     def valid_normalized_zip?(normalized, province_code: nil, partial_match: false)

data/lib/worldwide/regions_loader.rb

@@ -199,7 +199,7 @@ module Worldwide
 
     def country_codes
       @country_codes ||=
-        YAML.safe_load(File.read("#{Worldwide::Paths::DB_DATA_ROOT}/country_codes.yml"))["country_codes"]
+        YAML.safe_load_file("#{Worldwide::Paths::DB_DATA_ROOT}/country_codes.yml")["country_codes"]
     end
 
     def find_region(code:)
@@ -212,7 +212,7 @@ module Worldwide
     end
 
     def load_territory(filename)
-      spec = YAML.safe_load(File.read(filename))
+      spec = YAML.safe_load_file(filename)
       code = spec["code"]
 
       loaded_regions = []

data/lib/worldwide/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Worldwide
-  VERSION = "0.10.3"
+  VERSION = "0.11.0"
 end

data/lib/worldwide/zip.rb

@@ -107,40 +107,38 @@ module Worldwide
         zip = strip_extraneous_characters(zip: zip, country_code: country_code)
       end
 
-      result = if gb_style?(country_code: country.iso_code)
-        normalize_for_gb(zip: zip)
+      return normalize_for_gb(zip: zip) if gb_style?(country_code: country.iso_code)
+
+      # Remove both normal-width and double-width spaces
+      zip.delete!(" 　")
+      zip = replace_letters_and_numbers(country_code: country.iso_code, zip: zip)
+
+      result = if "BD" == country.iso_code
+        normalize_for_bd(zip: zip)
+      elsif "FO" == country.iso_code
+        normalize_for_fo(zip: zip)
+      elsif "GH" == country.iso_code
+        normalize_for_gh(zip: zip)
+      elsif "HT" == country.iso_code
+        normalize_for_ht(zip: zip)
+      elsif "LK" == country.iso_code
+        normalize_for_lk(zip: zip)
+      elsif "MD" == country.iso_code
+        normalize_for_md(zip: zip)
+      elsif "MG" == country.iso_code
+        normalize_for_mg(zip: zip)
+      elsif "NG" == country.iso_code
+        normalize_for_ng(zip: zip)
+      elsif "SG" == country.iso_code
+        normalize_for_sg(zip: zip)
+      elsif "MA" == country.iso_code
+        normalize_for_ma(zip: zip)
+      elsif "XK" == country.iso_code
+        normalize_for_xk(zip: zip)
+      elsif "BR" == country.iso_code || "JP" == country.iso_code
+        insert_spaces_and_hyphens_for_partial_code(country_code: country.iso_code, zip: zip)
       else
-        # Remove both normal-width and double-width spaces
-        zip.delete!(" 　")
-        zip = replace_letters_and_numbers(country_code: country.iso_code, zip: zip)
-
-        if "BD" == country.iso_code
-          normalize_for_bd(zip: zip)
-        elsif "FO" == country.iso_code
-          normalize_for_fo(zip: zip)
-        elsif "GH" == country.iso_code
-          normalize_for_gh(zip: zip)
-        elsif "HT" == country.iso_code
-          normalize_for_ht(zip: zip)
-        elsif "LK" == country.iso_code
-          normalize_for_lk(zip: zip)
-        elsif "MD" == country.iso_code
-          normalize_for_md(zip: zip)
-        elsif "MG" == country.iso_code
-          normalize_for_mg(zip: zip)
-        elsif "NG" == country.iso_code
-          normalize_for_ng(zip: zip)
-        elsif "SG" == country.iso_code
-          normalize_for_sg(zip: zip)
-        elsif "MA" == country.iso_code
-          normalize_for_ma(zip: zip)
-        elsif "XK" == country.iso_code
-          normalize_for_xk(zip: zip)
-        elsif "BR" == country.iso_code || "JP" == country.iso_code
-          insert_spaces_and_hyphens_for_partial_code(country_code: country.iso_code, zip: zip)
-        else
-          insert_spaces_and_hyphens(country_code: country.iso_code, zip: zip)
-        end
+        insert_spaces_and_hyphens(country_code: country.iso_code, zip: zip)
       end
 
       if country.send(:valid_normalized_zip?, result)
@@ -161,7 +159,26 @@ module Worldwide
 
       return zip unless @split_code_countries.include?(country_code.to_s.upcase)
 
-      normalize(country_code: country_code, zip: zip)&.split(" ")&.first
+      normalized_input = normalize(country_code: country_code, zip: zip).upcase
+      normalized_country_code = country_code.to_s.upcase
+
+      if Worldwide.region(code: country_code).valid_zip?(normalized_input)
+        # We successfully normalized the postcode, so we can split on the space to determine the outcode
+        normalized_input&.split(" ")&.first
+      else
+        # We have either an invalid or an incomplete postcode.  Let's try some fancy heuristics
+        case country_code.to_s.upcase
+        when "CA", "IE"
+          # the FSA / routing code is the first 3 characters
+          normalized_input[0..2]
+        when "GB", "GG", "IM", "JE"
+          gb_style_outcode(country_code: normalized_country_code, input: normalized_input)
+        when "GI"
+          "GX11"
+        else
+          normalized_input
+        end
+      end
     end
 
     def strip_optional_country_prefix(country_code:, zip:)
@@ -195,6 +212,55 @@ module Worldwide
       end
     end
 
+    def gb_style_outcode(country_code:, input:)
+      normalized = input
+
+      m = /^([A-Z]{1,2})/.match(normalized)
+      return normalized if m.nil?
+
+      area = m[1]
+      return normalized if area.nil?
+
+      # Let's get the first, second and third characters following the area
+      first = normalized[area.length]
+      second = normalized[area.length + 1]
+      third = normalized[area.length + 2]
+
+      candidate = case area
+      when "E", "EC", "N", "NW", "SE", "SW", "W", "WC"
+        # These London districts may include a single-letter suffix as part of the district
+        # In all such cases, the district is one digit + one letter
+
+        if /[A-Z]/.match?(second)
+          # This must be a district suffix, so disctrict consists of first + second
+          "#{area}#{first}#{second}".strip
+        elsif /[A-Z]/.match?(third)
+          # Because third is a letter, second must be the sector, and the district must be a single digit
+          "#{area}#{first}".strip
+        else
+          # Otherwise, we'll assume that we've got a two-digit district
+          "#{area}#{first}#{second}".strip
+        end
+      else
+        # The outcode is the area plus at most two digits following it
+
+        if /[A-Z]/.match?(third)
+          # Because third is a letter, second must be the sector, and the district must be a single digit
+          "#{area}#{first}"
+        else
+          "#{area}#{first}#{second}".strip
+        end
+      end
+
+      if /[0-9]/.match?(second) && !Worldwide::ExtantOutcodes.for_country(code: country_code).include?(candidate)
+        # We've guessed a two-digit district that does not actually exist, so we'll assume a single-digit district.
+        # For example, "GL71" can't be an outcode, so we'll assume the user meant outcode "GL7".
+        "#{area}#{first}"
+      else
+        candidate
+      end
+    end
+
     private
 
     # Countries that use GB-style postal code spacing, and should normalize the same way as GB
@@ -350,7 +416,7 @@ module Worldwide
     GB_POSTAL_TOWN_WITH_SECOND_CHAR_OH = ["C", "S", "P", "Y"]
     private_constant :GB_POSTAL_TOWN_WITH_SECOND_CHAR_OH
 
-    # Based on postal code formats here: https://en.wikipedia.org/wiki/List_of_postal_codes
+    # Based on postal code formats here: https://en.wikipedia.org/wiki/List_of_zips
     NUMERIC_ONLY_ZIP_COUNTRIES = Set.new([
       "AF",
       "AL",
@@ -528,6 +594,8 @@ module Worldwide
           confidence = candidate_regex[1]
 
           normalized = normalize(country_code: candidate_code, zip: zip, allow_autofill: false)
+          next unless /[A-Z]/.match?(normalized) # Numeric-only postal codes are insufficiently specific
+
           if normalized.match(regex)
             candidate = Worldwide.region(code: candidate_code)
             suggestions.append([candidate, confidence]) if candidate.valid_zip?(normalized)
@@ -784,11 +852,22 @@ module Worldwide
         return "#{postal_town}#{division}#{division_suffix} #{digit}#{alpha}"
       end
 
-      # Check for outcode-only postcode
-      m = upcased.match(/^([A-Z]{1,2}\d{1,2}[A-Z]{0,1})\s*$/)
-      if !m.nil? && m[1].length <= 4
+      # If the input is only the postcode area (one or two letters), return just that with no trailing space
+      return upcased.strip if /^[A-Z]{1,2}$/.match?(upcased.strip)
+
+      inferred_outcode = gb_style_outcode(country_code: "GB", input: upcased)
+
+      if inferred_outcode.strip == upcased.strip
         # Note that we're intentionally appending a space, so that this outcode will work for prefix matching
-        "#{m[1]} "
+        return "#{inferred_outcode.strip} "
+      end
+
+      if inferred_outcode.nil?
+        # Fallback to returning the unmodified input if we weren't able to make sense of it
+        input
+      else
+        remainder = upcased[inferred_outcode.length..-1]
+        "#{inferred_outcode.strip} #{remainder.strip}"
       end
     end
 

data/lib/worldwide.rb

@@ -10,6 +10,7 @@ require "worldwide/locale"
 require "worldwide/locales"
 require "worldwide/paths"
 require "worldwide/version"
+require "worldwide/extant_outcodes"
 
 require "worldwide/address"
 require "worldwide/address_validator"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: worldwide
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.11.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-14 00:00:00.000000000 Z
+date: 2024-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -8170,6 +8170,7 @@ files:
 - db/data/regions/_default/zh-CN.yml
 - db/data/regions/_default/zh-TW.yml
 - db/data/world.yml
+- db/extant_outcodes.yml
 - formats.md
 - lib/worldwide.rb
 - lib/worldwide/address.rb
@@ -8185,6 +8186,7 @@ files:
 - lib/worldwide/currency.rb
 - lib/worldwide/deprecated_time_zone_mapper.rb
 - lib/worldwide/discounts.rb
+- lib/worldwide/extant_outcodes.rb
 - lib/worldwide/field.rb
 - lib/worldwide/fields.rb
 - lib/worldwide/i18n_exception_handler.rb
@@ -8231,7 +8233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.7
 signing_key: 
 specification_version: 4
 summary: Internationalization and localization APIs