pico_phone 0.4.0 → 0.5.0

data/ext/pico_phone/carrier_mapper.cc

@@ -0,0 +1,127 @@
+// First-party pico_phone file. See carrier_mapper.h.
+
+#include "carrier_mapper.h"
+
+#include <algorithm>
+#include <cstring>
+#include <string>
+
+#include "phonenumbers/geocoding/area_code_map.h"
+#include "phonenumbers/geocoding/carrier_data.h"
+#include "phonenumbers/geocoding/mapping_file_provider.h"
+#include "phonenumbers/phonenumber.pb.h"
+
+#include "absl/synchronization/mutex.h"
+
+namespace i18n {
+namespace phonenumbers {
+
+using std::string;
+
+namespace {
+
+// Returns true if s1 comes strictly before s2 in lexicographic order.
+bool IsLowerThan(const char* s1, const char* s2) {
+  return strcmp(s1, s2) < 0;
+}
+
+}  // namespace
+
+PhoneNumberCarrierMapper::PhoneNumberCarrierMapper() {
+  provider_.reset(new MappingFileProvider(get_carrier_country_calling_codes(),
+                                          get_carrier_country_calling_codes_size(),
+                                          get_carrier_country_languages));
+  prefix_language_code_pairs_ = get_carrier_prefix_language_code_pairs();
+  prefix_language_code_pairs_size_ = get_carrier_prefix_language_code_pairs_size();
+  get_prefix_descriptions_ = get_carrier_prefix_descriptions;
+}
+
+PhoneNumberCarrierMapper::~PhoneNumberCarrierMapper() {
+  // Pointer-taking constructor, not the reference-taking one: this file
+  // compiles against two different Abseil versions depending on build path
+  // (vendored 20260526.0 for the static/native build, whatever Debian/Ubuntu
+  // packages for the dynamic/apt-linked build), and only the older
+  // pointer-taking overload exists in both. The vendored geocoder itself hit
+  // the same tension in the other direction (see build_deps.sh's
+  // absl::MutexLock patch) -- there it's a -Werror'd deprecation inside
+  // libphonenumber's own CMake build; here it's just a harmless warning
+  // since pico_phone's own extension build doesn't set -Werror.
+  absl::MutexLock l(&mu_);
+  for (AreaCodeMaps::const_iterator it = available_maps_.begin();
+       it != available_maps_.end(); ++it) {
+    delete it->second;
+  }
+}
+
+const AreaCodeMap* PhoneNumberCarrierMapper::GetPhonePrefixDescriptions(
+    int prefix, const string& language, const string& script,
+    const string& region) const {
+  string filename;
+  provider_->GetFileName(prefix, language, script, region, &filename);
+  if (filename.empty()) {
+    return NULL;
+  }
+  AreaCodeMaps::const_iterator it = available_maps_.find(filename);
+  if (it == available_maps_.end()) {
+    return LoadAreaCodeMapFromFile(filename);
+  }
+  return it->second;
+}
+
+const AreaCodeMap* PhoneNumberCarrierMapper::LoadAreaCodeMapFromFile(
+    const string& filename) const {
+  const char** const prefix_language_code_pairs_end =
+      prefix_language_code_pairs_ + prefix_language_code_pairs_size_;
+  const char** const prefix_language_code_pair =
+      std::lower_bound(prefix_language_code_pairs_,
+                       prefix_language_code_pairs_end,
+                       filename.c_str(), IsLowerThan);
+  if (prefix_language_code_pair != prefix_language_code_pairs_end &&
+      filename.compare(*prefix_language_code_pair) == 0) {
+    AreaCodeMap* const m = new AreaCodeMap();
+    m->ReadAreaCodeMap(get_prefix_descriptions_(
+            prefix_language_code_pair - prefix_language_code_pairs_));
+    return available_maps_.insert(AreaCodeMaps::value_type(filename, m))
+        .first->second;
+  }
+  return NULL;
+}
+
+const char* PhoneNumberCarrierMapper::GetAreaDescription(
+    const PhoneNumber& number, const string& lang, const string& script,
+    const string& region) const {
+  const int country_calling_code = number.country_code();
+  // NANPA area is not split in C++ code (matches PhoneNumberOfflineGeocoder).
+  const int phone_prefix = country_calling_code;
+  absl::MutexLock l(&mu_);
+  const AreaCodeMap* const descriptions = GetPhonePrefixDescriptions(
+      phone_prefix, lang, script, region);
+  const char* description = descriptions ? descriptions->Lookup(number) : NULL;
+  // When a carrier name is not available in the requested language, fall
+  // back to English.
+  if ((!description || *description == '\0') && MayFallBackToEnglish(lang)) {
+    const AreaCodeMap* default_descriptions = GetPhonePrefixDescriptions(
+        phone_prefix, "en", "", "");
+    if (!default_descriptions) {
+      return "";
+    }
+    description = default_descriptions->Lookup(number);
+  }
+  return description ? description : "";
+}
+
+// Don't fall back to English if the requested language is among the following:
+// - Chinese
+// - Japanese
+// - Korean
+bool PhoneNumberCarrierMapper::MayFallBackToEnglish(const string& lang) const {
+  return lang.compare("zh") && lang.compare("ja") && lang.compare("ko");
+}
+
+string PhoneNumberCarrierMapper::GetNameForNumber(
+    const PhoneNumber& number, const string& lang) const {
+  return GetAreaDescription(number, lang, "", "");
+}
+
+}  // namespace phonenumbers
+}  // namespace i18n

