atlas_engine 0.1.0

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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

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

@@ -0,0 +1,84 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class UnmatchedFieldConcern < AddressValidation::Concern
+          include ConcernFormatter
+          attr_reader :component, :matched_components, :address, :unmatched_field
+
+          COMPONENTS_TO_LABELS = {
+            zip: "ZIP",
+            province_code: "state",
+            city: "city",
+            street: "street name",
+          }.freeze
+
+          SHORTENED_COMPONENT_NAMES = {
+            province_code: :province,
+          }.freeze
+
+          sig do
+            params(
+              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)
+            @component = unmatched_component
+            @matched_components = matched_components
+            @address = address
+            @unmatched_field = unmatched_field
+
+            super(
+              code: code,
+              field_names: field_names,
+              message: message,
+              type: T.must(Concern::TYPES[:warning]),
+              type_level: 3,
+              suggestion_ids: suggestion_ids
+            )
+          end
+
+          sig { returns(String) }
+          def message
+            "Enter a valid #{COMPONENTS_TO_LABELS[component]} for #{valid_address_component_values.join(", ")}"
+          end
+
+          sig { returns(Symbol) }
+          def code
+            "#{shortened_component_name}_inconsistent".to_sym
+          end
+
+          sig { returns(T::Array[Symbol]) }
+          def field_names
+            [field_name]
+          end
+
+          private
+
+          sig { returns(T::Array[String]) }
+          def valid_address_component_values
+            matched_components.last(2).map do |component|
+              component == :province_code ? province_name : address[component]
+            end
+          end
+
+          sig { returns(Symbol) }
+          def shortened_component_name
+            SHORTENED_COMPONENT_NAMES[component] || component
+          end
+
+          def field_name
+            unmatched_field || shortened_component_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module FullAddress
+        class UnsupportedScriptResult < CandidateResultBase
+          extend T::Sig
+
+          sig { void }
+          def update_result
+            concern = InvalidZipConcernBuilder.for(session.address, [])
+            result.concerns << concern if concern
+
+            update_result_scope
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class Cache
+          extend T::Sig
+
+          sig { params(address: Address).void }
+          def initialize(address)
+            @address = address
+            @empty_region = Worldwide::Region.new(iso_code: "ZZ")
+          end
+
+          sig { returns(Worldwide::Region) }
+          def country
+            if @address.country_code.present?
+              @country ||= Worldwide.region(code: @address.country_code)
+            else
+              @empty_region
+            end
+          end
+
+          sig { returns(Worldwide::Region) }
+          def province
+            if @address.province_code.present?
+              @province ||= country.zone(code: @address.province_code)
+            else
+              @empty_region
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module City
+          class Present < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+              return if @cache.country.field(key: :city).autofill(locale: :en).present?
+
+              build_concern if @address.city.blank?
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:city],
+                code: :city_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :city).error(code: :blank).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Country
+          class Exists < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern unless @address.country_code.present? &&
+                @cache.country.country?
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:country],
+                code: :country_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: Worldwide.region(code: "US").field(key: :country).error(code: :blank),
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Country
+          class ValidForZip < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+              return if @address.zip.blank?
+
+              suggested_country = Worldwide::Zip.find_country(
+                country_code: @address.country_code,
+                zip: @address.zip,
+              )
+
+              return if suggested_country.nil? ||
+                suggested_country.iso_code == @address.country_code
+
+              build_concern(build_suggestion(suggested_country.iso_code))
+            end
+
+            private
+
+            sig { params(suggestion: Suggestion).returns(Concern) }
+            def build_concern(suggestion)
+              Concern.new(
+                field_names: [:country, :zip],
+                code: :country_invalid_for_zip,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 1,
+                suggestion_ids: [T.must(suggestion.id)],
+                message: @cache.country.field(key: :zip).error(
+                  code: :invalid_for_country,
+                  options: { country: @cache.country.full_name },
+                ),
+                suggestion: suggestion,
+              )
+            end
+
+            sig { params(suggested_country_code: String).returns(Suggestion) }
+            def build_suggestion(suggested_country_code)
+              Suggestion.new(
+                address1: address1,
+                address2: address2,
+                city: city,
+                zip: zip,
+                province_code: province_code,
+                country_code: suggested_country_code,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class NoEmojis < Predicate
+          sig { override.returns(T.nilable(Concern)) }
+          def evaluate
+            return unless @cache.country.country?
+
+            build_concern if contains_blocked_codepoints?(address.send(@field))
+          end
+
+          private
+
+          sig { returns(Concern) }
+          def build_concern
+            Concern.new(
+              field_names: [@field],
+              code: "#{@field}_contains_emojis".to_sym,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 3,
+              suggestion_ids: [],
+              message: @cache.country.field(key: @field)&.error(code: :contains_emojis).to_s,
+            )
+          end
+
+          sig { params(field_value: T.nilable(String)).returns(T::Boolean) }
+          def contains_blocked_codepoints?(field_value)
+            field_value.to_s.codepoints.any? { |x| (x > 0xffff) || (0x2190 <= x && x <= 0x2bff) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class NoHtmlTags < Predicate
+          sig { override.returns(T.nilable(Concern)) }
+          def evaluate
+            return unless @cache.country.country?
+
+            build_concern if contains_html_tags(address.send(@field))
+          end
+
+          private
+
+          sig { returns(Concern) }
+          def build_concern
+            Concern.new(
+              field_names: [@field],
+              code: "#{@field}_contains_html_tags".to_sym,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 3,
+              suggestion_ids: [],
+              message: @cache.country.field(key: @field).error(code: :contains_html_tags).to_s,
+            )
+          end
+
+          sig { params(field_value: T.nilable(String)).returns(T::Boolean) }
+          def contains_html_tags(field_value)
+            sanitized_field_value = ActionView::Base.full_sanitizer.sanitize(field_value)
+            field_value.to_s != HTMLEntities.new.decode(sanitized_field_value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class NoUrl < Predicate
+          sig { override.returns(T.nilable(Concern)) }
+          def evaluate
+            return unless @cache.country.country?
+
+            build_concern if contains_url(address.send(@field))
+          end
+
+          private
+
+          sig { returns(Concern) }
+          def build_concern
+            Concern.new(
+              field_names: [@field],
+              code: "#{@field}_contains_url".to_sym,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 3,
+              suggestion_ids: [],
+              message: @cache.country.field(key: @field).error(code: :contains_url).to_s,
+            )
+          end
+
+          sig { params(field_value: T.nilable(String)).returns(T::Boolean) }
+          def contains_url(field_value)
+            field_value.to_s.scan(%r{(http|https)?:\/\/|[\w-]{2,63}\.[a-zA-Z]{2,63}/}).any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class NotExceedMaxLength < Predicate
+          MAX_COMPONENT_LENGTH = 255
+          sig { override.returns(T.nilable(Concern)) }
+          def evaluate
+            return unless @cache.country.country?
+
+            build_concern if address.send(@field).to_s.length > MAX_COMPONENT_LENGTH
+          end
+
+          private
+
+          sig { returns(Concern) }
+          def build_concern
+            Concern.new(
+              field_names: [@field],
+              code: "#{@field}_too_long".to_sym,
+              type: T.must(Concern::TYPES[:error]),
+              type_level: 3,
+              suggestion_ids: [],
+              message: @cache.country.field(key: @field)&.error(code: :too_long).to_s,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class NotExceedMaxTokenCount < Predicate
+          MAX_TOKEN_COUNT = 15
+
+          sig { override.returns(T.nilable(Concern)) }
+          def evaluate
+            tokens = extract_address_tokens_from(address.send(@field))
+            build_concern if tokens.present? && tokens.count >= MAX_TOKEN_COUNT
+          end
+
+          private
+
+          sig { returns(Concern) }
+          def build_concern
+            message_field = @cache.country.field(key: @field)
+            message_arguments = {
+              code: :contains_too_many_words,
+              options: { word_count: MAX_TOKEN_COUNT },
+            }
+            if @field.in?([:address1, :address2])
+              build_specific_concern(
+                type: :warning,
+                message: message_field.warning(**message_arguments).to_s,
+              )
+            else
+              build_specific_concern(
+                type: :error,
+                message: message_field.error(**message_arguments).to_s,
+              )
+            end
+          end
+
+          sig { params(type: Symbol, message: String).returns(Concern) }
+          def build_specific_concern(type:, message:)
+            Concern.new(
+              field_names: [@field],
+              code: "#{@field}_contains_too_many_words".to_sym,
+              type: T.must(Concern::TYPES[type]),
+              type_level: 3,
+              suggestion_ids: [],
+              message: message,
+            )
+          end
+
+          sig { params(value: T.nilable(String)).returns(T::Array[String]) }
+          def extract_address_tokens_from(value)
+            Annex29.segment_words(value).filter_map do |substring|
+              next unless substring.match?(/\w/)
+
+              substring
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Phone
+          class Valid < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return if @address.country_code.blank?
+              return unless @cache.country.country?
+              return if @address.phone.blank?
+
+              phone = Worldwide::Phone.new(number: @address.phone, country_code: @address.country_code)
+
+              return if phone.valid?
+
+              build_concern
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:phone],
+                code: :phone_invalid,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :phone).error(code: :invalid).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        class Predicate
+          extend T::Helpers
+          extend T::Sig
+          abstract!
+
+          sig { returns(Symbol) }
+          attr_reader :field
+
+          sig { returns(Address) }
+          attr_reader :address
+
+          sig { returns(Cache) }
+          attr_reader :cache
+
+          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))
+            @field = field
+            @address = address
+            @cache = cache
+          end
+
+          sig { abstract.returns(T.nilable(Concern)) }
+          def evaluate; end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Province
+          class Exists < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+              return if address.province_code.present? ||
+                country_has_no_provinces ||
+                @cache.country.province_optional?
+
+              build_concern
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:province],
+                code: :province_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :province)&.error(code: :blank).to_s,
+              )
+            end
+
+            sig { returns(T::Boolean) }
+            def country_has_no_provinces
+              @cache.country.zones.blank? || @cache.country.hide_provinces_from_addresses
+            end
+          end
+        end
+      end
+    end
+  end
+end