atlas_engine 0.1.0

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

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Province
+          class ValidForCountry < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+              return if address.province_code.blank?
+              return if @cache.country.zones.none?(&:province?)
+              return if @cache.country.hide_provinces_from_addresses
+
+              unless @cache.province.province?
+                build_concern
+              end
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:province, :country],
+                code: :province_invalid,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :province).error(code: :blank),
+              )
+            end
+
+            sig { params(province: T.nilable(String)).returns(T.nilable(String)) }
+            def normalize_province(province)
+              ValidationTranscriber::ProvinceCodeNormalizer.normalize(
+                country_code: @cache.country.iso_code,
+                province_code: province,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Street
+          class BuildingNumberInAddress1 < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+
+              return unless @cache.country.building_number_required
+              return if @cache.country.building_number_may_be_in_address2
+
+              return if contains_number?(T.must(@address.address1))
+
+              build_concern
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:address1, :country],
+                code: :missing_building_number,
+                type: T.must(Concern::TYPES[:warning]),
+                type_level: 1,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :address1)&.error(code: :missing_building_number).to_s,
+              )
+            end
+
+            sig { params(text: String).returns(T::Boolean) }
+            def contains_number?(text)
+              /[0-9\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\uff10-\uff19]/.match?(text)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Street
+          class BuildingNumberInAddress1OrAddress2 < Predicate
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              return unless @cache.country.country?
+              return unless @cache.country.building_number_required
+              return unless @cache.country.building_number_may_be_in_address2
+              return if contains_number?(T.must(@address.address1)) || contains_number?(T.must(@address.address2))
+
+              build_concern
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:address1, :address2, :country],
+                code: :missing_building_number,
+                type: T.must(Concern::TYPES[:warning]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :address1)&.error(code: :missing_building_number).to_s,
+              )
+            end
+
+            sig { params(text: String).returns(T::Boolean) }
+            def contains_number?(text)
+              /[0-9\u0660-\u0669\u06f0-\u06f9\u0966-\u096f\uff10-\uff19]/.match?(text)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Zip
+          class Present < ZipBase
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if concerning?
+            end
+
+            sig { override.returns(T.nilable(T::Boolean)) }
+            def concerning?
+              return false unless super
+              return false if @address.zip.present?
+              return false if @cache.country.autofill_zip.present?
+
+              true
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:zip],
+                code: :zip_blank,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: address_zip_blank_message,
+              )
+            end
+
+            sig { returns(String) }
+            def address_zip_blank_message
+              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,
+                  options: { province: province_name },
+                ).to_s
+              else
+                @cache.country.field(key: :zip).error(
+                  code: :invalid_for_country,
+                  options: { country: @cache.country.short_name },
+                ).to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Zip
+          class ValidForCountry < ZipBase
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if concerning?
+            end
+
+            sig { override.returns(T.nilable(T::Boolean)) }
+            def concerning?
+              return false unless super
+              return false if @address.zip.blank?
+              return false if @cache.country.valid_zip?(@address.zip)
+
+              true
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:zip, :country],
+                code: :zip_invalid_for_country,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: @cache.country.field(key: :zip).error(
+                  code: :invalid_for_country,
+                  options: { country: @cache.country.short_name },
+                ).to_s,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Zip
+          class ValidForProvince < ZipBase
+            sig { override.returns(T.nilable(Concern)) }
+            def evaluate
+              build_concern if concerning?
+            end
+
+            sig { override.returns(T.nilable(T::Boolean)) }
+            def concerning?
+              return false unless super
+              return false if @address.zip.blank?
+              return false if @cache.country.hide_provinces_from_addresses
+              return false if @address.province_code.blank?
+              return false unless @cache.province.province?
+              return false if @cache.province.valid_zip?(@address.zip)
+
+              true
+            end
+
+            private
+
+            sig { returns(Concern) }
+            def build_concern
+              Concern.new(
+                field_names: [:zip, :country, :province],
+                code: :zip_invalid_for_province,
+                type: T.must(Concern::TYPES[:error]),
+                type_level: 3,
+                suggestion_ids: [],
+                message: invalid_for_province_message,
+              )
+            end
+
+            sig { returns(String) }
+            def invalid_for_province_message
+              province_name = @cache.province.province? ? @cache.province.full_name : address.province_code
+
+              @cache.country.field(key: :zip).error(
+                code: :invalid_for_province,
+                options: { province: province_name },
+              ).to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    module Validators
+      module Predicates
+        module Zip
+          class ZipBase < Predicate
+            abstract!
+
+            sig { returns(T.nilable(T::Boolean)) }
+            def concerning?
+              return false unless @cache.country.country?
+              return false unless @cache.country.has_zip?
+              return false unless @cache.country.zip_required?
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module AddressValidation
+    class ZipTruncator
+      extend T::Sig
+
+      sig { params(country_code: String).void }
+      def initialize(country_code:)
+        @country_code = T.let(country_code, String)
+      end
+
+      # For some countries, we only have partial postal codes in our data.
+      # Before comparing a user-provided code, we need to truncate it to the same level of detail.
+      sig { params(zip: T.nilable(String), country_code: T.nilable(String)).returns(T.nilable(String)) }
+      def truncate(zip:, country_code: nil)
+        return if zip.nil?
+
+        code = (country_code || @country_code).to_s.upcase
+        case code
+        when "IE"
+          T.must(zip[..2]) # our data only has the routing key (first part)
+        when "US"
+          T.must(zip[..4]) # our data only has 5-digit ZIP, not 9-digit ZIP+4
+        when String
+          zip
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/application_record.rb

@@ -0,0 +1,8 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/atlas_engine/coded_error.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  class CodedError < StandardError
+    extend T::Sig
+    ErrorCode = T.type_alias { T.any(Symbol, String) }
+
+    sig { returns(ErrorCode) }
+    attr_reader :code
+
+    sig { params(code: ErrorCode, message: String).void }
+    def initialize(code, message)
+      @code = code
+      super(message)
+    end
+  end
+end

data/app/models/atlas_engine/coded_errors.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  class CodedErrors
+    ErrorCode = T.type_alias { T.any(Symbol, String) }
+
+    class << self
+      extend T::Sig
+
+      sig { params(code: ErrorCode, message: String).returns(CodedError) }
+      def error(code, message)
+        CodedError.new(code, message)
+      end
+    end
+  end
+end

data/app/models/atlas_engine/country_import.rb

@@ -0,0 +1,44 @@
+# typed: false
+# frozen_string_literal: true
+
+module AtlasEngine
+  class CountryImport < ApplicationRecord
+    class InterruptionError < StandardError; end
+    has_many :events, dependent: :destroy, class_name: "AtlasEngine::Event"
+
+    PAGE_SIZE = 10
+
+    validates :country_code, presence: true
+
+    state_machine initial: :pending do
+      event :start do
+        transition pending: :in_progress
+      end
+
+      event :complete do
+        transition in_progress: :complete
+      end
+
+      event :interrupt do
+        transition [:pending, :in_progress, :failed] => :failed
+      end
+
+      state :in_progress do
+        validate :no_imports_in_progress?
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def detected_invalid_addresses?
+      events.where(category: :invalid_address).any?
+    end
+
+    private
+
+    def no_imports_in_progress?
+      if CountryImport.where(country_code: country_code).with_state(:in_progress).where.not(id: id).any?
+        errors.add(:state, "cannot be in progress when there is another import already in progress")
+      end
+    end
+  end
+end