atlas_engine 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56b5b41a624c3481954aadfa0101c9883dfe3479a3cdec373f8ecccab8bae879
-  data.tar.gz: 73ee021ecf5d8357ae8f000df7e963e7504153fdc3b7bb98f188445aa8cd7989
+  metadata.gz: 9948b64010b57506c90e07bf0fc324c7ad158112169375aa1ac1f7053850a9be
+  data.tar.gz: 872cd26b540c96af7a777b044a4af20cce6d1b7df5569f0b3cd7aaf999fb1847
 SHA512:
-  metadata.gz: b93dee8561c73619222ca4a4e803fb2f911b3149955c5b1af7803990318a7ebd36e781c41643cf3076197f579833e9c2d361e8e4550a9d2d3de628d8e7819ef7
-  data.tar.gz: f2f593c6e2a7849dae6dce6a52d9402ce7d907a90511664d1218133b5d4a501b5ae98a26e54a06412c3fb37e3dc74c75ae17c575ae24fa4805c02ad888467d21
+  metadata.gz: d8ea33678c4c924fb202cecf027e4796892430c35394233c0a971474166b71a10881a6ddc2cc6056d7f66df6b225a63cfdafe18b5590327035d19f3f4e70cf99
+  data.tar.gz: 30d5b8b914d14f4fd6871228435383ff90499e25617af0c7dc5a6a5580fbf4005854f2189034712f4030001878be8c6ee42223e5b94a1890b2a14f8be80e0dc3

data/app/countries/atlas_engine/gg/address_validation/validators/full_address/exclusions/city.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Gg
+    module AddressValidation
+      module Validators
+        module FullAddress
+          module Exclusions
+            class City <
+              AtlasEngine::AddressValidation::Validators::FullAddress::Exclusions::ExclusionBase
+              extend T::Sig
+              class << self
+                sig do
+                  override.params(
+                    candidate: AtlasEngine::AddressValidation::Candidate,
+                    address_comparison: AtlasEngine::AddressValidation::Validators::FullAddress::AddressComparison,
+                  )
+                    .returns(T::Boolean)
+                end
+                def apply?(candidate, address_comparison)
+                  # If the candidate city is already present in the parsings
+                  address_comparison.parsings.parsings.pluck(:city)&.include?(candidate.component(:city)&.value&.first)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/countries/atlas_engine/gg/country_profile.yml

@@ -3,5 +3,9 @@ validation:
   enabled: true
   default_matching_strategy: es
   has_provinces: false
+  address_parser: AtlasEngine::Gg::ValidationTranscriber::AddressParser
   restrictions:
     - class: AtlasEngine::Gg::AddressValidation::Validators::FullAddress::Restrictions::UnsupportedCity
+  exclusions:
+    city:
+      - AtlasEngine::Gg::AddressValidation::Validators::FullAddress::Exclusions::City

data/app/countries/atlas_engine/gg/validation_transcriber/address_parser.rb

