pico_phone 0.4.0 → 0.6.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,11 +14,18 @@
 // any ICU header is reachable.
 #undef UChar
 #include <phonenumbers/geocoding/phonenumber_offline_geocoder.h>
+#include <phonenumbers/phonenumbermatcher.h>
+#include <phonenumbers/phonenumbermatch.h>
+#include "carrier_mapper.h"
+#include "timezone_mapper.h"
+
+#include <climits>
 
 using namespace Rice;
 using namespace i18n::phonenumbers;
 
 static VALUE rb_cPhoneNumber;
+static VALUE rb_cPhoneNumberMatch;
 static VALUE rb_mPicoPhone;
 
 size_t phone_number_size(const void *data) { return sizeof(PhoneNumber); }
@@ -192,6 +200,112 @@ Object pico_phone_is_alpha_number(Object self, String str) {
   return phone_util.IsAlphaNumber(str.c_str()) ? Qtrue : Qfalse;
 }
 
+int pico_phone_country_calling_code(Object self, String region) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return phone_util.GetCountryCodeForRegion(std::string(region.c_str()));
+}
+
+static VALUE match_type_to_symbol(PhoneNumberUtil::MatchType match_type) {
+  switch (match_type) {
+    case PhoneNumberUtil::INVALID_NUMBER:  return rb_id2sym(rb_intern("invalid_number"));
+    case PhoneNumberUtil::NO_MATCH:        return rb_id2sym(rb_intern("no_match"));
+    case PhoneNumberUtil::SHORT_NSN_MATCH: return rb_id2sym(rb_intern("short_nsn_match"));
+    case PhoneNumberUtil::NSN_MATCH:       return rb_id2sym(rb_intern("nsn_match"));
+    case PhoneNumberUtil::EXACT_MATCH:     return rb_id2sym(rb_intern("exact_match"));
+    default:                               return rb_id2sym(rb_intern("no_match"));
+  }
+}
+
+Object pico_phone_number_match(Object self, String first, String second) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return match_type_to_symbol(phone_util.IsNumberMatchWithTwoStrings(first.c_str(), second.c_str()));
+}
+
+Object parsed_number_match_type(Object self, Object other) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  if (RTEST(rb_obj_is_kind_of(other, rb_cPhoneNumber))) {
+    PhoneNumber *other_number;
+    TypedData_Get_Struct(other, PhoneNumber, &phone_number_type, other_number);
+    return match_type_to_symbol(phone_util.IsNumberMatch(*phone_number, *other_number));
+  }
+
+  VALUE other_val = other.value();
+  std::string other_str(StringValuePtr(other_val), RSTRING_LEN(other_val));
+  return match_type_to_symbol(phone_util.IsNumberMatchWithOneString(*phone_number, other_str));
+}
+
+static PhoneNumberMatcher::Leniency symbol_to_leniency(VALUE sym) {
+  ID id = rb_to_id(sym);
+  if (id == rb_intern("possible"))        return PhoneNumberMatcher::POSSIBLE;
+  if (id == rb_intern("strict_grouping")) return PhoneNumberMatcher::STRICT_GROUPING;
+  if (id == rb_intern("exact_grouping"))  return PhoneNumberMatcher::EXACT_GROUPING;
+  return PhoneNumberMatcher::VALID;
+}
+
+Object phone_number_match_start(Object self) {
+  return rb_ivar_get(self, rb_intern("@start"));
+}
+
+Object phone_number_match_end_index(Object self) {
+  return rb_ivar_get(self, rb_intern("@end_index"));
+}
+
+Object phone_number_match_raw_string(Object self) {
+  return rb_ivar_get(self, rb_intern("@raw_string"));
+}
+
+Object phone_number_match_number(Object self) {
+  return rb_ivar_get(self, rb_intern("@number"));
+}
+
+VALUE pico_phone_find_numbers(int argc, VALUE *argv, VALUE self) {
+  VALUE text, region, kwargs;
+  rb_scan_args(argc, argv, "2:", &text, &region, &kwargs);
+
+  ID kwarg_ids[1] = { rb_intern("leniency") };
+  VALUE kwarg_vals[1];
+  rb_get_kwargs(kwargs, kwarg_ids, 0, 1, kwarg_vals);
+
+  PhoneNumberMatcher::Leniency leniency = PhoneNumberMatcher::VALID;
+  if (kwarg_vals[0] != Qundef) {
+    leniency = symbol_to_leniency(kwarg_vals[0]);
+  }
+
+  std::string text_str(StringValuePtr(text), RSTRING_LEN(text));
+  std::string region_str(StringValuePtr(region), RSTRING_LEN(region));
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  PhoneNumberMatcher matcher(phone_util, text_str, region_str, leniency, INT_MAX);
+
+  Array result;
+  PhoneNumberMatch match;
+  while (matcher.HasNext()) {
+    matcher.Next(&match);
+
+    int start_pos = match.start();
+    int end_pos = match.end();
+    std::string raw = match.raw_string();
+
+    std::string e164;
+    phone_util.Format(match.number(), PhoneNumberUtil::E164, &e164);
+    VALUE num_args[1] = { rb_str_new(e164.c_str(), e164.size()) };
+    VALUE number_obj = rb_class_new_instance(1, num_args, rb_cPhoneNumber);
+
+    VALUE match_obj = rb_obj_alloc(rb_cPhoneNumberMatch);
+    rb_ivar_set(match_obj, rb_intern("@start"), INT2FIX(start_pos));
+    rb_ivar_set(match_obj, rb_intern("@end_index"), INT2FIX(end_pos));
+    rb_ivar_set(match_obj, rb_intern("@raw_string"), rb_str_new(raw.c_str(), raw.size()));
+    rb_ivar_set(match_obj, rb_intern("@number"), number_obj);
+
+    result.push(Object(match_obj));
+  }
+
+  return result;
+}
+
 static const ShortNumberInfo& GetShortNumberInfo() {
   static ShortNumberInfo instance;
   return instance;
@@ -223,6 +337,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;
 }
