atlas_engine 0.2.0 → 0.3.0

data/app/models/atlas_engine/address_validation/validators/full_address/concern_builder.rb

@@ -10,8 +10,6 @@ module AtlasEngine
 
           attr_reader :unmatched_component, :unmatched_field, :matched_components, :address, :suggestion_ids
 
-          UNMATCHED_COMPONENTS_SUGGESTION_THRESHOLD = 2
-
           class << self
             extend T::Sig
 
@@ -22,16 +20,21 @@ module AtlasEngine
               ).returns(T::Boolean)
             end
             def should_suggest?(address, unmatched_component_keys)
-              return false if too_many_unmatched_components?(unmatched_component_keys)
+              return false if too_many_unmatched_components?(address, unmatched_component_keys)
 
               return false if province_and_city_xor_zip?(unmatched_component_keys) && !valid_zip_for_province?(address)
 
               true
             end
 
-            sig { params(unmatched_component_keys: T::Array[Symbol]).returns(T::Boolean) }
-            def too_many_unmatched_components?(unmatched_component_keys)
-              unmatched_component_keys.size > UNMATCHED_COMPONENTS_SUGGESTION_THRESHOLD
+            sig do
+              params(
+                address: AbstractAddress,
+                unmatched_component_keys: T::Array[Symbol],
+              ).returns(T::Boolean)
+            end
+            def too_many_unmatched_components?(address, unmatched_component_keys)
+              unmatched_component_keys.size > unmatched_components_suggestion_threshold(address)
             end
 
             sig { params(address: AbstractAddress).returns(T::Boolean) }
@@ -62,6 +65,12 @@ module AtlasEngine
 
               province.valid_zip?(address.zip)
             end
+
+            sig { params(address: AbstractAddress).returns(Integer) }
+            def unmatched_components_suggestion_threshold(address)
+              country_profile = CountryProfile.for(T.must(address.country_code))
+              country_profile.validation.unmatched_components_suggestion_threshold
+            end
           end
 
           sig do

data/app/models/atlas_engine/address_validation/validators/full_address/exclusions/exclusion_base.rb

@@ -12,8 +12,14 @@ module AtlasEngine
               extend T::Helpers
               abstract!
 
-              sig { abstract.params(session: Session, candidate: Candidate).returns(T::Boolean) }
-              def apply?(session, candidate); end
+              sig do
+                abstract.params(
+                  session: Session,
+                  candidate: Candidate,
+                  address_comparison: AddressComparison,
+                ).returns(T::Boolean)
+              end
+              def apply?(session, candidate, address_comparison); end
             end
           end
         end

data/app/models/atlas_engine/address_validation/validators/full_address/field_comparison_base.rb

@@ -0,0 +1,77 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class FieldComparisonBase
+          extend T::Sig
+          extend T::Helpers
+
+          abstract!
+
+          SUPPORTED_FIELDS = Set.new([:street, :city, :zip, :province_code, :building])
+
+          sig { params(address: AbstractAddress, candidate: Candidate, datastore: DatastoreBase).void }
+          def initialize(address:, candidate:, datastore:)
+            @address = address
+            @datastore = datastore
+            @candidate = candidate
+          end
+
+          sig { abstract.returns(T.any(T.nilable(Token::Sequence::Comparison), T.nilable(NumberComparison))) }
+          def sequence_comparison; end
+
+          sig { returns(T::Boolean) }
+          def match?
+            return false if sequence_comparison.nil?
+
+            T.must(sequence_comparison).match?
+          end
+
+          private
+
+          sig { returns(AbstractAddress) }
+          attr_reader :address
+
+          sig { returns(DatastoreBase) }
+          attr_reader :datastore
+
+          sig { returns(Candidate) }
+          attr_reader :candidate
+
+          sig do
+            params(
+              sequence: Token::Sequence,
+              component_sequences: T::Array[Token::Sequence],
+              comparison_policy: Token::Sequence::ComparisonPolicy,
+            ).returns(T.nilable(Token::Sequence::Comparison))
+          end
+          def best_comparison(
+            sequence,
+            component_sequences,
+            comparison_policy = Token::Sequence::ComparisonPolicy::DEFAULT_POLICY
+          )
+            component_sequences.map do |component_sequence|
+              Token::Sequence::Comparator.new(
+                left_sequence: sequence,
+                right_sequence: component_sequence,
+                comparison_policy:,
+              ).compare
+            end.min_by.with_index do |comparison, index|
+              # ruby's `min` and `sort` methods are not stable
+              # so we need to prefer the leftmost comparison when two comparisons are equivalent
+              [comparison, index]
+            end
+          end
+
+          sig { params(field: Symbol).returns(Token::Sequence::ComparisonPolicy) }
+          def field_policy(field)
+            datastore.country_profile.validation.comparison_policy(field)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/full_address/province_code_comparison.rb

