atlas_engine 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99901e1ca20e5c32dd90945bbe7bd2199ad9cf0c11507524e7210b621f0a647c
-  data.tar.gz: c14b30e2629d198b5341e87190c0ccc38d016a644b9fea74e6d1bece611360b1
+  metadata.gz: 3285871f59bee7bdf0084bfb5f985a6e582a173a78baa496c07ba9e8bd526eda
+  data.tar.gz: b25b6b4d8637c34d43a78e60f457342ccd9f7117f02d039f961476a7a4ef310e
 SHA512:
-  metadata.gz: b424ffd2640d6248aa00adfa8e1942fad3b0f954ecfeb339257eccf84e2976107151f7da4cf936f4f48eb450337582c1692e90d79b4ecf6658964cc78507b963
-  data.tar.gz: 463dbcc8c3ad8a9aab64ee1212fc9d9148b49c5ad44a51fece73a1d8185af58453c6d9fa4002df4f9acca3aa8ee0122a140575e4b6a90b67633fc4565d5659ce
+  metadata.gz: ea581fe90f17c1924f2d370fef820dc8bf18ed094e570666cdc60f13b0ec37b7e8876749176bbb14cd9f408931c525f6f7b29afdf4da47270bf24f147f8f0bce
+  data.tar.gz: 6ef3dca52ae9bfc224d694c6cb326f743701280cb8d6be14f30421ea247c53822d8017acdeaad5641cfe34ac080ca33a1b010308575057fec2e040a1d7a3222e

data/app/countries/atlas_engine/au/country_profile.yml

@@ -3,8 +3,8 @@ ingestion:
   settings:
     min_zip_edge_ngram: "1"
     max_zip_edge_ngram: "4"
-  open_address:
-    feature_mapper: AtlasEngine::Au::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Au::AddressImporter::OpenAddress::Mapper
 validation:
   address_parser: AtlasEngine::Au::ValidationTranscriber::AddressParser
   enabled: true

data/app/countries/atlas_engine/bm/country_profile.yml

@@ -3,8 +3,8 @@ ingestion:
   correctors:
     open_address:
       - AtlasEngine::Bm::AddressImporter::Corrections::OpenAddress::CityAliasCorrector
-  open_address:
-    feature_mapper: AtlasEngine::Bm::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Bm::AddressImporter::OpenAddress::Mapper
 validation:
   enabled: true
   has_provinces: true

data/app/countries/atlas_engine/ch/country_profile.yml

@@ -9,8 +9,8 @@ validation:
     - fr
     - it
 ingestion:
-  open_address:
-    feature_mapper: AtlasEngine::Ch::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Ch::AddressImporter::OpenAddress::Mapper
   correctors:
     open_address:
       - AtlasEngine::Ch::AddressImporter::Corrections::OpenAddress::LocaleCorrector

data/app/countries/atlas_engine/es/country_profile.yml

@@ -1,3 +1,4 @@
 id: ES
 validation:
   address_parser: AtlasEngine::Es::ValidationTranscriber::AddressParser
+

data/app/countries/atlas_engine/gb/address_validation/es/query_builder.rb

@@ -8,9 +8,15 @@ module AtlasEngine
         class QueryBuilder < AtlasEngine::AddressValidation::Es::QueryBuilder
           extend T::Sig
 
