atlas_engine 1.0.0 → 1.2.0

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

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class PredicatePipelineBuilder
+      extend T::Sig
+
+      sig { returns(PredicatePipeline) }
+      attr_reader :predicate_pipeline
+
+      sig { returns(AbstractAddress) }
+      attr_reader :address
+
+      sig { returns(Result) }
+      attr_reader :result
+
+      sig { returns(MessageFormat) }
+      attr_reader :message_format
+
+      sig do
+        params(
+          matching_strategy_name: String,
+          address: AbstractAddress,
+          result: Result,
+          message_format: MessageFormat,
+        ).void
+      end
+      def initialize(matching_strategy_name:, address:, result:, message_format:)
+        @address = address
+        @predicate_pipeline = T.let(PredicatePipeline.find(matching_strategy_name), PredicatePipeline)
+        @result = result
+        @message_format = message_format
+      end
+
+      sig { returns(T::Array[PredicatePipeline::PredicateConfig]) }
+      def pipeline
+        predicate_pipeline.pipeline.reject do |predicate_config|
+          unsupported_fields.include?(predicate_config.field)
+        end
+      end
+
+      sig { returns(T.nilable(FullAddressValidatorBase)) }
+      def full_address_validator
+        predicate_pipeline.full_address_validator&.new(
+          address: address,
+          result: result,
+          message_format: message_format,
+        )
+      end
+
+      sig do
+        returns(T::Array[Symbol])
+      end
+      def unsupported_fields
+        @unsupported_fields ||= T.let(
+          begin
+            unsupported_fields = []
+            unsupported_fields += address1_format == :extended ? [:address1] : [:street_name, :street_number]
+            unsupported_fields += address2_format == :extended ? [:address2] : [:line2, :neighborhood]
+            unsupported_fields
+          end,
+          T.nilable(T::Array[T.untyped]),
+        )
+      end
+
+      private
+
+      sig { returns(Symbol) }
+      def address1_format
+        T.let(
+          [:street_name, :street_number].all? do |field|
+            address.send(field).nil?
+          end ? :standard : :extended,
+          Symbol,
+        )
+      end
+
+      sig { returns(Symbol) }
+      def address2_format
+        T.let(
+          [:neighborhood, :line2].all? do |field|
+            address.send(field).nil?
+          end ? :standard : :extended,
+          Symbol,
+        )
+      end
+    end
+  end
+end

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

@@ -7,6 +7,7 @@ module AtlasEngine
       const :address, AbstractAddress
       const :locale, String, default: "en"
       const :matching_strategy, T.nilable(T.any(String, Symbol)), default: nil
+      const :message_format, T.nilable(T.any(String, Symbol)), default: nil
     end
   end
 end

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

@@ -12,9 +12,21 @@ module AtlasEngine
       sig { returns(T.nilable(String)) }
       attr_accessor :address1
 
+      sig { returns(T.nilable(String)) }
+      attr_accessor :street_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :street_number
+
       sig { returns(T.nilable(String)) }
       attr_accessor :address2
 
+      sig { returns(T.nilable(String)) }
+      attr_accessor :line2
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :neighborhood
+
       sig { returns(T.nilable(String)) }
       attr_accessor :city
 
@@ -30,16 +42,25 @@ module AtlasEngine
       sig do
         params(
           address1: T.nilable(String),
+          street_name: T.nilable(String),
+          street_number: T.nilable(String),
           address2: T.nilable(String),
+          line2: T.nilable(String),
+          neighborhood: T.nilable(String),
           city: T.nilable(String),
           zip: T.nilable(String),
           province_code: T.nilable(String),
           country_code: T.nilable(String),
         ).void
       end
-      def initialize(address1: nil, address2: nil, city: nil, zip: nil, province_code: nil, country_code: nil)
+      def initialize(address1: nil, street_name: nil, street_number: nil, address2: nil, line2: nil, neighborhood: nil,
+        city: nil, zip: nil, province_code: nil, country_code: nil)
         @address1 = address1
+        @street_name = street_name
+        @street_number = street_number
         @address2 = address2
+        @line2 = line2
+        @neighborhood = neighborhood
         @city = city
         @zip = zip
         @province_code = province_code
