Class: RE2::Regexp

Inherits:
Object
  • Object
show all
Defined in:
ext/re2/re2.cc

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(pattern) ⇒ RE2::Regexp #initialize(pattern, options) ⇒ RE2::Regexp

Returns a new RE2::Regexp object with a compiled version of pattern stored inside.

Overloads:

  • #initialize(pattern) ⇒ RE2::Regexp

    Returns a new RE2::Regexp object with a compiled version of pattern stored inside with the default options.

    Parameters:

    • pattern (String) —

      the pattern to compile

    Raises:

    • (NoMemoryError) —

      if memory could not be allocated for the compiled pattern

  • #initialize(pattern, options) ⇒ RE2::Regexp

    Returns a new RE2::Regexp object with a compiled version of pattern stored inside with the specified options.

    Parameters:

    • pattern (String) —

      the pattern to compile

    • options (Hash) —

      the options with which to compile the pattern

    Options Hash (options):

    • :utf8 (Boolean) — default: true —

      text and pattern are UTF-8; otherwise Latin-1

    • :posix_syntax (Boolean) — default: false —

      restrict regexps to POSIX egrep syntax

    • :longest_match (Boolean) — default: false —

      search for longest match, not first match

    • :log_errors (Boolean) — default: true —

      log syntax and execution errors to ERROR

    • :max_mem (Fixnum) —

      approx. max memory footprint of RE2

    • :literal (Boolean) — default: false —

      interpret string as literal, not regexp

    • :never_nl (Boolean) — default: false —

      never match \n, even if it is in regexp

    • :case_sensitive (Boolean) — default: true —

      match is case-sensitive (regexp can override with (?i) unless in posix_syntax mode)

    • :perl_classes (Boolean) — default: false —

      allow Perl’s \d \s \w D S W when in posix_syntax mode

    • :word_boundary (Boolean) — default: false —

      allow \b B (word boundary and not) when in posix_syntax mode

    • :one_line (Boolean) — default: false —

      ^ and $ only match beginning and end of text when in posix_syntax mode

    Raises:

    • (NoMemoryError) —

      if memory could not be allocated for the compiled pattern



669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
 
# File 'ext/re2/re2.cc', line 669

static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
  VALUE pattern, options, utf8, posix_syntax, longest_match, log_errors,
        max_mem, literal, never_nl, case_sensitive, perl_classes,
        word_boundary, one_line;
  re2_pattern *p;

  rb_scan_args(argc, argv, "11", &pattern, &options);
  Data_Get_Struct(self, re2_pattern, p);

  if (RTEST(options)) {
    if (TYPE(options) != T_HASH) {
      rb_raise(rb_eArgError, "options should be a hash");
    }

    RE2::Options re2_options;

    utf8 = rb_hash_aref(options, ID2SYM(id_utf8));
    if (!NIL_P(utf8)) {
      re2_options.set_encoding(RTEST(utf8) ? RE2::Options::EncodingUTF8 : RE2::Options::EncodingLatin1);
    }

    posix_syntax = rb_hash_aref(options, ID2SYM(id_posix_syntax));
    if (!NIL_P(posix_syntax)) {
      re2_options.set_posix_syntax(RTEST(posix_syntax));
    }

    longest_match = rb_hash_aref(options, ID2SYM(id_longest_match));
    if (!NIL_P(longest_match)) {
      re2_options.set_longest_match(RTEST(longest_match));
    }

    log_errors = rb_hash_aref(options, ID2SYM(id_log_errors));
    if (!NIL_P(log_errors)) {
      re2_options.set_log_errors(RTEST(log_errors));
    }

    max_mem = rb_hash_aref(options, ID2SYM(id_max_mem));
    if (!NIL_P(max_mem)) {
      re2_options.set_max_mem(NUM2INT(max_mem));
    }

    literal = rb_hash_aref(options, ID2SYM(id_literal));
    if (!NIL_P(literal)) {
      re2_options.set_literal(RTEST(literal));
    }

    never_nl = rb_hash_aref(options, ID2SYM(id_never_nl));
    if (!NIL_P(never_nl)) {
      re2_options.set_never_nl(RTEST(never_nl));
    }

    case_sensitive = rb_hash_aref(options, ID2SYM(id_case_sensitive));
    if (!NIL_P(case_sensitive)) {
      re2_options.set_case_sensitive(RTEST(case_sensitive));
    }

    perl_classes = rb_hash_aref(options, ID2SYM(id_perl_classes));
    if (!NIL_P(perl_classes)) {
      re2_options.set_perl_classes(RTEST(perl_classes));
    }

    word_boundary = rb_hash_aref(options, ID2SYM(id_word_boundary));
    if (!NIL_P(word_boundary)) {
      re2_options.set_word_boundary(RTEST(word_boundary));
    }

    one_line = rb_hash_aref(options, ID2SYM(id_one_line));
    if (!NIL_P(one_line)) {
      re2_options.set_one_line(RTEST(one_line));
    }

    p->pattern = new(nothrow) RE2(StringValuePtr(pattern), re2_options);
  } else {
    p->pattern = new(nothrow) RE2(StringValuePtr(pattern));
  }

  if (p->pattern == 0) {
    rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
  }

  return self;
}

