src/third_party/libaddressinput/src/cpp/src/rule.cc

   1 // Copyright (C) 2013 Google Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "rule.h"
  16
  17 #include <cassert>
  18 #include <cstddef>
  19 #include <map>
  20 #include <string>
  21 #include <utility>
  22
  23 #include <re2/re2.h>
  24
  25 #include "address_field_util.h"
  26 #include "format_element.h"
  27 #include "grit.h"
  28 #include "messages.h"
  29 #include "region_data_constants.h"
  30 #include "util/json.h"
  31 #include "util/re2ptr.h"
  32 #include "util/string_split.h"
  33
  34 namespace i18n {
  35 namespace addressinput {
  36
  37 namespace {
  38
  39 typedef std::map<std::string, int> NameMessageIdMap;
  40
  41 // Used as a separator in a list of items. For example, the list of supported
  42 // languages can be "de~fr~it".
  43 const char kSeparator = '~';
  44
  45 NameMessageIdMap InitAdminAreaMessageIds() {
  46   NameMessageIdMap message_ids;
  47   message_ids.insert(std::make_pair(
  48       "area", IDS_LIBADDRESSINPUT_AREA));
  49   message_ids.insert(std::make_pair(
  50       "county", IDS_LIBADDRESSINPUT_COUNTY));
  51   message_ids.insert(std::make_pair(
  52       "department", IDS_LIBADDRESSINPUT_DEPARTMENT));
  53   message_ids.insert(std::make_pair(
  54       "district", IDS_LIBADDRESSINPUT_DISTRICT));
  55   message_ids.insert(std::make_pair(
  56       "do_si", IDS_LIBADDRESSINPUT_DO_SI));
  57   message_ids.insert(std::make_pair(
  58       "emirate", IDS_LIBADDRESSINPUT_EMIRATE));
  59   message_ids.insert(std::make_pair(
  60       "island", IDS_LIBADDRESSINPUT_ISLAND));
  61   message_ids.insert(std::make_pair(
  62       "oblast", IDS_LIBADDRESSINPUT_OBLAST));
  63   message_ids.insert(std::make_pair(
  64       "parish", IDS_LIBADDRESSINPUT_PARISH));
  65   message_ids.insert(std::make_pair(
  66       "prefecture", IDS_LIBADDRESSINPUT_PREFECTURE));
  67   message_ids.insert(std::make_pair(
  68       "province", IDS_LIBADDRESSINPUT_PROVINCE));
  69   message_ids.insert(std::make_pair(
  70       "state", IDS_LIBADDRESSINPUT_STATE));
  71   return message_ids;
  72 }
  73
  74 const NameMessageIdMap& GetAdminAreaMessageIds() {
  75   static const NameMessageIdMap kAdminAreaMessageIds(InitAdminAreaMessageIds());
  76   return kAdminAreaMessageIds;
  77 }
  78
  79 NameMessageIdMap InitPostalCodeMessageIds() {
  80   NameMessageIdMap message_ids;
  81   message_ids.insert(std::make_pair(
  82       "postal", IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL));
  83   message_ids.insert(std::make_pair(
  84       "zip", IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL));
  85   return message_ids;
  86 }
  87
  88 const NameMessageIdMap& GetPostalCodeMessageIds() {
  89   static const NameMessageIdMap kPostalCodeMessageIds(
  90       InitPostalCodeMessageIds());
  91   return kPostalCodeMessageIds;
  92 }
  93
  94 int GetMessageIdFromName(const std::string& name,
  95                          const NameMessageIdMap& message_ids) {
  96   NameMessageIdMap::const_iterator it = message_ids.find(name);
  97   return it != message_ids.end() ? it->second : INVALID_MESSAGE_ID;
  98 }
  99
 100 // Determines whether a given string is a reg-exp or a string. We consider a
 101 // string to be anything that doesn't contain characters with special meanings
 102 // in regular expressions - (, [, \, {, ?. These special characters are all the
 103 // ones that appear in the postal code regular expressions.
 104 bool ContainsRegExSpecialCharacters(const std::string& input) {
 105   return input.find_first_of("([\\{?") != std::string::npos;
 106 }
 107
 108 }  // namespace
 109
 110 Rule::Rule()
 111     : id_(),
 112       format_(),
 113       latin_format_(),
 114       required_(),
 115       sub_keys_(),
 116       languages_(),
 117       postal_code_matcher_(NULL),
 118       sole_postal_code_(),
 119       admin_area_name_message_id_(INVALID_MESSAGE_ID),
 120       postal_code_name_message_id_(INVALID_MESSAGE_ID),
 121       name_(),
 122       latin_name_(),
 123       postal_code_example_(),
 124       post_service_url_() {}
 125
 126 Rule::~Rule() {}
 127
 128 // static
 129 const Rule& Rule::GetDefault() {
 130   // Allocated once and leaked on shutdown.
 131   static Rule* default_rule = NULL;
 132   if (default_rule == NULL) {
 133     default_rule = new Rule;
 134     default_rule->ParseSerializedRule(
 135         RegionDataConstants::GetDefaultRegionData());
 136   }
 137   return *default_rule;
 138 }
 139
 140 void Rule::CopyFrom(const Rule& rule) {
 141   assert(this != &rule);
 142   id_ = rule.id_;
 143   format_ = rule.format_;
 144   latin_format_ = rule.latin_format_;
 145   required_ = rule.required_;
 146   sub_keys_ = rule.sub_keys_;
 147   languages_ = rule.languages_;
 148   postal_code_matcher_.reset(
 149       rule.postal_code_matcher_ == NULL
 150           ? NULL
 151           : new RE2ptr(new RE2(rule.postal_code_matcher_->ptr->pattern(),
 152                                rule.postal_code_matcher_->ptr->options())));
 153   sole_postal_code_ = rule.sole_postal_code_;
 154   admin_area_name_message_id_ = rule.admin_area_name_message_id_;
 155   postal_code_name_message_id_ = rule.postal_code_name_message_id_;
 156   name_ = rule.name_;
 157   latin_name_ = rule.latin_name_;
 158   postal_code_example_ = rule.postal_code_example_;
 159   post_service_url_ = rule.post_service_url_;
 160 }
 161
 162 bool Rule::ParseSerializedRule(const std::string& serialized_rule) {
 163   Json json;
 164   if (!json.ParseObject(serialized_rule)) {
 165     return false;
 166   }
 167   ParseJsonRule(json);
 168   return true;
 169 }
 170
 171 void Rule::ParseJsonRule(const Json& json) {
 172   std::string value;
 173   if (json.GetStringValueForKey("id", &value)) {
 174     id_.swap(value);
 175   }
 176
 177   if (json.GetStringValueForKey("fmt", &value)) {
 178     ParseFormatRule(value, &format_);
 179   }
 180
 181   if (json.GetStringValueForKey("lfmt", &value)) {
 182     ParseFormatRule(value, &latin_format_);
 183   }
 184
 185   if (json.GetStringValueForKey("require", &value)) {
 186     ParseAddressFieldsRequired(value, &required_);
 187   }
 188
 189   if (json.GetStringValueForKey("sub_keys", &value)) {
 190     SplitString(value, kSeparator, &sub_keys_);
 191   }
 192
 193   if (json.GetStringValueForKey("languages", &value)) {
 194     SplitString(value, kSeparator, &languages_);
 195   }
 196
 197   sole_postal_code_.clear();
 198   if (json.GetStringValueForKey("zip", &value)) {
 199     // The "zip" field in the JSON data is used in two different ways to
 200     // validate the postal code. At the country level, the "zip" field indicates
 201     // a Java compatible regular expression corresponding to all postal codes in
 202     // the country. At other levels, the regular expression indicates the postal
 203     // code prefix expected for addresses in that region.
 204     //
 205     // In order to make the RE2 object created from the "zip" field useable for
 206     // both these purposes, the pattern string is here prefixed with "^" to
 207     // anchor it at the beginning of the string so that it can be used with
 208     // RE2::PartialMatch() to perform prefix matching or else with
 209     // RE2::FullMatch() to perform matching against the entire string.
 210     RE2::Options options;
 211     options.set_never_capture(true);
 212     RE2* matcher = new RE2("^(" + value + ")", options);
 213     if (matcher->ok()) {
 214       postal_code_matcher_.reset(new RE2ptr(matcher));
 215     } else {
 216       postal_code_matcher_.reset(NULL);
 217       delete matcher;
 218     }
 219     // If the "zip" field is not a regular expression, then it is the sole
 220     // postal code for this rule.
 221     if (!ContainsRegExSpecialCharacters(value)) {
 222       sole_postal_code_.swap(value);
 223     }
 224   }
 225
 226   if (json.GetStringValueForKey("state_name_type", &value)) {
 227     admin_area_name_message_id_ =
 228         GetMessageIdFromName(value, GetAdminAreaMessageIds());
 229   }
 230
 231   if (json.GetStringValueForKey("zip_name_type", &value)) {
 232     postal_code_name_message_id_ =
 233         GetMessageIdFromName(value, GetPostalCodeMessageIds());
 234   }
 235
 236   if (json.GetStringValueForKey("name", &value)) {
 237     name_.swap(value);
 238   }
 239
 240   if (json.GetStringValueForKey("lname", &value)) {
 241     latin_name_.swap(value);
 242   }
 243
 244   if (json.GetStringValueForKey("zipex", &value)) {
 245     postal_code_example_.swap(value);
 246   }
 247
 248   if (json.GetStringValueForKey("posturl", &value)) {
 249     post_service_url_.swap(value);
 250   }
 251 }
 252
 253 }  // namespace addressinput
 254 }  // namespace i18n