atlas_engine 1.1.0 → 1.2.0

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

@@ -74,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,

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

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Neighborhood
+          class Present < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if @address.neighborhood.blank? && @cache.country.neighborhood_required?
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:neighborhood],
+                code: :neighborhood_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :neighborhood).error(
+                  code: "blank_#{message_format.serialize}".to_sym,
+                ).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/validators/predicates/not_exceed_max_length.rb

@@ -6,14 +6,29 @@ module AtlasEngine
     module Validators
       module Predicates
         class NotExceedMaxLength < Predicate
-          MAX_COMPONENT_LENGTH = 255
+          MAX_COMPONENT_LENGTH = T.let(
+            {
+              street_name: 200,
+              street_number: 50,
+              line2: 175,
+              neighborhood: 75,
+              default: 255,
+            },
+            T::Hash[Symbol, Integer],
+          )
+
           sig { override.returns(T.nilable(Concern)) }
           def evaluate
-            build_concern if address.send(@field).to_s.length > MAX_COMPONENT_LENGTH
+            build_concern if address.send(@field).to_s.length > limit
           end
 
           private
 
+          sig { returns(Integer) }
+          def limit
+            @limit ||= T.let(MAX_COMPONENT_LENGTH[@field] || T.must(MAX_COMPONENT_LENGTH[:default]), T.nilable(Integer))
+          end
+
           sig { returns(Concern) }
           def build_concern
             Concern.new(
@@ -22,7 +37,7 @@ module AtlasEngine
               type: T.must(Concern::TYPES[:error]),
               type_level: 3,
               suggestion_ids: [],
-              message: @cache.country.field(key: @field)&.error(code: :too_long).to_s,
+              message: @cache.country.field(key: @field)&.error(code: :too_long, options: { limit: limit }).to_s,
             )
           end
         end

data/app/models/atlas_engine/address_validation/validators/predicates/phone/valid.rb

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

data/app/models/atlas_engine/address_validation/validators/predicates/predicate.rb

@@ -19,13 +19,17 @@ module AtlasEngine
           sig { returns(Cache) }
           attr_reader :cache
 
+          sig { returns(MessageFormat) }
+          attr_reader :message_format
+
           delegate :address1, :address2, :city, :zip, :province_code, :country_code, to: :address
 
-          sig { params(field: Symbol, address: Address, cache: Cache).void }
-          def initialize(field:, address:, cache: Cache.new(address))
+          sig { params(field: Symbol, address: Address, message_format: MessageFormat, cache: Cache).void }
+          def initialize(field:, address:, message_format: MessageFormat::Instructional, cache: Cache.new(address))
             @field = field
             @address = address
             @cache = cache
+            @message_format = message_format
           end
 
           sig { abstract.returns(T.nilable(Concern)) }

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module StreetName
+          class Present < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if @address.street_name.blank? && @cache.country.street_name_required?
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:street_name],
+                code: :street_name_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :street_name).error(
+                  code: "blank_#{message_format.serialize}".to_sym,
+                ).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module StreetNumber
+          class Present < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if @address.street_number.blank? && @cache.country.street_number_required?
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:street_number],
+                code: :street_number_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :street_number).error(
+                  code: "blank_#{message_format.serialize}".to_sym,
+                ).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,12 +40,12 @@ module AtlasEngine
               province_name = @cache.province.province? ? @cache.province.full_name : address.province_code
               if province_name.present?
                 @cache.country.field(key: :zip).error(
-                  code: :invalid_for_province,
+                  code: "invalid_for_province_#{message_format.serialize}".to_sym,
                   options: { province: province_name },
                 ).to_s
               else
                 @cache.country.field(key: :zip).error(
-                  code: :invalid_for_country,
+                  code: "invalid_for_country_#{message_format.serialize}".to_sym,
                   options: { country: @cache.country.short_name },
                 ).to_s
               end

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

@@ -32,7 +32,7 @@ module AtlasEngine
                 type_level: 3,
                 suggestion_ids: [],
                 message: @cache.country.field(key: :zip).error(
-                  code: :invalid_for_country,
+                  code: "invalid_for_country_#{message_format.serialize}".to_sym,
                   options: { country: @cache.country.short_name },
                 ).to_s,
               )

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

@@ -43,7 +43,7 @@ module AtlasEngine
               province_name = @cache.province.province? ? @cache.province.full_name : address.province_code
 
               @cache.country.field(key: :zip).error(
-                code: :invalid_for_province,
+                code: "invalid_for_province_#{message_format.serialize}".to_sym,
                 options: { province: province_name },
               ).to_s
             end

data/app/models/atlas_engine/services/validation.rb

@@ -22,11 +22,15 @@ module AtlasEngine
               AddressValidation::MatchingStrategies::Local
             end
 
+            message_format = AddressValidation::MessageFormat.try_deserialize(request.message_format) ||
+              AddressValidation::MessageFormat::Instructional
+
             validator = AddressValidation::Validator.new(
               address: request.address,
               locale: request.locale,
               matching_strategy: matching_strategy,
               context: request.address.context.to_h,
+              message_format: message_format,
             )
             result = validator.run
 

data/db/data/validation_pipelines/es.yml

@@ -52,6 +52,52 @@ pipeline:
     class: AtlasEngine::AddressValidation::Validators::Predicates::Street::BuildingNumberInAddress1OrAddress2
   - field: address1
     class: AtlasEngine::AddressValidation::Validators::Predicates::Street::BuildingNumberInAddress1
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::StreetName::Present
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoEmojis
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxTokenCount
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxLength
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoUrl
+  - field: street_name
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoHtmlTags
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::StreetNumber::Present
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoEmojis
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxTokenCount
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxLength
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoUrl
+  - field: street_number
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoHtmlTags
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::Neighborhood::Present
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoEmojis
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxTokenCount
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxLength
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoUrl
+  - field: neighborhood
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoHtmlTags
+  - field: line2
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoEmojis
+  - field: line2
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxTokenCount
+  - field: line2
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NotExceedMaxLength
+  - field: line2
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoUrl
+  - field: line2
+    class: AtlasEngine::AddressValidation::Validators::Predicates::NoHtmlTags
   - field: phone
     class: AtlasEngine::AddressValidation::Validators::Predicates::Phone::Valid