Class Method Details

.compile ⇒ Object

.escape(unquoted) ⇒ String

Returns a version of str with all potentially meaningful regexp characters escaped. The returned string, used as a regular expression, will exactly match the original string.

Examples:

RE2::Regexp.escape("1.5-2.0?")    #=> "1\.5\-2\.0\?"

Parameters:

  • unquoted (String) —

    the unquoted string

Returns:

  • (String) —

    the escaped string



1344
1345
1346
1347
1348
 
# File 'ext/re2/re2.cc', line 1344

static VALUE re2_QuoteMeta(VALUE self, VALUE unquoted) {
  UNUSED(self);
  string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
  return rb_str_new(quoted_string.data(), quoted_string.size());
}

.quote(unquoted) ⇒ String

Returns a version of str with all potentially meaningful regexp characters escaped. The returned string, used as a regular expression, will exactly match the original string.

Examples:

RE2::Regexp.escape("1.5-2.0?")    #=> "1\.5\-2\.0\?"

Parameters:

  • unquoted (String) —

    the unquoted string

Returns:

  • (String) —

    the escaped string



1344
1345
1346
1347
1348
 
# File 'ext/re2/re2.cc', line 1344

static VALUE re2_QuoteMeta(VALUE self, VALUE unquoted) {
  UNUSED(self);
  string quoted_string = RE2::QuoteMeta(StringValuePtr(unquoted));
  return rb_str_new(quoted_string.data(), quoted_string.size());
}

Instance Method Details

#===(text) ⇒ Boolean

Returns true or false to indicate a successful match. Equivalent to re2.match(text, 0).

Returns:

  • (Boolean) —

    whether the match was successful



1228
1229
1230
1231
1232
1233
1234
 
# File 'ext/re2/re2.cc', line 1228

static VALUE re2_regexp_match_query(VALUE self, VALUE text) {
  VALUE argv[2];
  argv[0] = text;
  argv[1] = INT2FIX(0);

  return re2_regexp_match(2, argv, self);
}

#=~(text) ⇒ Boolean

Returns true or false to indicate a successful match. Equivalent to re2.match(text, 0).

Returns:

  • (Boolean) —

    whether the match was successful



1228
1229
1230
1231
1232
1233
1234
 
# File 'ext/re2/re2.cc', line 1228

static VALUE re2_regexp_match_query(VALUE self, VALUE text) {
  VALUE argv[2];
  argv[0] = text;
  argv[1] = INT2FIX(0);

  return re2_regexp_match(2, argv, self);
}

#case_insensitive? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the case_sensitive option set to false.

Examples:

re2 = RE2::Regexp.new("woo?", :case_sensitive => true)
re2.case_insensitive?    #=> false
re2.casefold?    #=> false

Returns:

  • (Boolean) —

    the inverse of the case_sensitive option



936
937
938
 
# File 'ext/re2/re2.cc', line 936

static VALUE re2_regexp_case_insensitive(VALUE self) {
  return BOOL2RUBY(re2_regexp_case_sensitive(self) != Qtrue);
}

