CPP: Update metadata/code to v3.4.

cpp/src/phonenumberutil.cc

@@ -453,7 +453,13 @@ char32 ToUnicodeCodepoint(const char* unicode_char) {
 // defined order.
 void CreateRegularExpressions() {
   unique_international_prefix.reset(new RE2("[\\d]+(?:[~⁓∼～][\\d]+)?"));
-  first_group_capturing_pattern.reset(new RE2("(\\$1)"));
+
+  // The first_group_capturing_pattern was originally set to $1 but there are
+  // some countries for which the first group is not used in the national
+  // pattern (e.g. Argentina) so the $1 group does not match correctly.
+  // Therefore, we use \d, so that the first group actually used in the pattern
+  // will be matched.
+  first_group_capturing_pattern.reset(new RE2("(\\$\\d)"));
   carrier_code_pattern.reset(new RE2("\\$CC"));
   capturing_digit_pattern.reset(new RE2(StrCat("([", kValidDigits, "])")));
   capturing_ascii_digits_pattern.reset(new RE2("(\\d+)"));
@@ -1284,14 +1290,10 @@ void PhoneNumberUtil::GetRegionCodeForNumberFromRegionList(
 
 int PhoneNumberUtil::GetCountryCodeForRegion(const string& region_code) const {
   if (!IsValidRegionCode(region_code)) {
-    logger->Info("Invalid or unknown country code provided.");
+    logger->Error("Invalid or unknown country code provided.");
     return 0;
   }
   const PhoneMetadata* metadata = GetMetadataForRegion(region_code);
-  if (!metadata) {
-    logger->Error("Unsupported country code provided.");
-    return 0;
-  }
   return metadata->country_code();
 }
 
@@ -1312,6 +1314,10 @@ bool PhoneNumberUtil::GetExampleNumberForType(
     PhoneNumberUtil::PhoneNumberType type,
     PhoneNumber* number) const {
   DCHECK(number);
+  if (!IsValidRegionCode(region_code)) {
+    logger->Warning("Invalid or unknown region code provided.");
+    return false;
+  }
   const PhoneMetadata* region_metadata = GetMetadataForRegion(region_code);
   const PhoneNumberDesc* description =
       GetNumberDescByType(*region_metadata, type);

cpp/src/phonenumberutil_test.cc

@@ -308,8 +308,9 @@ TEST_F(PhoneNumberUtilTest, GetInstanceLoadARMetadata) {
   EXPECT_EQ("0(?:(11|343|3715)15)?", metadata->national_prefix_for_parsing());
   EXPECT_EQ("9$1", metadata->national_prefix_transform_rule());
   ASSERT_EQ(5, metadata->number_format_size());
-  EXPECT_EQ("$1 15 $2-$3", metadata->number_format(2).format());
-  EXPECT_EQ("9(\\d{4})(\\d{2})(\\d{4})", metadata->number_format(3).pattern());
+  EXPECT_EQ("$2 15 $3-$4", metadata->number_format(2).format());
+  EXPECT_EQ("(9)(\\d{4})(\\d{2})(\\d{4})",
+            metadata->number_format(3).pattern());
   EXPECT_EQ("(9)(\\d{4})(\\d{2})(\\d{4})",
             metadata->intl_number_format(3).pattern());
   EXPECT_EQ("$1 $2 $3 $4", metadata->intl_number_format(3).format());
@@ -380,6 +381,13 @@ TEST_F(PhoneNumberUtilTest, GetExampleNumber) {
                                                 &test_number);
   EXPECT_TRUE(success);
   EXPECT_NE(PhoneNumber::default_instance(), test_number);
+
+  test_number.Clear();
+  // CS is an invalid region, so we have no data for it. We should return false.
+  EXPECT_FALSE(phone_util_.GetExampleNumberForType(RegionCode::CS(),
+                                                   PhoneNumberUtil::MOBILE,
+                                                   &test_number));
+  EXPECT_EQ(PhoneNumber::default_instance(), test_number);
 }
 
 TEST_F(PhoneNumberUtilTest, FormatUSNumber) {
@@ -584,6 +592,51 @@ TEST_F(PhoneNumberUtilTest, FormatARNumber) {
   EXPECT_EQ("+5491187654321", formatted_number);
 }
 
+TEST_F(PhoneNumberUtilTest, FormatMXNumber) {
+  PhoneNumber test_number;
+  string formatted_number;
+  test_number.set_country_code(52);
+  test_number.set_national_number(12345678900ULL);
+  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
+  EXPECT_EQ("045 234 567 8900", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
+                     &formatted_number);
+  EXPECT_EQ("+52 1 234 567 8900", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::E164,
+                     &formatted_number);
+  EXPECT_EQ("+5212345678900", formatted_number);
+
+  test_number.set_national_number(15512345678ULL);
+  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
+  EXPECT_EQ("045 55 1234 5678", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
+                     &formatted_number);
+  EXPECT_EQ("+52 1 55 1234 5678", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::E164,
+                     &formatted_number);
+  EXPECT_EQ("+5215512345678", formatted_number);
+
+  test_number.set_national_number(3312345678LL);
+  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
+  EXPECT_EQ("01 33 1234 5678", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
+                     &formatted_number);
+  EXPECT_EQ("+52 33 1234 5678", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::E164,
+                     &formatted_number);
+  EXPECT_EQ("+523312345678", formatted_number);
+
+  test_number.set_national_number(8211234567LL);
+  phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
+  EXPECT_EQ("01 821 123 4567", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
+                     &formatted_number);
+  EXPECT_EQ("+52 821 123 4567", formatted_number);
+  phone_util_.Format(test_number, PhoneNumberUtil::E164,
+                     &formatted_number);
+  EXPECT_EQ("+528211234567", formatted_number);
+}
+
 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryCallingNumber) {
   PhoneNumber test_number;
   string formatted_number;
@@ -1169,7 +1222,7 @@ TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
   // However, it should be recognised as from La Mayotte.
   string region_code;
   phone_util_.GetRegionCodeForNumber(re_number, &region_code);
-  EXPECT_EQ("YT", region_code);
+  EXPECT_EQ(RegionCode::YT(), region_code);
   // This number is valid in both places.
   re_number.set_national_number(800123456ULL);
   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
@@ -2551,8 +2604,8 @@ TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
   PhoneNumber nz_number;
   nz_number.set_country_code(64);
   nz_number.set_national_number(33316005ULL);
-  // "ZZ" is allowed only if the number starts with a '+' - then
-  // the country code can be calculated.
+  // "ZZ" is allowed only if the number starts with a '+' - then the country
+  // code can be calculated.
   PhoneNumber result_proto;
   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
             phone_util_.Parse("+64 3 331 6005", RegionCode::ZZ(),

tools/java/common/src/com/google/i18n/phonenumbers/tools/BuildMetadataFromXml.java

@@ -160,11 +160,14 @@ public class BuildMetadataFromXml {
 
     // Extract availableFormats
     NodeList numberFormatElements = element.getElementsByTagName("numberFormat");
+    boolean hasExplicitIntlFormatDefined = false;
+
     int numOfFormatElements = numberFormatElements.getLength();
     if (numOfFormatElements > 0) {
       for (int i = 0; i < numOfFormatElements; i++) {
         Element numberFormatElement = (Element) numberFormatElements.item(i);
         NumberFormat.Builder format = NumberFormat.newBuilder();
+
         if (numberFormatElement.hasAttribute("nationalPrefixFormattingRule")) {
           format.setNationalPrefixFormattingRule(
               getNationalPrefixFormattingRuleFromElement(numberFormatElement, nationalPrefix));
@@ -178,8 +181,11 @@ public class BuildMetadataFromXml {
         } else {
           format.setDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
         }
+
+        // Extract the pattern for the national format.
         setLeadingDigitsPatterns(numberFormatElement, format);
         format.setPattern(validateRE(numberFormatElement.getAttribute("pattern")));
+
         NodeList formatPattern = numberFormatElement.getElementsByTagName("format");
         if (formatPattern.getLength() != 1) {
           LOGGER.log(Level.SEVERE,
@@ -187,35 +193,46 @@ public class BuildMetadataFromXml {
           throw new RuntimeException("Invalid number of format patterns for country: " +
                                      regionCode);
         }
-        format.setFormat(formatPattern.item(0).getFirstChild().getNodeValue());
+        String nationalFormat = formatPattern.item(0).getFirstChild().getNodeValue();
+        format.setFormat(nationalFormat);
         metadata.addNumberFormat(format);
-      }
-    }
 
-    NodeList intlNumberFormatElements = element.getElementsByTagName("intlNumberFormat");
-    int numOfIntlFormatElements = intlNumberFormatElements.getLength();
-    if (numOfIntlFormatElements > 0) {
-      for (int i = 0; i < numOfIntlFormatElements; i++) {
-        Element numberFormatElement = (Element) intlNumberFormatElements.item(i);
-        NumberFormat.Builder format = NumberFormat.newBuilder();
-        setLeadingDigitsPatterns(numberFormatElement, format);
-        format.setPattern(validateRE(numberFormatElement.getAttribute("pattern")));
-        NodeList formatPattern = numberFormatElement.getElementsByTagName("format");
-        if (formatPattern.getLength() != 1) {
+        // Extract the pattern for international format. If there is no intlFormat, default to
+        // using the national format. If the intlFormat is set to "NA" the intlFormat should be
+        // ignored.
+        NumberFormat.Builder intlFormat = NumberFormat.newBuilder();
+        setLeadingDigitsPatterns(numberFormatElement, intlFormat);
+        intlFormat.setPattern(numberFormatElement.getAttribute("pattern"));
+        NodeList intlFormatPattern = numberFormatElement.getElementsByTagName("intlFormat");
+
+        if (intlFormatPattern.getLength() > 1) {
           LOGGER.log(Level.SEVERE,
-                     "Only one format pattern for a numberFormat element should be defined.");
-          throw new RuntimeException("Invalid number of format patterns for country: " +
+                     "A maximum of one intlFormat pattern for a numberFormat element should be " +
+                     "defined.");
+          throw new RuntimeException("Invalid number of intlFormat patterns for country: " +
                                      regionCode);
-        }
-        format.setFormat(validateRE(formatPattern.item(0).getFirstChild().getNodeValue()));
-        if (numberFormatElement.hasAttribute("carrierCodeFormattingRule")) {
-          format.setDomesticCarrierCodeFormattingRule(validateRE(
-              getDomesticCarrierCodeFormattingRuleFromElement(numberFormatElement,
-                                                              nationalPrefix)));
+        } else if (intlFormatPattern.getLength() == 0) {
+          // Default to use the same as the national pattern if none is defined.
+          intlFormat.setFormat(nationalFormat);
         } else {
-          format.setDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
+           String intlFormatPatternValue =
+               intlFormatPattern.item(0).getFirstChild().getNodeValue();
+           if (!intlFormatPatternValue.equals("NA")) {
+             intlFormat.setFormat(intlFormatPatternValue);
+           }
+           hasExplicitIntlFormatDefined = true;
         }
-        metadata.addIntlNumberFormat(format);
+
+        if (intlFormat.hasFormat()) {
+          metadata.addIntlNumberFormat(intlFormat);
+        }
+      }
+      // Only a small number of regions need to specify the intlFormats in the xml. For the majority
+      // of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat
+      // metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
+      // actually differ in some way to the national formats.
+      if (!hasExplicitIntlFormatDefined) {
+        metadata.clearIntlNumberFormat();
       }
     }