-          sig { params(address: AtlasEngine::AddressValidation::AbstractAddress, locale: T.nilable(String)).void }
-          def initialize(address, locale = nil)
-            super(address, locale)
+          sig do
+            params(
+              address: AtlasEngine::AddressValidation::AbstractAddress,
+              parsings: AtlasEngine::ValidationTranscriber::AddressParsings,
+              profile: AtlasEngine::CountryProfile,
+            ).void
+          end
+          def initialize(address, parsings, profile)
+            super(address, parsings, profile)
 
             @parsings = T.let(
               AtlasEngine::Gb::ValidationTranscriber::FullAddressParser

data/app/countries/atlas_engine/it/address_validation/validators/full_address/exclusions/city.rb

@@ -12,13 +12,12 @@ module AtlasEngine
               class << self
                 sig do
                   override.params(
-                    session: AtlasEngine::AddressValidation::Session,
                     candidate: AtlasEngine::AddressValidation::Candidate,
                     address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
                   )
                     .returns(T::Boolean)
                 end
-                def apply?(session, candidate, address_comparison)
+                def apply?(candidate, address_comparison)
                   true
                 end
               end

data/app/countries/atlas_engine/it/country_profile.yml

@@ -8,8 +8,8 @@ validation:
       - AtlasEngine::It::AddressValidation::Validators::FullAddress::Exclusions::City
   unmatched_components_suggestion_threshold: 1
 ingestion:
-  open_address:
-    feature_mapper: AtlasEngine::It::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::It::AddressImporter::OpenAddress::Mapper
   correctors:
     open_address:
       - AtlasEngine::It::AddressImporter::Corrections::OpenAddress::CityCorrector

data/app/countries/atlas_engine/kr/address_validation/validators/full_address/exclusions/city.rb

@@ -18,18 +18,17 @@ module AtlasEngine
 
                 sig do
                   override.params(
-                    session: AtlasEngine::AddressValidation::Session,
                     candidate: AtlasEngine::AddressValidation::Candidate,
                     address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
                   )
                     .returns(T::Boolean)
                 end
-                def apply?(session, candidate, address_comparison)
+                def apply?(candidate, address_comparison)
                   candidate_si = extract_component_from_city(candidate, :si)
                   candidate_gu = extract_component_from_city(candidate, :gu)
 
-                  (candidate_si.present? && contains_component?(:si, candidate_si, session)) ||
-                    (candidate_gu.present? && contains_component?(:gu, candidate_gu, session))
+                  (candidate_si.present? && contains_component?(:si, candidate_si, address_comparison)) ||
+                    (candidate_gu.present? && contains_component?(:gu, candidate_gu, address_comparison))
                 end
 
                 private
@@ -53,11 +52,12 @@ module AtlasEngine
                   params(
                     type: Symbol,
                     value: String,
-                    session: AtlasEngine::AddressValidation::Session,
+                    address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
                   ).returns(T::Boolean)
                 end
-                def contains_component?(type, value, session)
-                  session.parsings.parsings.pluck(type)&.include?(value) || session.city&.include?(value)
+                def contains_component?(type, value, address_comparison)
+                  address_comparison.parsings.parsings.pluck(type)&.include?(value) ||
+                    address_comparison.address.city&.include?(value)
                 end
               end
             end

data/app/countries/atlas_engine/kr/country_profile.yml

@@ -1,7 +1,7 @@
 id: KR
 ingestion:
-  open_address:
-    feature_mapper: AtlasEngine::Kr::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Kr::AddressImporter::OpenAddress::Mapper
 validation:
   enabled: true
   default_matching_strategy: es

data/app/countries/atlas_engine/pl/address_validation/exclusions/placeholder_postal_code.rb

@@ -11,12 +11,11 @@ module AtlasEngine
           class << self
             sig do
               override.params(
-                session: AtlasEngine::AddressValidation::Session,
                 candidate: AtlasEngine::AddressValidation::Candidate,
                 address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
               ).returns(T::Boolean)
             end
-            def apply?(session, candidate, address_comparison)
+            def apply?(candidate, address_comparison)
               placeholder_postal_code?(candidate)
             end
 

data/app/countries/atlas_engine/pl/address_validation/exclusions/rural_address.rb

@@ -11,12 +11,11 @@ module AtlasEngine
           class << self
             sig do
               override.params(
-                session: AtlasEngine::AddressValidation::Session,
                 candidate: AtlasEngine::AddressValidation::Candidate,
                 address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
               ).returns(T::Boolean)
             end
-            def apply?(session, candidate, address_comparison)
+            def apply?(candidate, address_comparison)
               rural_address?(candidate) && poor_city_match?(address_comparison)
             end
 

data/app/countries/atlas_engine/pt/address_validation/validators/full_address/exclusions/zip.rb

@@ -11,13 +11,12 @@ module AtlasEngine
               class << self
                 sig do
                   override.params(
-                    session: AtlasEngine::AddressValidation::Session,
                     candidate: AtlasEngine::AddressValidation::Candidate,
                     address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
                   )
                     .returns(T::Boolean)
                 end
-                def apply?(session, candidate, address_comparison)
+                def apply?(candidate, address_comparison)
                   street_comparison_result = address_comparison.street_comparison.sequence_comparison
                   building_comparison_result = address_comparison.building_comparison.sequence_comparison
 

data/app/countries/atlas_engine/pt/country_profile.yml

@@ -3,8 +3,8 @@ ingestion:
   correctors:
     open_address:
       - AtlasEngine::Pt::AddressImporter::Corrections::OpenAddress::CityCorrector
-  open_address:
-    feature_mapper: AtlasEngine::Pt::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Pt::AddressImporter::OpenAddress::Mapper
 validation:
   enabled: true
   default_matching_strategy: es

data/app/countries/atlas_engine/si/address_validation/exclusions/unknown_city.rb

@@ -11,12 +11,11 @@ module AtlasEngine
           class << self
             sig do
               override.params(
-                session: AtlasEngine::AddressValidation::Session,
                 candidate: AtlasEngine::AddressValidation::Candidate,
                 address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
               ).returns(T::Boolean)
             end
-            def apply?(session, candidate, address_comparison)
+            def apply?(candidate, address_comparison)
               poor_city_match?(address_comparison)
             end
 

data/app/countries/atlas_engine/si/country_profile.yml

@@ -1,7 +1,7 @@
 id: SI
 ingestion:
-  open_address:
-    feature_mapper: AtlasEngine::Si::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Si::AddressImporter::OpenAddress::Mapper
   correctors:
     open_address:
       - AtlasEngine::Si::AddressImporter::OpenAddress::Corrections::CityDistrictCorrector

data/app/countries/atlas_engine/tt/country_profile.yml

@@ -1,7 +1,7 @@
 id: TT
 ingestion:
-  open_address:
-    feature_mapper: AtlasEngine::Tt::AddressImporter::OpenAddress::Mapper
+  post_address_mapper:
+    open_address: AtlasEngine::Tt::AddressImporter::OpenAddress::Mapper
 validation:
   address_parser: AtlasEngine::ValidationTranscriber::AddressParserNorthAmerica
   has_provinces: false

data/app/lib/atlas_engine/validation_transcriber/address_parser_base.rb

@@ -23,15 +23,15 @@ module AtlasEngine
 
       BUILDING_NAME = "(?<building_name>[\\w ]+)"
       BUILDING_NUM =
-        "(?<building_num>("\
-          '([[:digit:]]+\s)?([[:digit:]]+/[[:digit:]]+)|'\
-          '[[:digit:]][[:alpha:][:digit:]/\-]*|'\
-          '[[:alpha:]][[:digit:]][[:alpha:][:digit:]/\-]*'\
+        "(?<building_num>(" \
+          '([[:digit:]]+\s)?([[:digit:]]+/[[:digit:]]+)|' \
+          '[[:digit:]][[:alpha:][:digit:]/\-]*|' \
+          '[[:alpha:]][[:digit:]][[:alpha:][:digit:]/\-]*' \
           "))"
       NUMERIC_ONLY_BUILDING_NUM =
-        "(?<building_num>("\
-          '([[:digit:]]+\s+)?[[:digit:]][[:digit:]/]*[[:digit:]]|'\
-          "[[:digit:]]+"\
+        "(?<building_num>(" \
+          '([[:digit:]]+\s+)?[[:digit:]][[:digit:]/]*[[:digit:]]|' \
+          "[[:digit:]]+" \
           "))"
       NON_NUMERIC_STREET = "(?<street>[^[:digit:]/ -].*)"
       STREET = "(?<street>.+)"

data/app/models/atlas_engine/address_importer/open_address/transformer.rb

@@ -11,7 +11,7 @@ module AtlasEngine
         def initialize(country_import:, locale: nil)
           @country_code = country_import.country_code
           @locale = locale
-          @mapper = CountryProfile.for(@country_code).ingestion.open_address_feature_mapper.new(
+          @mapper = CountryProfile.for(@country_code).ingestion.post_address_mapper("open_address").new(
             country_code: @country_code, locale: @locale,
           )
           @corrector = AddressImporter::Corrections::Corrector.new(country_code: @country_code, source: "open_address")

data/app/models/atlas_engine/address_validation/es/data_mappers/default_data_mapper.rb

@@ -38,6 +38,7 @@ module AtlasEngine
                   .slice(:id, :locale, :country_code, :province_code, :region1, :region2, :region3, :region4)
                   .deep_symbolize_keys,
               )
+              data[:city] = post_address[:city].first
               data[:city_aliases] = city_aliases(post_address[:city])
               data[:suburb] = post_address[:suburb]
               data[:zip] = Worldwide::Zip.normalize(

data/app/models/atlas_engine/address_validation/es/datastore.rb

@@ -33,7 +33,7 @@ module AtlasEngine
           end
 
           @parsings = ValidationTranscriber::AddressParsings.new(address_input: address, locale: locale)
-          @query_builder = QueryBuilder.for(address, locale)
+          @query_builder = QueryBuilder.for(address, parsings, locale)
         end
 
         sig do

data/app/models/atlas_engine/address_validation/es/query_builder.rb

@@ -12,18 +12,30 @@ module AtlasEngine
         class << self
           extend T::Sig
 
-          sig { params(address: AbstractAddress, locale: T.nilable(String)).returns(QueryBuilder) }
-          def for(address, locale = nil)
+          sig do
+            params(
+              address: AbstractAddress,
+              parsings: AtlasEngine::ValidationTranscriber::AddressParsings,
+              locale: T.nilable(String),
+            ).returns(QueryBuilder)
+          end
+          def for(address, parsings, locale = nil)
             profile = CountryProfile.for(T.must(address.country_code), locale)
-            profile.attributes.dig("validation", "query_builder").constantize.new(address, locale)
+            profile.attributes.dig("validation", "query_builder").constantize.new(address, parsings, profile)
           end
         end
 
-        sig { params(address: AbstractAddress, locale: T.nilable(String)).void }
-        def initialize(address, locale = nil)
+        sig do
+          params(
+            address: AbstractAddress,
+            parsings: AtlasEngine::ValidationTranscriber::AddressParsings,
+            profile: CountryProfile,
+          ).void
+        end
+        def initialize(address, parsings, profile)
           @address = address
-          @profile = CountryProfile.for(T.must(address.country_code), locale)
-          @parsings = ValidationTranscriber::AddressParsings.new(address_input: address, locale: locale)
+          @profile = profile
+          @parsings = parsings
         end
 
         sig { abstract.returns(T::Hash[String, T.untyped]) }
@@ -133,16 +145,22 @@ module AtlasEngine
 
         sig { returns(T.nilable(Hash)) }
         def city_clause
-          {
-            "nested" => {
-              "path" => "city_aliases",
-              "query" => {
-                "match" => {
-                  "city_aliases.alias" => { "query" => address.city.to_s, "fuzziness" => "auto" },
+          if profile.validation.city_alias
+            {
+              "nested" => {
+                "path" => "city_aliases",
+                "query" => {
+                  "match" => {
+                    "city_aliases.alias" => { "query" => address.city.to_s, "fuzziness" => "auto" },
+                  },
                 },
               },
-            },
-          }
+            }
+          else
+            {
+              "match" => { "city" => { "query" => address.city.to_s, "fuzziness" => "auto" } },
+            }
+          end
         end
 
         sig { returns(Hash) }

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

@@ -11,18 +11,21 @@ module AtlasEngine
 
           attr_reader :address, :candidate, :datastore
 
+          delegate :parsings, to: :datastore
+
           sig { params(address: AbstractAddress, candidate: Candidate, datastore: DatastoreBase).void }
           def initialize(address:, candidate:, datastore:)
             @address = address
             @candidate = candidate
             @datastore = datastore
+            @comparators_hash = {}
           end
 
           sig { params(other: AddressComparison).returns(Integer) }
           def <=>(other)
             # prefer addresses having more matched fields, e.g. matching on street + city + zip is better than
             # just matching on street + zip, or street + province
-            matches = comparisons.count(&:match?) <=> other.comparisons.count(&:match?)
+            matches = comparators.count(&:match?) <=> other.comparators.count(&:match?)
             return matches * -1 if matches.nonzero?
 
             # merge all sequence comparisons together, erasing the individual field boundaries, and prefer
@@ -32,7 +35,7 @@ module AtlasEngine
 
           sig { returns(String) }
           def inspect
-            "<addrcomp street#{comparisons.inspect}/>"
+            "<addrcomp street#{comparators.inspect}/>"
           end
 
           sig { returns(T::Boolean) }
@@ -42,27 +45,50 @@ module AtlasEngine
 
           sig { returns(ZipComparison) }
           def zip_comparison
-            @zip_comparison ||= field_comparison(field: :zip)
+            T.cast(self.for(:zip), ZipComparison)
           end
 
           sig { returns(StreetComparison) }
           def street_comparison
-            @street_comparison ||= field_comparison(field: :street)
+            T.cast(self.for(:street), StreetComparison)
           end
 
           sig { returns(CityComparison) }
           def city_comparison
-            @city_comparison ||= field_comparison(field: :city)
+            T.cast(self.for(:city), CityComparison)
           end
 
           sig { returns(ProvinceCodeComparison) }
           def province_code_comparison
-            @province_code_comparison ||= field_comparison(field: :province_code)
+            T.cast(self.for(:province_code), ProvinceCodeComparison)
           end
 
           sig { returns(BuildingComparison) }
           def building_comparison
-            @building_comparison ||= field_comparison(field: :building)
+            T.cast(self.for(:building), BuildingComparison)
+          end
+
+          sig { params(component: Symbol).returns(FieldComparisonBase) }
+          def for(component)
+            @comparators_hash[component] ||= begin
+              klass = datastore.country_profile.validation.component_comparison(component)
+              klass.new(
+                address: address,
+                candidate: candidate,
+                datastore: datastore,
+                component: component,
+              )
+            end
+          end
+
+          sig { returns(T::Array[Symbol]) }
+          def components
+            comparators.map(&:component)
+          end
+
+          sig { returns(T::Array[Symbol]) }
+          def relevant_components
+            comparators.select(&:relevant?).map(&:component)
           end
 
           protected
@@ -70,36 +96,24 @@ module AtlasEngine
           sig do
             returns(T::Array[FieldComparisonBase])
           end
-          def comparisons
-            [
-              street_comparison,
-              city_comparison,
-              zip_comparison,
-              province_code_comparison,
-              building_comparison,
-            ].compact_blank
+          def comparators
+            datastore.country_profile.validation.address_comparison.keys.map do |component|
+              self.for(component.to_sym)
+            end
           end
 
           sig { returns(T::Array[AtlasEngine::AddressValidation::Token::Sequence::Comparison]) }
           def text_comparisons
-            [
-              street_comparison.sequence_comparison,
-              city_comparison.sequence_comparison,
-              zip_comparison.sequence_comparison,
-              province_code_comparison.sequence_comparison,
-            ].compact_blank
+            comparators.filter_map do |comparator|
+              comparison = comparator.sequence_comparison
+              comparison if comparison.class == AtlasEngine::AddressValidation::Token::Sequence::Comparison
+            end.compact_blank
           end
 
           sig { returns(AtlasEngine::AddressValidation::Token::Sequence::Comparison) }
           def merged_comparison
             @merged_comparisons ||= text_comparisons.reduce(&:merge)
           end
-
-          sig { params(field: Symbol).returns(FieldComparisonBase) }
-          def field_comparison(field:)
-            klass = CountryProfile.for(address.country_code).validation.address_comparison(field: field)
-            klass.new(address: address, candidate: candidate, datastore: datastore)
-          end
         end
       end
     end

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

@@ -8,6 +8,11 @@ module AtlasEngine
         class BuildingComparison < FieldComparisonBase
           extend T::Sig
 
+          sig { override.returns(T::Boolean) }
+          def relevant?
+            false
+          end
+
           sig { override.returns(T.nilable(NumberComparison)) }
           def sequence_comparison
             @building_comparison ||= NumberComparison.new(

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

@@ -9,8 +9,6 @@ module AtlasEngine
           extend T::Sig
           include LogHelper
 
-          delegate :street_comparison, to: :address_comparison
-
           sig do
             params(
               candidate: AddressValidation::CandidateTuple,
@@ -127,8 +125,8 @@ module AtlasEngine
           def matched_and_unmatched_components
             components = {}
             @matched_and_unmatched_components ||= begin
-              components_to_compare.each do |field|
-                components[field] = @address_comparison.send(:"#{field}_comparison").sequence_comparison
+              components_to_compare.each do |component|
+                components[component] = @address_comparison.for(component).sequence_comparison
               end
               components
             end

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

@@ -8,6 +8,11 @@ module AtlasEngine
         class CityComparison < FieldComparisonBase
           extend T::Sig
 
+          sig { override.returns(T::Boolean) }
+          def relevant?
+            true
+          end
+
           sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
           def sequence_comparison
             return @city_comparison if defined?(@city_comparison)

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

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

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

@@ -11,15 +11,27 @@ module AtlasEngine
 
           abstract!
 
-          SUPPORTED_FIELDS = Set.new([:street, :city, :zip, :province_code, :building])
+          sig { returns(Symbol) }
+          attr_reader :component
 
-          sig { params(address: AbstractAddress, candidate: Candidate, datastore: DatastoreBase).void }
-          def initialize(address:, candidate:, datastore:)
+          sig do
+            params(
+              address: AbstractAddress,
+              candidate: Candidate,
+              datastore: DatastoreBase,
+              component: Symbol,
+            ).void
+          end
+          def initialize(address:, candidate:, datastore:, component:)
             @address = address
             @datastore = datastore
             @candidate = candidate
+            @component = component
           end
 
+          sig { abstract.returns(T::Boolean) }
+          def relevant?; end
+
           sig { abstract.returns(T.any(T.nilable(Token::Sequence::Comparison), T.nilable(NumberComparison))) }
           def sequence_comparison; end
 

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

@@ -8,6 +8,11 @@ module AtlasEngine
         class ProvinceCodeComparison < FieldComparisonBase
           extend T::Sig
 
+          sig { override.returns(T::Boolean) }
+          def relevant?
+            true
+          end
+
           sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
           def sequence_comparison
             return @province_code_comparison if defined?(@province_code_comparison)

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

@@ -17,13 +17,6 @@ module AtlasEngine
           sig { returns(AddressComparison) }
           attr_reader :address_comparison
 
-          ALL_SUPPORTED_COMPONENTS = [
-            :province_code,
-            :city,
-            :zip,
-            :street,
-          ].freeze
-
           sig do
             params(
               session: Session,
@@ -35,11 +28,12 @@ module AtlasEngine
             @session = session
             @candidate = candidate
             @address_comparison = address_comparison
+            @all_supported_components = address_comparison.relevant_components.dup
           end
 
           sig { returns(T::Array[Symbol]) }
           def components_to_validate
-            supported_components = ALL_SUPPORTED_COMPONENTS.dup - unsupported_components_for_country
+            supported_components = @all_supported_components.dup - unsupported_components_for_country
             apply_exclusions(supported_components)
             supported_components.delete(:street) if exclude_street_validation?
             supported_components
@@ -47,7 +41,7 @@ module AtlasEngine
 
           sig { returns(T::Array[Symbol]) }
           def components_to_compare
-            ALL_SUPPORTED_COMPONENTS.dup - unsupported_components_for_country
+            @all_supported_components.dup - unsupported_components_for_country
           end
 
           private
@@ -56,7 +50,7 @@ module AtlasEngine
           def apply_exclusions(supported_components)
             supported_components.delete_if do |component|
               exclusions(component).any? do |exclusion|
-                if exclusion.apply?(session, candidate, address_comparison)
+                if exclusion.apply?(candidate, address_comparison)
                   emit_excluded_validation(component, "excluded")
                   true
                 end

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

@@ -8,6 +8,11 @@ module AtlasEngine
         class StreetComparison < FieldComparisonBase
           extend T::Sig
 
+          sig { override.returns(T::Boolean) }
+          def relevant?
+            true
+          end
+
           sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
           def sequence_comparison
             return @street_comparison if defined?(@street_comparison)

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

@@ -8,6 +8,11 @@ module AtlasEngine
         class ZipComparison < FieldComparisonBase
           extend T::Sig
 
+          sig { override.returns(T::Boolean) }
+          def relevant?
+            true
+          end
+
           sig { override.returns(T.nilable(Token::Sequence::Comparison)) }
           def sequence_comparison
             return @zip_comparison if defined?(@zip_comparison)

data/app/models/atlas_engine/country_profile.rb

@@ -71,6 +71,11 @@ module AtlasEngine
 
     DEFAULT_PROFILE = "DEFAULT"
 
+    COUNTRIES = T.let(
+      Worldwide::Regions.all.select(&:country?).reject(&:deprecated?).map(&:iso_code).to_set,
+      T::Set[String],
+    )
+
     add_index :id, unique: true
     self.base_path = ""
     self.backend = Backend
@@ -183,7 +188,7 @@ module AtlasEngine
       def for(country_code, locale = nil)
         raise CountryNotFoundError if country_code.blank?
 
-        unless country_code == DEFAULT_PROFILE || Worldwide.region(code: country_code).country?
+        unless country_code == DEFAULT_PROFILE || COUNTRIES.include?(country_code.upcase)
           raise CountryNotFoundError
         end
 

data/app/models/atlas_engine/country_profile_ingestion_subset.rb

@@ -24,9 +24,9 @@ module AtlasEngine
       attributes.dig("settings", "min_zip_edge_ngram")
     end
 
-    sig { returns(T::Class[AddressImporter::OpenAddress::DefaultMapper]) }
-    def open_address_feature_mapper
-      attributes.dig("open_address", "feature_mapper").constantize
+    sig { params(source: String).returns(T::Class[AddressImporter::OpenAddress::DefaultMapper]) }
+    def post_address_mapper(source)
+      attributes.dig("post_address_mapper", source).constantize
     end
 
     sig { returns(T.nilable(String)) }

data/app/models/atlas_engine/country_profile_validation_subset.rb

@@ -69,18 +69,19 @@ module AtlasEngine
       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
+    sig { params(component: Symbol).returns(T::Class[AddressValidation::Validators::FullAddress::FieldComparisonBase]) }
+    def component_comparison(component)
+      attributes.dig("address_comparison", component.to_s).constantize
     end
 
     sig { returns(Integer) }
     def zip_prefix_length
       attributes.dig("zip_prefix_length") || 0
     end
+
+    sig { returns(T::Boolean) }
+    def city_alias
+      attributes.dig("city_alias").nil? ? true : attributes.dig("city_alias")
+    end
   end
 end

data/app/models/atlas_engine/elasticsearch/repository.rb

@@ -230,7 +230,7 @@ module AtlasEngine
         ).void
       end
       def update_aliases_for_index(index_name:, remove_alias:, add_alias:)
-        is_writable = add_alias == active_alias ? true : false
+        is_writable = add_alias == active_alias
 
         body = {
           actions: [

data/app/tasks/maintenance/atlas_engine/geo_json_import_task.rb

@@ -18,12 +18,14 @@ module Maintenance
       attribute :geojson_file_path, :string
       attribute :locale, :string
 
-      def process = ::AtlasEngine::AddressImporter::OpenAddress::GeoJsonImportLauncherJob.perform_later(
-        country_code:,
-        geojson_file_path: geojson_file_path.strip,
-        clear_records:,
-        locale:,
-      )
+      def process
+        ::AtlasEngine::AddressImporter::OpenAddress::GeoJsonImportLauncherJob.perform_later(
+          country_code:,
+          geojson_file_path: geojson_file_path.strip,
+          clear_records:,
+          locale:,
+        )
+      end
     end
   end
 end

data/db/data/address_synonyms/index_configurations/default.yml

@@ -28,6 +28,13 @@ mappings:
       fields:
         keyword:
           type: keyword
+    city:
+      type: text
+      analyzer: text_analyzer
+      search_analyzer: city_analyzer
+      fields:
+        keyword:
+          type: keyword
     city_aliases:
       type: nested
       dynamic: "false"

data/db/data/country_profiles/default.yml

@@ -4,11 +4,13 @@ ingestion:
   correctors: {}
   settings: {}
   data_mapper: AtlasEngine::AddressValidation::Es::DataMappers::DefaultDataMapper
-  open_address:
-    feature_mapper: AtlasEngine::AddressImporter::OpenAddress::DefaultMapper
+  post_address_mapper:
+    open_address: AtlasEngine::AddressImporter::OpenAddress::DefaultMapper
 validation:
   enabled: false
   has_provinces: true
+  zip_prefix_length: 0
+  city_alias: true
   index_locales: []
   default_matching_strategy: local
   normalized_components: []

data/lib/atlas_engine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-13 00:00:00.000000000 Z
+date: 2024-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: annex_29