google_i18n 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ec23d03d53d26a896f98d7fabc66aca0c4746f2ed186726f3f539f7a0596861
+  data.tar.gz: 9140529284abd1d9baaf8a892f819be6488eed5b9b90dfd1194e18590a604fdf
+SHA512:
+  metadata.gz: b4f5fd00aa37ff3af5c0ff170a89d393a16314818627f4327419890c4591504e897642f844bd787f19cf9b1c8a4d65202c0019d6248aee6ceb3951aeac95c94f
+  data.tar.gz: 8c17dc7c93918202286e304be5f971c4003ad996a3473562bc230516298f30a9dffbf9fa52483d9f0840e39c9defb7e6ccd16d0e579c0c2878bf42ffc800c6d2

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in google_i18n.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    google_i18n (0.1.3)
+      activesupport
+      json
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    json (2.5.1)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (10.5.0)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  google_i18n!
+  pry (~> 0.13.1)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.3

data/README.md

@@ -0,0 +1,89 @@
+# Google I18n Address
+
+This gem provides I18n address normalization and validation based on
+[Google's i18n address repository](https://chromium-i18n.appspot.com/ssl-address).
+
+Code was ported to Ruby from this 
+[Python package](https://github.com/mirumee/google-i18n-address).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'google_i18n'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google_i18n
+
+## Usage
+
+Initialize with some combination of the following:
+ - `country_code` The two-letter ISO 3166-1 country code
+ - `street_address` The street address
+ - `city` The city or town
+ - `city_area` The sublocality or district
+ - `name` A person's name
+ - `company_name` The name of a company or organization
+ - `country_area` The region, province or state
+ - `sorting_code` The sorting code
+ - `postal_code` The postal code or zip code
+
+### Normalization
+
+```
+address = {country_code: 'US', country_area: 'California', city: 'Mountain View', postal_code: '94043', street_address: '1600 Amphitheatre Pkwy'}
+a = GoogleI18n::Address.new(address)
+a.normalize
+ => #<GoogleI18n::Address @country_code="US", @country_area="CA", @city="MOUNTAIN VIEW", @city_area="", @postal_code="94043", @street_address="1600 Amphitheatre Pkwy", @sorting_code="">
+a.to_s
+ => "1600 Amphitheatre Pkwy\nMOUNTAIN VIEW , CA 94043\nUNITED STATES"
+a.field_order
+ => [["name"], ["company_name"], ["street_address"], ["city", "country_area", "postal_code"], ["country_name"]]
+
+address = {country_code: 'CN', 'country_area': 'Beijing', 'city': 'Chaoyang', 'postal_code': '100600', street_address: '55 Anjialou Rd'}
+GoogleI18n::Address.new(address).normalize
+ => #<GoogleI18n::Address @country_code="CN", @street_address="55 Anjialou Rd", @city="朝阳区", @country_area="北京市", @postal_code="100600", @city_area="", @sorting_code="">
+```
+
+### Latinization
+
+```
+address = {'country_code': 'CN', 'country_area': '北京市', 'city': '朝阳区', 'city_area': '三元桥', 'street_address': '安家楼路55号', 'postal_code': '100600'}
+GoogleI18n::Address.new(address).latinize
+ => #<GoogleI18n::Address @country_code="CN", @country_area="Beijing Shi", @city="Chaoyang Qu", @city_area="三元桥", @postal_code="100600", @street_address="安家楼路55号", @sorting_code="">
+GoogleI18n::Address.new(address).latinize.normalize
+ => #<GoogleI18n::Address @country_code="CN", @street_address="55 Anjialou Rd", @city="朝阳区", @country_area="北京市", @postal_code="100600", @city_area="", @sorting_code="">
+```
+
+### Validation
+
+```
+GoogleI18n::Address.new({country_code: 'US'}).normalize
+ => GoogleI18n::InvalidAddress (Invalid address {"country_area"=>"required", "city"=>"required", "postal_code"=>"required", "street_address"=>"required"})
+```
+
+### Country Areas
+
+```
+GoogleI18n::Address.new({country_code: 'US'}).country_area_choices
+ => [['AL', 'Alabama'], ..., ['WY', 'Wyoming']]
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitLab at https://gitlab.com/dimitridee/google_i18n

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "google_i18n"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/google_i18n.gemspec

@@ -0,0 +1,45 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "google_i18n/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "google_i18n"
+  spec.version       = GoogleI18n::VERSION
+  spec.authors       = ["Dimitri D"]
+  spec.email         = ["demonitri@gmail.com"]
+
+  spec.summary       = %q{i18n address standardization and validation using Google's i18n address repo}
+  # spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://gitlab.com/dimitri_dee/google_i18n"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = spec.homepage
+    spec.metadata["changelog_uri"] = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.13.1"
+
+  spec.add_dependency 'json'
+  spec.add_dependency "activesupport"
+end

data/lib/google_i18n.rb

@@ -0,0 +1,12 @@
+require "json"
+require "active_support/core_ext/object/blank"
+require "active_support/ordered_hash"
+
+module GoogleI18n
+  class InvalidAddress < StandardError; end
+  class Error < StandardError; end
+
+  require "google_i18n/version"
+  require "google_i18n/validation_rules"
+  require "google_i18n/address"
+end

data/lib/google_i18n/address.rb

@@ -0,0 +1,495 @@
+module GoogleI18n
+  class Address
+    VALID_COUNTRY_CODE = %r(^\w{2,3}$)
+    VALIDATION_DATA_DIR = File.join(File.dirname(__FILE__), "data")
+    VALIDATION_DATA_PATH = File.join(VALIDATION_DATA_DIR, "%s.json")
+
+    FIELD_MAPPING = {
+      "A" => "street_address",
+      "C" => "city",
+      "D" => "city_area",
+      "N" => "name",
+      "O" => "company_name",
+      "S" => "country_area",
+      "X" => "sorting_code",
+      "Z" => "postal_code",
+    }
+
+    KNOWN_FIELDS = FIELD_MAPPING.values.push("country_code")
+
+    attr_accessor :country_code, :street_address, :city, :city_area, :name, :company_name, 
+                  :country_area, :sorting_code, :postal_code
+
+    # Creates a new Address object from component parts
+    # 
+    # @option options [String] :country_code The two-letter ISO 3166-1 country code
+    # @option options [String] :street_address The street address
+    # @option options [String] :city The city or town
+    # @option options [String] :city_area The sublocality or district
+    # @option options [String] :name A person's name
+    # @option options [String] :company_name The name of a company or organization
+    # @option options [String] :country_area The region, province or state
+    # @option options [String] :sorting_code The sorting code
+    # @option options [String] :postal_code The postal code or zip code
+    # 
+    # @return [GoogleI18n::Address] The constructed Address
+    def initialize(options={})
+      @country_code = options[:country_code] if options[:country_code]
+      @street_address = options[:street_address] if options[:street_address]
+      @city = options[:city] if options[:city]
+      @city_area = options[:city_area] if options[:city_area]
+      @name = options[:name] if options[:name]
+      @company_name = options[:company_name] if options[:company_name]
+      @country_area = options[:country_area] if options[:country_area]
+      @sorting_code = options[:sorting_code] if options[:sorting_code]
+      @postal_code = options[:postal_code] if options[:postal_code]
+    end
+
+    def dup
+      self.class.new(
+        country_code: self.country_code ? self.country_code.dup : nil,
+        street_address: self.street_address ? self.street_address.dup : nil,
+        city: self.city ? self.city.dup : nil,
+        city_area: self.city_area ? self.city_area.dup : nil,
+        name: self.name ? self.name.dup : nil,
+        company_name: self.company_name ? self.company_name.dup : nil,
+        country_area: self.country_area ? self.country_area.dup : nil,
+        sorting_code: self.sorting_code ? self.sorting_code.dup : nil,
+        postal_code: self.postal_code ? self.postal_code.dup : nil,
+      )
+    end
+
+    def to_h
+      {
+        country_code: self.country_code,
+        street_address: self.street_address,
+        city: self.city,
+        city_area: self.city_area,
+        name: self.name,
+        company_name: self.company_name,
+        country_area: self.country_area,
+        sorting_code: self.sorting_code,
+        postal_code: self.postal_code,
+      }
+    end
+
+    # Displays the address in a newline delimited format suitable for printing
+    # 
+    # @param normalize [Boolean] If true, address will be normalized first
+    # @param latin [Boolean] Show the address fields in Latinized order
+    # 
+    # @return [String]
+    def to_s(normalize: true, latin: false)
+      cleaned_data = address.dup
+      cleaned_data = cleaned_data.normalize if normalize
+
+      rules = get_validation_rules
+
+      address_format = if latin
+        rules.address_latin_format
+      else
+        rules.address_format
+      end
+
+      address_line_formats = address_format.split("%n")
+
+      address_lines = address_line_formats.inject([]) do |m, line_format|
+        m << format_address_line(line_format, cleaned_data, rules)
+        m
+      end
+
+      address_lines << rules.country_name
+      address_lines.keep_if(&:present?)
+      address_lines.join("\n")
+    end
+
+    # Returns an array where each element is an array representing the fields to include on each address line, e.g:
+    #   [["name"], ["company_name"], ["street_address"], ["city", "country_area", "postal_code"], ["country_name"]]
+    # 
+    # @param latin [Boolean] Show the address fields in Latinized order
+    # 
+    # @return [Array<Array<String>>]
+    def field_order(latin: false)
+      rules = get_validation_rules
+
+      address_format = if latin
+        rules.address_latin_format
+      else
+        rules.address_format
+      end
+
+      address_lines = address_format.split("%n")
+
+      replacements = FIELD_MAPPING.inject({}) do |m, (code, field_name)|
+        m["%#{code}"] = field_name
+        m
+      end
+
+      all_lines = []
+      address_lines.each do |line|
+        fields = line.split(%r{(%.)})
+        single_line = fields.map {|field| replacements[field]}.compact
+        all_lines << single_line
+      end
+
+      all_lines << Array('country_name')
+    end
+
+    # Returns an array where each element is an array representing the key and value for each country area. e.g:
+    #   [['AL', 'Alabama'], ..., ['WY', 'Wyoming']]
+    def country_area_choices
+      get_validation_rules.country_area_choices
+    end
+
+    # Format the address in a way suitable for use in its part of the world
+    # 
+    # @return [GoogleI18n::Address]
+    def normalize
+      errors = {}
+      # begin
+        rules = get_validation_rules
+      # rescue StandardError
+      #   errors["country_code"] = "invalid"
+      # end
+
+      if errors.blank?
+        cleaned_data = address.dup
+        country_code = cleaned_data.country_code
+        if country_code.blank?
+          errors["country_code"] = "required"
+        else
+          cleaned_data.country_code = country_code.upcase
+        end
+
+        cleaned_data.country_area, errors = normalize_field("country_area", rules, cleaned_data, rules.country_area_choices, errors)
+        cleaned_data.city, errors = normalize_field("city", rules, cleaned_data, rules.city_choices, errors)
+        cleaned_data.city_area, errors = normalize_field("city_area", rules, cleaned_data, rules.city_area_choices, errors)
+        cleaned_data.postal_code, errors = normalize_field("postal_code", rules, cleaned_data, [], errors)
+
+        postal_code = cleaned_data.postal_code
+        if rules.postal_code_matchers.present? && postal_code.present?
+          rules.postal_code_matchers.each do |matcher|
+            if !matcher.match(postal_code)
+              errors["postal_code"] = "invalid"
+              break
+            end
+          end
+        end
+
+        cleaned_data.street_address, errors = normalize_field("street_address", rules, cleaned_data, [], errors)
+        cleaned_data.sorting_code, errors = normalize_field("sorting_code", rules, cleaned_data, [], errors)
+        cleaned_data
+      end
+
+      if errors.present?
+        raise InvalidAddress, "Invalid address #{errors}"
+      end
+
+      cleaned_data
+    end
+
+    # Format the address in a way suitable for use in Latin alphabets.
+    #   If a latinized version is not available, the local version will be used instead.
+    # 
+    # @param normalize [Boolean] If true, address will be normalized first
+    # 
+    # @return [GoogleI18n::Address]
+    def latinize(normalize: true)
+      cleaned_data = address.dup
+      cleaned_data = cleaned_data.normalize if normalize
+
+      country_code = cleaned_data.country_code&.upcase
+      dummy_country_data, database = load_country_data(country_code)
+
+      if country_code.present?
+        country_area = cleaned_data.country_area
+        if country_area.present?
+          key = "%s/%s" % [country_code, country_area]
+          country_area_data = database[key]
+          if country_area_data.present?
+            cleaned_data.country_area = country_area_data.fetch("lname", country_area_data.fetch("name", country_area))
+            city = cleaned_data.city
+            key = "%s/%s/%s" % [country_code, country_area, city]
+            city_data = database[key]
+            if city_data.present?
+              cleaned_data.city = city_data.fetch("lname", city_data.fetch("name", city))
+              city_area = cleaned_data.city_area
+              key = "%s/%s/%s/%s" % [country_code, country_area, city, city_area]
+              city_area_data = database[key]
+              if city_area_data.present?
+                cleaned_data.city_area = city_area_data.fetch("lname", city_area_data.fetch("name", city_area))
+              end
+            end
+          end
+        end
+      end
+
+      cleaned_data
+    end
+
+    private
+
+    def address
+      self
+    end
+
+    def format_address_line(line_format, address, rules)
+      replacements = FIELD_MAPPING.inject({}) do |m, (code, field_name)|
+        value = address.send(field_name)
+        value = value.upcase if rules.upper_fields.include?(field_name)
+        m["%#{code}"] = value
+        m
+      end
+
+      fields = line_format.split(%r{(%.)})
+      fields = fields.map {|field| replacements.fetch(field, field)&.strip}
+      fields.keep_if(&:present?)
+      fields.join(' ')
+    end
+
+    def normalize_field(name, rules, data, choices, errors)
+      value = data.send(name)
+
+      if rules.upper_fields.include?(name) && value.present?
+        data.send("#{name}=", value.upcase)
+      end
+
+      if !rules.allowed_fields.include?(name)
+        data.send("#{name}=", "")
+      elsif value.blank?
+        if rules.required_fields.include?(name)
+          errors[name] = "required"
+        else
+          data.send("#{name}=", "")
+        end
+      elsif choices.present?
+        if value.present? || rules.required_fields.include?(name)
+          value = match_choices(value, choices)
+          if value.present?
+            data.send("#{name}=", value)
+          else
+            errors[name] = "invalid"
+          end
+        end
+      end
+
+      [data.send(name), errors]
+    end
+
+    def make_choices(rules, translated = false)
+      sub_keys = rules["sub_keys"]
+      return if sub_keys.blank?
+
+      choices = []
+      sub_keys = sub_keys.split("~")
+
+      if sub_names = rules["sub_names"]
+        choices += sub_keys.zip(sub_names.split("~"))
+      elsif !translated
+        choices += sub_keys.zip(sub_keys)
+      end
+
+      if !translated
+        if sub_lnames = rules["sub_lnames"]
+          choices += sub_keys.zip(sub_lnames.split("~"))
+        end
+
+        if sub_lfnames = rules["sub_lfnames"]
+          choices += sub_keys.zip(sub_lfnames.split("~"))
+        end
+      end
+
+      choices
+    end
+
+    # This returns the regional form of `value`.
+    # `choices` looks something like this: [['安徽省', 'Anhui Sheng'], ['安徽省', '安徽省']]
+    # the idea is that whether `value` is 'Anhui Sheng' or '安徽省', it will return '安徽省'
+    def match_choices(value, choices)
+      return if value.blank?
+      value = value.strip.downcase
+      # using `match` here rather than `==` because we want them to be able to use "New York" and "New York City"
+      matched = choices.select { |name, label| name&.downcase.to_s.match(value) || label&.downcase.to_s.match(value) }
+      matched.flatten.first
+    end
+
+    # This returns something like:
+    # [['AL', 'Alabama'], ['AK', 'Alaska'], ['AS', 'American Samoa'], ['AZ', 'Arizona'], ...]
+    # or for non-latin alphabets:
+    # [['安徽省', 'Anhui Sheng'], ['安徽省', '安徽省'], ['澳门', 'Macau'], ['澳门', '澳门'], ['北京市', 'Beijing Shi'], ['北京市', '北京市'], ...]
+    def compact_choices(choices)
+      value_map = ActiveSupport::OrderedHash.new {|hsh, key| hsh[key] = [] }
+      choices.each do |key, value|
+        value_map[key] << value.to_s
+      end
+
+      ret = []
+      value_map.each do |k,vv|
+        vv.sort.each do |v|
+          ret << [k,v]
+        end
+      end
+
+      ret
+    end
+
+    def get_validation_rules
+      country_code = address.country_code&.upcase
+      country_data, database = load_country_data(country_code)
+      country_name = country_data.fetch("name", "")
+      address_format = country_data["fmt"]
+      address_latin_format = country_data.fetch("lfmt", address_format)
+
+      allowed_fields = address_format.scan(%r{%([#{FIELD_MAPPING.keys.join}])}).flatten
+      allowed_fields = FIELD_MAPPING.fetch_values(*allowed_fields)
+      required_fields = FIELD_MAPPING.fetch_values(*country_data["require"].split(//))
+      upper_fields = FIELD_MAPPING.fetch_values(*country_data["upper"].split(//))
+
+      languages = country_data["languages"]&.split("~") || []
+
+      postal_code_matchers = []
+      if allowed_fields.include?("postal_code") && country_data.has_key?("zip")
+        postal_code_matchers << %r(^#{country_data["zip"]}$)
+      end
+
+      postal_code_examples = country_data["zipex"]&.split(",") || []
+
+      country_area_choices = []
+      city_choices = []
+      city_area_choices = []
+      country_area_type = country_data["state_name_type"]
+      city_type = country_data["locality_name_type"]
+      city_area_type = country_data["sublocality_name_type"]
+      postal_code_type = country_data["zip_name_type"]
+      postal_code_prefix = country_data.fetch("postprefix", "")
+
+      # second level of data is for administrative areas
+      country_area = nil
+      city = nil
+      city_area = nil
+      if database.has_key?(country_code)
+        if country_data.has_key?("sub_keys")
+          languages.each do |language|
+            is_default_language = (language.blank? || language == country_data["lang"])
+            matched_country_area = nil
+            matched_city = nil
+            if is_default_language
+              localized_country_data = database[country_code]
+            else
+              localized_country_data = database["#{country_code}--#{language}"]
+            end
+
+            localized_country_area_choices = make_choices(localized_country_data)
+            country_area_choices += localized_country_area_choices
+            existing_choice = country_area.present?
+            matched_country_area = country_area = match_choices(address.country_area, localized_country_area_choices)
+
+            # third level of data is for cities
+            if matched_country_area.present?
+              if is_default_language
+                country_area_data = database["#{country_code}/#{country_area}"]
+              else
+                country_area_data = database["#{country_code}/#{country_area}--#{language}"]
+              end
+
+              if existing_choice.blank?
+                if country_area_data.include?("zip")
+                  postal_code_matchers << %r(^#{country_area_data["zip"]})
+                end
+
+                if country_area_data.include?("zipex")
+                  postal_code_examples = country_area_data["zipex"].split(",")
+                end
+              end
+
+              if country_area_data.include?("sub_keys")
+                localized_city_choices = make_choices(country_area_data)
+                city_choices += localized_city_choices
+                existing_choice = city.present?
+                matched_city = city = match_choices(address.city, localized_city_choices)
+              end
+
+              # fourth level of data is for dependent sublocalities
+              if matched_city.present?
+                if is_default_language
+                  city_data = database["#{country_code}/#{country_area}/#{city}"]
+                else
+                  city_data = database["#{country_code}/#{country_area}/#{city}--#{language}"]
+                end
+
+                if existing_choice.blank?
+                  if city_data.include?("zip")
+                    postal_code_matchers << %r(^#{city_data["zip"]})
+                  end
+
+                  if city_data.include?("zipex")
+                    postal_code_examples = city_data["zipex"].split(",")
+                  end
+                end
+
+                if city_data.include?("sub_keys")
+                  localized_city_area_choices = make_choices(city_data)
+                  city_area_choices += localized_city_area_choices
+                  existing_choice = city_area.present?
+                  matched_city_area = city_area = match_choices(address.city_area, localized_city_area_choices)
+                  if matched_city_area.present?
+                    if is_default_language
+                      city_area_data = database["#{country_code}/#{country_area}/#{city}/#{city_area}"]
+                    else
+                      city_area_data = database["#{country_code}/#{country_area}/#{city}/#{city_area}--#{language}"]
+                    end
+
+                    if existing_choice.blank?
+                      if city_area_data.include?("zip")
+                        postal_code_matchers << %r(^#{city_area_data["zip"]})
+                      end
+                      if city_area_data.include?("zipex")
+                        postal_code_examples = city_area_data["zipex"].split(",")
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          country_area_choices = compact_choices(country_area_choices)
+          city_choices = compact_choices(city_choices)
+          city_area_choices = compact_choices(city_area_choices)
+        end
+      end
+
+      ValidationRules.new(country_code, country_name, address_format, address_latin_format,
+                          allowed_fields, required_fields, upper_fields, country_area_type,
+                          country_area_choices, city_type, city_choices, city_area_type, city_area_choices,
+                          postal_code_type, postal_code_matchers, postal_code_examples, postal_code_prefix)
+    end
+
+    def load_validation_data(country_code="all")
+      if !VALID_COUNTRY_CODE.match(country_code)
+        raise "#{country_code} is not a valid country code"
+      end
+
+      path = VALIDATION_DATA_PATH % country_code.downcase
+      if !File.exist?(path)
+        raise "No metadata file exists at path: #{path}"
+      end
+
+      JSON.parse(File.read(path))
+    end
+
+    def load_country_data(country_code)
+      # This ZZ stuff is just defaults to init with
+      database = load_validation_data("zz")
+      country_data = database["ZZ"]
+      if country_code
+        country_code = country_code.upcase
+        if country_code.downcase == "zz"
+          raise "'#{country_code}' is not a valid country code"
+        end
+        database = load_validation_data(country_code.downcase)
+        country_data.merge!(database[country_code.upcase])
+      end
+      [country_data, database]
+    end
+  end
+end