pico_phone 0.2.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92c709a6d082670f302a45e0eda2c20e6af69e94ff7fe635e337a39271fbef8a
+  data.tar.gz: 2331a5283c685db4d5dd441bfaec5baebe31edd69456839bdbe378c824abb872
+SHA512:
+  metadata.gz: a9ce8ce3e336b6fe6c8e5f9feb23d5c41bab94e5624ad6c69f5e094856ec338172c7e05fbfac130a3abd7beff110ed6c9087b6c5da9bc0768c23e1bdd2b497da
+  data.tar.gz: d9b54379e85a95ff513c6412dacb3370afa31d804cbfd0c1e5123b461c3fa7df8e41f7914bbf981f308a1c14da271c5957ee974e54c2253c2304248291d710d7

data/ext/pico_phone/extconf.rb

@@ -0,0 +1,66 @@
+require "mkmf-rice"
+
+$CXXFLAGS << ' -std=c++17'
+
+VENDOR_INSTALL = File.expand_path("vendor/install", __dir__)
+NATIVE_BUILD = ENV["PICO_PHONE_NATIVE_BUILD"] == "1"
+
+if NATIVE_BUILD
+  # Static linking against vendored libraries for native gem builds.
+  # All five dependencies are baked into the .so — users need nothing installed.
+  $INCFLAGS << " -I#{VENDOR_INSTALL}/include"
+
+  static_libs = []
+  static_libs << "#{VENDOR_INSTALL}/lib/libphonenumber.a"
+  static_libs << "#{VENDOR_INSTALL}/lib/libprotobuf.a"
+  static_libs += Dir["#{VENDOR_INSTALL}/lib/libabsl_*.a"].sort
+
+  if RUBY_PLATFORM.include?("darwin")
+    boost_prefix = `brew --prefix boost 2>/dev/null`.strip
+    icu_prefix   = `brew --prefix icu4c@78 2>/dev/null`.strip
+
+    %w[libboost_date_time libboost_thread libboost_atomic].each do |lib|
+      static_libs << "#{boost_prefix}/lib/#{lib}.a"
+    end
+
+    %w[libicui18n libicuuc libicudata].each do |lib|
+      static_libs << "#{icu_prefix}/lib/#{lib}.a"
+    end
+  else
+    # Linux: libphonenumber was built with USE_BOOST=OFF so no Boost needed.
+    # Ubuntu's libicu-dev static archives are not compiled with -fPIC and cannot
+    # be linked into a shared object. Link ICU dynamically instead — libicu74 is
+    # part of the Ubuntu 24.04 base system and is present in the target environment.
+    $LOCAL_LIBS << " -licui18n -licuuc -licudata -lpthread -ldl"
+  end
+
+  $LOCAL_LIBS << " " + static_libs.join(" ")
+
+  unless find_header("phonenumbers/phonenumberutil.h")
+    abort "Could not find phonenumberutil.h in #{VENDOR_INSTALL}/include — run build_deps.sh first"
+  end
+else
+  # Dynamic linking against system/Homebrew libraries (default developer workflow).
+  if RUBY_PLATFORM.include?("darwin")
+    %w[libphonenumber protobuf abseil].each do |pkg|
+      prefix = `brew --prefix #{pkg} 2>/dev/null`.strip
+      next if prefix.empty?
+      $INCFLAGS << " -I#{prefix}/include"
+      $LDFLAGS  << " -L#{prefix}/lib"
+    end
+  end
+
+  $LOCAL_LIBS << " -lphonenumber"
+
+  unless find_header("phonenumbers/phonenumberutil.h")
+    abort <<~MSG
+
+      Could not find libphonenumber. Please install it before installing this gem:
+        macOS:  brew install libphonenumber
+        Ubuntu: sudo apt-get install libphonenumber-dev
+        Fedora: sudo dnf install libphonenumber-devel
+    MSG
+  end
+end
+
+create_makefile("pico_phone/pico_phone")

data/ext/pico_phone/pico_phone.cpp