@@ -0,0 +1,43 @@
+# typed: true
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Gg
+    module ValidationTranscriber
+      class AddressParser < AtlasEngine::ValidationTranscriber::AddressParserBase
+        private
+
+        CITY = %r{
+          (?<city>
+            st\.?\s?saviour[']?[s]?|
+            st\.?\s?sampson[']?[s]?|
+            st\.?\s?andrew[']?[s]?|
+            st\.?\s?martin[']?[s]?|
+            st\.?\s?peter[']?[s]?\s?port|
+            st\.?\s?peter[']?[s]?|
+            st\.?\s?pierre\s?du\s?bois|
+            vale|
+            torteval|
+            castel|
+            forest
+          )
+        }ix
+
+        sig { returns(T::Array[Regexp]) }
+        def country_regex_formats
+          @country_regex_formats ||= [
+            /^#{BUILDING_NAME},\s+#{CITY}$/,
+            /^#{BUILDING_NAME},\s+#{STREET_NO_COMMAS},\s+#{CITY}$/,
+            /^#{BUILDING_NAME},\s+#{STREET_NO_COMMAS}$/,
+            /^#{NUMERIC_ONLY_BUILDING_NUM}?\s+#{STREET_NO_COMMAS},\s+#{CITY}$/,
+            /^#{UNIT_TYPE}\s+#{UNIT_NUM_NO_HYPHEN},\s+#{BUILDING_NAME},\s+#{CITY}$/,
+            /^#{CITY}$/,
+            /^#{NUMERIC_ONLY_BUILDING_NUM}?\s+#{STREET_NO_COMMAS}$/,
+            /^#{BUILDING_NAME}$/,
+            /^#{STREET_NO_COMMAS}$/,
+          ]
+        end
+      end
+    end
+  end
+end

data/app/models/atlas_engine/address_validation/es/datastore.rb

@@ -128,6 +128,9 @@ module AtlasEngine
             end
             Token::Sequence.new(tokens: tokens, raw_value: city_value)
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "city_sequence")
+          Token::Sequence.new(tokens: [], raw_value: city_value)
         end
 
         sig { returns(T::Array[T::Hash[String, T.untyped]]) }
@@ -135,6 +138,9 @@ module AtlasEngine
           measure_es_validation_request_time(method: "full_address_candidates") do
             repository.search(query_builder.full_address_query)
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "full_address_candidates")
+          []
         end
 
         sig { returns(T::Array[Token::Sequence]) }
@@ -154,6 +160,9 @@ module AtlasEngine
               end
             end
           end
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "street_sequence")
+          [Token::Sequence.new(tokens: [], raw_value: "")]
         end
 
         sig { params(candidates: T::Array[Candidate]).void }
@@ -165,6 +174,8 @@ module AtlasEngine
           end
 
           TermVectors.new(term_vectors_hashes: candidate_term_vectors, candidates: candidates).set_candidate_sequences
+        rescue Elasticsearch::Error => e
+          log_elasticsearch_error(error: e, method: "term_vectors")
         end
 
         sig { params(candidates: T::Array[Candidate]).returns(T::Hash[String, T.untyped]) }
@@ -190,6 +201,18 @@ module AtlasEngine
           )
         end
 
+        sig { params(error: Elasticsearch::Error, method: String).void }
+        def log_elasticsearch_error(error:, method:)
+          log_error("Elasticsearch error: #{error.message}")
+          StatsD.increment(
+            "AddressValidation.elasticsearch_error",
+            tags: {
+              country: country_code,
+              method:,
+            },
+          )
+        end
+
         sig { params(future: T.nilable(Concurrent::Promises::Future), method: String).void }
         def log_future_state_on_join(future:, method:)
           state = future&.state || :unsubmitted

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

@@ -109,10 +109,6 @@ module AtlasEngine
             concern = InvalidZipConcernBuilder.for(address, suggestion_ids)
             return concern if concern
 
-            if :province_code.in?(matched_components) && :city.in?(matched_components)
-              return UnknownZipForAddressConcernBuilder.new(address).build(suggestion_ids)
-            end
-
             build_default_concern
           end
 

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

@@ -56,7 +56,7 @@ module AtlasEngine
 
           sig { returns(String) }
           def message
-            "Enter a valid #{COMPONENTS_TO_LABELS[component]} for #{valid_address_component_values.join(", ")}"
+            country.field(key: field_name).error(code: :unknown_for_address).to_s
           end
 
           sig { returns(Symbol) }

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

@@ -28,7 +28,7 @@ module AtlasEngine
             sig { params(suggestion: Suggestion).returns(Concern) }
             def build_concern(suggestion)
               Concern.new(
-                field_names: [:country, :zip],
+                field_names: [:country],
                 code: :country_invalid_for_zip,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 1,

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

@@ -24,7 +24,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:province, :country],
+                field_names: [:province],
                 code: :province_invalid,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

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

@@ -24,7 +24,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:address1, :country],
+                field_names: [:address1],
                 code: :missing_building_number,
                 type: T.must(Concern::TYPES[:warning]),
                 type_level: 1,

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

@@ -22,7 +22,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:address1, :address2, :country],
+                field_names: [:address1, :address2],
                 code: :missing_building_number,
                 type: T.must(Concern::TYPES[:warning]),
                 type_level: 3,

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