#case_sensitive? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the case_sensitive option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :case_sensitive => true)
re2.case_sensitive?    #=> true

Returns:

  • (Boolean) —

    the case_sensitive option



920
921
922
923
924
 
# File 'ext/re2/re2.cc', line 920

static VALUE re2_regexp_case_sensitive(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().case_sensitive());
}

#casefold? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the case_sensitive option set to false.

Examples:

re2 = RE2::Regexp.new("woo?", :case_sensitive => true)
re2.case_insensitive?    #=> false
re2.casefold?    #=> false

Returns:

  • (Boolean) —

    the inverse of the case_sensitive option



936
937
938
 
# File 'ext/re2/re2.cc', line 936

static VALUE re2_regexp_case_insensitive(VALUE self) {
  return BOOL2RUBY(re2_regexp_case_sensitive(self) != Qtrue);
}

#error ⇒ String?

If the RE2 could not be created properly, returns an error string otherwise returns nil.

Returns:

  • (String, nil) —

    the error string or nil



991
992
993
994
995
996
997
998
999
 
# File 'ext/re2/re2.cc', line 991

static VALUE re2_regexp_error(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  if (p->pattern->ok()) {
    return Qnil;
  } else {
    return rb_str_new(p->pattern->error().data(), p->pattern->error().size());
  }
}

#error_arg ⇒ String?

If the RE2 could not be created properly, returns the offending portion of the regexp otherwise returns nil.

Returns:

  • (String, nil) —

    the offending portion of the regexp or nil



1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
 
# File 'ext/re2/re2.cc', line 1007

static VALUE re2_regexp_error_arg(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  if (p->pattern->ok()) {
    return Qnil;
  } else {
    return ENCODED_STR_NEW(p->pattern->error_arg().data(),
        p->pattern->error_arg().size(),
        p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
  }
}

#inspect ⇒ String

Returns a printable version of the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.inspect    #=> "#<RE2::Regexp /woo?/>"

Returns:

  • (String) —

    a printable version of the regular expression



760
761
762
763
764
765
766
767
768
769
770
771
772
773
 
# File 'ext/re2/re2.cc', line 760

static VALUE re2_regexp_inspect(VALUE self) {
  re2_pattern *p;
  VALUE result;
  ostringstream output;

  Data_Get_Struct(self, re2_pattern, p);

  output << "#<RE2::Regexp /" << p->pattern->pattern() << "/>";

  result = ENCODED_STR_NEW(output.str().data(), output.str().length(),
      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");

  return result;
}

#literal? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the literal option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :literal => true)
re2.literal?    #=> true

Returns:

  • (Boolean) —

    the literal option



890
891
892
893
894
 
# File 'ext/re2/re2.cc', line 890

static VALUE re2_regexp_literal(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().literal());
}

#log_errors? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the log_errors option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :log_errors => true)
re2.log_errors?    #=> true

Returns:

  • (Boolean) —

    the log_errors option



860
861
862
863
864
 
# File 'ext/re2/re2.cc', line 860

static VALUE re2_regexp_log_errors(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().log_errors());
}

#longest_match? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the longest_match option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :longest_match => true)
re2.longest_match?    #=> true

Returns:

  • (Boolean) —

    the longest_match option



845
846
847
848
849
 
# File 'ext/re2/re2.cc', line 845

static VALUE re2_regexp_longest_match(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().longest_match());
}

#match(text) ⇒ RE2::MatchData #match(text, 0) ⇒ Boolean #match(text, number_of_matches) ⇒ RE2::MatchData

Match the pattern against the given text and return either a boolean (if no submatches are required) or a MatchData instance.

Overloads:

  • #match(text) ⇒ RE2::MatchData

    Returns an MatchData containing the matching pattern and all subpatterns resulting from looking for the regexp in text.

    Examples:

    r = RE2::Regexp.new('w(o)(o)')
r.match('woo')    #=> #<RE2::MatchData "woo" 1:"o" 2:"o">

    Parameters:

    • text (String) —

      the text to search

    Returns:

    Raises:

    • (NoMemoryError) —

      if there was not enough memory to allocate the matches

  • #match(text, 0) ⇒ Boolean

    Returns either true or false indicating whether a successful match was made.

    Examples:

    r = RE2::Regexp.new('w(o)(o)')
