Autofill phone number enhancements and integration of Phone Number Util Library: part 1

third_party/libphonenumber/chrome/regexp_adapter_icuregexp.cc

+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/libphonenumber/cpp/src/regexp_adapter.h"
+
+// Setup all of the Chromium and WebKit defines

[Mark Mentovai, 2011/04/27 16:53:01]

“Set up” as a verb is two words.

[GeorgeY, 2011/04/28 07:21:18]

Fixed

+#include <build/build_config.h>

[Mark Mentovai, 2011/04/27 16:53:01]

These should all be "…" includes, not <…> includes. Only use <…> for system
headers like <stdio.h> and <vector>. Because these aren’t system includes, you
should put them in the same section as the base includes below.

[GeorgeY, 2011/04/28 07:21:18]

Yes, I used their style while the file was in their subfolder, now that I moved
it to separate folder I forgot to fix it. Fixed now.

+#include <unicode/regex.h>
+#include <unicode/stringpiece.h>
+#include <unicode/unistr.h>
+
+#include "base/logging.h"
+#include "base/scoped_ptr.h"
+
+namespace {
+
+// Converts |source| to utf8 string, returns it.

[Mark Mentovai, 2011/04/27 16:53:01]

“to a UTF-8 string.”

This comment is silent on what |pos| is used for.

[GeorgeY, 2011/04/28 07:21:18]

Done.

+std::string UnicodeStringToUtf8String(icu::UnicodeString const& source,
+                                      int pos) {

[Mark Mentovai, 2011/04/27 16:53:01]

This looks like it would have fit on the preceding line.

[GeorgeY, 2011/04/28 07:21:18]

Nope, short by two characters.

+  std::string data;
+  source.toUTF8String<std::string>(data);
+  return data.substr(pos);
+}
+
+}  // namespace
+
+// Implementation of the abstract classes RegularExpressionInput and
+// RegularExpression using ICU regular expression capabilities.
+
+// The reg exp input class.

[Mark Mentovai, 2011/04/27 16:53:01]

Don’t abbreviate. Regular expression.

[GeorgeY, 2011/04/28 07:21:18]

Done.

+class IcuRegularExpressionInput : public reg_exp::RegularExpressionInput {
+ public:
+  explicit IcuRegularExpressionInput(const char* utf8_input);
+
+  // RegularExpressionInput implementation:
+  // Matches string to regular expression, returns true if expression was
+  // matched, false otherwise, advances position in the match.
+  // |reg_exp| - expression to be matched.
+  // |beginning_only| - if true match would be successfull only if appears at
+  // the beginning of the tested region of the string.
+  // |matched_string1| - successfully matched first string. Can be NULL.
+  // |matched_string2| - successfully matched second string. Can be NULL.
+  virtual bool ConsumeRegExp(std::string const& reg_exp,
+                             bool beginning_only,
+                             std::string* matched_string1,
+                             std::string* matched_string2);
+
+  // Convert unmatched input to a string.
+  virtual std::string ToString() const;
+
+  icu::UnicodeString* Data() { return &utf8_input_; }
+
+  // Position in the input. For the newly created input position is 0,
+  // each call to ConsumeRegExp() or RegularExpression::Consume() advances
+  // position in the case of the successful match to be after the match.
+  int pos() const { return pos_; }
+  void set_pos(int pos) { pos_ = pos; }
+
+ private:
+  icu::UnicodeString utf8_input_;
+  int pos_;
+
+  DISALLOW_COPY_AND_ASSIGN(IcuRegularExpressionInput);
+};
+
+// The regular expression class.
+class IcuRegularExpression : public reg_exp::RegularExpression {
+ public:
+  explicit IcuRegularExpression(const char* utf8_regexp);
+
+  // RegularExpression implementation:
+  // Matches string to regular expression, returns true if expression was
+  // matched, false otherwise, advances position in the match.
+  // |input_string| - string to be searched.
+  // |beginning_only| - if true match would be successfull only if appears at
+  // the beginning of the tested region of the string.
+  // |matched_string1| - successfully matched first string. Can be NULL.
+  // |matched_string2| - successfully matched second string. Can be NULL.
+  virtual bool Consume(reg_exp::RegularExpressionInput* input_string,
+                       bool beginning_only,
+                       std::string* matched_string1,
+                       std::string* matched_string2) const;
+
+  // Matches string to regular expression, returns true if expression was
+  // matched, false otherwise.
+  // |input_string| - string to be searched.
+  // |full_match| - if true match would be successfull only if it matches the
+  // complete string.
+  // |matched_string| - successfully matched string. Can be NULL.
+  virtual bool Match(const char* input_string,
+                     bool full_match,
+                     std::string* matched_string) const;
+
+  // Replaces match(es) in the |string_to_process|. if |global| is true,
+  // replaces all the matches, only the first match otherwise.
+  // |replacement_string| - text the matches are replaced with.
+  // Returns true if expression successfully processed through the string,
+  // even if no actual replacements were made. Returns false in case of an
+  // error.
+  virtual bool Replace(std::string* string_to_process,
+                       bool global,
+                       const char* replacement_string) const;
+ private:
+  scoped_ptr<icu::RegexPattern> utf8_regexp_;
+
+  DISALLOW_COPY_AND_ASSIGN(IcuRegularExpression);
+};
+
+IcuRegularExpressionInput::IcuRegularExpressionInput(
+    const char* utf8_input)