@@ -55,7 +76,11 @@ module AtlasEngine
         {
           id: id,
           address1: address1,
+          street_name: street_name,
+          street_number: street_number,
           address2: address2,
+          line2: line2,
+          neighborhood: neighborhood,
           city: city,
           zip: zip,
           province_code: province_code,

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

@@ -28,6 +28,12 @@ module AtlasEngine
       sig { returns(T.nilable(FullAddressValidatorBase)) }
       attr_reader :full_address_validator
 
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :unsupported_fields
+
+      sig { returns(MessageFormat) }
+      attr_reader :message_format
+
       FIELD_MAP = T.let(
         {
           country: "country_code",
@@ -36,6 +42,10 @@ module AtlasEngine
           city: "city",
           address1: "address1",
           address2: "address2",
+          street_name: "street_name",
+          street_number: "street_number",
+          neighborhood: "neighborhood",
+          line2: "line2",
           phone: "phone",
         },
         T::Hash[Symbol, String],
@@ -47,13 +57,15 @@ module AtlasEngine
           matching_strategy: Strategies,
           locale: String,
           context: T::Hash[T.untyped, T.untyped],
+          message_format: MessageFormat,
         ).void
       end
       def initialize(
         address:,
         matching_strategy:,
         locale: "en",
-        context: {}
+        context: {},
+        message_format: MessageFormat::Instructional
       )
         @address = T.let(address, AbstractAddress)
         @address1 = T.let(address.address1, T.nilable(String))
@@ -65,9 +77,9 @@ module AtlasEngine
         @country_code = T.let(address.country_code, T.nilable(String))
         @context = T.let(context, T::Hash[T.untyped, T.untyped])
         @matching_strategy = T.let(matching_strategy, Strategies)
+        @message_format = T.let(message_format, MessageFormat)
 
         matching_strategy_name = matching_strategy.serialize
-        @predicate_pipeline = T.let(PredicatePipeline.find(matching_strategy_name), PredicatePipeline)
 
         @result = T.let(
           Result.new(
@@ -78,14 +90,14 @@ module AtlasEngine
           ),
           Result,
         )
+        pipeline_builder = PredicatePipelineBuilder.new(matching_strategy_name:, address:, result:, message_format:)
 
-        @full_address_validator = T.let(
-          @predicate_pipeline.full_address_validator&.new(
-            address: @address,
-            result: @result,
-          ),
-          T.nilable(FullAddressValidatorBase),
+        @pipeline = T.let(
+          pipeline_builder.pipeline,
+          T::Array[AtlasEngine::AddressValidation::PredicatePipeline::PredicateConfig],
         )
+        @unsupported_fields = T.let(pipeline_builder.unsupported_fields, T::Array[Symbol])
+        @full_address_validator = T.let(pipeline_builder.full_address_validator, T.nilable(FullAddressValidatorBase))
       end
 
       sig { override.returns(Result) }
@@ -113,15 +125,20 @@ module AtlasEngine
         pipeline_address = Address.from_address(address: address)
         local_concerns = {}
         cache = Validators::Predicates::Cache.new(pipeline_address)
-        @predicate_pipeline.pipeline.each do |config|
+        @pipeline.each do |predicate_config|
           break if local_concerns[:country].present?
 
-          local_concerns[config.field] = [] if local_concerns[config.field].nil?
-          next if local_concerns[config.field].present?
+          local_concerns[predicate_config.field] = [] if local_concerns[predicate_config.field].nil?
+          next if local_concerns[predicate_config.field].present?
 
-          concern = config.class_name.new(field: config.field, address: pipeline_address, cache: cache).evaluate
+          concern = predicate_config.class_name.new(
+            field: predicate_config.field,
+            address: pipeline_address,
+            cache: cache,
+            message_format: message_format,
+          ).evaluate
 
-          local_concerns[config.field] << concern if concern.present?
+          local_concerns[predicate_config.field] << concern if concern.present?
         end
         local_concerns
       end
@@ -129,7 +146,7 @@ module AtlasEngine
       sig { params(local_concerns: T::Hash[Symbol, T::Array[Concern]]).void }
       def populate_result(local_concerns)
         local_concerns.keys.each do |field|
-          if local_concerns[field]&.empty? && [:address2, :phone].exclude?(field)
+          if local_concerns[field]&.empty? && [:address2, :phone].concat(unsupported_fields).exclude?(field)
             result.validation_scope << T.must(FIELD_MAP[field])
           end
 

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

@@ -14,10 +14,11 @@ module AtlasEngine
               address_comparison: AddressComparison,
               matching_strategy: AddressValidation::MatchingStrategies,
               result: Result,
+              message_format: MessageFormat,
             ).void
           end
-          def initialize(address_comparison:, matching_strategy:, result:)
-            super(address: address_comparison.address, result: result)
+          def initialize(address_comparison:, matching_strategy:, result:, message_format:)
+            super(address: address_comparison.address, result: result, message_format: message_format)
             @address_comparison = address_comparison
             @candidate = address_comparison.candidate
             @matching_strategy = matching_strategy
@@ -56,11 +57,11 @@ module AtlasEngine
 
           sig { void }
           def add_concerns_without_suggestions
-            concern = InvalidZipConcernBuilder.for(address, [])
+            concern = InvalidZipConcernBuilder.for(address, [], message_format)
             result.concerns << concern if concern
 
             if ConcernBuilder.too_many_unmatched_components?(address, unmatched_components.keys)
-              result.concerns << UnknownAddressConcernBuilder.new(address).build
+              result.concerns << UnknownAddressConcernBuilder.new(address, message_format).build
             end
           end
 
@@ -79,6 +80,7 @@ module AtlasEngine
                 matched_components: matched_components_to_validate.keys,
                 address: address,
                 suggestion_ids: [suggestion.id].compact,
+                message_format: message_format,
               ).build
               result.concerns << concern
             end