@@ -26,7 +26,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:zip, :country],
+                field_names: [:zip],
                 code: :zip_invalid_for_country,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

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

@@ -29,7 +29,7 @@ module AtlasEngine
             sig { returns(Concern) }
             def build_concern
               Concern.new(
-                field_names: [:zip, :country, :province],
+                field_names: [:zip],
                 code: :zip_invalid_for_province,
                 type: T.must(Concern::TYPES[:error]),
                 type_level: 3,

data/app/models/atlas_engine/elasticsearch/error.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AtlasEngine
+  module Elasticsearch
+    class Error < StandardError
+      extend T::Sig
+
+      sig { params(message: String, cause: T.nilable(Exception)).void }
+      def initialize(message, cause = nil)
+        super(message)
+        @cause = cause
+      end
+
+      sig { returns(T.nilable(Exception)) }
+      attr_reader :cause
+    end
+  end
+end

data/app/models/atlas_engine/elasticsearch/repository.rb

@@ -133,8 +133,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "hits" => { "hits" => [] } }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(query: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
@@ -143,8 +143,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "tokens" => [] }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(query: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
@@ -153,8 +153,8 @@ module AtlasEngine
         response = client.post(path, query, {})
 
         response.body
-      rescue ::Elastic::Transport::Transport::Error
-        { "docs" => [] }
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(id: T.any(String, Integer)).returns(T::Hash[String, T.untyped]) }
@@ -163,8 +163,8 @@ module AtlasEngine
         response = client.get(path, nil, {})
 
         response.body["_source"]
-      rescue ::Elastic::Transport::Transport::Error
-        {}
+      rescue ::Elastic::Transport::Transport::Error => e
+        raise Elasticsearch::Error.new(e.message, e)
       end
 
       sig { override.params(post_address: PostAddressData).returns(T::Hash[Symbol, T.untyped]) }

data/lib/atlas_engine/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module AtlasEngine
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atlas_engine
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-26 00:00:00.000000000 Z
+date: 2024-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: annex_29
@@ -305,8 +305,10 @@ files:
 - app/countries/atlas_engine/gb/country_profile.yml
 - app/countries/atlas_engine/gb/validation_transcriber/full_address_parser.rb
 - app/countries/atlas_engine/gb/validation_transcriber/parsed_address.rb
+- app/countries/atlas_engine/gg/address_validation/validators/full_address/exclusions/city.rb
 - app/countries/atlas_engine/gg/address_validation/validators/full_address/restrictions/unsupported_city.rb
 - app/countries/atlas_engine/gg/country_profile.yml
+- app/countries/atlas_engine/gg/validation_transcriber/address_parser.rb
 - app/countries/atlas_engine/ie/country_profile.yml
 - app/countries/atlas_engine/it/address_importer/corrections/open_address/city_corrector.rb
 - app/countries/atlas_engine/it/address_importer/corrections/open_address/province_corrector.rb
@@ -494,7 +496,6 @@ files:
 - app/models/atlas_engine/address_validation/validators/full_address/suggestion_builder.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
@@ -530,6 +531,7 @@ files:
 - app/models/atlas_engine/country_repository.rb
 - app/models/atlas_engine/elasticsearch/client.rb
 - app/models/atlas_engine/elasticsearch/client_interface.rb
+- app/models/atlas_engine/elasticsearch/error.rb
 - app/models/atlas_engine/elasticsearch/repository.rb
 - app/models/atlas_engine/elasticsearch/repository_interface.rb
 - app/models/atlas_engine/elasticsearch/response.rb

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

@@ -1,34 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module AtlasEngine
-  module AddressValidation
-    module Validators
-      module FullAddress
-        class UnknownZipForAddressConcernBuilder
-          extend T::Sig
-          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 = "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,
-            )
-          end
-        end
-      end
-    end
-  end
-end