atlas_engine 0.1.2 → 0.2.0

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

@@ -6,128 +6,128 @@ module AtlasEngine
     module Validators
       module FullAddress
         class ComparisonHelper
-          class << self
-            extend T::Sig
-
-            sig do
-              params(
-                datastore: DatastoreBase,
-                candidate: Candidate,
-              ).returns(T.nilable(Token::Sequence::Comparison))
-            end
-            def street_comparison(datastore:, candidate:)
-              street_sequences = datastore.fetch_street_sequences
-              candidate_sequences = T.must(candidate.component(:street)).sequences
-
-              street_sequences.map do |street_sequence|
-                best_comparison(
-                  street_sequence,
-                  candidate_sequences,
-                )
-              end.min
-            end
+          extend T::Sig
 
-            sig do
-              params(
-                datastore: DatastoreBase,
-                candidate: Candidate,
-              ).returns(T.nilable(Token::Sequence::Comparison))
-            end
-            def city_comparison(datastore:, candidate:)
-              best_comparison(
-                datastore.fetch_city_sequence,
-                T.must(candidate.component(:city)).sequences,
-              )
-            end
+          sig { params(address: AbstractAddress, candidate: Candidate, datastore: DatastoreBase).void }
+          def initialize(address:, candidate:, datastore:)
+            @address = address
+            @datastore = datastore
+            @candidate = candidate
+          end
 
-            sig do
-              params(
-                address: AbstractAddress,
-                candidate: Candidate,
-              ).returns(T.nilable(Token::Sequence::Comparison))
-            end
-            def province_code_comparison(address:, candidate:)
-              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,
-              )
+          sig { returns(T.nilable(Token::Sequence::Comparison)) }
+          def street_comparison
+            return @street_comparison if defined?(@street_comparison)
 
-              best_comparison(
-                Token::Sequence.from_string(normalized_session_province_code),
-                [Token::Sequence.from_string(normalized_candidate_province_code)],
-              )
-            end
+            street_sequences = datastore.fetch_street_sequences
+            candidate_sequences = T.must(candidate.component(:street)).sequences
 
-            sig do
-              params(
-                address: AbstractAddress,
-                candidate: Candidate,
-              ).returns(T.nilable(Token::Sequence::Comparison))
-            end
-            def zip_comparison(address:, candidate:)
-              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)
+            @street_comparison = street_sequences.map do |street_sequence|
               best_comparison(
-                zip_sequence,
-                T.must(candidate.component(:zip)).sequences,
+                street_sequence,
+                candidate_sequences,
               )
-            end
+            end.min
+          end
 
-            sig do
-              params(
-                datastore: DatastoreBase,
-                candidate: Candidate,
-              ).returns(NumberComparison)
-            end
-            def building_comparison(datastore:, candidate:)
-              NumberComparison.new(
-                numbers: datastore.parsings.potential_building_numbers,
-                candidate_ranges: building_ranges_from_candidate(candidate),
-              )
-            end
+          sig { returns(T.nilable(Token::Sequence::Comparison)) }
+          def city_comparison
+            return @city_comparison if defined?(@city_comparison)
 
-            private
+            @city_comparison = best_comparison(
+              datastore.fetch_city_sequence,
+              T.must(candidate.component(:city)).sequences,
+            )
+          end
 
-            sig do
-              params(
-                sequence: Token::Sequence,
-                component_sequences: T::Array[Token::Sequence],
-              ).returns(T.nilable(Token::Sequence::Comparison))
-            end
-            def best_comparison(sequence, component_sequences)
-              component_sequences.map do |component_sequence|
-                Token::Sequence::Comparator.new(
-                  left_sequence: sequence,
-                  right_sequence: component_sequence,
-                ).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 { returns(T.nilable(Token::Sequence::Comparison)) }
+          def province_code_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)],
+            )
+          end
+
+          sig { returns(T.nilable(Token::Sequence::Comparison)) }
+          def zip_comparison
+            return @zip_comparison if defined?(@zip_comparison)
 