[Mark Mentovai, 2011/04/27 16:53:01]

This looks like it would fit on the preceding line.

[GeorgeY, 2011/04/28 07:21:18]

Done.

+    : pos_(0) {
+  DCHECK(utf8_input);
+  utf8_input_ = icu::UnicodeString::fromUTF8(utf8_input);
+}
+
+bool IcuRegularExpressionInput::ConsumeRegExp(std::string const& reg_exp,
+                                              bool beginning_only,
+                                              std::string* matched_string1,
+                                              std::string* matched_string2) {
+  IcuRegularExpression re(reg_exp.c_str());
+
+  return re.Consume(this, beginning_only, matched_string1, matched_string2);
+}
+
+std::string IcuRegularExpressionInput::ToString() const {
+  if (pos_ < 0 || pos_ > utf8_input_.length())
+    return std::string();
+  return UnicodeStringToUtf8String(utf8_input_, pos_);
+}
+
+IcuRegularExpression::IcuRegularExpression(const char* utf8_regexp) {
+  DCHECK(utf8_regexp);
+  UParseError pe;
+  UErrorCode status = U_ZERO_ERROR;
+  utf8_regexp_.reset(icu::RegexPattern::compile(
+      icu::UnicodeString::fromUTF8(utf8_regexp), 0, pe, status));
+  if (U_FAILURE(status)) {
+    // All of the passed Regular expressions should compile correctly.

[Mark Mentovai, 2011/04/27 16:53:01]

Lowercase r.

[GeorgeY, 2011/04/28 07:21:18]

Done.

+    utf8_regexp_.reset(NULL);
+    NOTREACHED();
+  }
+}
+
+bool IcuRegularExpression::Consume(
+    reg_exp::RegularExpressionInput* input_string,
+    bool beginning_only,
+    std::string* matched_string1,
+    std::string* matched_string2) const {
+  DCHECK(input_string);
+  // matched_string1 may be NULL
+  // matched_string2 may be NULL
+  if (!utf8_regexp_.get())
+    return false;
+
+  IcuRegularExpressionInput* input =
+      reinterpret_cast<IcuRegularExpressionInput *>(input_string);
+  UErrorCode status = U_ZERO_ERROR;
+  scoped_ptr<icu::RegexMatcher> matcher(utf8_regexp_->matcher(*(input->Data()),
+                                                              status));
+
+  if (U_FAILURE(status))
+    return false;
+
+  if (beginning_only) {
+    if (!matcher->lookingAt(input->pos(), status))
+      return false;
+  } else {
+    if (!matcher->find(input->pos(), status))
+      return false;
+  }
+  if (U_FAILURE(status))
+    return false;
+  // If less matches than expected - fail.
+  if ((matched_string2 && matcher->groupCount() < 2) ||
+      (matched_string1 && matcher->groupCount() < 1)) {
+    return false;
+  }
+  if (matcher->groupCount() > 0 && matched_string1) {
+    *matched_string1 = UnicodeStringToUtf8String(matcher->group(1, status), 0);
+  }
+  if (matcher->groupCount() > 1 && matched_string2) {
+    *matched_string2 = UnicodeStringToUtf8String(matcher->group(2, status), 0);
+  }
+  input->set_pos(matcher->end(status));
+  return true;
+}
+
+bool IcuRegularExpression::Match(const char* input_string,
+                                 bool full_match,
+                                 std::string* matched_string) const {
+  DCHECK(input_string);
+  // matched_string may be NULL
+  if (!utf8_regexp_.get())
+    return false;
+
+  IcuRegularExpressionInput input(input_string);
+  UErrorCode status = U_ZERO_ERROR;
+  scoped_ptr<icu::RegexMatcher> matcher(utf8_regexp_->matcher(*(input.Data()),
+                                                              status));
+
+  if (U_FAILURE(status))
+    return false;
+
+  if (full_match) {
+    if (!matcher->matches(input.pos(), status))
+      return false;
+  } else {
+    if (!matcher->find(input.pos(), status))
+      return false;
+  }
+  if (U_FAILURE(status))
+    return false;
+  if (matcher->groupCount() > 0 && matched_string) {
+    *matched_string = UnicodeStringToUtf8String(matcher->group(1, status), 0);
+  }
+  return true;
+}
+
+bool IcuRegularExpression::Replace(std::string* string_to_process,
+                                   bool global,
+                                   const char* replacement_string) const {
+  DCHECK(string_to_process);
+  DCHECK(replacement_string);
+
+  std::string adapted_replacement(replacement_string);
+  // Adapt replacement string from RE2 (\0-9 for matches) format to ICU format
+  // ($0-9 for matches). All '$' should be pre-pended with '\' as well.

[Mark Mentovai, 2011/04/27 16:53:01]

prepended (no hyphen).

[GeorgeY, 2011/04/28 07:21:18]

Tell it to VS spell-checker :). Fixed.