@@ -0,0 +1,834 @@
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+#include <string.h>
+#include <list>
+#include <set>
+#include <phonenumbers/phonenumber.pb.h>
+#include <phonenumbers/phonenumberutil.h>
+#include <phonenumbers/shortnumberinfo.h>
+
+using namespace Rice;
+using namespace i18n::phonenumbers;
+
+static VALUE rb_cPhoneNumber;
+static VALUE rb_mPicoPhone;
+
+size_t phone_number_size(const void *data) { return sizeof(PhoneNumber); }
+
+void phone_number_free(void *data) {
+  PhoneNumber *phone_number = static_cast<PhoneNumber *>(data);
+  phone_number->~PhoneNumber();
+  xfree(data);
+}
+
+static const rb_data_type_t phone_number_type = {
+  .wrap_struct_name = "phone_number",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = phone_number_free,
+            .dsize = phone_number_size,
+        },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE rb_phone_number_alloc(VALUE self) {
+  void *phone_number_data = ALLOC(PhoneNumber);
+  PhoneNumber *phone_number = new (phone_number_data) PhoneNumber();
+  phone_number = phone_number;
+
+  return TypedData_Wrap_Struct(self, &phone_number_type, phone_number);
+}
+
+VALUE pico_phone_phone_number_parse(int argc, VALUE *argv, Object self) {
+  return rb_class_new_instance(argc, argv, rb_cPhoneNumber);
+}
+
+void pico_phone_set_default_country(VALUE self, VALUE str_code) {
+  if (RB_NIL_P(str_code)) {
+    str_code = rb_str_new("ZZ", 2);
+  }
+
+  rb_ivar_set(self, rb_intern("@default_country"), str_code);
+}
+
+void pico_phone_set_default_extension_prefix(VALUE self, VALUE str_code) {
+  if (RB_NIL_P(str_code)) {
+    str_code = rb_str_new(";", 1);
+  }
+
+  rb_ivar_set(self, rb_intern("@default_extn_prefix"), str_code);
+}
+
+String pico_phone_get_default_country(Object self) {
+  return self.iv_get("@default_country");
+}
+
+Object is_phone_number_valid(Object self, String str, String cc) {
+  std::string phone_number = str.c_str();
+  std::string country = cc.c_str();
+
+  if (country.empty() || phone_number.empty()) {
+    return Qfalse;
+  }
+
+  PhoneNumber parsed_number;
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  auto result = phone_util.ParseAndKeepRawInput(phone_number, country, &parsed_number);
+
+  if (result != PhoneNumberUtil::NO_PARSING_ERROR) {
+    return Qfalse;
+  }
+
+  if (country == "ZZ" && phone_util.IsValidNumber(parsed_number)) {
+    return Qtrue;
+  } else if (phone_util.IsValidNumberForRegion(parsed_number, country)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+Object is_phone_number_possible(Object self, String str, String cc) {
+  std::string phone_number = str.c_str();
+  std::string country = cc.c_str();
+
+  if (country.empty() || phone_number.empty()) {
+    return Qnil;
+  }
+
+  PhoneNumber parsed_number;
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  auto result = phone_util.Parse(phone_number, country, &parsed_number);
+
+  if (result == PhoneNumberUtil::NO_PARSING_ERROR && phone_util.IsPossibleNumber(parsed_number)) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+Object pico_phone_is_valid_for_default_country(Object self, String phone_number) {
+  String country = self.iv_get("@default_country");
+  return is_phone_number_valid(self, phone_number, country);
+}
+
+Object pico_phone_is_valid_for_country(Object self, String phone_number, String country) {
+  return is_phone_number_valid(self, phone_number, country);
+}
+
+Object pico_phone_is_possible_for_default_country(Object self, String phone_number) {
+  String country = self.iv_get("@default_country");
+  return is_phone_number_possible(self, phone_number, country);
+}
+
+Object pico_phone_is_possible_for_country(Object self, String phone_number, String country) {
+  return is_phone_number_possible(self, phone_number, country);
+}
+
+static Array regions_for_number(const PhoneNumber& number, bool strict) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::list<std::string> regions;
+  phone_util.GetRegionCodesForCountryCallingCode(number.country_code(), &regions);
+
+  Array result;
+
+  // For the lenient (possible) check with a single region there is nothing to
+  // disambiguate, so a length-only check is sufficient and preferable: it lets
+  // possible_countries return the region for numbers that are the right length
+  // but fail strict pattern validation (e.g. a digit transposition in a French
+  // number still belongs to France). For ambiguous calling codes (+1, +7, +44,
+  // …) we must use IsValidNumberForRegion to distinguish between the candidate
+  // regions regardless of strictness, since IsPossibleNumber has no concept of
+  // region and would accept every candidate region equally.
+  if (!strict && regions.size() == 1) {
+    if (phone_util.IsPossibleNumber(number)) {
+      const auto& region = regions.front();
+      result.push(Object(rb_str_new(region.c_str(), region.size())));
+    }
+    return result;
+  }
+
+  for (const auto& region : regions) {
+    if (phone_util.IsValidNumberForRegion(number, region)) {
+      result.push(Object(rb_str_new(region.c_str(), region.size())));
+    }
+  }
+  return result;
+}
+
+Array pico_phone_supported_regions(Object self) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::set<std::string> regions;
+  phone_util.GetSupportedRegions(&regions);
+
+  Array result;
+  for (const auto& region : regions) {
+    result.push(Object(rb_str_new(region.c_str(), region.size())));
+  }
+  return result;
+}
+
+String pico_phone_convert_alpha_characters(Object self, String str) {
+  std::string phone_str = str.c_str();
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  phone_util.ConvertAlphaCharactersInNumber(&phone_str);
+  return rb_str_new(phone_str.c_str(), phone_str.size());
+}
+
+Object pico_phone_is_alpha_number(Object self, String str) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return phone_util.IsAlphaNumber(str.c_str()) ? Qtrue : Qfalse;
+}
+
+static const ShortNumberInfo& GetShortNumberInfo() {
+  static ShortNumberInfo instance;
+  return instance;
+}
+
+Object pico_phone_is_emergency_number(Object self, String number, String region) {
+  return GetShortNumberInfo().IsEmergencyNumber(number.c_str(), region.c_str()) ? Qtrue : Qfalse;
+}
+
+Object pico_phone_is_short_number_valid(Object self, String str, String region) {
+  std::string number_str = str.c_str();
+  std::string region_str = region.c_str();
+
+  PhoneNumber parsed;
+  if (PhoneNumberUtil::GetInstance()->Parse(number_str, region_str, &parsed) != PhoneNumberUtil::NO_PARSING_ERROR) {
+    return Qfalse;
+  }
+  return GetShortNumberInfo().IsValidShortNumberForRegion(parsed, region_str) ? Qtrue : Qfalse;
+}
+
+Object pico_phone_short_number_cost(Object self, String str, String region) {
+  std::string number_str = str.c_str();
+  std::string region_str = region.c_str();
+
+  PhoneNumber parsed;
+  if (PhoneNumberUtil::GetInstance()->Parse(number_str, region_str, &parsed) != PhoneNumberUtil::NO_PARSING_ERROR) {
+    return rb_id2sym(rb_intern("unknown_cost"));
+  }
+
+  VALUE cost;
+  switch (GetShortNumberInfo().GetExpectedCostForRegion(parsed, region_str)) {
+    case ShortNumberInfo::TOLL_FREE:
+      cost = rb_intern("toll_free");
+      break;
+    case ShortNumberInfo::STANDARD_RATE:
+      cost = rb_intern("standard_rate");
+      break;
+    case ShortNumberInfo::PREMIUM_RATE:
+      cost = rb_intern("premium_rate");
+      break;
+    default:
+      cost = rb_intern("unknown_cost");
+      break;
+  }
+  return rb_id2sym(cost);
+}
+
+Array pico_phone_possible_countries_for_string(Object self, String str) {
+  std::string phone_number_str = str.c_str();
+  if (phone_number_str.empty()) return Array();
+
+  PhoneNumber parsed_number;
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  auto parse_result = phone_util.Parse(phone_number_str, "ZZ", &parsed_number);
+  if (parse_result != PhoneNumberUtil::NO_PARSING_ERROR) return Array();
+
+  return regions_for_number(parsed_number, false);
+}
+
+Array pico_phone_valid_countries_for_string(Object self, String str) {
+  std::string phone_number_str = str.c_str();
+  if (phone_number_str.empty()) return Array();
+
+  PhoneNumber parsed_number;
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  auto parse_result = phone_util.Parse(phone_number_str, "ZZ", &parsed_number);
+  if (parse_result != PhoneNumberUtil::NO_PARSING_ERROR) return Array();
+
+  return regions_for_number(parsed_number, true);
+}
+
+Object parsed_number_possible_with_reason(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@possible_with_reason"))) {
+    return rb_iv_get(self, "@possible_with_reason");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  VALUE reason;
+  switch (phone_util.IsPossibleNumberWithReason(*phone_number)) {
+    case PhoneNumberUtil::IS_POSSIBLE:
+      reason = rb_intern("is_possible");
+      break;
+    case PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY:
+      reason = rb_intern("is_possible_local_only");
+      break;
+    case PhoneNumberUtil::TOO_SHORT:
+      reason = rb_intern("too_short");
+      break;
+    case PhoneNumberUtil::TOO_LONG:
+      reason = rb_intern("too_long");
+      break;
+    case PhoneNumberUtil::INVALID_COUNTRY_CODE:
+      reason = rb_intern("invalid_country_code");
+      break;
+    case PhoneNumberUtil::INVALID_LENGTH:
+      reason = rb_intern("invalid_length");
+      break;
+    default:
+      reason = rb_intern("unknown");
+      break;
+  }
+  return rb_iv_set(self, "@possible_with_reason", rb_id2sym(reason));
+}
+
+Object parsed_number_geographical(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return phone_util.IsNumberGeographical(*phone_number) ? Qtrue : Qfalse;
+}
+
+Object parsed_number_can_be_internationally_dialled(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return phone_util.CanBeInternationallyDialled(*phone_number) ? Qtrue : Qfalse;
+}
+
+VALUE phone_number_nullify_ivars(Object self) {
+  rb_iv_set(self, "@input_country", Qnil);
+  rb_iv_set(self, "@possible", Qfalse);
+  rb_iv_set(self, "@valid", Qfalse);
+  rb_iv_set(self, "@type", Qnil);
+  rb_iv_set(self, "@national", Qnil);
+  rb_iv_set(self, "@international", Qnil);
+  rb_iv_set(self, "@e164", Qnil);
+  rb_iv_set(self, "@country_code", Qnil);
+  rb_iv_set(self, "@country", Qnil);
+  rb_iv_set(self, "@area_code", Qnil);
+  rb_iv_set(self, "@local_number", Qnil);
+  rb_iv_set(self, "@original_format", Qnil);
+  rb_iv_set(self, "@raw_national", Qnil);
+  rb_iv_set(self, "@possible_with_reason", Qnil);
+
+  return Qtrue;
+}
+
+VALUE phone_number_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE str;
+  VALUE input_country;
+
+  rb_scan_args(argc, argv, "11", &str, &input_country);
+  rb_iv_set(self, "@input_country", input_country);
+  rb_iv_set(self, "@original", str);
+
+  if (RB_NIL_P(input_country)) {
+    input_country = rb_iv_get(rb_mPicoPhone, "@default_country");
+  }
+
+  if (RB_FIXNUM_P(str)) {
+    str = rb_fix2str(str, 10);
+  } else if (!RB_TYPE_P(str, T_STRING)) {
+    return phone_number_nullify_ivars(self);
+  }
+
+  PhoneNumber *phone_number;
+
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::string phone_number_value(StringValuePtr(str), RSTRING_LEN(str));
+  std::string country(StringValuePtr(input_country), RSTRING_LEN(input_country));
+
+  PhoneNumber parsed_number;
+
+  auto result = phone_util.ParseAndKeepRawInput(phone_number_value, country, &parsed_number);
+
+  if (result != PhoneNumberUtil::NO_PARSING_ERROR) {
+    phone_number_nullify_ivars(self);
+  }
+
+  phone_number->Swap(&parsed_number);
+
+  return self;
+}
+
+Object is_parsed_phone_number_possible(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@possible"))) {
+    return rb_iv_get(self, "@possible");
+  }
+
+  PhoneNumber *phone_number;
+
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  if (phone_util.IsPossibleNumber(*phone_number)) {
+    return rb_iv_set(self, "@possible", Qtrue);
+  } else {
+    return rb_iv_set(self, "@possible", Qfalse);
+  }
+}
+
+Object is_parsed_phone_number_impossible(Object self) {
+  return (bool) is_parsed_phone_number_possible(self) ? Qfalse : Qtrue;
+}
+
+Object is_parsed_phone_number_valid(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@valid"))) {
+    return rb_iv_get(self, "@valid");
+  }
+
+  VALUE input_country = rb_iv_get(self, "@input_country");
+  if (RB_NIL_P(input_country)) {
+    input_country = rb_iv_get(rb_mPicoPhone, "@default_country");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  if (!rb_str_equal(input_country, rb_str_new_literal("ZZ"))) {
+    std::string country(StringValuePtr(input_country), RSTRING_LEN(input_country));
+    if (phone_util.IsValidNumberForRegion(*phone_number, country)) {
+      return rb_iv_set(self, "@valid", Qtrue);
+    } else {
+      return rb_iv_set(self, "@valid", Qfalse);
+    }
+  }
+
+  if (phone_util.IsValidNumber(*phone_number)) {
+    return rb_iv_set(self, "@valid", Qtrue);
+  } else {
+    return rb_iv_set(self, "@valid", Qfalse);
+  }
+}
+
+Object is_parsed_phone_number_invalid(Object self) {
+  return (bool) is_parsed_phone_number_valid(self) ? Qfalse : Qtrue;
+}
+
+static VALUE phone_number_type_to_symbol(PhoneNumberUtil::PhoneNumberType type) {
+  switch (type) {
+    case PhoneNumberUtil::FIXED_LINE:          return rb_id2sym(rb_intern("fixed_line"));
+    case PhoneNumberUtil::MOBILE:              return rb_id2sym(rb_intern("mobile"));
+    case PhoneNumberUtil::FIXED_LINE_OR_MOBILE:return rb_id2sym(rb_intern("fixed_line_or_mobile"));
+    case PhoneNumberUtil::TOLL_FREE:           return rb_id2sym(rb_intern("toll_free"));
+    case PhoneNumberUtil::PREMIUM_RATE:        return rb_id2sym(rb_intern("premium_rate"));
+    case PhoneNumberUtil::SHARED_COST:         return rb_id2sym(rb_intern("shared_cost"));
+    case PhoneNumberUtil::VOIP:                return rb_id2sym(rb_intern("voip"));
+    case PhoneNumberUtil::PERSONAL_NUMBER:     return rb_id2sym(rb_intern("personal_number"));
+    case PhoneNumberUtil::PAGER:               return rb_id2sym(rb_intern("pager"));
+    case PhoneNumberUtil::UAN:                 return rb_id2sym(rb_intern("uan"));
+    case PhoneNumberUtil::VOICEMAIL:           return rb_id2sym(rb_intern("voicemail"));
+    default:                                   return rb_id2sym(rb_intern("unknown"));
+  }
+}
+
+static PhoneNumberUtil::PhoneNumberType symbol_to_phone_number_type(VALUE sym) {
+  ID id = rb_to_id(sym);
+  if (id == rb_intern("fixed_line"))           return PhoneNumberUtil::FIXED_LINE;
+  if (id == rb_intern("mobile"))               return PhoneNumberUtil::MOBILE;
+  if (id == rb_intern("fixed_line_or_mobile")) return PhoneNumberUtil::FIXED_LINE_OR_MOBILE;
+  if (id == rb_intern("toll_free"))            return PhoneNumberUtil::TOLL_FREE;
+  if (id == rb_intern("premium_rate"))         return PhoneNumberUtil::PREMIUM_RATE;
+  if (id == rb_intern("shared_cost"))          return PhoneNumberUtil::SHARED_COST;
+  if (id == rb_intern("voip"))                 return PhoneNumberUtil::VOIP;
+  if (id == rb_intern("personal_number"))      return PhoneNumberUtil::PERSONAL_NUMBER;
+  if (id == rb_intern("pager"))                return PhoneNumberUtil::PAGER;
+  if (id == rb_intern("uan"))                  return PhoneNumberUtil::UAN;
+  if (id == rb_intern("voicemail"))            return PhoneNumberUtil::VOICEMAIL;
+  return PhoneNumberUtil::UNKNOWN;
+}
+
+Object parsed_phone_type(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@type"))) {
+    return rb_iv_get(self, "@type");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return rb_iv_set(self, "@type", phone_number_type_to_symbol(phone_util.GetNumberType(*phone_number)));
+}
+
+static inline String format_parsed_phone_number(Object self, PhoneNumberUtil::PhoneNumberFormat selected_format, bool full_format = false) {
+  PhoneNumber *phone_number;
+
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  PhoneNumber copied_proto(*phone_number);
+
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::string formatted_phone_number;
+  String extension_prefix = rb_iv_get(rb_mPicoPhone, "@default_extn_prefix");
+
+  // if the phone number has an extension
+  // remove it so it's not part of formatting
+  if (phone_number->has_extension()) {
+    copied_proto.clear_extension();
+  }
+
+  phone_util.Format(copied_proto, selected_format, &formatted_phone_number);
+
+  return (full_format && phone_number->has_extension()) ? formatted_phone_number.append(extension_prefix.c_str()).append(phone_number->extension()) : formatted_phone_number;
+}
+
+String format_parsed_number_national(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@national"))) {
+    return rb_iv_get(self, "@national");
+  }
+
+  return rb_iv_set(self, "@national", format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::NATIONAL));
+}
+
+String format_parsed_number_full_national(Object self) {
+  return format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::NATIONAL, true);
+}
+
+String format_parsed_number_raw_national(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@raw_national"))) {
+    return rb_iv_get(self, "@raw_national");
+  }
+
+  PhoneNumber *phone_number;
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  std::string national_number;
+  phone_util.GetNationalSignificantNumber(*phone_number, &national_number);
+
+  return rb_iv_set(self, "@raw_national", rb_str_new(national_number.c_str(), national_number.size()));
+}
+
+String format_parsed_international(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@international"))) {
+    return rb_iv_get(self, "@international");
+  }
+  return rb_iv_set(self, "@international", format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL));
+}
+
+String format_parsed_full_international(Object self) {
+  return format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::INTERNATIONAL, true);
+}
+
+String format_parsed_number_raw_international(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@raw_international"))) {
+    return rb_iv_get(self, "@raw_international");
+  }
+
+  String formatted;
+
+  if (rb_ivar_defined(self, rb_intern("@e164"))) {
+    formatted = rb_iv_get(self, "@e164");
+  } else {
+    formatted = format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::E164);
+  }
+
+  std::string formatted_raw = formatted.str().erase(0, 1);
+
+  return rb_iv_set(self, "@raw_international", (String) formatted_raw);
+}
+
+String format_parsed_number_e164(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@e164"))) {
+    return rb_iv_get(self, "@e164");
+  }
+  return rb_iv_set(self, "@e164", format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::E164));
+}
+
+String format_parsed_number_full_e164(Object self) {
+  return format_parsed_phone_number(self, PhoneNumberUtil::PhoneNumberFormat::E164, true);
+}
+
+String format_parsed_number_in_original_format(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@original_format"))) {
+    return rb_iv_get(self, "@original_format");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  VALUE input_country = rb_iv_get(self, "@input_country");
+  if (RB_NIL_P(input_country)) {
+    input_country = rb_iv_get(rb_mPicoPhone, "@default_country");
+  }
+  std::string region(StringValuePtr(input_country), RSTRING_LEN(input_country));
+
+  std::string formatted;
+  phone_util.FormatInOriginalFormat(*phone_number, region, &formatted);
+  return rb_iv_set(self, "@original_format", rb_str_new(formatted.c_str(), formatted.size()));
+}
+
+String format_parsed_number_out_of_country(Object self, String calling_from) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  std::string formatted;
+  phone_util.FormatOutOfCountryCallingNumber(*phone_number, calling_from.c_str(), &formatted);
+  return rb_str_new(formatted.c_str(), formatted.size());
+}
+
+String format_parsed_number_mobile_dialing(Object self, String calling_from) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  std::string formatted;
+  phone_util.FormatNumberForMobileDialing(*phone_number, calling_from.c_str(), true, &formatted);
+  return rb_str_new(formatted.c_str(), formatted.size());
+}
+
+Object parsed_phone_number_has_extension(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  return phone_number->has_extension() ? Qtrue : Qfalse;
+}
+
+// Returns the extension for the parsed phone number according to the pattern in
+// libphonenumber library https://github.com/google/libphonenumber/blob/424617599369e7adba8a5d1509b910d9ce2e3e44/cpp/src/phonenumbers/phonenumberutil.cc#L220
+String parsed_number_extension(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  if (phone_number->has_extension()) {
+    return phone_number->extension();
+  } else {
+    return String("");
+  }
+}
+
+Object parsed_number_country_code(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@country_code"))) {
+    return rb_iv_get(self, "@country_code");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+
+  int code = phone_number->country_code();
+
+  return rb_iv_set(self, "@country_code", INT2FIX(code));
+}
+
+String parsed_number_country(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@country"))) {
+    return rb_iv_get(self, "@country");
+  }
+
+  VALUE input_country = rb_iv_get(self, "@input_country");
+
+  if(RB_NIL_P(input_country)) {
+    PhoneNumber *phone_number;
+    std::string country;
+    TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+    const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+    phone_util.GetRegionCodeForCountryCode(phone_number->country_code(), &country);
+
+    return rb_iv_set(self, "@country", rb_str_new(country.c_str(), country.size()));
+  } else {
+    return rb_iv_set(self, "@country", input_country);
+  }
+}
+
+String parsed_number_area_code(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@area_code"))) {
+    return rb_iv_get(self, "@area_code");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::string national_significant_number;
+  std::string area_code;
+  int area_code_size = phone_util.GetLengthOfGeographicalAreaCode(*phone_number);
+
+  if (area_code_size > 0) {
+    phone_util.GetNationalSignificantNumber(*phone_number, &national_significant_number);
+    area_code = national_significant_number.substr(0, area_code_size);
+  } else {
+    area_code = "";
+  }
+
+  return rb_iv_set(self, "@area_code", rb_str_new(area_code.c_str(), area_code.size()));
+}
+
+String parsed_number_local_number(Object self) {
+  if (rb_ivar_defined(self, rb_intern("@local_number"))) {
+    return rb_iv_get(self, "@local_number");
+  }
+
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+
+  std::string national_significant_number;
+  phone_util.GetNationalSignificantNumber(*phone_number, &national_significant_number);
+
+  int area_code_length = phone_util.GetLengthOfGeographicalAreaCode(*phone_number);
+  std::string local = area_code_length > 0
+    ? national_significant_number.substr(area_code_length)
+    : national_significant_number;
+
+  return rb_iv_set(self, "@local_number", rb_str_new(local.c_str(), local.size()));
+}
+
+Object parsed_number_valid_for_country(Object self, String country) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  return phone_util.IsValidNumberForRegion(*phone_number, country.c_str()) ? Qtrue : Qfalse;
+}
+
+Object parsed_number_invalid_for_country(Object self, String country) {
+  return RTEST(parsed_number_valid_for_country(self, country)) ? Qfalse : Qtrue;
+}
+
+Object parsed_number_original(Object self) {
+  return rb_iv_get(self, "@original");
+}
+
+Object parsed_number_to_s(Object self) {
+  if (RTEST(is_parsed_phone_number_valid(self))) {
+    return format_parsed_number_e164(self);
+  }
+  VALUE original = rb_iv_get(self, "@original");
+  return RB_NIL_P(original) ? Object(rb_str_new("", 0)) : Object(original);
+}
+
+Array parsed_number_possible_countries(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  return regions_for_number(*phone_number, false);
+}
+
+Array parsed_number_valid_countries(Object self) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  return regions_for_number(*phone_number, true);
+}
+
+Array pico_phone_supported_types_for_region(Object self, String region) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  std::set<PhoneNumberUtil::PhoneNumberType> types;
+  phone_util.GetSupportedTypesForRegion(region.c_str(), &types);
+
+  Array result;
+  for (const auto& type : types) {
+    result.push(Object(phone_number_type_to_symbol(type)));
+  }
+  return result;
+}
+
+Object pico_phone_example_number(Object self, String region) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  PhoneNumber example;
+  if (!phone_util.GetExampleNumber(region.c_str(), &example)) return Qnil;
+
+  std::string formatted;
+  phone_util.Format(example, PhoneNumberUtil::E164, &formatted);
+  VALUE args[1] = { rb_str_new(formatted.c_str(), formatted.size()) };
+  return rb_class_new_instance(1, args, rb_cPhoneNumber);
+}
+
+Object pico_phone_example_number_for_type(Object self, String region, Object type_sym) {
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  PhoneNumber example;
+  PhoneNumberUtil::PhoneNumberType type = symbol_to_phone_number_type(type_sym);
+  if (!phone_util.GetExampleNumberForType(region.c_str(), type, &example)) return Qnil;
+
+  std::string formatted;
+  phone_util.Format(example, PhoneNumberUtil::E164, &formatted);
+  VALUE args[1] = { rb_str_new(formatted.c_str(), formatted.size()) };
+  return rb_class_new_instance(1, args, rb_cPhoneNumber);
+}
+
+Object parsed_number_possible_for_type(Object self, Object type_sym) {
+  PhoneNumber *phone_number;
+  TypedData_Get_Struct(self, PhoneNumber, &phone_number_type, phone_number);
+  const PhoneNumberUtil &phone_util(*PhoneNumberUtil::GetInstance());
+  PhoneNumberUtil::PhoneNumberType type = symbol_to_phone_number_type(type_sym);
+  return phone_util.IsPossibleNumberForType(*phone_number, type) ? Qtrue : Qfalse;
+}
+
+extern "C"
+void Init_pico_phone() {
+  rb_mPicoPhone = define_module("PicoPhone")
+    .define_singleton_method("default_country", &pico_phone_get_default_country)
+    .define_singleton_method("valid?", &pico_phone_is_valid_for_default_country)
+    .define_singleton_method("valid_for_country?", &pico_phone_is_valid_for_country)
+    .define_singleton_method("possible?", &pico_phone_is_possible_for_default_country)
+    .define_singleton_method("possible_for_country?", &pico_phone_is_possible_for_country)
+    .define_singleton_method("possible_countries", &pico_phone_possible_countries_for_string)
+    .define_singleton_method("valid_countries", &pico_phone_valid_countries_for_string)
+    .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("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);
+
+    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);
+    rb_define_singleton_method(rb_mPicoPhone, "parse", reinterpret_cast<VALUE (*)(...)>(pico_phone_phone_number_parse), -1);
+    rb_ivar_set(rb_mPicoPhone, rb_intern("@default_country"), rb_str_new("ZZ", 2));
+    rb_ivar_set(rb_mPicoPhone, rb_intern("@default_extn_prefix"), rb_str_new(";", 1));
+
+  rb_cPhoneNumber = define_class_under(rb_mPicoPhone, "PhoneNumber")
+    .define_method("possible?", &is_parsed_phone_number_possible)
+    .define_method("impossible?", &is_parsed_phone_number_impossible)
+    .define_method("valid?", &is_parsed_phone_number_valid)
+    .define_method("invalid?", &is_parsed_phone_number_invalid)
+    .define_method("type", &parsed_phone_type)
+    .define_method("national", &format_parsed_number_national)
+    .define_method("international", &format_parsed_international)
+    .define_method("e164", &format_parsed_number_e164)
+    .define_method("extension", &parsed_number_extension)
+    .define_method("has_extension?", &parsed_phone_number_has_extension)
+    .define_method("full_national", &format_parsed_number_full_national)
+    .define_method("full_international", &format_parsed_full_international)
+    .define_method("full_e164", &format_parsed_number_full_e164)
+    .define_method("format_in_original_format", &format_parsed_number_in_original_format)
+    .define_method("out_of_country_format", &format_parsed_number_out_of_country)
+    .define_method("mobile_dialing_format", &format_parsed_number_mobile_dialing)
+    .define_method("country_code", &parsed_number_country_code)
+    .define_method("country", &parsed_number_country)
+    .define_method("area_code", &parsed_number_area_code)
+    .define_method("local_number", &parsed_number_local_number)
+    .define_method("valid_for_country?", &parsed_number_valid_for_country)
+    .define_method("invalid_for_country?", &parsed_number_invalid_for_country)
+    .define_method("original", &parsed_number_original)
+    .define_method("to_s", &parsed_number_to_s)
+    .define_method("raw_national", &format_parsed_number_raw_national)
+    .define_method("raw_international", &format_parsed_number_raw_international)
+    .define_method("possible_countries", &parsed_number_possible_countries)
+    .define_method("valid_countries", &parsed_number_valid_countries)
+    .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);
+
+    rb_define_alloc_func(rb_cPhoneNumber, rb_phone_number_alloc);
+    rb_define_method(rb_cPhoneNumber, "initialize", reinterpret_cast<VALUE (*)(...)>(phone_number_initialize), -1);
+}