@@ -167,7 +169,9 @@ module AtlasEngine
 
             original_street = T.must(unmatched_components_to_validate[:street]).left_sequence.raw_value
 
-            if address.address1.to_s.include?(original_street)
+            if address.street_name.present?
+              :street_name
+            elsif address.address1.to_s.include?(original_street)
               :address1
             elsif address.address2.to_s.include?(original_street)
               :address2

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

@@ -11,10 +11,11 @@ module AtlasEngine
 
           abstract!
 
-          sig { params(address: AbstractAddress, result: Result).void }
-          def initialize(address:, result:)
+          sig { params(address: AbstractAddress, result: Result, message_format: MessageFormat).void }
+          def initialize(address:, result:, message_format: MessageFormat::Instructional)
             @address = address
             @result = result
+            @message_format = message_format
           end
 
           sig { void }
@@ -22,7 +23,7 @@ module AtlasEngine
 
           private
 
-          attr_reader :result, :address
+          attr_reader :result, :address, :message_format
 
           sig { void }
           def update_result_scope

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

@@ -8,7 +8,12 @@ module AtlasEngine
         class ConcernBuilder
           extend T::Sig
 
-          attr_reader :unmatched_component, :unmatched_field, :matched_components, :address, :suggestion_ids
+          attr_reader :unmatched_component,
+            :unmatched_field,
+            :matched_components,
+            :address,
+            :suggestion_ids,
+            :message_format
 
           class << self
             extend T::Sig
@@ -79,15 +84,24 @@ module AtlasEngine
               matched_components: T::Array[Symbol],
               address: AbstractAddress,
               suggestion_ids: T::Array[String],
+              message_format: MessageFormat,
               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:,
+            suggestion_ids:,
+            message_format:,
+            unmatched_field: nil
+          )
             @unmatched_component = unmatched_component
             @unmatched_field = unmatched_field
             @matched_components = matched_components
             @address = address
             @suggestion_ids = suggestion_ids
+            @message_format = message_format
           end
 
           sig { returns(AddressValidation::Concern) }
@@ -106,7 +120,7 @@ module AtlasEngine
 
           sig { returns(AddressValidation::Concern) }
           def build_zip_concern
-            concern = InvalidZipConcernBuilder.for(address, suggestion_ids)
+            concern = InvalidZipConcernBuilder.for(address, suggestion_ids, message_format)
             return concern if concern
 
             build_default_concern
@@ -115,7 +129,7 @@ module AtlasEngine
           sig { returns(AddressValidation::Concern) }
           def build_province_concern
             if ([:zip, :city] - matched_components).empty?
-              UnknownProvinceConcernBuilder.new(address).build(suggestion_ids)
+              UnknownProvinceConcernBuilder.new(address, message_format).build(suggestion_ids)
             else
               build_default_concern
             end