+  size_t backslash_pos = adapted_replacement.find('\\');
+  size_t dollar_pos = adapted_replacement.find('$');
+  while (backslash_pos != std::string::npos ||
+         dollar_pos != std::string::npos) {
+    bool process_dollar = false;
+    if (backslash_pos == std::string::npos ||
+        (dollar_pos != std::string::npos && dollar_pos < backslash_pos)) {
+      process_dollar = true;
+    }
+    if (process_dollar) {
+      adapted_replacement.insert(dollar_pos, "\\");
+      dollar_pos = adapted_replacement.find('$', dollar_pos + 2);
+      if (backslash_pos != std::string::npos)
+        ++backslash_pos;
+    } else {
+      if (adapted_replacement.length() > backslash_pos + 1) {
+        if (adapted_replacement[backslash_pos + 1] >= '0' &&
+            adapted_replacement[backslash_pos + 1] <= '9') {
+          adapted_replacement[backslash_pos] = '$';
+        }
+        if (adapted_replacement[backslash_pos + 1] == '\\') {
+          // Skip two characters instead of one.
+          ++backslash_pos;
+        }
+      }
+      backslash_pos = adapted_replacement.find('\\', backslash_pos + 1);
+    }
+  }
+
+  IcuRegularExpressionInput input(string_to_process->c_str());
+  UErrorCode status = U_ZERO_ERROR;
+  scoped_ptr<icu::RegexMatcher> matcher(utf8_regexp_->matcher(*(input.Data()),
+                                                              status));
+  if (U_FAILURE(status))
+    return false;
+
+  icu::UnicodeString result;
+
+  if (global) {
+    result = matcher->replaceAll(
+        icu::UnicodeString::fromUTF8(adapted_replacement),
+        status);
+  } else {
+    result = matcher->replaceFirst(
+        icu::UnicodeString::fromUTF8(adapted_replacement),
+        status);
+  }
+  if (U_FAILURE(status))
+    return false;
+  *string_to_process = UnicodeStringToUtf8String(result, 0);
+  return true;
+}
+
+
+namespace reg_exp {
+
+RegularExpressionInput* CreateRegularExpressionInput(const char* utf8_input) {
+  return new IcuRegularExpressionInput(utf8_input);
+}
+
+RegularExpression* CreateRegularExpression(const char* utf8_regexp) {
+  return new IcuRegularExpression(utf8_regexp);
+}
+
+}  // namespace reg_exp
+

[Mark Mentovai, 2011/04/27 16:53:01]

This blank line isn’t necessary.

[GeorgeY, 2011/04/28 07:21:18]

It is, otherwise Lint would report the lack of the line as an error.

[Mark Mentovai, 2011/04/28 14:27:03]

GeorgeY wrote:
lint reports an error if the last line in the file doesn’t have an LF at the end
of it. In other words, if there’s anything at all in the file, it needs to end
in an LF.

This file ends in two LFs, meaning that you have a blank line at EOF. lint
doesn’t require that.

[GeorgeY, 2011/05/02 23:36:59]

Apparently Lint does require empty line at the end - removing it produces the
following error:
+} // namespace reg_exp
Could not find a newline character at the end of the file.

Oh, and other files *do* have it.