@@ -802,6 +961,24 @@ Object parsed_number_possible_for_type(Object self, Object type_sym) {
   return phone_util.IsPossibleNumberForType(*phone_number, type) ? Qtrue : Qfalse;
 }
 
+Object parsed_number_truncate(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  // TruncateTooLongNumber returns true for already-valid numbers without
+  // modifying them. Guard so callers get nil for the "nothing to do" case.
+  if (phone_util.IsValidNumber(*phone_number)) return Qnil;
+
+  PhoneNumber copy(*phone_number);
+  if (!phone_util.TruncateTooLongNumber(&copy)) return Qnil;
+
+  std::string formatted;
+  phone_util.Format(copy, PhoneNumberUtil::E164, &formatted);
+  VALUE args[1] = { rb_str_new(formatted.c_str(), formatted.size()) };
+  return rb_class_new_instance(1, args, rb_cPhoneNumber);
+}
+
 extern "C"
 void Init_pico_phone() {
   rb_mPicoPhone = define_module("PicoPhone")
@@ -815,12 +992,16 @@ void Init_pico_phone() {
     .define_singleton_method("supported_regions", &pico_phone_supported_regions)
     .define_singleton_method("convert_alpha_characters", &pico_phone_convert_alpha_characters)
     .define_singleton_method("alpha_number?", &pico_phone_is_alpha_number)
+    .define_singleton_method("number_match", &pico_phone_number_match)
     .define_singleton_method("emergency_number?", &pico_phone_is_emergency_number)
     .define_singleton_method("short_number_valid?", &pico_phone_is_short_number_valid)
     .define_singleton_method("short_number_cost", &pico_phone_short_number_cost)
     .define_singleton_method("supported_types_for_region", &pico_phone_supported_types_for_region)
     .define_singleton_method("example_number", &pico_phone_example_number)
-    .define_singleton_method("example_number_for_type", &pico_phone_example_number_for_type);
+    .define_singleton_method("example_number_for_type", &pico_phone_example_number_for_type)
+    .define_singleton_method("country_calling_code", &pico_phone_country_calling_code);
+
+    rb_define_singleton_method(rb_mPicoPhone, "find_numbers", reinterpret_cast<VALUE (*)(...)>(pico_phone_find_numbers), -1);
 
     rb_define_module_function(rb_mPicoPhone, "default_country=", reinterpret_cast<VALUE (*)(...)>(pico_phone_set_default_country), 1);
     rb_define_module_function(rb_mPicoPhone, "default_extension_prefix=", reinterpret_cast<VALUE (*)(...)>(pico_phone_set_default_extension_prefix), 1);
@@ -860,9 +1041,19 @@ 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)
+    .define_method("truncate", &parsed_number_truncate)
+    .define_method("match_type", &parsed_number_match_type);
+
+    rb_cPhoneNumberMatch = define_class_under(rb_mPicoPhone, "PhoneNumberMatch")
+      .define_method("start", &phone_number_match_start)
+      .define_method("end_index", &phone_number_match_end_index)
+      .define_method("raw_string", &phone_number_match_raw_string)
+      .define_method("number", &phone_number_match_number);
 
     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);
 }