r.match('woo', 0) #=> true
r.match('bob', 0) #=> false

    Parameters:

    • text (String) —

      the text to search

    Returns:

    • (Boolean) —

      whether the match was successful

    Raises:

    • (NoMemoryError) —

      if there was not enough memory to allocate the matches

  • #match(text, number_of_matches) ⇒ RE2::MatchData

    See match(text) but with a specific number of matches returned (padded with nils if necessary).

    Examples:

    r = RE2::Regexp.new('w(o)(o)')
r.match('woo', 1) #=> #<RE2::MatchData "woo" 1:"o">
r.match('woo', 3) #=> #<RE2::MatchData "woo" 1:"o" 2:"o" 3:nil>

    Parameters:

    • text (String) —

      the text to search

    • number_of_matches (Fixnum) —

      the number of matches to return

    Returns:

    Raises:

    • (NoMemoryError) —

      if there was not enough memory to allocate the matches

Returns:



1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
 
# File 'ext/re2/re2.cc', line 1167

static VALUE re2_regexp_match(int argc, VALUE *argv, VALUE self) {
  int n;
  bool matched;
  re2_pattern *p;
  re2_matchdata *m;
  VALUE text, number_of_matches, matchdata;

  rb_scan_args(argc, argv, "11", &text, &number_of_matches);

  /* Ensure text is a string. */
  text = StringValue(text);

  Data_Get_Struct(self, re2_pattern, p);

  if (RTEST(number_of_matches)) {
    n = NUM2INT(number_of_matches);
  } else {
    n = p->pattern->NumberOfCapturingGroups();
  }

  if (n == 0) {
    matched = match(p->pattern, StringValuePtr(text), 0,
        static_cast<int>(RSTRING_LEN(text)), RE2::UNANCHORED, 0, 0);
    return BOOL2RUBY(matched);
  } else {

    /* Because match returns the whole match as well. */
    n += 1;

    matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
    Data_Get_Struct(matchdata, re2_matchdata, m);
    m->matches = new(nothrow) re2::StringPiece[n];
    m->regexp = self;
    m->text = rb_str_dup(text);
    rb_str_freeze(m->text);

    if (m->matches == 0) {
      rb_raise(rb_eNoMemError,
               "not enough memory to allocate StringPieces for matches");
    }

    m->number_of_matches = n;

    matched = match(p->pattern, StringValuePtr(m->text), 0,
                    static_cast<int>(RSTRING_LEN(m->text)),
                    RE2::UNANCHORED, m->matches, n);

    if (matched) {
      return matchdata;
    } else {
      return Qnil;
    }
  }
}

#match?(text) ⇒ Boolean

Returns true or false to indicate a successful match. Equivalent to re2.match(text, 0).

Returns:

  • (Boolean) —

    whether the match was successful



1228
1229
1230
1231
1232
1233
1234
 
# File 'ext/re2/re2.cc', line 1228

static VALUE re2_regexp_match_query(VALUE self, VALUE text) {
  VALUE argv[2];
  argv[0] = text;
  argv[1] = INT2FIX(0);

  return re2_regexp_match(2, argv, self);
}

#max_mem ⇒ Fixnum

Returns the max_mem setting for the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?", :max_mem => 1024)
re2.max_mem    #=> 1024

Returns:

  • (Fixnum) —

    the max_mem option



875
876
877
878
879
 
# File 'ext/re2/re2.cc', line 875

static VALUE re2_regexp_max_mem(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return INT2FIX(p->pattern->options().max_mem());
}

#named_capturing_groups ⇒ Hash

Returns a hash of names to capturing indices of groups.

Returns:

  • (Hash) —

    a hash of names to capturing indices



1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
 
# File 'ext/re2/re2.cc', line 1103

