atlas_engine 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3285871f59bee7bdf0084bfb5f985a6e582a173a78baa496c07ba9e8bd526eda
-  data.tar.gz: b25b6b4d8637c34d43a78e60f457342ccd9f7117f02d039f961476a7a4ef310e
+  metadata.gz: 9948b64010b57506c90e07bf0fc324c7ad158112169375aa1ac1f7053850a9be
+  data.tar.gz: 872cd26b540c96af7a777b044a4af20cce6d1b7df5569f0b3cd7aaf999fb1847
 SHA512:
-  metadata.gz: ea581fe90f17c1924f2d370fef820dc8bf18ed094e570666cdc60f13b0ec37b7e8876749176bbb14cd9f408931c525f6f7b29afdf4da47270bf24f147f8f0bce
-  data.tar.gz: 6ef3dca52ae9bfc224d694c6cb326f743701280cb8d6be14f30421ea247c53822d8017acdeaad5641cfe34ac080ca33a1b010308575057fec2e040a1d7a3222e
+  metadata.gz: d8ea33678c4c924fb202cecf027e4796892430c35394233c0a971474166b71a10881a6ddc2cc6056d7f66df6b225a63cfdafe18b5590327035d19f3f4e70cf99
+  data.tar.gz: 30d5b8b914d14f4fd6871228435383ff90499e25617af0c7dc5a6a5580fbf4005854f2189034712f4030001878be8c6ee42223e5b94a1890b2a14f8be80e0dc3

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Gg
+    module AddressValidation
+      module Validators
+        module FullAddress
+          module Exclusions
+            class City <
+              AtlasEngine::AddressValidation::Validators::FullAddress::Exclusions::ExclusionBase
+              extend T::Sig
+              class << self
+                sig do
+                  override.params(
+                    candidate: AtlasEngine::AddressValidation::Candidate,
+                    address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
+                  )
+                    .returns(T::Boolean)
+                end
+                def apply?(candidate, address_comparison)
+                  # If the candidate city is already present in the parsings
+                  address_comparison.parsings.parsings.pluck(:city)&.include?(candidate.component(:city)&.value&.first)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,5 +3,9 @@ validation:
   enabled: true
   default_matching_strategy: es
   has_provinces: false
+  address_parser: AtlasEngine::Gg::ValidationTranscriber::AddressParser
   restrictions:
     - class: AtlasEngine::Gg::AddressValidation::Validators::FullAddress::Restrictions::UnsupportedCity
+  exclusions:
+    city:
+      - AtlasEngine::Gg::AddressValidation::Validators::FullAddress::Exclusions::City