@@ -0,0 +1,34 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class ProvinceCodeComparison < FieldComparisonBase
+          extend T::Sig
+
+          sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
+          def sequence_comparison
+            return @province_code_comparison if defined?(@province_code_comparison)
+
+            normalized_session_province_code = ValidationTranscriber::ProvinceCodeNormalizer.normalize(
+              country_code: address.country_code,
+              province_code: address.province_code,
+            )
+            normalized_candidate_province_code = ValidationTranscriber::ProvinceCodeNormalizer.normalize(
+              country_code: T.must(candidate.component(:country_code)).value,
+              province_code: T.must(candidate.component(:province_code)).value,
+            )
+
+            @province_code_comparison = best_comparison(
+              Token::Sequence.from_string(normalized_session_province_code),
+              [Token::Sequence.from_string(normalized_candidate_province_code)],
+              field_policy(:province_code),
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/full_address/relevant_components.rb

@@ -8,7 +8,14 @@ module AtlasEngine
         class RelevantComponents
           extend T::Sig
 
-          attr_reader :session, :candidate, :street_comparison
+          sig { returns(Session) }
+          attr_reader :session
+
+          sig { returns(Candidate) }
+          attr_reader :candidate
+
+          sig { returns(AddressComparison) }
+          attr_reader :address_comparison
 
           ALL_SUPPORTED_COMPONENTS = [
             :province_code,
@@ -21,18 +28,19 @@ module AtlasEngine
             params(
               session: Session,
               candidate: Candidate,
-              street_comparison: T.nilable(AtlasEngine::AddressValidation::Token::Sequence::Comparison),
+              address_comparison: AddressComparison,
             ).void
           end
-          def initialize(session, candidate, street_comparison)
+          def initialize(session, candidate, address_comparison)
             @session = session
             @candidate = candidate
-            @street_comparison = street_comparison
+            @address_comparison = address_comparison
           end
 
           sig { returns(T::Array[Symbol]) }
           def components_to_validate
             supported_components = ALL_SUPPORTED_COMPONENTS.dup - unsupported_components_for_country
+            apply_exclusions(supported_components)
             supported_components.delete(:street) if exclude_street_validation?
             supported_components
           end
@@ -44,6 +52,18 @@ module AtlasEngine
 
           private
 
+          sig { params(supported_components: T::Array[Symbol]).void }
+          def apply_exclusions(supported_components)
+            supported_components.delete_if do |component|
+              exclusions(component).any? do |exclusion|
+                if exclusion.apply?(session, candidate, address_comparison)
+                  emit_excluded_validation(component, "excluded")
+                  true
+                end
+              end
+            end
+          end
+
           sig { returns(T::Boolean) }
           def exclude_street_validation?
             return @exclude_street_validation if defined?(@exclude_street_validation)
@@ -51,23 +71,25 @@ module AtlasEngine
             @exclude_street_validation = if session.matching_strategy !=
                 AddressValidation::MatchingStrategies::EsStreet
               true
-            elsif street_comparison.blank?
-              emit_excluded_validation("street", "not_found")
-              true
-            elsif exclusions("street").any? { |exclusion| exclusion.apply?(session, candidate) }
-              emit_excluded_validation("street", "excluded")
+            elsif address_comparison.street_comparison.sequence_comparison.blank?
+              emit_excluded_validation(:street, "not_found")
               true
             else
               false
             end
           end
 
-          sig { params(component: String).returns(T::Array[T.class_of(Exclusions::ExclusionBase)]) }
+          sig { params(component: Symbol).returns(T::Array[T.class_of(Exclusions::ExclusionBase)]) }
           def exclusions(component)
-            CountryProfile.for(session.country_code).validation.validation_exclusions(component: component)
+            country_profile.validation.validation_exclusions(component: component)
+          end
+
+          sig { returns(CountryProfile) }
+          def country_profile
+            @country_profile ||= CountryProfile.for(session.country_code)
           end
 
-          sig { params(component: String, reason: String).void }
+          sig { params(component: Symbol, reason: String).void }
           def emit_excluded_validation(component, reason)
             tags = [
               "reason:#{reason}",

data/app/models/atlas_engine/address_validation/validators/full_address/street_comparison.rb

@@ -0,0 +1,30 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class StreetComparison < FieldComparisonBase
+          extend T::Sig
+
+          sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
+          def sequence_comparison
+            return @street_comparison if defined?(@street_comparison)
+
+            street_sequences = datastore.fetch_street_sequences
+            candidate_sequences = T.must(candidate.component(:street)).sequences
+
+            @street_comparison = street_sequences.map do |street_sequence|
+              best_comparison(
+                street_sequence,
+                candidate_sequences,
+                field_policy(:street),
+              )
+            end.min
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/full_address/suggestion_builder.rb

@@ -126,7 +126,7 @@ module AtlasEngine
               ).returns(String)
             end
             def generic_field_suggestion(comparison, candidate, field)
-              if comparison.token_match_count == 0 || comparison.aggregate_edit_distance > 2
+              if comparison.token_match_count == 0 || comparison.aggregate_distance > 2
                 candidate.component(field)&.first_value
               else
                 comparison.right_sequence.raw_value

data/app/models/atlas_engine/address_validation/validators/full_address/zip_comparison.rb

@@ -0,0 +1,37 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class ZipComparison < FieldComparisonBase
+          extend T::Sig
+
+          sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
+          def sequence_comparison
+            return @zip_comparison if defined?(@zip_comparison)
+
+            candidate.component(:zip)&.value = PostalCodeMatcher.new(
+              T.must(address.country_code),
+              T.must(address.zip),
+              candidate.component(:zip)&.value,
+            ).truncate
+
+            normalized_zip = ValidationTranscriber::ZipNormalizer.normalize(
+              country_code: address.country_code, zip: address.zip,
+            )
+
+            zip_sequence = Token::Sequence.from_string(normalized_zip)
+
+            @zip_comparison = best_comparison(
+              zip_sequence,
+              T.must(candidate.component(:zip)).sequences,
+              field_policy(:zip),
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/predicates/street/building_number_in_address1_or_address2.rb

@@ -12,7 +12,7 @@ module AtlasEngine
               return unless @cache.country.country?
               return unless @cache.country.building_number_required
               return unless @cache.country.building_number_may_be_in_address2
-              return if contains_number?(T.must(@address.address1)) || contains_number?(T.must(@address.address2))
+              return if contains_number?(T.must(@address.address1)) || contains_number?(@address.address2)
 
               build_concern
             end
@@ -31,7 +31,7 @@ module AtlasEngine
               )
             end
 
-            sig { params(text: String).returns(T::Boolean) }
+            sig { params(text: T.nilable(String)).returns(T::Boolean) }
             def contains_number?(text)
               /[0-9\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\uff10-\uff19]/.match?(text)
             end

data/app/models/atlas_engine/country_profile_validation_subset.rb

@@ -24,11 +24,11 @@ module AtlasEngine
     end
 
     sig do
-      params(component: String)
+      params(component: Symbol)
         .returns(T::Array[T.class_of(AddressValidation::Validators::FullAddress::Exclusions::ExclusionBase)])
     end
     def validation_exclusions(component:)
-      validation_exclusions = attributes.dig("exclusions", component) || []
+      validation_exclusions = attributes.dig("exclusions", component.to_s) || []
       validation_exclusions.map(&:constantize)
     end
 
@@ -49,5 +49,38 @@ module AtlasEngine
     def normalized_components
       attributes.dig("normalized_components") || []
     end
+
+    sig { params(field: Symbol).returns(AddressValidation::Token::Sequence::ComparisonPolicy) }
+    def comparison_policy(field)
+      field_policy = attributes.dig(
+        "comparison_policies",
+        field.to_s,
+      )&.deep_symbolize_keys&.deep_transform_values!(&:to_sym)
+
+      if field_policy.present?
+        AddressValidation::Token::Sequence::ComparisonPolicy.new(**field_policy)
+      else
+        AddressValidation::Token::Sequence::ComparisonPolicy::DEFAULT_POLICY
+      end
+    end
+
+    sig { returns(Integer) }
+    def unmatched_components_suggestion_threshold
+      attributes.dig("unmatched_components_suggestion_threshold") || 2
+    end
+
+    sig { params(field: Symbol).returns(T::Class[AddressValidation::Validators::FullAddress::FieldComparisonBase]) }
+    def address_comparison(field:)
+      unless field.in?(AddressValidation::Validators::FullAddress::FieldComparisonBase::SUPPORTED_FIELDS)
+        raise ArgumentError.new, "Field #{field} is not supported"
+      end
+
+      attributes.dig("address_comparison", field.to_s).constantize
+    end
+
+    sig { returns(Integer) }
+    def zip_prefix_length
+      attributes.dig("zip_prefix_length") || 0
+    end
   end
 end

data/db/data/country_profiles/default.yml

@@ -17,5 +17,17 @@ validation:
   query_builder: AtlasEngine::AddressValidation::Es::DefaultQueryBuilder
   address_parser: AtlasEngine::ValidationTranscriber::AddressParserBase
   restrictions: []
+  comparison_policies:
+    street: {}
+    city: {}
+    zip: {}
+    province_code: {}
+  unmatched_components_suggestion_threshold: 2
+  address_comparison:
+    street: AtlasEngine::AddressValidation::Validators::FullAddress::StreetComparison
+    city: AtlasEngine::AddressValidation::Validators::FullAddress::CityComparison
+    zip: AtlasEngine::AddressValidation::Validators::FullAddress::ZipComparison
+    province_code: AtlasEngine::AddressValidation::Validators::FullAddress::ProvinceCodeComparison
+    building: AtlasEngine::AddressValidation::Validators::FullAddress::BuildingComparison
 decompounding_patterns:
   street: []

data/lib/atlas_engine/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AtlasEngine
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/tasks/atlas_engine/graphql.rake

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+T.bind(self, Rake::DSL)
+
+namespace :atlas_engine do
+  namespace :graphql do
+    desc "Dump the GraphQL Schema"
+    task schema_dump: :environment do
+      AtlasEngine::Schema.dump
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_engine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-24 00:00:00.000000000 Z
+date: 2024-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: annex_29
@@ -212,14 +212,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.7
 description: The Atlas Engine is a rails engine that provides a GraphQL API for address
   validation.
 email: developers@shopify.com
@@ -278,6 +278,10 @@ files:
 - app/countries/atlas_engine/dk/country_profile.yml
 - app/countries/atlas_engine/dk/synonyms.yml
 - app/countries/atlas_engine/dk/validation_transcriber/address_parser.rb
+- app/countries/atlas_engine/es/country_profile.yml
+- app/countries/atlas_engine/es/synonyms.yml
+- app/countries/atlas_engine/es/validation_transcriber/address_parser.rb
+- app/countries/atlas_engine/fo/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/fo/country_profile.yml
 - app/countries/atlas_engine/fr/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/fr/country_profile.yml
@@ -293,11 +297,14 @@ files:
 - app/countries/atlas_engine/it/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/it/address_importer/corrections/open_address/province_corrector.rb
 - app/countries/atlas_engine/it/address_importer/open_address/mapper.rb
+- app/countries/atlas_engine/it/address_validation/validators/full_address/exclusions/city.rb
 - app/countries/atlas_engine/it/country_profile.yml
 - app/countries/atlas_engine/jp/address_validation/es/data_mapper.rb
 - app/countries/atlas_engine/jp/country_profile.yml
 - app/countries/atlas_engine/kr/address_importer/open_address/mapper.rb
+- app/countries/atlas_engine/kr/address_validation/validators/full_address/exclusions/city.rb
 - app/countries/atlas_engine/kr/country_profile.yml
+- app/countries/atlas_engine/kr/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/li/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/li/country_profile.yml
 - app/countries/atlas_engine/li/index_configuration.yml
@@ -305,8 +312,10 @@ files:
 - app/countries/atlas_engine/lt/country_profile.yml
 - app/countries/atlas_engine/lt/synonyms.yml
 - app/countries/atlas_engine/lt/validation_transcriber/address_parser.rb
+- app/countries/atlas_engine/lu/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/lu/address_importer/corrections/open_address/locale_corrector.rb
 - app/countries/atlas_engine/lu/country_profile.yml
+- app/countries/atlas_engine/lu/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/nl/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/nl/country_profile.yml
 - app/countries/atlas_engine/nl/index_configuration.yml
@@ -314,14 +323,27 @@ files:
 - app/countries/atlas_engine/nl/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/no/country_profile.yml
 - app/countries/atlas_engine/nz/country_profile.yml
+- app/countries/atlas_engine/pl/address_importer/corrections/open_address/city_corrector.rb
+- app/countries/atlas_engine/pl/address_importer/corrections/open_address/empty_street_corrector.rb
+- app/countries/atlas_engine/pl/address_validation/exclusions/placeholder_postal_code.rb
+- app/countries/atlas_engine/pl/address_validation/exclusions/rural_address.rb
 - app/countries/atlas_engine/pl/country_profile.yml
+- app/countries/atlas_engine/pl/synonyms.yml
 - app/countries/atlas_engine/pl/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/pt/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/pt/address_importer/open_address/mapper.rb
+- app/countries/atlas_engine/pt/address_validation/validators/full_address/exclusions/zip.rb
 - app/countries/atlas_engine/pt/country_profile.yml
 - app/countries/atlas_engine/pt/synonyms.yml
+- app/countries/atlas_engine/pt/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/sa/country_profile.yml
 - app/countries/atlas_engine/se/country_profile.yml
+- app/countries/atlas_engine/si/address_importer/open_address/corrections/city_district_corrector.rb
+- app/countries/atlas_engine/si/address_importer/open_address/mapper.rb
+- app/countries/atlas_engine/si/address_validation/exclusions/unknown_city.rb
+- app/countries/atlas_engine/si/country_profile.yml
+- app/countries/atlas_engine/si/synonyms.yml
+- app/countries/atlas_engine/si/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/tt/address_importer/open_address/mapper.rb
 - app/countries/atlas_engine/tt/country_profile.yml
 - app/countries/atlas_engine/us/country_profile.yml
@@ -437,28 +459,34 @@ files:
 - app/models/atlas_engine/address_validation/token/sequence.rb
 - app/models/atlas_engine/address_validation/token/sequence/comparator.rb
 - app/models/atlas_engine/address_validation/token/sequence/comparison.rb
+- app/models/atlas_engine/address_validation/token/sequence/comparison_policy.rb
 - app/models/atlas_engine/address_validation/token/synonyms.rb
 - app/models/atlas_engine/address_validation/validator.rb
 - app/models/atlas_engine/address_validation/validators/full_address/address_comparison.rb
+- app/models/atlas_engine/address_validation/validators/full_address/building_comparison.rb
 - app/models/atlas_engine/address_validation/validators/full_address/candidate_result.rb
 - app/models/atlas_engine/address_validation/validators/full_address/candidate_result_base.rb
-- app/models/atlas_engine/address_validation/validators/full_address/comparison_helper.rb
+- app/models/atlas_engine/address_validation/validators/full_address/city_comparison.rb
 - app/models/atlas_engine/address_validation/validators/full_address/concern_builder.rb
 - app/models/atlas_engine/address_validation/validators/full_address/exclusions/exclusion_base.rb
+- app/models/atlas_engine/address_validation/validators/full_address/field_comparison_base.rb
 - app/models/atlas_engine/address_validation/validators/full_address/invalid_zip_concern_builder.rb
 - app/models/atlas_engine/address_validation/validators/full_address/invalid_zip_for_country_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/invalid_zip_for_province_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/no_candidate_result.rb
 - app/models/atlas_engine/address_validation/validators/full_address/number_comparison.rb
 - app/models/atlas_engine/address_validation/validators/full_address/postal_code_matcher.rb
+- app/models/atlas_engine/address_validation/validators/full_address/province_code_comparison.rb
 - app/models/atlas_engine/address_validation/validators/full_address/relevant_components.rb
 - app/models/atlas_engine/address_validation/validators/full_address/result_updater.rb
+- app/models/atlas_engine/address_validation/validators/full_address/street_comparison.rb
 - app/models/atlas_engine/address_validation/validators/full_address/suggestion_builder.rb
 - app/models/atlas_engine/address_validation/validators/full_address/unknown_address_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/unknown_province_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/unknown_zip_for_address_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/unmatched_field_concern.rb
 - app/models/atlas_engine/address_validation/validators/full_address/unsupported_script_result.rb
+- app/models/atlas_engine/address_validation/validators/full_address/zip_comparison.rb
 - app/models/atlas_engine/address_validation/validators/predicates/cache.rb
 - app/models/atlas_engine/address_validation/validators/predicates/city/present.rb
 - app/models/atlas_engine/address_validation/validators/predicates/country/exists.rb
@@ -530,6 +558,7 @@ files:
 - lib/atlas_engine/engine.rb
 - lib/atlas_engine/version.rb
 - lib/tasks/atlas_engine/address_importer.rake
+- lib/tasks/atlas_engine/graphql.rake
 homepage: https://github.com/Shopify/atlas_engine
 licenses:
 - MIT
@@ -553,7 +582,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.4
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: Address Validation API