static VALUE re2_regexp_named_capturing_groups(VALUE self) {
  VALUE capturing_groups;
  re2_pattern *p;
  map<string, int> groups;
  map<string, int>::iterator iterator;

  Data_Get_Struct(self, re2_pattern, p);
  groups = p->pattern->NamedCapturingGroups();
  capturing_groups = rb_hash_new();

  for (iterator = groups.begin(); iterator != groups.end(); iterator++) {
    rb_hash_aset(capturing_groups,
        ENCODED_STR_NEW(iterator->first.data(), iterator->first.size(),
          p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1"),
        INT2FIX(iterator->second));
  }

  return capturing_groups;
}

#never_nl? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the never_nl option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :never_nl => true)
re2.never_nl?    #=> true

Returns:

  • (Boolean) —

    the never_nl option



905
906
907
908
909
 
# File 'ext/re2/re2.cc', line 905

static VALUE re2_regexp_never_nl(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().never_nl());
}

#number_of_capturing_groups ⇒ Fixnum

Returns the number of capturing subpatterns, or -1 if the regexp wasn’t valid on construction. The overall match ($0) does not count: if the regexp is “(a)(b)”, returns 2.

Returns:

  • (Fixnum) —

    the number of capturing subpatterns



1091
1092
1093
1094
1095
1096
 
# File 'ext/re2/re2.cc', line 1091

static VALUE re2_regexp_number_of_capturing_groups(VALUE self) {
  re2_pattern *p;

  Data_Get_Struct(self, re2_pattern, p);
  return INT2FIX(p->pattern->NumberOfCapturingGroups());
}

#ok? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled successfully or not.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.ok?    #=> true

Returns:

  • (Boolean) —

    whether or not compilation was successful



800
801
802
803
804
 
# File 'ext/re2/re2.cc', line 800

static VALUE re2_regexp_ok(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->ok());
}

#one_line? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the one_line option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :one_line => true)
re2.one_line?    #=> true

Returns:

  • (Boolean) —

    the one_line option



979
980
981
982
983
 
# File 'ext/re2/re2.cc', line 979

static VALUE re2_regexp_one_line(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().one_line());
}

#options ⇒ Hash

Returns a hash of the options currently set for re2.

Returns:

  • (Hash) —

    the options



1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
 
# File 'ext/re2/re2.cc', line 1038

static VALUE re2_regexp_options(VALUE self) {
  VALUE options;
  re2_pattern *p;

  Data_Get_Struct(self, re2_pattern, p);
  options = rb_hash_new();

  rb_hash_aset(options, ID2SYM(id_utf8),
      BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8));

  rb_hash_aset(options, ID2SYM(id_posix_syntax),
      BOOL2RUBY(p->pattern->options().posix_syntax()));

  rb_hash_aset(options, ID2SYM(id_longest_match),
      BOOL2RUBY(p->pattern->options().longest_match()));

  rb_hash_aset(options, ID2SYM(id_log_errors),
      BOOL2RUBY(p->pattern->options().log_errors()));

  rb_hash_aset(options, ID2SYM(id_max_mem),
      INT2FIX(p->pattern->options().max_mem()));

  rb_hash_aset(options, ID2SYM(id_literal),
      BOOL2RUBY(p->pattern->options().literal()));

  rb_hash_aset(options, ID2SYM(id_never_nl),
      BOOL2RUBY(p->pattern->options().never_nl()));

  rb_hash_aset(options, ID2SYM(id_case_sensitive),
      BOOL2RUBY(p->pattern->options().case_sensitive()));

  rb_hash_aset(options, ID2SYM(id_perl_classes),
      BOOL2RUBY(p->pattern->options().perl_classes()));

  rb_hash_aset(options, ID2SYM(id_word_boundary),
      BOOL2RUBY(p->pattern->options().word_boundary()));

  rb_hash_aset(options, ID2SYM(id_one_line),
      BOOL2RUBY(p->pattern->options().one_line()));

  /* This is a read-only hash after all... */
  rb_obj_freeze(options);

  return options;
}

#pattern ⇒ String

Returns a string version of the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.to_s    #=> "woo?"

Returns:

  • (String) —

    a string version of the regular expression



783
784
785
786
787
788
789
 
# File 'ext/re2/re2.cc', line 783