@@ -128,6 +142,7 @@ module AtlasEngine
               matched_components,
               address,
               unmatched_field,
+              message_format,
             ).build(suggestion_ids)
           end
         end

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

@@ -13,9 +13,10 @@ module AtlasEngine
               params(
                 address: AbstractAddress,
                 suggestion_ids: T::Array[String],
+                message_format: MessageFormat,
               ).returns(T.nilable(AddressValidation::Concern))
             end
-            def for(address, suggestion_ids)
+            def for(address, suggestion_ids, message_format)
               country = Worldwide.region(code: address.country_code)
 
               province = country.zone(code: address.province_code.presence || "")
@@ -24,11 +25,11 @@ module AtlasEngine
               if country_expects_zone_in_address?(country) && province.province?
                 return if province.valid_zip?(address.zip)
 
-                InvalidZipForProvinceConcernBuilder.new(address).build
+                InvalidZipForProvinceConcernBuilder.new(address, message_format).build
               else
                 return if country.valid_zip?(address.zip)
 
-                InvalidZipForCountryConcernBuilder.new(address).build(suggestion_ids)
+                InvalidZipForCountryConcernBuilder.new(address, message_format).build(suggestion_ids)
               end
             end
 

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

@@ -9,16 +9,18 @@ module AtlasEngine
           extend T::Sig
           include ConcernFormatter
           attr_reader :address
+          attr_reader :message_format
 
-          sig { params(address: AbstractAddress).void }
-          def initialize(address)
+          sig { params(address: AbstractAddress, message_format: MessageFormat).void }
+          def initialize(address, message_format)
             @address = address
+            @message_format = message_format
           end
 
           sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
           def build(suggestion_ids = [])