-            sig { params(candidate: Candidate).returns(T::Array[AddressNumberRange]) }
-            def building_ranges_from_candidate(candidate)
-              building_and_unit_ranges = candidate.component(:building_and_unit_ranges)&.value
-              return [] if building_and_unit_ranges.blank?
+            candidate.component(:zip)&.value = PostalCodeMatcher.new(
+              T.must(address.country_code),
+              T.must(address.zip),
+              candidate.component(:zip)&.value,
+            ).truncate
 
-              building_ranges = JSON.parse(building_and_unit_ranges).keys
-              building_ranges.map { |building_range| AddressNumberRange.new(range_string: building_range) }
+            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,
+            )
+          end
+
+          sig { returns(NumberComparison) }
+          def building_comparison
+            @building_comparison ||= NumberComparison.new(
+              numbers: datastore.parsings.potential_building_numbers,
+              candidate_ranges: building_ranges_from_candidate(candidate),
+            )
+          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],
+            ).returns(T.nilable(Token::Sequence::Comparison))
+          end
+          def best_comparison(
+            sequence,
+            component_sequences
+          )
+            component_sequences.map do |component_sequence|
+              Token::Sequence::Comparator.new(
+                left_sequence: sequence,
+                right_sequence: component_sequence,
+              ).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(candidate: Candidate).returns(T::Array[AddressNumberRange]) }
+          def building_ranges_from_candidate(candidate)
+            building_and_unit_ranges = candidate.component(:building_and_unit_ranges)&.value
+            return [] if building_and_unit_ranges.blank?
+
+            building_ranges = JSON.parse(building_and_unit_ranges).keys
+            building_ranges.map { |building_range| AddressNumberRange.new(range_string: building_range) }
+          end
         end
       end
     end

data/app/models/atlas_engine/address_validation/validators/full_address/{components_to_validate.rb → relevant_components.rb}

@@ -5,7 +5,7 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class ComponentsToValidate
+        class RelevantComponents
           extend T::Sig
 
           attr_reader :session, :candidate, :street_comparison
@@ -31,29 +31,35 @@ module AtlasEngine
           end
 
           sig { returns(T::Array[Symbol]) }
-          def run
+          def components_to_validate
             supported_components = ALL_SUPPORTED_COMPONENTS.dup - unsupported_components_for_country
             supported_components.delete(:street) if exclude_street_validation?
             supported_components
           end
 
+          sig { returns(T::Array[Symbol]) }
+          def components_to_compare
+            ALL_SUPPORTED_COMPONENTS.dup - unsupported_components_for_country
+          end
+
           private
 
           sig { returns(T::Boolean) }
           def exclude_street_validation?
-            return true unless session.matching_strategy == AddressValidation::MatchingStrategies::EsStreet
+            return @exclude_street_validation if defined?(@exclude_street_validation)
 
-            if street_comparison.blank?
+            @exclude_street_validation = if session.matching_strategy !=
+                AddressValidation::MatchingStrategies::EsStreet
+              true
+            elsif street_comparison.blank?
               emit_excluded_validation("street", "not_found")
-              return true
-            end
-
-            if exclusions("street").any? { |exclusion| exclusion.apply?(session, candidate) }
+              true
+            elsif exclusions("street").any? { |exclusion| exclusion.apply?(session, candidate) }
               emit_excluded_validation("street", "excluded")
-              return true
+              true
+            else
+              false
             end
-
-            false
           end
 
           sig { params(component: String).returns(T::Array[T.class_of(Exclusions::ExclusionBase)]) }
@@ -73,13 +79,15 @@ module AtlasEngine
 
           sig { returns(T::Array[Symbol]) }
           def unsupported_components_for_country