data/ext/pico_phone/carrier_mapper.h

@@ -0,0 +1,88 @@
+// First-party pico_phone file. A trimmed mirror of libphonenumber's
+// PhoneNumberOfflineGeocoder (phonenumbers/geocoding/
+// phonenumber_offline_geocoder.h in the vendored source), reusing the same
+// AreaCodeMap/MappingFileProvider machinery -- lazy per (country calling
+// code, language) file loading, cached for the life of the process -- but
+// backed by carrier_data.cc instead of geocoding_data.cc, and with the
+// ICU-based country-name fallback removed: carrier data has no natural
+// "fall back to the country name" concept (unlike geocoding), so an
+// unmapped prefix returns an empty string, matching phonelib's carrier
+// semantics. This also means, unlike the geocoder, this class has no ICU
+// dependency at all.
+
+#ifndef PICO_PHONE_CARRIER_MAPPER_H_
+#define PICO_PHONE_CARRIER_MAPPER_H_
+
+#include <map>
+#include <string>
+
+#include "absl/synchronization/mutex.h"
+#include "phonenumbers/base/memory/scoped_ptr.h"
+
+namespace i18n {
+namespace phonenumbers {
+
+class AreaCodeMap;
+class MappingFileProvider;
+class PhoneNumber;
+struct CountryLanguages;
+struct PrefixDescriptions;
+
+class PhoneNumberCarrierMapper {
+ private:
+  typedef std::map<std::string, const AreaCodeMap*> AreaCodeMaps;
+
+ public:
+  PhoneNumberCarrierMapper();
+
+  PhoneNumberCarrierMapper(const PhoneNumberCarrierMapper&) = delete;
+  PhoneNumberCarrierMapper& operator=(const PhoneNumberCarrierMapper&) = delete;
+
+  ~PhoneNumberCarrierMapper();
+
+  // Returns the carrier name for the given phone number in the given
+  // language, or an empty string if no carrier mapping is available for
+  // this prefix. lang is a two or three-letter lowercase ISO 639 language
+  // code, as with PhoneNumberOfflineGeocoder.
+  //
+  // The carrier name is the one the number was originally allocated to,
+  // however if the country supports mobile number portability the number
+  // might not belong to the returned carrier anymore (same caveat as
+  // upstream's Java-only PhoneNumberToCarrierMapper.getNameForNumber,
+  // verbatim -- see java/carrier/src/.../PhoneNumberToCarrierMapper.java
+  // in the vendored source tree).
+  std::string GetNameForNumber(const PhoneNumber& number,
+                               const std::string& lang) const;
+
+ private:
+  typedef const PrefixDescriptions* (*prefix_descriptions_getter)(int index);
+
+  const AreaCodeMap* LoadAreaCodeMapFromFile(
+      const std::string& filename) const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  const AreaCodeMap* GetPhonePrefixDescriptions(
+      int prefix, const std::string& language, const std::string& script,
+      const std::string& region) const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
+  const char* GetAreaDescription(const PhoneNumber& number,
+                                 const std::string& lang,
+                                 const std::string& script,
+                                 const std::string& region) const
+      ABSL_LOCKS_EXCLUDED(mu_);
+
+  bool MayFallBackToEnglish(const std::string& lang) const;
+
+  scoped_ptr<const MappingFileProvider> provider_;
+
+  const char** prefix_language_code_pairs_;
+  int prefix_language_code_pairs_size_;
+  prefix_descriptions_getter get_prefix_descriptions_;
+
+  mutable absl::Mutex mu_;
+  mutable AreaCodeMaps available_maps_ ABSL_GUARDED_BY(mu_);
+};
+
+}  // namespace phonenumbers
+}  // namespace i18n
+
+#endif  // PICO_PHONE_CARRIER_MAPPER_H_