data/app/countries/atlas_engine/gg/validation_transcriber/address_parser.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Gg
+    module ValidationTranscriber
+      class AddressParser < AtlasEngine::ValidationTranscriber::AddressParserBase
+        private
+
+        CITY = %r{
+          (?<city>
+            st\.?\s?saviour[']?[s]?|
+            st\.?\s?sampson[']?[s]?|
+            st\.?\s?andrew[']?[s]?|
+            st\.?\s?martin[']?[s]?|
+            st\.?\s?peter[']?[s]?\s?port|
+            st\.?\s?peter[']?[s]?|
+            st\.?\s?pierre\s?du\s?bois|
+            vale|
+            torteval|
+            castel|
+            forest
+          )
+        }ix
+
+        sig { returns(T::Array[Regexp]) }
+        def country_regex_formats
+          @country_regex_formats ||= [
+            /^#{BUILDING_NAME},\s+#{CITY}$/,
+            /^#{BUILDING_NAME},\s+#{STREET_NO_COMMAS},\s+#{CITY}$/,
+            /^#{BUILDING_NAME},\s+#{STREET_NO_COMMAS}$/,
+            /^#{NUMERIC_ONLY_BUILDING_NUM}?\s+#{STREET_NO_COMMAS},\s+#{CITY}$/,
+            /^#{UNIT_TYPE}\s+#{UNIT_NUM_NO_HYPHEN},\s+#{BUILDING_NAME},\s+#{CITY}$/,
+            /^#{CITY}$/,
+            /^#{NUMERIC_ONLY_BUILDING_NUM}?\s+#{STREET_NO_COMMAS}$/,
+            /^#{BUILDING_NAME}$/,
+            /^#{STREET_NO_COMMAS}$/,
+          ]
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/candidate.rb

@@ -6,9 +6,10 @@ module AtlasEngine
     class Candidate
       extend T::Sig
       attr_reader :id, :index
+      attr_accessor :position
 
-      sig { params(id: String, source: Hash, index: T.nilable(String)).void }
-      def initialize(id:, source:, index: nil)
+      sig { params(id: String, source: Hash, position: Integer, index: T.nilable(String)).void }
+      def initialize(id:, source:, position: 0, index: nil)
         components_hash = Hash.new { |hash, key| hash[key] = Component.new(key, nil) }
 
         @components = source.each_with_object(components_hash) do |(key, value), hash|

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

@@ -21,7 +21,7 @@ module AtlasEngine
           end
         end
 
-        sig { returns(T.nilable(CandidateTuple)) }
+        sig { returns(T.nilable(AddressValidation::Validators::FullAddress::AddressComparison)) }
         def best_candidate
           street_sequences_future = datastore.fetch_street_sequences_async
           city_sequences_future = datastore.fetch_city_sequence_async
@@ -36,28 +36,28 @@ module AtlasEngine
 
         attr_reader :datastore, :address
 
-        sig { returns(T::Array[CandidateTuple]) }
+        sig { returns(T::Array[AddressValidation::Validators::FullAddress::AddressComparison]) }
         def sorted_candidates
-          sorted_candidate_tuples = datastore.fetch_full_address_candidates
+          sorted_address_comparisons = datastore.fetch_full_address_candidates
             .filter_map.with_index(1) do |candidate, position|
-              address_comparison = AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison.new(
+              candidate.position = position
+              address_comparison = AddressValidation::Validators::FullAddress::AddressComparison.new(
                 address: address,
                 candidate: candidate,
                 datastore: datastore,
               )
-              tuple = CandidateTuple.new(address_comparison, position, candidate)
-              tuple if tuple.address_comparison.potential_match?
+              address_comparison if address_comparison.potential_match?
             end.sort
 
-          emit_sorted_candidates(sorted_candidate_tuples)
-          sorted_candidate_tuples
+          emit_sorted_candidates(sorted_address_comparisons.map(&:candidate))
+          sorted_address_comparisons
         end
 
-        sig { params(sorted_candidate_tuples: T::Array[CandidateTuple]).void }
-        def emit_sorted_candidates(sorted_candidate_tuples)
-          log_info("Sorted candidates:\n #{sorted_candidate_tuples.map { |tuple| tuple.candidate.serialize }}")
+        sig { params(sorted_candidates: T::Array[Candidate]).void }
+        def emit_sorted_candidates(sorted_candidates)
+          log_info("Sorted candidates:\n #{sorted_candidates.map(&:serialize)}")
 
-          initial_position_top_candidate = sorted_candidate_tuples.first&.position || 0
+          initial_position_top_candidate = sorted_candidates.first&.position || 0
           StatsD.distribution(
             "AddressValidation.query.initial_position_top_candidate",
             initial_position_top_candidate,

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

@@ -128,6 +128,9 @@ module AtlasEngine
             end
             Token::Sequence.new(tokens: tokens, raw_value: city_value)
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "city_sequence")
+          Token::Sequence.new(tokens: [], raw_value: city_value)
         end
 
         sig { returns(T::Array[T::Hash[String, T.untyped]]) }
@@ -135,6 +138,9 @@ module AtlasEngine
           measure_es_validation_request_time(method: "full_address_candidates") do
             repository.search(query_builder.full_address_query)
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "full_address_candidates")
+          []
         end
 
         sig { returns(T::Array[Token::Sequence]) }
@@ -154,6 +160,9 @@ module AtlasEngine
               end
             end
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "street_sequence")
+          [Token::Sequence.new(tokens: [], raw_value: "")]
         end
 
         sig { params(candidates: T::Array[Candidate]).void }
@@ -165,6 +174,8 @@ module AtlasEngine
           end
 
           TermVectors.new(term_vectors_hashes: candidate_term_vectors, candidates: candidates).set_candidate_sequences
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "term_vectors")
         end
 
         sig { params(candidates: T::Array[Candidate]).returns(T::Hash[String, T.untyped]) }
@@ -190,6 +201,18 @@ module AtlasEngine
           )
         end
 
+        sig { params(error: Elasticsearch::Error, method: String).void }
+        def log_elasticsearch_error(error:, method:)
+          log_error("Elasticsearch error: #{error.message}")
+          StatsD.increment(
+            "AddressValidation.elasticsearch_error",
+            tags: {
+              country: country_code,
+              method:,
+            },
+          )
+        end
+
         sig { params(future: T.nilable(Concurrent::Promises::Future), method: String).void }
         def log_future_state_on_join(future:, method:)
           state = future&.state || :unsubmitted

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

@@ -9,12 +9,11 @@ module AtlasEngine
           include LogHelper
 
           attr_reader :address, :result
-          attr_accessor :session
 
           sig { params(address: TAddress, result: Result).void }
           def initialize(address:, result: Result.new)
             super
-            @session = T.let(Session.new(address: address, matching_strategy: MatchingStrategies::Es), Session)
+            @matching_strategy = MatchingStrategies::Es
           end
 
           sig { override.returns(Result) }
@@ -30,23 +29,23 @@ module AtlasEngine
           sig { returns(AddressValidation::Validators::FullAddress::CandidateResultBase) }
           def build_candidate_result
             unless supported_address?(address)
-              return AddressValidation::Validators::FullAddress::UnsupportedScriptResult.new(session:, result:)
+              return AddressValidation::Validators::FullAddress::UnsupportedScriptResult.new(address:, result:)
             end
 
             if best_candidate.nil?
-              AddressValidation::Validators::FullAddress::NoCandidateResult.new(session:, result:)
+              AddressValidation::Validators::FullAddress::NoCandidateResult.new(address:, result:)
             else
               AddressValidation::Validators::FullAddress::CandidateResult.new(
-                candidate: T.must(best_candidate),
+                address_comparison: T.must(best_candidate),
+                matching_strategy: @matching_strategy,
                 result: result,
-                session: session,
               )
             end
           end
 
           private
 
-          sig { returns(T.nilable(CandidateTuple)) }
+          sig { returns(T.nilable(AddressValidation::Validators::FullAddress::AddressComparison)) }
           def best_candidate
             @best_candidate ||= T.let(
               begin
@@ -63,15 +62,15 @@ module AtlasEngine
                 # We want our futures to complete even when we do not consume their value.
                 candidate_futures&.map(&:wait!)
               end,
-              T.nilable(CandidateTuple),
+              T.nilable(AddressValidation::Validators::FullAddress::AddressComparison),
             )
           end
 
           sig { params(locale: T.nilable(String)).returns(Concurrent::Promises::Future) }
           def best_candidate_future(locale = nil)
             AddressValidation::Es::CandidateSelector.new(
-              datastore: session.datastore(locale: locale),
-              address: session.address,
+              datastore: Es::Datastore.new(address: address, locale: locale),
+              address: address,
             ).best_candidate_async
           end
 

data/app/models/atlas_engine/address_validation/es/validators/full_address_street.rb

@@ -9,7 +9,7 @@ module AtlasEngine
           sig { params(address: TAddress, result: Result).void }
           def initialize(address:, result: Result.new)
             super
-            @session = T.let(Session.new(address: address, matching_strategy: MatchingStrategies::EsStreet), Session)
+            @matching_strategy = MatchingStrategies::EsStreet
           end
         end
       end

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

@@ -11,16 +11,16 @@ module AtlasEngine
 
           sig do
             params(
-              candidate: AddressValidation::CandidateTuple,
-              session: Session,
+              address_comparison: AddressComparison,
+              matching_strategy: AddressValidation::MatchingStrategies,
               result: Result,
-            )
-              .void
+            ).void
           end
-          def initialize(candidate:, session:, result:)
-            super(session: session, result: result)
-            @candidate = candidate.candidate
-            @address_comparison = candidate.address_comparison
+          def initialize(address_comparison:, matching_strategy:, result:)
+            super(address: address_comparison.address, result: result)
+            @address_comparison = address_comparison
+            @candidate = address_comparison.candidate
+            @matching_strategy = matching_strategy
           end
 
           sig { override.void }
@@ -34,7 +34,7 @@ module AtlasEngine
 
           sig { returns(T::Boolean) }
           def suggestable?
-            ConcernBuilder.should_suggest?(session.address, unmatched_components.keys)
+            ConcernBuilder.should_suggest?(address, unmatched_components.keys)
           end
 
           private
@@ -56,11 +56,11 @@ module AtlasEngine
 
           sig { void }
           def add_concerns_without_suggestions
-            concern = InvalidZipConcernBuilder.for(session.address, [])
+            concern = InvalidZipConcernBuilder.for(address, [])
             result.concerns << concern if concern
 
-            if ConcernBuilder.too_many_unmatched_components?(session.address, unmatched_components.keys)
-              result.concerns << UnknownAddressConcern.new(session.address)
+            if ConcernBuilder.too_many_unmatched_components?(address, unmatched_components.keys)
+              result.concerns << UnknownAddressConcernBuilder.new(address).build
             end
           end
 
@@ -77,7 +77,7 @@ module AtlasEngine
                 unmatched_component: unmatched_component,
                 unmatched_field: field_name,
                 matched_components: matched_components_to_validate.keys,
-                address: session.address,
+                address: address,
                 suggestion_ids: [suggestion.id].compact,
               ).build
               result.concerns << concern
@@ -90,7 +90,7 @@ module AtlasEngine
             unmatched_fields = { street: unmatched_field_name(:street) }.compact
 
             @suggestion ||= SuggestionBuilder.from_comparisons(
-              session.address.to_h,
+              address.to_h,
               unmatched_components_to_validate,
               candidate,
               unmatched_fields,
@@ -126,7 +126,7 @@ module AtlasEngine
             components = {}
             @matched_and_unmatched_components ||= begin
               components_to_compare.each do |component|
-                components[component] = @address_comparison.for(component).sequence_comparison
+                components[component] = address_comparison.for(component).sequence_comparison
               end
               components
             end
@@ -144,7 +144,7 @@ module AtlasEngine
 
           sig { returns(RelevantComponents) }
           def relevant_components
-            @relevant_components ||= RelevantComponents.new(session, candidate, address_comparison)
+            @relevant_components ||= RelevantComponents.new(address_comparison, @matching_strategy)
           end
 
           sig do
@@ -167,17 +167,17 @@ module AtlasEngine
 
             original_street = T.must(unmatched_components_to_validate[:street]).left_sequence.raw_value
 
-            if session.address.address1.to_s.include?(original_street)
+            if address.address1.to_s.include?(original_street)
               :address1
-            elsif session.address.address2.to_s.include?(original_street)
+            elsif address.address2.to_s.include?(original_street)
               :address2
             end
           end
 
           sig { void }
           def log_unknown_field_name
-            potential_streets = { potential_streets: session.parsings.potential_streets }
-            input_address = session.address.to_h.compact_blank.except(:phone)
+            potential_streets = { potential_streets: address_comparison.parsings.potential_streets }
+            input_address = address.to_h.compact_blank.except(:phone)
             log_details = input_address.merge(potential_streets)
             log_info("[AddressValidation] Unable to identify unmatched field name", log_details)
           end

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

@@ -11,9 +11,9 @@ module AtlasEngine
 
           abstract!
 
-          sig { params(session: Session, result: Result).void }
-          def initialize(session:, result:)
-            @session = session
+          sig { params(address: AbstractAddress, result: Result).void }
+          def initialize(address:, result:)
+            @address = address
             @result = result
           end
 
@@ -22,9 +22,7 @@ module AtlasEngine
 
           private
 
-          attr_reader :session, :result
-
-          delegate :address, to: :session
+          attr_reader :result, :address
 
           sig { void }
           def update_result_scope

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

@@ -109,17 +109,13 @@ module AtlasEngine
             concern = InvalidZipConcernBuilder.for(address, suggestion_ids)
             return concern if concern
 
-            if :province_code.in?(matched_components) && :city.in?(matched_components)
-              return UnknownZipForAddressConcern.new(address, suggestion_ids)
-            end
-
             build_default_concern
           end
 
           sig { returns(AddressValidation::Concern) }
           def build_province_concern
             if ([:zip, :city] - matched_components).empty?
-              UnknownProvinceConcern.new(address, suggestion_ids)
+              UnknownProvinceConcernBuilder.new(address).build(suggestion_ids)
             else
               build_default_concern
             end
@@ -127,7 +123,12 @@ module AtlasEngine
 
           sig { returns(AddressValidation::Concern) }
           def build_default_concern
-            UnmatchedFieldConcern.new(unmatched_component, matched_components, address, suggestion_ids, unmatched_field)
+            UnmatchedFieldConcernBuilder.new(
+              unmatched_component,
+              matched_components,
+              address,
+              unmatched_field,
+            ).build(suggestion_ids)
           end
         end
       end

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

@@ -22,9 +22,13 @@ module AtlasEngine
               return unless country.has_zip?
 
               if country_expects_zone_in_address?(country) && province.province?
-                InvalidZipForProvinceConcern.new(address, suggestion_ids) unless province.valid_zip?(address.zip)
+                return if province.valid_zip?(address.zip)
+
+                InvalidZipForProvinceConcernBuilder.new(address).build
               else
-                InvalidZipForCountryConcern.new(address, suggestion_ids) unless country.valid_zip?(address.zip)
+                return if country.valid_zip?(address.zip)
+
+                InvalidZipForCountryConcernBuilder.new(address).build(suggestion_ids)
               end
             end
 

data/app/models/atlas_engine/address_validation/validators/full_address/{invalid_zip_for_country_concern.rb → invalid_zip_for_country_concern_builder.rb}

@@ -5,31 +5,32 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class InvalidZipForCountryConcern < AddressValidation::Concern
+        class InvalidZipForCountryConcernBuilder
+          extend T::Sig
           include ConcernFormatter
           attr_reader :address
 
-          sig { params(address: AbstractAddress, suggestion_ids: T::Array[String]).void }
-          def initialize(address, suggestion_ids)
+          sig { params(address: AbstractAddress).void }
+          def initialize(address)
             @address = address
+          end
+
+          sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
+          def build(suggestion_ids = [])
+            message =  country.field(key: :zip).error(
+              code: :invalid_for_country,
+              options: { country: country.full_name },
+            ).to_s
 
-            super(
+            Concern.new(
               code: :zip_invalid_for_country,
               field_names: [:zip],
               message: message,
               type: T.must(Concern::TYPES[:error]),
               type_level: 1,
-              suggestion_ids: suggestion_ids
+              suggestion_ids: suggestion_ids,
             )
           end
-
-          sig { returns(String) }
-          def message
-            country.field(key: :zip).error(
-              code: :invalid_for_country,
-              options: { country: country.full_name },
-            ).to_s
-          end
         end
       end
     end

data/app/models/atlas_engine/address_validation/validators/full_address/{invalid_zip_for_province_concern.rb → invalid_zip_for_province_concern_builder.rb}

@@ -5,30 +5,30 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class InvalidZipForProvinceConcern < AddressValidation::Concern
+        class InvalidZipForProvinceConcernBuilder
+          extend T::Sig
           include ConcernFormatter
           attr_reader :address
 
-          sig { params(address: AbstractAddress, suggestion_ids: T::Array[String]).void }
-          def initialize(address, suggestion_ids)
+          def initialize(address)
             @address = address
-
-            super(
-              code: :zip_invalid_for_province,
-              field_names: [:zip],
-              message: message,
-              type: T.must(Concern::TYPES[:error]),
-              type_level: 1,
-              suggestion_ids: suggestion_ids
-            )
           end
 
-          sig { returns(String) }
-          def message
-            country.field(key: :zip).error(
+          sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
+          def build(suggestion_ids = [])
+            message = country.field(key: :zip).error(
               code: :invalid_for_province,
               options: { province: province_name },
             ).to_s
+
+            Concern.new(
+              field_names: [:zip],
+              code: :zip_invalid_for_province,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 1,
+              suggestion_ids: suggestion_ids,
+              message: message,
+            )
           end
         end
       end

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

@@ -10,11 +10,9 @@ module AtlasEngine
 
           sig { void }
           def update_result
-            result.concerns << UnknownAddressConcern.new(
-              address,
-            )
+            result.concerns << UnknownAddressConcernBuilder.new(address).build
 
-            concern = InvalidZipConcernBuilder.for(session.address, [])
+            concern = InvalidZipConcernBuilder.for(address, [])
             result.concerns << concern if concern
 
             update_result_scope

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

@@ -8,9 +8,6 @@ module AtlasEngine
         class RelevantComponents
           extend T::Sig
 
-          sig { returns(Session) }
-          attr_reader :session
-
           sig { returns(Candidate) }
           attr_reader :candidate
 
@@ -19,15 +16,15 @@ module AtlasEngine
 
           sig do
             params(
-              session: Session,
-              candidate: Candidate,
               address_comparison: AddressComparison,
+              matching_strategy: AtlasEngine::AddressValidation::MatchingStrategies,
             ).void
           end
-          def initialize(session, candidate, address_comparison)
-            @session = session
-            @candidate = candidate
+          def initialize(address_comparison, matching_strategy)
             @address_comparison = address_comparison
+            @matching_strategy = matching_strategy
+            @address = address_comparison.address
+            @candidate = address_comparison.candidate
             @all_supported_components = address_comparison.relevant_components.dup
           end
 
@@ -62,8 +59,7 @@ module AtlasEngine
           def exclude_street_validation?
             return @exclude_street_validation if defined?(@exclude_street_validation)
 
-            @exclude_street_validation = if session.matching_strategy !=
-                AddressValidation::MatchingStrategies::EsStreet
+            @exclude_street_validation = if @matching_strategy != AddressValidation::MatchingStrategies::EsStreet
               true
             elsif address_comparison.street_comparison.sequence_comparison.blank?
               emit_excluded_validation(:street, "not_found")
@@ -80,7 +76,7 @@ module AtlasEngine
 
           sig { returns(CountryProfile) }
           def country_profile
-            @country_profile ||= CountryProfile.for(session.country_code)
+            @country_profile ||= CountryProfile.for(@address.country_code)
           end
 
           sig { params(component: Symbol, reason: String).void }
@@ -88,7 +84,7 @@ module AtlasEngine
             tags = [
               "reason:#{reason}",
               "component:#{component}",
-              "country:#{session.country_code}",
+              "country:#{@address.country_code}",
             ]
             StatsD.increment("AddressValidation.skip", sample_rate: 1.0, tags: tags)
           end
@@ -97,7 +93,7 @@ module AtlasEngine
           def unsupported_components_for_country
             @unsupported_components_for_country ||= begin
               unsupported_components = []
-              country = Worldwide.region(code: session.address.country_code)
+              country = Worldwide.region(code: @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?

data/app/models/atlas_engine/address_validation/validators/full_address/{unknown_address_concern.rb → unknown_address_concern_builder.rb}

@@ -5,7 +5,8 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class UnknownAddressConcern < AddressValidation::Concern
+        class UnknownAddressConcernBuilder
+          extend T::Sig
           include ConcernFormatter
 
           sig { returns(TAddress) }
@@ -14,12 +15,18 @@ module AtlasEngine
           sig { params(address: TAddress).void }
           def initialize(address)
             @address = address
-            super(
+          end
+
+          sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
+          def build(suggestion_ids = [])
+            message = country.field(key: :address).error(code: :may_not_exist)
+
+            Concern.new(
               code: :address_unknown,
-              message: Worldwide.region(code: address.country_code).field(key: :address).error(code: :may_not_exist),
+              message: message,
               type: T.must(Concern::TYPES[:warning]),
               type_level: 1,
-              suggestion_ids: [],
+              suggestion_ids: suggestion_ids,
               field_names: [:address1],
             )
           end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class UnknownProvinceConcernBuilder
+          extend T::Sig
+          include ConcernFormatter
+          attr_reader :address
+
+          sig { params(address: AbstractAddress).void }
+          def initialize(address)
+            @address = address
+          end
+
+          sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
+          def build(suggestion_ids = [])
+            message = country.field(key: :province).error(
+              code: :unknown_for_city_and_zip,
+              options: { city: address.city, zip: address.zip },
+            ).to_s
+
+            Concern.new(
+              code: :province_inconsistent,
+              field_names: [:province],
+              message: message,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 1,
+              suggestion_ids: suggestion_ids,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/full_address/{unmatched_field_concern.rb → unmatched_field_concern_builder.rb}

@@ -5,9 +5,10 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class UnmatchedFieldConcern < AddressValidation::Concern
+        class UnmatchedFieldConcernBuilder
+          extend T::Sig
           include ConcernFormatter
-          attr_reader :component, :matched_components, :address, :unmatched_field
+          attr_reader :address, :component, :matched_components, :unmatched_field
 
           COMPONENTS_TO_LABELS = {
             zip: "ZIP",
@@ -25,29 +26,37 @@ module AtlasEngine
               unmatched_component: Symbol,
               matched_components: T::Array[Symbol],
               address: AbstractAddress,
-              suggestion_ids: T::Array[String],
               unmatched_field: T.nilable(Symbol),
             ).void
           end
-          def initialize(unmatched_component, matched_components, address, suggestion_ids, unmatched_field = nil)
+          def initialize(unmatched_component, matched_components, address, unmatched_field = nil)
+            @address = address
             @component = unmatched_component
             @matched_components = matched_components
-            @address = address
             @unmatched_field = unmatched_field
+          end
 
-            super(
+          sig do
+            params(
+              suggestion_ids: T::Array[String],
+            ).returns(Concern)
+          end
+          def build(suggestion_ids = [])
+            Concern.new(
               code: code,
               field_names: field_names,
               message: message,
               type: T.must(Concern::TYPES[:warning]),
               type_level: 3,
-              suggestion_ids: suggestion_ids
+              suggestion_ids: suggestion_ids,
             )
           end
 
+          private
+
           sig { returns(String) }
           def message
-            "Enter a valid #{COMPONENTS_TO_LABELS[component]} for #{valid_address_component_values.join(", ")}"
+            country.field(key: field_name).error(code: :unknown_for_address).to_s
           end
 
           sig { returns(Symbol) }
@@ -60,8 +69,6 @@ module AtlasEngine
             [field_name]
           end
 
-          private
-
           sig { returns(T::Array[String]) }
           def valid_address_component_values
             matched_components.last(2).map do |component|
@@ -74,6 +81,7 @@ module AtlasEngine
             SHORTENED_COMPONENT_NAMES[component] || component
           end
 
+          sig { returns(Symbol) }
           def field_name
             unmatched_field || shortened_component_name
           end

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

@@ -10,7 +10,7 @@ module AtlasEngine
 
           sig { void }
           def update_result
-            concern = InvalidZipConcernBuilder.for(session.address, [])
+            concern = InvalidZipConcernBuilder.for(address, [])
             result.concerns << concern if concern
 
             update_result_scope

data/app/models/atlas_engine/address_validation/validators/predicates/country/valid_for_zip.rb

@@ -28,7 +28,7 @@ module AtlasEngine
             sig { params(suggestion: Suggestion).returns(Concern) }
             def build_concern(suggestion)
               Concern.new(
-                field_names: [:country, :zip],
+                field_names: [:country],
                 code: :country_invalid_for_zip,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 1,

data/app/models/atlas_engine/address_validation/validators/predicates/province/valid_for_country.rb

@@ -24,7 +24,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:province, :country],
+                field_names: [:province],
                 code: :province_invalid,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

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

@@ -24,7 +24,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:address1, :country],
+                field_names: [:address1],
                 code: :missing_building_number,
                 type: T.must(Concern::TYPES[:warning]),
                 type_level: 1,

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

@@ -22,7 +22,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:address1, :address2, :country],
+                field_names: [:address1, :address2],
                 code: :missing_building_number,
                 type: T.must(Concern::TYPES[:warning]),
                 type_level: 3,

data/app/models/atlas_engine/address_validation/validators/predicates/zip/valid_for_country.rb

@@ -26,7 +26,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:zip, :country],
+                field_names: [:zip],
                 code: :zip_invalid_for_country,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

data/app/models/atlas_engine/address_validation/validators/predicates/zip/valid_for_province.rb

@@ -29,7 +29,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:zip, :country, :province],
+                field_names: [:zip],
                 code: :zip_invalid_for_province,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

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

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Elasticsearch
+    class Error < StandardError
+      extend T::Sig
+
+      sig { params(message: String, cause: T.nilable(Exception)).void }
+      def initialize(message, cause = nil)
+        super(message)
+        @cause = cause
+      end
+
+      sig { returns(T.nilable(Exception)) }
+      attr_reader :cause
+    end
+  end
+end

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

@@ -133,8 +133,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "hits" => { "hits" => [] } }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(query: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
@@ -143,8 +143,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "tokens" => [] }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(query: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
@@ -153,8 +153,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "docs" => [] }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(id: T.any(String, Integer)).returns(T::Hash[String, T.untyped]) }
@@ -163,8 +163,8 @@ module AtlasEngine
         response = client.get(path, nil, {})
 
         response.body["_source"]
-      rescue ::Elastic::Transport::Transport::Error
-        {}
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(post_address: PostAddressData).returns(T::Hash[Symbol, T.untyped]) }

data/lib/atlas_engine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_engine
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: annex_29
@@ -305,8 +305,10 @@ files:
 - app/countries/atlas_engine/gb/country_profile.yml
 - app/countries/atlas_engine/gb/validation_transcriber/full_address_parser.rb
 - app/countries/atlas_engine/gb/validation_transcriber/parsed_address.rb
+- app/countries/atlas_engine/gg/address_validation/validators/full_address/exclusions/city.rb
 - app/countries/atlas_engine/gg/address_validation/validators/full_address/restrictions/unsupported_city.rb
 - app/countries/atlas_engine/gg/country_profile.yml
+- app/countries/atlas_engine/gg/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/ie/country_profile.yml
 - 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
@@ -437,7 +439,6 @@ files:
 - app/models/atlas_engine/address_validation/abstract_address.rb
 - app/models/atlas_engine/address_validation/address.rb
 - app/models/atlas_engine/address_validation/candidate.rb
-- app/models/atlas_engine/address_validation/candidate_tuple.rb
 - app/models/atlas_engine/address_validation/concern.rb
 - app/models/atlas_engine/address_validation/concern_producer.rb
 - app/models/atlas_engine/address_validation/concern_queue.rb
@@ -463,7 +464,6 @@ files:
 - app/models/atlas_engine/address_validation/request.rb
 - app/models/atlas_engine/address_validation/result.rb
 - app/models/atlas_engine/address_validation/runs_validation.rb
-- app/models/atlas_engine/address_validation/session.rb
 - app/models/atlas_engine/address_validation/statsd_emitter.rb
 - app/models/atlas_engine/address_validation/strategies.rb
 - app/models/atlas_engine/address_validation/suggestion.rb
@@ -485,20 +485,18 @@ files:
 - 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/invalid_zip_for_country_concern_builder.rb
+- app/models/atlas_engine/address_validation/validators/full_address/invalid_zip_for_province_concern_builder.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/unknown_address_concern_builder.rb
+- app/models/atlas_engine/address_validation/validators/full_address/unknown_province_concern_builder.rb
+- app/models/atlas_engine/address_validation/validators/full_address/unmatched_field_concern_builder.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
@@ -533,6 +531,7 @@ files:
 - app/models/atlas_engine/country_repository.rb
 - app/models/atlas_engine/elasticsearch/client.rb
 - app/models/atlas_engine/elasticsearch/client_interface.rb
+- app/models/atlas_engine/elasticsearch/error.rb
 - app/models/atlas_engine/elasticsearch/repository.rb
 - app/models/atlas_engine/elasticsearch/repository_interface.rb
 - app/models/atlas_engine/elasticsearch/response.rb

data/app/models/atlas_engine/address_validation/candidate_tuple.rb

@@ -1,15 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module AtlasEngine
-  module AddressValidation
-    CandidateTuple = Struct.new(:address_comparison, :position, :candidate) do
-      extend T::Sig
-
-      sig { params(other: CandidateTuple).returns(Integer) }
-      def <=>(other)
-        to_a[0..1] <=> other.to_a[0..1] # only consider address_comparison and position
-      end
-    end
-  end
-end

data/app/models/atlas_engine/address_validation/session.rb

@@ -1,47 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "forwardable"
-
-module AtlasEngine
-  module AddressValidation
-    class Session
-      extend Forwardable
-      extend T::Sig
-
-      sig { returns(AbstractAddress) }
-      attr_reader :address
-
-      sig { returns(MatchingStrategies) }
-      attr_accessor :matching_strategy
-
-      sig { returns(T::Hash[String, AtlasEngine::AddressValidation::DatastoreBase]) }
-      attr_reader :datastore_hash
-
-      def_delegators :@address, :address1, :address2, :city, :province_code, :country_code, :zip, :phone
-
-      sig do
-        params(
-          address: AbstractAddress,
-          matching_strategy: MatchingStrategies,
-        ).void
-      end
-      def initialize(address:, matching_strategy: MatchingStrategies::Es)
-        @address = address
-        @matching_strategy = matching_strategy
-        @datastore_hash = T.let({}, T::Hash[String, AtlasEngine::AddressValidation::DatastoreBase])
-      end
-
-      sig { params(locale: T.nilable(String)).returns(ValidationTranscriber::AddressParsings) }
-      def parsings(locale: nil)
-        datastore(locale: locale).parsings
-      end
-
-      sig { params(locale: T.nilable(String)).returns(AtlasEngine::AddressValidation::DatastoreBase) }
-      def datastore(locale: nil)
-        key = locale || "default"
-        @datastore_hash[key] ||= AtlasEngine::AddressValidation::Es::Datastore.new(address: address, locale: locale)
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module AtlasEngine
-  module AddressValidation
-    module Validators
-      module FullAddress
-        class ResultUpdater
-          extend T::Sig
-          extend T::Helpers
-          abstract!
-
-          sig { params(session: Session, result: Result).void }
-          def initialize(session:, result:)
-            @session = session
-            @result = result
-          end
-
-          private
-
-          attr_reader :session, :result
-
-          delegate :address, to: :session
-
-          sig { void }
-          def update_result_scope
-            concern_fields = result.concerns.flat_map(&:field_names).uniq
-            scopes_to_remove = concern_fields.flat_map { |field| contained_scopes_for(field) }
-            result.validation_scope.reject! { |scope| scope.in?(scopes_to_remove) }
-          end
-
-          sig { params(scope: Symbol).returns(T.nilable(T::Array[Symbol])) }
-          def contained_scopes_for(scope)
-            return [] unless (scope_index = Result::SORTED_VALIDATION_SCOPES.index(scope))
-
-            Result::SORTED_VALIDATION_SCOPES.slice(scope_index..)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module AtlasEngine
-  module AddressValidation
-    module Validators
-      module FullAddress
-        class UnknownProvinceConcern < AddressValidation::Concern
-          include ConcernFormatter
-          attr_reader :address
-
-          sig { params(address: AbstractAddress, suggestion_ids: T::Array[String]).void }
-          def initialize(address, suggestion_ids)
-            @address = address
-            super(
-              code: :province_inconsistent,
-              field_names: [:province],
-              message: message,
-              type: T.must(Concern::TYPES[:error]),
-              type_level: 1,
-              suggestion_ids: suggestion_ids
-            )
-          end
-
-          sig { returns(String) }
-          def message
-            country
-              .field(key: :province)
-              .error(
-                code: :unknown_for_city_and_zip,
-                options: { city: address.city, zip: address.zip },
-              ).to_s
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module AtlasEngine
-  module AddressValidation
-    module Validators
-      module FullAddress
-        class UnknownZipForAddressConcern < AddressValidation::Concern
-          attr_reader :address
-
-          sig { params(address: AbstractAddress, suggestion_ids: T::Array[String]).void }
-          def initialize(address, suggestion_ids)
-            @address = address
-            super(
-              code: :zip_inconsistent,
-              field_names: [:zip],
-              message: message,
-              type: T.must(Concern::TYPES[:warning]),
-              type_level: 3,
-              suggestion_ids: suggestion_ids
-            )
-          end
-
-          sig { returns(String) }
-          def message
-            "Enter a valid ZIP for #{address.address1}, #{address.city}"
-          end
-        end
-      end
-    end
-  end
-end