static VALUE re2_regexp_to_s(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return ENCODED_STR_NEW(p->pattern->pattern().data(),
      p->pattern->pattern().size(),
      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
}

#perl_classes? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the perl_classes option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :perl_classes => true)
re2.perl_classes?    #=> true

Returns:

  • (Boolean) —

    the perl_classes option



949
950
951
952
953
 
# File 'ext/re2/re2.cc', line 949

static VALUE re2_regexp_perl_classes(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().perl_classes());
}

#posix_syntax? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the posix_syntax option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :posix_syntax => true)
re2.posix_syntax?    #=> true

Returns:

  • (Boolean) —

    the posix_syntax option



830
831
832
833
834
 
# File 'ext/re2/re2.cc', line 830

static VALUE re2_regexp_posix_syntax(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().posix_syntax());
}

#program_size ⇒ Fixnum

Returns the program size, a very approximate measure of a regexp’s “cost”. Larger numbers are more expensive than smaller numbers.

Returns:

  • (Fixnum) —

    the regexp “cost”



1026
1027
1028
1029
1030
 
# File 'ext/re2/re2.cc', line 1026

static VALUE re2_regexp_program_size(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return INT2FIX(p->pattern->ProgramSize());
}

#scan(text) ⇒ Object

Returns a Scanner for scanning the given text incrementally.

Examples:

c = RE2::Regexp.new('(\w+)').scan("Foo bar baz")



1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
 
# File 'ext/re2/re2.cc', line 1242

static VALUE re2_regexp_scan(VALUE self, VALUE text) {
  re2_pattern *p;
  re2_scanner *c;
  VALUE scanner;

  Data_Get_Struct(self, re2_pattern, p);
  scanner = rb_class_new_instance(0, 0, re2_cScanner);
  Data_Get_Struct(scanner, re2_scanner, c);

  c->input = new(nothrow) re2::StringPiece(StringValuePtr(text));
  c->regexp = self;
  c->text = text;
  c->number_of_capturing_groups = p->pattern->NumberOfCapturingGroups();
  c->eof = false;

  return scanner;
}

#source ⇒ String

Returns a string version of the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.to_s    #=> "woo?"

Returns:

  • (String) —

    a string version of the regular expression



783
784
785
786
787
788
789
 
# File 'ext/re2/re2.cc', line 783

static VALUE re2_regexp_to_s(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return ENCODED_STR_NEW(p->pattern->pattern().data(),
      p->pattern->pattern().size(),
      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
}

#to_s ⇒ String

Returns a string version of the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.to_s    #=> "woo?"

Returns:

  • (String) —

    a string version of the regular expression



783
784
785
786
787
788
789
 
# File 'ext/re2/re2.cc', line 783

static VALUE re2_regexp_to_s(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return ENCODED_STR_NEW(p->pattern->pattern().data(),
      p->pattern->pattern().size(),
      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
}

#to_str ⇒ String

Returns a string version of the regular expression re2.

Examples:

re2 = RE2::Regexp.new("woo?")
re2.to_s    #=> "woo?"

Returns:

  • (String) —

    a string version of the regular expression



783
784
785
786
787
788
789
 
# File 'ext/re2/re2.cc', line 783

static VALUE re2_regexp_to_s(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return ENCODED_STR_NEW(p->pattern->pattern().data(),
      p->pattern->pattern().size(),
      p->pattern->options().encoding() == RE2::Options::EncodingUTF8 ? "UTF-8" : "ISO-8859-1");
}

#utf8? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the utf8 option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :utf8 => true)
re2.utf8?    #=> true

Returns:

  • (Boolean) —

    the utf8 option



815
816
817
818
819
 
# File 'ext/re2/re2.cc', line 815

static VALUE re2_regexp_utf8(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
}

#word_boundary? ⇒ Boolean

Returns whether or not the regular expression re2 was compiled with the word_boundary option set to true.

Examples:

re2 = RE2::Regexp.new("woo?", :word_boundary => true)
re2.word_boundary?    #=> true

Returns:

  • (Boolean) —

    the word_boundary option



964
965
966
967
968
 
# File 'ext/re2/re2.cc', line 964

static VALUE re2_regexp_word_boundary(VALUE self) {
  re2_pattern *p;
  Data_Get_Struct(self, re2_pattern, p);
  return BOOL2RUBY(p->pattern->options().word_boundary());
}