data/ext/pico_phone/extconf.rb

@@ -2,6 +2,14 @@ require "mkmf-rice"
 
 $CXXFLAGS << ' -std=c++17'
 
+# carrier_mapper.cc needs AreaCodeMap/MappingFileProvider/the
+# CountryLanguages+PrefixDescriptions structs, none of which libphonenumber
+# installs publicly (only phonenumber_offline_geocoder.h is installed) in
+# either build path below. Headers vendored verbatim under
+# vendor_headers/phonenumbers/geocoding/ -- see that directory's own
+# comments. Needed unconditionally, regardless of NATIVE_BUILD.
+$INCFLAGS << " -I#{File.expand_path("vendor_headers", __dir__)}"
+
 VENDOR_INSTALL = File.expand_path("vendor/install", __dir__)
 NATIVE_BUILD = ENV["PICO_PHONE_NATIVE_BUILD"] == "1"
 

data/ext/pico_phone/pico_phone.cpp

@@ -3,6 +3,7 @@
 #include <string.h>
 #include <list>
 #include <set>
+#include <vector>
 #include <phonenumbers/phonenumber.pb.h>
 #include <phonenumbers/phonenumberutil.h>
 #include <phonenumbers/shortnumberinfo.h>
@@ -13,6 +14,8 @@
 // any ICU header is reachable.
 #undef UChar
 #include <phonenumbers/geocoding/phonenumber_offline_geocoder.h>
+#include "carrier_mapper.h"
+#include "timezone_mapper.h"
 
 using namespace Rice;
 using namespace i18n::phonenumbers;
@@ -223,6 +226,51 @@ VALUE parsed_number_geo_name(int argc, VALUE *argv, VALUE self) {
   return rb_str_new(description.c_str(), description.size());
 }
 
+// PhoneNumberCarrierMapper mirrors PhoneNumberOfflineGeocoder's lazy
+// per-(prefix, language) file loading and caching -- see carrier_mapper.h.
+static const PhoneNumberCarrierMapper& GetCarrierMapper() {
+  static PhoneNumberCarrierMapper instance;
+  return instance;
+}
+
+VALUE parsed_number_carrier_name(int argc, VALUE *argv, VALUE self) {
+  VALUE language;
+  rb_scan_args(argc, argv, "01", &language);
+
+  std::string language_code = RB_NIL_P(language)
+    ? "en"
+    : std::string(StringValuePtr(language), RSTRING_LEN(language));
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  std::string name = GetCarrierMapper().GetNameForNumber(*phone_number, language_code);
+
+  return rb_str_new(name.c_str(), name.size());
+}
+
+// PhoneNumberTimeZonesMapper eagerly loads its single flat prefix table
+// once at construction (unlike the geocoder/carrier mappers, there's no
+// per-language dimension or lazy per-file loading to do here) -- see
+// timezone_mapper.h.
+static const PhoneNumberTimeZonesMapper& GetTimeZonesMapper() {
+  static PhoneNumberTimeZonesMapper instance;
+  return instance;
+}
+
+Array parsed_number_timezones(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  std::vector<std::string> zones = GetTimeZonesMapper().GetTimeZonesForNumber(*phone_number);
+
+  Array result;
+  for (const auto& zone : zones) {
+    result.push(Object(rb_str_new(zone.c_str(), zone.size())));
+  }
+  return result;
+}
+
 Object pico_phone_is_emergency_number(Object self, String number, String region) {
   return GetShortNumberInfo().IsEmergencyNumber(number.c_str(), region.c_str()) ? Qtrue : Qfalse;
 }
@@ -860,9 +908,11 @@ void Init_pico_phone() {
     .define_method("possible_with_reason", &parsed_number_possible_with_reason)
     .define_method("geographical?", &parsed_number_geographical)
     .define_method("can_be_internationally_dialled?", &parsed_number_can_be_internationally_dialled)
-    .define_method("possible_for_type?", &parsed_number_possible_for_type);
+    .define_method("possible_for_type?", &parsed_number_possible_for_type)
+    .define_method("timezones", &parsed_number_timezones);
 
     rb_define_alloc_func(rb_cPhoneNumber, rb_phone_number_alloc);
     rb_define_method(rb_cPhoneNumber, "initialize", reinterpret_cast<VALUE (*)(...)>(phone_number_initialize), -1);
     rb_define_method(rb_cPhoneNumber, "geo_name", reinterpret_cast<VALUE (*)(...)>(parsed_number_geo_name), -1);
+    rb_define_method(rb_cPhoneNumber, "carrier_name", reinterpret_cast<VALUE (*)(...)>(parsed_number_carrier_name), -1);
 }