-            unsupported_components = []
-            country = Worldwide.region(code: session.address.country_code)
-            unsupported_components << :province_code if country.province_optional?
-            unsupported_components << :province_code if country.hide_provinces_from_addresses
-            unsupported_components << :city unless country.city_required?
-            unsupported_components << :zip unless country.zip_required? && !country.zip_autofill_enabled
-            unsupported_components.uniq
+            @unsupported_components_for_country ||= begin
+              unsupported_components = []
+              country = Worldwide.region(code: session.address.country_code)
+              unsupported_components << :province_code if country.province_optional?
+              unsupported_components << :province_code if country.hide_provinces_from_addresses
+              unsupported_components << :city unless country.city_required?
+              unsupported_components << :zip unless country.zip_required? && !country.zip_autofill_enabled
+              unsupported_components.uniq
+            end
           end
         end
       end

data/app/models/atlas_engine/country_profile_validation_subset.rb

@@ -44,5 +44,10 @@ module AtlasEngine
     def address_parser
       attributes.dig("address_parser").constantize
     end
+
+    sig { returns(T::Array[String]) }
+    def normalized_components
+      attributes.dig("normalized_components") || []
+    end
   end
 end

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

@@ -36,7 +36,7 @@ module Maintenance
         record_count = ::AtlasEngine::PostAddress.where(address_conditions).size
         raise "No records to process for country code: #{country_code}" if record_count.zero?
 
-        repository.create_next_index(ensure_clean: true)
+        repository.create_next_index(ensure_clean: true, raise_errors: true)
 
         ::AtlasEngine::PostAddress.where(address_conditions).in_batches(of: batch_size)
       end

data/db/data/country_profiles/default.yml

@@ -11,8 +11,6 @@ validation:
   has_provinces: true
   index_locales: []
   default_matching_strategy: local
-  city_fields:
-    - city_aliases
   normalized_components: []
   exclusions: {}
   partial_postal_code_range_for_length: {}

data/lib/atlas_engine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_engine
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-01-18 00:00:00.000000000 Z
+date: 2024-01-24 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'
+        version: 0.6.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.4
 description: The Atlas Engine is a rails engine that provides a GraphQL API for address
   validation.
 email: developers@shopify.com
@@ -250,9 +250,11 @@ files:
 - app/countries/atlas_engine/au/synonyms.yml
 - app/countries/atlas_engine/au/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/be/country_profile.yml
+- app/countries/atlas_engine/be/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/bm/address_importer/corrections/open_address/city_alias_corrector.rb
 - app/countries/atlas_engine/bm/address_importer/open_address/mapper.rb
 - app/countries/atlas_engine/bm/country_profile.yml
+- app/countries/atlas_engine/bm/synonyms.yml
 - app/countries/atlas_engine/br/country_profile.yml
 - app/countries/atlas_engine/ca/country_profile.yml
 - app/countries/atlas_engine/ca/synonyms.yml
@@ -263,8 +265,12 @@ files:
 - app/countries/atlas_engine/ch/locales/de/country_profile.yml
 - app/countries/atlas_engine/ch/locales/de/index_configuration.yml
 - app/countries/atlas_engine/ch/locales/de/synonyms.yml
+- app/countries/atlas_engine/ch/locales/fr/country_profile.yml
 - app/countries/atlas_engine/ch/locales/fr/synonyms.yml
+- app/countries/atlas_engine/ch/locales/fr/validation_transcriber/address_parser.rb
+- app/countries/atlas_engine/cz/address_validation/es/query_builder.rb
 - app/countries/atlas_engine/cz/country_profile.yml
+- app/countries/atlas_engine/cz/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/de/country_profile.yml
 - app/countries/atlas_engine/de/index_configuration.yml
 - app/countries/atlas_engine/de/synonyms.yml
@@ -437,7 +443,6 @@ files:
 - 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/components_to_validate.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/invalid_zip_concern_builder.rb
@@ -446,6 +451,7 @@ files:
 - 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/relevant_components.rb
 - app/models/atlas_engine/address_validation/validators/full_address/result_updater.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