-            message =  country.field(key: :zip).error(
-              code: :invalid_for_country,
+            message = country.field(key: :zip).error(
+              code: "invalid_for_country_#{message_format.serialize}".to_sym,
               options: { country: country.full_name },
             ).to_s
 

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

@@ -9,15 +9,17 @@ module AtlasEngine
           extend T::Sig
           include ConcernFormatter
           attr_reader :address
+          attr_reader :message_format
 
-          def initialize(address)
+          def initialize(address, message_format)
             @address = address
+            @message_format = message_format
           end
 
           sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
           def build(suggestion_ids = [])
             message = country.field(key: :zip).error(
-              code: :invalid_for_province,
+              code: "invalid_for_province_#{message_format.serialize}".to_sym,
               options: { province: province_name },
             ).to_s
 

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

@@ -12,7 +12,7 @@ module AtlasEngine
           def update_result
             result.concerns << UnknownAddressConcernBuilder.new(address).build
 
-            concern = InvalidZipConcernBuilder.for(address, [])
+            concern = InvalidZipConcernBuilder.for(address, [], message_format)
             result.concerns << concern if concern
 
             update_result_scope

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

@@ -12,7 +12,11 @@ module AtlasEngine
               params(
                 address: {
                   address1: T.nilable(String),
+                  street_name: T.nilable(String),
+                  street_number: T.nilable(String),
                   address2: T.nilable(String),
+                  line2: T.nilable(String),
+                  neighborhood: T.nilable(String),
                   city: T.nilable(String),
                   province_code: T.nilable(String),
                   country_code: T.nilable(String),
@@ -70,9 +74,12 @@ module AtlasEngine
               original_street = comparison.left_sequence.raw_value
               field = unmatched_fields[:street]
 
-              if field == :address1
+              case field
+              when :street_name
+                suggestion.street_name = suggested_street
+              when :address1
                 suggestion.address1 = suggestion.address1.to_s.sub(original_street, suggested_street)
-              elsif field == :address2
+              when :address2
                 suggestion.address2 = suggestion.address2.to_s.sub(original_street, suggested_street)
               end
 

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

@@ -12,14 +12,20 @@ module AtlasEngine
           sig { returns(TAddress) }
           attr_reader :address
 
-          sig { params(address: TAddress).void }
-          def initialize(address)
+          sig { returns(MessageFormat) }
+          attr_reader :message_format
+
+          sig { params(address: TAddress, message_format: MessageFormat).void }
+          def initialize(address, message_format = MessageFormat::Instructional)
             @address = address
+            @message_format = message_format
           end
 
           sig { params(suggestion_ids: T::Array[String]).returns(Concern) }
           def build(suggestion_ids = [])
-            message = country.field(key: :address).error(code: :may_not_exist)
+            message = country.field(key: :address).error(
+              code: "may_not_exist_#{message_format.serialize}".to_sym,
+            ).to_s
 
             Concern.new(
               code: :address_unknown,
@@ -27,9 +33,15 @@ module AtlasEngine
               type: T.must(Concern::TYPES[:warning]),
               type_level: 1,
               suggestion_ids: suggestion_ids,
-              field_names: [:address1],
+              field_names: [field],
             )
           end
+
+          private
+
+          def field
+            address.street_name.present? ? :street_name : :address1
+          end
         end
       end
     end

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

@@ -8,17 +8,22 @@ module AtlasEngine
         class UnknownProvinceConcernBuilder
           extend T::Sig
           include ConcernFormatter
+
           attr_reader :address
 
-          sig { params(address: AbstractAddress).void }
-          def initialize(address)
+          sig { returns(MessageFormat) }
+          attr_reader :message_format
+
+          sig { params(address: AbstractAddress, message_format: MessageFormat).void }
+          def initialize(address, message_format = MessageFormat::Instructional)
             @address = address
+            @message_format = message_format
           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,
+              code: "unknown_for_city_and_zip_#{message_format.serialize}".to_sym,
               options: { city: address.city, zip: address.zip },
             ).to_s
 

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

@@ -8,7 +8,7 @@ module AtlasEngine
         class UnmatchedFieldConcernBuilder
           extend T::Sig
           include ConcernFormatter
-          attr_reader :address, :unmatched_component, :matched_components, :unmatched_field
+          attr_reader :address, :unmatched_component, :matched_components, :unmatched_field, :message_format
 
           COMPONENTS_TO_LABELS = {
             zip: "ZIP",
@@ -27,13 +27,21 @@ module AtlasEngine
               matched_components: T::Array[Symbol],
               address: AbstractAddress,
               unmatched_field: T.nilable(Symbol),
+              message_format: MessageFormat,
             ).void
           end
-          def initialize(unmatched_component, matched_components, address, unmatched_field = nil)
+          def initialize(
+            unmatched_component,
+            matched_components,
+            address,
+            unmatched_field = nil,
+            message_format = MessageFormat::Instructional
+          )
             @address = address
             @unmatched_component = unmatched_component
             @matched_components = matched_components
             @unmatched_field = unmatched_field || unmatched_component
+            @message_format = message_format
           end
 
           sig do
@@ -56,7 +64,9 @@ module AtlasEngine
 
           sig { returns(String) }
           def message
-            country.field(key: field_name).error(code: :unknown_for_address).to_s
+            country.field(key: field_name).error(
+              code: "unknown_for_address_#{message_format.serialize}".to_sym,
+            ).to_s
           end
 
           sig { returns(Symbol) }

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(address, [])
+            concern = InvalidZipConcernBuilder.for(address, [], message_format)
             result.concerns << concern if concern
 
             update_result_scope

data/app/models/atlas_engine/address_validation/validators/predicates/city/present.rb

@@ -24,7 +24,7 @@ module AtlasEngine
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,
                 suggestion_ids: [],
-                message: @cache.country.field(key: :city).error(code: :blank).to_s,
+                message: @cache.country.field(key: :city).error(code: "blank_#{message_format.serialize}".to_sym).to_s,
               )
             end
           end

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

@@ -23,7 +23,11 @@ module AtlasEngine
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,
                 suggestion_ids: [],
-                message: Worldwide.region(code: "US").field(key: :country).error(code: :blank),
+                message: Worldwide
+                  .region(code: "US")
+                  .field(key: :country)
+                  .error(code: "blank_#{message_format.serialize}".to_sym)
+                  .to_s,
               )
             end
           end

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

@@ -34,7 +34,7 @@ module AtlasEngine
                 type_level: 1,
                 suggestion_ids: [T.must(suggestion.id)],
                 message: @cache.country.field(key: :zip).error(
-                  code: :invalid_for_country,
+                  code: "invalid_for_country_#{message_format.serialize}".to_sym,
                   options: { country: @cache.country.full_name },
                 ),
                 suggestion: suggestion,