data/lib/pico_phone/phone_number.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# Not loaded at runtime — exists only for YARD and IDE tooling.
+# All methods are defined in ext/pico_phone/pico_phone.cpp via Rice.
+
+module PicoPhone
+  # @!method self.parse(string, region = nil)
+  #   Parse a phone number string into a PhoneNumber object.
+  #   @param string [String] raw phone number input
+  #   @param region [String, nil] ISO 3166-1 alpha-2 region hint (e.g. "US")
+  #   @return [PhoneNumber]
+
+  # @!method self.valid?(string)
+  #   @param string [String]
+  #   @return [Boolean]
+
+  # @!method self.possible?(string)
+  #   @param string [String]
+  #   @return [Boolean]
+
+  # @!method self.valid_for_country?(string, region)
+  #   @param string [String]
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Boolean]
+
+  # @!method self.possible_for_country?(string, region)
+  #   @param string [String]
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Boolean]
+
+  # @!method self.possible_countries(string)
+  #   Regions that could own this number based on length or pattern.
+  #   @param string [String]
+  #   @return [Array<String>] ISO 3166-1 alpha-2 region codes
+
+  # @!method self.valid_countries(string)
+  #   Regions for which this number passes strict pattern validation.
+  #   @param string [String]
+  #   @return [Array<String>] ISO 3166-1 alpha-2 region codes
+
+  # @!method self.supported_types_for_region(region)
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Array<Symbol>]
+
+  # @!method self.example_number(region)
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [PhoneNumber]
+
+  # @!method self.example_number_for_type(region, type)
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @param type [Symbol] e.g. :mobile, :fixed_line, :toll_free
+  #   @return [PhoneNumber]
+
+  # @!method self.emergency_number?(string, region)
+  #   @param string [String]
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Boolean]
+
+  # @!method self.short_number_valid?(string, region)
+  #   @param string [String]
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Boolean]
+
+  # @!method self.short_number_cost(string, region)
+  #   @param string [String]
+  #   @param region [String] ISO 3166-1 alpha-2 region code
+  #   @return [Symbol] :toll_free, :standard_rate, :premium_rate, or :unknown_cost
+
+  # @!method self.supported_regions
+  #   All region codes the library knows about (~245 in libphonenumber 9.x).
+  #   @return [Array<String>] ISO 3166-1 alpha-2 region codes
+
+  # @!method self.convert_alpha_characters(string)
+  #   Convert vanity number alpha characters to digits (e.g. "1-800-FLOWERS" → "1-800-3569377").
+  #   @param string [String]
+  #   @return [String]
+
+  # @!method self.alpha_number?(string)
+  #   @param string [String]
+  #   @return [Boolean]
+
+  class PhoneNumber
+    # @param string [String, nil] raw phone number input
+    # @param region [String, nil] ISO 3166-1 alpha-2 region hint (e.g. "US")
+    def initialize(string, region = nil); end
+
+    # @return [Boolean]
+    def valid?; end
+
+    # @return [Boolean]
+    def invalid?; end
+
+    # @return [Boolean]
+    def possible?; end
+
+    # @return [Boolean]
+    def impossible?; end
+
+    # Why the number is or is not possible.
+    # @return [Symbol] :is_possible, :is_possible_local_only, :too_short, :too_long,
+    #   :invalid_country_code, or :invalid_length
+    def possible_with_reason; end
+
+    # @return [String] e.g. "(510) 274-5656"
+    def national; end
+
+    # @return [String] e.g. "+1 510-274-5656"
+    def international; end
+
+    # @return [String] e.g. "+15102745656"
+    def e164; end
+
+    # @return [String, nil]
+    def extension; end
+
+    # @return [Boolean]
+    def has_extension?; end
+
+    # National format with extension appended using the configured prefix.
+    # @return [String]
+    def full_national; end
+
+    # International format with extension appended using the configured prefix.
+    # @return [String]
+    def full_international; end
+
+    # E.164 format with extension appended using the configured prefix.
+    # @return [String]
+    def full_e164; end
+
+    # @return [Integer] e.g. 1 for US/CA, 61 for AU
+    def country_code; end
+
+    # @return [String] ISO 3166-1 alpha-2 region code (e.g. "US")
+    def country; end
+
+    # @return [String] geographic area code digits, or empty string if none
+    def area_code; end
+
+    # National significant number as plain digits, no formatting punctuation.
+    # @return [String]
+    def raw_national; end
+
+    # International number digits with calling code, no formatting punctuation.
+    # @return [String]
+    def raw_international; end
+
+    # @return [Symbol] :fixed_line, :mobile, :fixed_line_or_mobile, :toll_free,
+    #   :premium_rate, :shared_cost, :voip, :personal_number, :pager, :uan,
+    #   :voicemail, or :unknown
+    def type; end
+
+    # Subscriber number after the area code. Returns the full national number when
+    # there is no geographic area code (e.g. mobile numbers in AU).
+    # @return [String]
+    def local_number; end
+
+    # @param region [String] ISO 3166-1 alpha-2 region code
+    # @return [Boolean]
+    def valid_for_country?(region); end
+
+    # @param region [String] ISO 3166-1 alpha-2 region code
+    # @return [Boolean]
+    def invalid_for_country?(region); end
+
+    # The raw input string as passed to the constructor. Survives a failed parse.
+    # @return [String, nil]
+    def original; end
+
+    # E.164 for a valid number; falls back to {#original} for an invalid one.
+    # Returns an empty string when nil was passed as input.
+    # @return [String]
+    def to_s; end
+
+    # Format using the same style (international vs. national) as the original input.
+    # @return [String]
+    def format_in_original_format; end
+
+    # Format the number as it would be dialed from outside its home country.
+    # @param region [String] ISO 3166-1 alpha-2 region of the caller
+    # @return [String]
+    def out_of_country_format(region); end
+
+    # Format the number for convenient dialing on a mobile device in the given region.
+    # @param region [String] ISO 3166-1 alpha-2 region of the caller
+    # @return [String]
+    def mobile_dialing_format(region); end
+
+    # Regions that could own this number based on length (unambiguous codes) or
+    # pattern (shared calling codes like +1 or +7).
+    # @return [Array<String>] ISO 3166-1 alpha-2 region codes
+    def possible_countries; end
+
+    # Regions for which this number passes strict pattern validation.
+    # @return [Array<String>] ISO 3166-1 alpha-2 region codes
+    def valid_countries; end
+
+    # True for fixed-line numbers tied to a geographic area code.
+    # @return [Boolean]
+    def geographical?; end
+
+    # True when the number's digit count is consistent with the given type in its region.
+    # More permissive than {#type}: a 10-digit US number is possible for both
+    # :fixed_line_or_mobile and :toll_free since they share the same digit count.
+    # @param type [Symbol] e.g. :mobile, :toll_free, :fixed_line
+    # @return [Boolean]
+    def possible_for_type?(type); end
+
+    # False for numbers that only work within their own country.
+    # @return [Boolean]
+    def can_be_internationally_dialled?; end
+  end
+end

data/lib/pico_phone/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PicoPhone
+  VERSION = "0.2.0"
+end

data/lib/pico_phone.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+require "pico_phone/version"
+require "pico_phone/pico_phone"
+
+module PicoPhone
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: pico_phone
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: x86_64-linux
+authors:
+- Gabi Jack
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: pico_phone wraps Google's libphonenumber C++ library via a Rice native
+  extension, providing phone number parsing, validation, and formatting for any country.
+  It uses the same engine as Android's dialer and delivers native C++ performance
+  for high-throughput server-side use.
+email:
+- gabi@gabijack.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/pico_phone/extconf.rb
+- ext/pico_phone/pico_phone.cpp
+- lib/pico_phone.rb
+- lib/pico_phone/phone_number.rb
+- lib/pico_phone/pico_phone.so
+- lib/pico_phone/version.rb
+homepage: https://github.com/gjack/pico_phone
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gjack/pico_phone
+  source_code_uri: https://github.com/gjack/pico_phone
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: A thin Ruby wrapper around Google's libphonenumber for parsing, validating,
+  and formatting phone numbers
+test_files: []