atlas_engine 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3285871f59bee7bdf0084bfb5f985a6e582a173a78baa496c07ba9e8bd526eda
-  data.tar.gz: b25b6b4d8637c34d43a78e60f457342ccd9f7117f02d039f961476a7a4ef310e
+  metadata.gz: 56b5b41a624c3481954aadfa0101c9883dfe3479a3cdec373f8ecccab8bae879
+  data.tar.gz: 73ee021ecf5d8357ae8f000df7e963e7504153fdc3b7bb98f188445aa8cd7989
 SHA512:
-  metadata.gz: ea581fe90f17c1924f2d370fef820dc8bf18ed094e570666cdc60f13b0ec37b7e8876749176bbb14cd9f408931c525f6f7b29afdf4da47270bf24f147f8f0bce
-  data.tar.gz: 6ef3dca52ae9bfc224d694c6cb326f743701280cb8d6be14f30421ea247c53822d8017acdeaad5641cfe34ac080ca33a1b010308575057fec2e040a1d7a3222e
+  metadata.gz: b93dee8561c73619222ca4a4e803fb2f911b3149955c5b1af7803990318a7ebd36e781c41643cf3076197f579833e9c2d361e8e4550a9d2d3de628d8e7819ef7
+  data.tar.gz: f2f593c6e2a7849dae6dce6a52d9402ce7d907a90511664d1218133b5d4a501b5ae98a26e54a06412c3fb37e3dc74c75ae17c575ae24fa4805c02ad888467d21

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/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

@@ -110,7 +110,7 @@ module AtlasEngine
             return concern if concern
 
             if :province_code.in?(matched_components) && :city.in?(matched_components)
-              return UnknownZipForAddressConcern.new(address, suggestion_ids)
+              return UnknownZipForAddressConcernBuilder.new(address).build(suggestion_ids)
             end
 
             build_default_concern
@@ -119,7 +119,7 @@ module AtlasEngine
           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 +127,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/{unknown_zip_for_address_concern.rb → unknown_zip_for_address_concern_builder.rb}

@@ -5,26 +5,28 @@ module AtlasEngine
   module AddressValidation
     module Validators
       module FullAddress
-        class UnknownZipForAddressConcern < AddressValidation::Concern
+        class UnknownZipForAddressConcernBuilder
+          extend T::Sig
           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
-            super(
+          end
+
+          sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
+          def build(suggestion_ids = [])
+            message = "Enter a valid ZIP for #{address.address1}, #{address.city}"
+
+            Concern.new(
               code: :zip_inconsistent,
               field_names: [:zip],
               message: message,
               type: T.must(Concern::TYPES[:warning]),
               type_level: 3,
-              suggestion_ids: suggestion_ids
+              suggestion_ids: suggestion_ids,
             )
           end
-
-          sig { returns(String) }
-          def message
-            "Enter a valid ZIP for #{address.address1}, #{address.city}"
-          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,26 +26,34 @@ 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(", ")}"
@@ -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/lib/atlas_engine/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AtlasEngine
-  VERSION = "0.5.0"
+  VERSION = "0.6.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.6.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-20 00:00:00.000000000 Z
+date: 2024-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: annex_29
@@ -437,7 +437,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 +462,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 +483,19 @@ 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/unknown_zip_for_address_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

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