oniguruma 0.9.0

data/History.txt

@@ -0,0 +1,5 @@
+== 1.0.0 / 2007-03-19
+
+* 1 major enhancement
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/oniguruma.rb
+ext/oregexp.c
+test/test_oniguruma.rb

data/README.txt

@@ -0,0 +1,65 @@
+== ONIGURUMA FOR RUBY:
+
+Ruby bindings to the Oniguruma[http://www.geocities.jp/kosako3/oniguruma/] regular expression library (no need to recompile Ruby).
+
+== FEATURES:
+  
+* Increased performance. 
+* Same interface than standard Regexp class (easy transition!). 
+* Support for named groups, look-ahead, look-behind, and other 
+  cool features!
+
+== SYNOPSIS:
+
+ reg = Oniguruma::ORegex.new( '(?<before>.*)(a)(?<after>.*)' )
+ match = reg.match( 'terraforming' )
+ puts match[0]         <= 'terraforming'
+ puts match[:before]   <= 'terr'
+ puts match[:after]    <= 'forming'
+
+== REQUIREMENTS:
+
+* Oniguruma[http://www.geocities.jp/kosako3/oniguruma/] library v. 2.0 or greater
+
+== INSTALL:
+
+sudo gem install -r oniguruma
+
+== BUGS/PROBLEMS/INCOMPATIBILITIES:
+
+* <code>ORegexp#~</code> is not implemented.
+* <code>ORegexp#kcode</code> results are not compatible with <code>Regexp</code>.
+* <code>ORegexp</code> options set in the string are not visible, this affects
+  <code>ORegexp#options</code>, <code>ORegexp#to_s</code>, <code>ORegexp#inspect</code>
+  and <code>ORegexp#==</code>.
+
+== TODO:
+
+* Complete documentation (methods, oniguruma syntax).
+
+== CREDITS:
+
+* K.Kosako, for his great library.
+* A lot of the documentation has been copied from the orininal Ruby Regex documentation.
+
+== LICENSE:
+
+New BSD License
+
+Copyright (c) 2007, Dizan Vasquez
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the 
+  documentation and/or other materials provided with the distribution.
+* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this 
+  software without specific prior written permission.
+            
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'hoe'
+
+class Hoe; def extra_deps; @extra_deps.reject { |x| Array(x).first == 'hoe' }; end end
+
+Hoe.new('oniguruma', '0.9.0') do |p|
+  p.rubyforge_name = 'oniguruma'
+  p.author = 'Dizan Vasquez'
+  p.email = 'dix_ans@yahoo.com'
+  p.summary = 'Bindings for the oniguruma regular expression library'
+  p.description = p.paragraphs_of('README.txt', 1 ).join('\n\n')
+  p.url = 'http://oniguruma.rubyforge.org'
+  p.spec_extras[:extensions] = ["ext/extconf.rb"]
+  p.rdoc_pattern = /^(lib|bin|ext)|txt$/
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+have_library("onig")
+create_makefile( "oregexp" )

data/ext/oregexp.c

@@ -0,0 +1,194 @@
+#include <ruby.h>
+#include <oniguruma.h>
+/*
+   TODO:
+      - Add named backreferences.
+*/
+
+typedef struct _oregexp {
+   regex_t * reg;
+} ORegexp;
+
+VALUE mOniguruma;
+VALUE nameHash;
+
+static void oregexp_free( ORegexp  * oregexp) {
+   onig_free( oregexp->reg );
+   free( oregexp );
+}
+
+static VALUE oregexp_allocate( VALUE klass ) {
+   ORegexp * oregexp = malloc( sizeof( ORegexp ) );
+   oregexp->reg = NULL;
+   return Data_Wrap_Struct( klass, 0, oregexp_free, oregexp );
+}
+
+
+static OnigEncodingType * int2encoding( int index ) {
+   switch( index ) {
+      case 0: return ONIG_ENCODING_ASCII;
+      case 1: return ONIG_ENCODING_ISO_8859_1;
+      case 2: return ONIG_ENCODING_ISO_8859_2;
+      case 3: return ONIG_ENCODING_ISO_8859_3;
+      case 4: return ONIG_ENCODING_ISO_8859_4;
+      case 5: return ONIG_ENCODING_ISO_8859_5;
+      case 6: return ONIG_ENCODING_ISO_8859_6;
+      case 7: return ONIG_ENCODING_ISO_8859_7;
+      case 8: return ONIG_ENCODING_ISO_8859_8;
+      case 9: return ONIG_ENCODING_ISO_8859_9;
+      case 10: return ONIG_ENCODING_ISO_8859_10;
+      case 11: return ONIG_ENCODING_ISO_8859_11;
+      case 12: return ONIG_ENCODING_ISO_8859_11;
+      case 13: return ONIG_ENCODING_ISO_8859_13;
+      case 14: return ONIG_ENCODING_ISO_8859_14;
+      case 15: return ONIG_ENCODING_ISO_8859_15;
+      case 16: return ONIG_ENCODING_ISO_8859_16;
+      case 17: return ONIG_ENCODING_UTF8;
+      case 18: return ONIG_ENCODING_UTF16_BE;
+      case 19: return ONIG_ENCODING_UTF16_LE;
+      case 20: return ONIG_ENCODING_UTF32_BE;
+      case 21: return ONIG_ENCODING_UTF32_LE;
+      case 22: return ONIG_ENCODING_EUC_JP;
+      case 23: return ONIG_ENCODING_EUC_TW;
+      case 24: return ONIG_ENCODING_EUC_KR;
+      case 25: return ONIG_ENCODING_EUC_CN;
+      case 26: return ONIG_ENCODING_SJIS;
+      /*case 27: return ONIG_ENCODING_KOI8;*/
+      case 28: return ONIG_ENCODING_KOI8_R;
+      case 29: return ONIG_ENCODING_CP1251;
+      case 30: return ONIG_ENCODING_BIG5;
+      case 31: return ONIG_ENCODING_GB18030;
+      case 32: return ONIG_ENCODING_UNDEF;
+   }
+   return ONIG_ENCODING_UNDEF;
+}
+
+static OnigSyntaxType * int2syntax( int index ) {
+   switch( index ) {
+      case 0: return ONIG_SYNTAX_ASIS;
+      case 1: return ONIG_SYNTAX_POSIX_BASIC;
+      case 2: return ONIG_SYNTAX_POSIX_EXTENDED;
+      case 3: return ONIG_SYNTAX_EMACS;
+      case 4: return ONIG_SYNTAX_GREP;
+      case 5: return ONIG_SYNTAX_GNU_REGEX;
+      case 6: return ONIG_SYNTAX_JAVA;
+      case 7: return ONIG_SYNTAX_PERL;
+      case 8: return ONIG_SYNTAX_PERL_NG;
+      case 9: return ONIG_SYNTAX_RUBY;
+      case 10: return ONIG_SYNTAX_DEFAULT;
+   }
+   return ONIG_SYNTAX_DEFAULT;
+}
+
+static int name_callback(
+   const UChar* name, 
+   const UChar* name_end,
+   int ngroup_num, 
+   int* group_nums,
+   regex_t* reg, 
+   void* arg
+) {
+   int i, gn, ref;
+   OnigRegion *region = (OnigRegion* )arg;
+
+   for (i = 0; i < ngroup_num; i++) {
+      gn = group_nums[i];
+      ref = onig_name_to_backref_number(reg, name, name_end, region);
+      if (ref != gn )
+         rb_raise(rb_eException, "Oniguruma Error: group and backreference names are different");
+      rb_hash_aset( nameHash, ID2SYM(rb_intern(name)), INT2FIX( gn ) );
+  }
+  return 0;  
+}
+
+static VALUE oregexp_initialize( VALUE self, VALUE pattern, VALUE options ) { 
+   ORegexp *oregexp;
+   Data_Get_Struct( self, ORegexp, oregexp );
+
+   VALUE pattern_str = StringValue( pattern );
+   rb_iv_set( self, "@pattern", pattern_str );
+   rb_iv_set( self, "@options", options );
+   UChar* pat_ptr = RSTRING(pattern_str)->ptr;
+   int pat_len = RSTRING(pattern_str)->len;
+
+   VALUE rOptions = rb_hash_aref( options, ID2SYM( rb_intern( "options" ) ) );
+   VALUE rEncoding = rb_hash_aref( options, ID2SYM( rb_intern( "encoding" ) ) );
+   VALUE rSyntax = rb_hash_aref( options, ID2SYM( rb_intern( "syntax" ) ) );
+   int iOptions = NUM2INT( rOptions );
+   int iEncoding = int2encoding( rEncoding );
+   int iSyntax = int2syntax( rSyntax );
+
+
+   int r;
+   OnigErrorInfo einfo;
+   r = onig_new(&(oregexp->reg), pat_ptr, pat_ptr + pat_len, iOptions, iEncoding, iSyntax, &einfo);
+   if (r != ONIG_NORMAL) {
+      char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+      onig_error_code_to_str(s, r, &einfo);
+      rb_raise(rb_eException, "Oniguruma Error: %s", s);
+   }
+   return self;
+}
+
+/*
+ *  call-seq:
+ *     rxp.match(str)   => matchdata or nil
+ *  
+ *  Returns a <code>MatchData</code> object describing the match, or
+ *  <code>nil</code> if there was no match. This is equivalent to retrieving the
+ *  value of the special variable <code>$~</code> following a normal match.
+ *     
+ *     /(.)(.)(.)/.match("abc")[2]   #=> "b"
+ */
+static VALUE oregexp_match( VALUE self, VALUE string ) {
+   ORegexp *oregexp;
+   Data_Get_Struct( self, ORegexp, oregexp );
+
+   VALUE string_str = StringValue( string );
+   UChar* str_ptr = RSTRING(string_str)->ptr;
+   int str_len = RSTRING(string_str)->len;
+
+   OnigRegion *region = onig_region_new();
+   int r = onig_search(oregexp->reg, str_ptr, str_ptr + str_len, str_ptr, str_ptr + str_len, region, ONIG_OPTION_NONE);
+   if (r >= 0) {
+   
+      VALUE begins = rb_ary_new();
+      VALUE ends = rb_ary_new();
+      nameHash = rb_hash_new();
+      
+      onig_foreach_name(oregexp->reg, name_callback, (void* )region);
+
+ 
+      int i;
+
+      for (i = 0; i < region->num_regs; i++) {
+         rb_ary_push( begins, INT2FIX( region->beg[i] ) );
+         rb_ary_push( ends, INT2FIX( region->end[i] ) );
+      }
+      VALUE kMatchData = rb_const_get( mOniguruma, rb_intern( "MatchData" ) );
+      VALUE kORegexp = rb_const_get( mOniguruma, rb_intern( "ORegexp" ) );
+      VALUE matchData = rb_funcall(kMatchData, rb_intern("new"), 4, string_str, begins, ends, nameHash ); 
+      rb_cv_set( kORegexp, "@@last_match", matchData );
+
+      onig_region_free(region, 1 );
+      return matchData;
+   } else if (r == ONIG_MISMATCH) {
+      onig_region_free(region, 1 );
+      return Qnil;
+   } else {
+      onig_region_free(region, 1 );
+      char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+      onig_error_code_to_str(s, r);
+      rb_raise(rb_eException, "Oniguruma Error: %s", s);
+   }
+
+}
+
+void Init_oregexp() {
+   mOniguruma = rb_define_module("Oniguruma");
+   VALUE cORegexp = rb_define_class_under(mOniguruma, "ORegexp", rb_cObject);
+   rb_define_alloc_func(cORegexp, oregexp_allocate);
+   rb_define_method( cORegexp, "initialize", oregexp_initialize, 2 );
+   rb_define_method( cORegexp, "match", oregexp_match, 1 );
+   
+}

data/lib/oniguruma.rb

@@ -0,0 +1,491 @@
+require 'oregexp'
+
+module Oniguruma
+   OPTION_NONE                 = 0
+   OPTION_IGNORECASE           = 1
+   OPTION_EXTEND               = (OPTION_IGNORECASE         << 1)
+   OPTION_MULTILINE            = (OPTION_EXTEND             << 1)
+   OPTION_SINGLELINE           = (OPTION_MULTILINE          << 1)
+   OPTION_FIND_LONGEST         = (OPTION_SINGLELINE         << 1)
+   OPTION_FIND_NOT_EMPTY       = (OPTION_FIND_LONGEST       << 1)
+   OPTION_NEGATE_SINGLELINE    = (OPTION_FIND_NOT_EMPTY     << 1)
+   OPTION_DONT_CAPTURE_GROUP   = (OPTION_NEGATE_SINGLELINE  << 1)
+   OPTION_CAPTURE_GROUP        = (OPTION_DONT_CAPTURE_GROUP << 1)
+   OPTION_NOTBOL               = (OPTION_CAPTURE_GROUP << 1)
+   OPTION_NOTEOL               = (OPTION_NOTBOL << 1)
+   OPTION_POSIX_REGION         = (OPTION_NOTEOL << 1)
+   OPTION_MAXBIT               = OPTION_POSIX_REGION
+   OPTION_DEFAULT              = OPTION_NONE
+
+   SYNTAX_ASIS                 = 0
+   SYNTAX_POSIX_BASIC          = 1
+   SYNTAX_POSIX_EXTENDED       = 2
+   SYNTAX_EMACS                = 3
+   SYNTAX_GREP                 = 4
+   SYNTAX_GNU_REGEX            = 5
+   SYNTAX_JAVA                 = 6
+   SYNTAX_PERL                 = 7
+   SYNTAX_PERL_NG              = 8
+   SYNTAX_RUBY                 = 9
+   SYNTAX_DEFAULT              = 10
+
+   ENCODING_ASCII              = 0
+   ENCODING_ISO_8859_1         = 1
+   ENCODING_ISO_8859_2         = 2
+   ENCODING_ISO_8859_3         = 3
+   ENCODING_ISO_8859_4         = 4
+   ENCODING_ISO_8859_5         = 5
+   ENCODING_ISO_8859_6         = 6
+   ENCODING_ISO_8859_7         = 7
+   ENCODING_ISO_8859_8         = 8
+   ENCODING_ISO_8859_9         = 9
+   ENCODING_ISO_8859_10        = 10
+   ENCODING_ISO_8859_11        = 11
+   ENCODING_ISO_8859_12        = 12
+   ENCODING_ISO_8859_13        = 13
+   ENCODING_ISO_8859_14        = 14
+   ENCODING_ISO_8859_15        = 15
+   ENCODING_ISO_8859_16        = 16
+   ENCODING_UTF8               = 17
+   ENCODING_UTF16_BE           = 18
+   ENCODING_UTF16_LE           = 19
+   ENCODING_UTF32_BE           = 20
+   ENCODING_UTF32_LE           = 21
+   ENCODING_EUC_JP             = 22
+   ENCODING_EUC_TW             = 23
+   ENCODING_EUC_KR             = 24
+   ENCODING_EUC_CN             = 25
+   ENCODING_SJIS               = 26
+   ENCODING_KOI8               = 27
+   ENCODING_KOI8_R             = 28
+   ENCODING_CP1251             = 29
+   ENCODING_BIG5               = 30
+   ENCODING_GB18030            = 31
+   ENCODING_UNDEF              = 32
+
+   
+   class ORegexp
+   
+      class << self
+         # :stopdoc:
+         alias compile new
+         # :startdoc:
+      
+         # call-seq:
+         # ORegexp.escape(str)   => a_str
+         # ORegexp.quote(str)    => a_str
+         # 
+         # Escapes any characters that would have special meaning in a regular
+         # expression. Returns a new escaped string, or self if no characters are
+         # escaped.  For any string,
+         # <code>Regexp.escape(<i>str</i>)=~<i>str</i></code> will be true.
+         # 
+         #    ORegexp.escape('\\*?{}.')   #=> \\\\\*\?\{\}\.
+         # 
+         
+         def escape( *args )
+            Regexp.escape( *args )
+         end
+         # :stopdoc:
+         alias quote escape
+         # :startdoc:
+         
+         # call-seq:
+         #    ORegexp.last_match           => matchdata
+         #    ORegexp.last_match(fixnum)   => str
+         #  
+         # The first form returns the <code>MatchData</code> object generated by the
+         # last successful pattern match. The second form returns the nth field in this
+         # <code>MatchData</code> object.
+         #     
+         #    ORegexp.new( 'c(.)t' ) =~ 'cat'       #=> 0
+         #    ORegexp.last_match                    #=> #<MatchData:0x401b3d30>
+         #    ORegexp.last_match(0)                 #=> "cat"
+         #    ORegexp.last_match(1)                 #=> "a"
+         #    ORegexp.last_match(2)                 #=> nil
+         
+         def last_match( index = nil)
+            if index
+               @@last_match[index]
+            else
+               @@last_match
+            end
+         end
+      end
+      
+      # :stopdoc:
+      alias old_initialize initialize 
+      # :startdoc:
+      
+      # Constructs a new regular expression from <i>pattern</i>, which is a 
+      # <code>String</code>. The paramter <i>options</i> is a <code>Hash</code> 
+      # of the form:
+      #
+      # <code>{ :options => option_value, :encoding => encoding_value, :syntax => syntax_value }</code>
+      #
+      # Where <code>option_value</code> is a bitwise <code>OR</code> of 
+      # <code>Oniguruma::OPTION_XXX</code> constants; <code>encoding_value</code>
+      # is one of <code>Oniguruma::ENCODING_XXX</code> constants; and 
+      # <code>syntax_value</code> is one of <code>Oniguruma::SYNTAX_XXX</code>
+      # constants.
+      #  
+      #     r1 = ORegexp.new('^a-z+:\\s+\w+')                                            #=> /^a-z+:\s+\w+/
+      #     r2 = ORegexp.new('cat', :options => OPTION_IGNORECASE )                      #=> /cat/i
+      #     r3 = ORegexp.new('dog', :options => OPTION_EXTEND )                          #=> /dog/x
+      #
+      #     #Accept java syntax on SJIS encoding:
+      #     r4 = ORegexp.new('ape', :syntax  => SYNTAX_JAVA, :encoding => ENCODING_SJIS) #=> /ape/ 
+      
+      def initialize( pattern, options = {} )
+         defaults = { :options => OPTION_DEFAULT, :encoding => ENCODING_ASCII, :syntax => SYNTAX_DEFAULT}
+         old_initialize( pattern,  defaults.merge( options ).freeze )
+      end
+      
+      # call-seq:
+      #    rxp == other_rxp      => true or false
+      #    rxp.eql?(other_rxp)   => true or false
+      #  
+      # Equality---Two regexps are equal if their patterns are identical, they have
+      # the same character set code, and their <code>#casefold?</code> values are the
+      # same.
+      
+      def == regexp
+         @pattern == regexp.source && kcode == regexp.kcode && casefold? == regexp.casefold?
+      end
+      alias eql? ==
+      
+      # call-seq:
+      #    rxp.casefold?   => true of false
+      #
+      # Returns the value of the case-insensitive flag.
+      
+      def casefold?
+         (@options[:options] & OPTION_IGNORECASE) > 0
+      end
+      
+      # call-seq:
+      #    rxp.kode        => int
+      #
+      # Returns the character set code for the regexp.
+      def kcode
+         @options[:encoding]
+      end
+      
+      # call-seq:
+      #    rxp.options   => fixnum
+      # 
+      # Returns the set of bits corresponding to the options used when creating this
+      # ORegexp (see <code>ORegexp::new</code> for details. Note that additional bits
+      # may be set in the returned options: these are used internally by the regular
+      # expression code. These extra bits are ignored if the options are passed to
+      # <code>ORegexp::new</code>.
+      #    
+      #    Oniguruma::OPTION_IGNORECASE                                 #=> 1
+      #    Oniguruma::OPTION_EXTEND                                     #=> 2
+      #    Oniguruma::OPTION_MULTILINE                                  #=> 4
+      #    
+      #    Regexp.new(r.source, :options => Oniguruma::OPTION_EXTEND )  #=> 2
+      
+      def options
+         @options[:options]
+      end
+      
+      # call-seq:
+      #    rxp.to_s   => str
+      # 
+      # Returns a string containing the regular expression and its options (using the
+      # <code>(?xxx:yyy)</code> notation. This string can be fed back in to
+      # <code>Regexp::new</code> to a regular expression with the same semantics as
+      # the original. (However, <code>Regexp#==</code> may not return true when
+      # comparing the two, as the source of the regular expression itself may
+      # differ, as the example shows).  <code>Regexp#inspect</code> produces a
+      # generally more readable version of <i>rxp</i>.
+      #    
+      #    r1 = ORegexp.new( 'ab+c', :options OPTION_IGNORECASE | OPTION_EXTEND ) #=> /ab+c/ix
+      #    s1 = r1.to_s                                                           #=> "(?ix-m:ab+c)"
+      #    r2 = ORegexp.new(s1)                                                   #=> /(?ix-m:ab+c)/
+      #    r1 == r2                                                               #=> false
+      #    r1.source                                                              #=> "ab+c"
+      #    r2.source                                                              #=> "(?ix-m:ab+c)"      
+      
+      def to_s
+         opt_str = "(?"
+         opt_str += "i" if (@options[:options] & OPTION_IGNORECASE) > 0
+         opt_str += "m" if (@options[:options] & OPTION_MULTILINE) > 0
+         opt_str += "x" if (@options[:options] & OPTION_EXTEND) > 0
+         unless opt_str == "(?imx"
+            opt_str += "-"
+            opt_str += "i" if (@options[:options] & OPTION_IGNORECASE) == 0
+            opt_str += "m" if (@options[:options] & OPTION_MULTILINE) == 0
+            opt_str += "x" if (@options[:options] & OPTION_EXTEND) == 0
+         end
+         opt_str += ")"
+         opt_str + ORegexp.escape( @pattern )
+      end
+      
+      
+      # call-seq:
+      #    rxp.inspect   => string
+      #
+      # Returns a readable version of <i>rxp</i>
+      #
+      #    ORegexp.new( 'cat', :options => OPTION_MULTILINE | OPTION_IGNORECASE ).inspect  => /cat/im
+      #    ORegexp.new( 'cat', :options => OPTION_MULTILINE | OPTION_IGNORECASE ).to_s     => (?im-x)cat
+      
+      def inspect
+         opt_str = ""
+         opt_str += "i" if (@options[:options] & OPTION_IGNORECASE) > 0
+         opt_str += "m" if (@options[:options] & OPTION_MULTILINE) > 0
+         opt_str += "x" if (@options[:options] & OPTION_EXTEND) > 0
+         "/" + ORegexp.escape( @pattern ) + "/" + opt_str
+      end
+      
+      # call-seq:
+      #    rxp =~ string  => int or nil
+      #
+      # Matches <code>rxp</code> against <code>string</code>, returning the offset of the 
+      # start of the match or <code>nil</code> if the match failed. Sets $~ to the corresponding 
+      # <code>MatchData</code> or <code>nil</code>.
+      #
+      #    ORegexp.new( 'SIT' ) =~ "insensitive"                                 #=>    nil
+      #    ORegexp.new( 'SIT', :options => OPTION_IGNORECASE ) =~ "insensitive"  #=>    5
+      
+      def =~ string
+         return nil unless string
+         m = match( string )
+         return nil unless m
+         m.begin
+      end
+      
+      # call-seq:
+      #    rxp === str   => true or false
+      # 
+      # Case Equality---Synonym for <code>Regexp#=~</code> used in case statements.
+      #    
+      #    a = "HELLO"
+      #    case a
+      #    when ORegexp.new('^[a-z]*$'); print "Lower case\n"
+      #    when ORegexp.new('^[A-Z]*$'); print "Upper case\n"
+      #    else;                         print "Mixed case\n"
+      #    end
+      #    
+      # <em>produces:</em>
+      #    
+      #    Upper case      
+      
+      alias === =~
+      
+      def source
+         @pattern.freeze
+      end
+      
+      def match_all string
+         matches = []
+         positions = []
+         position = 0
+         tmp_string = string
+         while tmp_string != ""
+            if m = match( tmp_string )
+               matches << m
+               positions << position
+               tmp_string = m.post_match
+               position += m.end
+               #if m.end == m.begin
+               #   tmp_string = tmp_string[1..-1]
+               #   position += 1
+               #end
+            else
+               break
+            end
+         end
+         if matches.size > 0
+            MultiMatchData.new( string, matches, positions )
+         else
+            nil
+         end
+      end
+      
+      def sub string, replacement = nil
+         matches = match( string )
+         if matches
+            replacement = yield matches[0] unless replacement
+            string.sub( matches[0], replacement )
+         else
+            return string
+         end
+      end
+      
+      def gsub string, replacement = nil
+         result = string
+         matches = match_all( string )
+         string_replace = replacement
+         if matches
+            matches.each do |m, p|
+               replacement = yield( m[0], m ) unless string_replace
+               result = result.sub( m[0], replacement )
+            end
+         end
+         result
+      end
+      
+      def sub! string, replacement = nil
+         matches = match( string )
+         if matches
+            replacement = yield matches[0] unless replacement
+            string.sub!( matches[0], replacement )
+         else
+            return string
+         end
+      end
+      
+      def gsub! string, replacement = nil
+         matches = match_all( string )
+         string_replace = replacement
+         if matches
+            matches.each do |m, p|
+               replacement = yield( m[0], m ) unless string_replace
+               string.sub!( m[0], replacement )
+            end
+         end
+         string
+      end
+   end
+   
+   class MultiMatchData
+      def initialize( string, matches, positions )
+         @matches = matches
+         @positions = positions
+         @string = string
+      end
+      
+      def position index
+         @positions[index]
+      end
+      
+      def [] ( value1, value2 = nil )
+         unless value2
+            @matches[value1]
+         else
+            @matches[value1, value2]
+         end
+      end
+      
+      def begin index
+         @matches[index].begin + @positions[index]
+      end
+      
+      def end index
+         @matches[index].end + @positions[index]
+      end
+      
+      def length
+         @matches.size
+      end
+      alias size length
+      
+      def offset index
+         [self.begin(index), self.end(index) ]
+      end
+      
+      def string
+         @string.freeze
+      end
+      
+      def to_a
+         @matches
+      end
+      
+      def each
+         @matches.size.times do |i|
+            yield @matches[i], @positions[i]
+         end
+      end
+   end
+   
+   class MatchData
+      def initialize( string, starts, ends, names )
+         @string = string
+         @starts = starts
+         @ends = ends
+         @matches = []
+         @starts.size.times do |i|
+            @matches << @string[@starts[i]...@ends[i]]
+         end
+         @match_count = @matches.size
+         @start_pos = 0
+         @names = names
+      end
+      
+      def [] ( value1, value2 = nil )
+         unless value2
+            if index = to_index( value1 )
+               @matches[index]
+            else
+               nil
+            end
+         else
+            @matches[value1, value2]
+         end
+      end
+      
+      def to_index name 
+         if name.is_a? Symbol
+            @names[name]
+         else
+            name
+         end
+      end
+      
+      def begin index = 0
+         @starts[to_index( index )]
+      end
+      
+      def end index = 0
+         @ends[to_index( index )]
+      end
+      
+      def captures
+         @matches[1..-1]
+      end
+      
+      def length
+         @match_count
+      end
+      alias size length
+      
+      def offset index = 0
+         [@starts[to_index( index )], @ends[to_index( index )]]
+      end
+      
+      def post_match
+         @string[@ends[0], @string.length]
+      end
+      
+      def pre_match
+         @string[0, @starts[0]]
+      end
+      
+      def select &block
+         @matches.select( &block )
+      end
+      
+      def string
+         @string.freeze
+      end
+      
+      def to_a
+         @matches
+      end
+      
+      def to_s
+         @matches[0]
+      end
+      
+      def values_at *values
+         result = []
+         values.each { |v| result << @matches[v] }
+         result
+      end
+   end
+end
+

data/test/test_oniguruma.rb

@@ -0,0 +1,214 @@
+require 'oniguruma'
+require 'test/unit'
+
+
+class ORegexpTestCase < Test::Unit::TestCase
+   def test_initialization
+      assert_nothing_raised do
+         reg  = Oniguruma::ORegexp.new( "(3.)(.*)(3.)" )
+      end
+   end
+   
+   def test_compile
+      assert_nothing_raised do
+         reg  = Oniguruma::ORegexp.compile( "(3.)(.*)(3.)" )
+      end
+   end
+   
+   def test_escape
+      assert_equal( '\\\\\*\?\{\}\.', Oniguruma::ORegexp.escape('\\*?{}.') ) 
+   end
+   
+   def test_last_match
+      assert_equal( 0, Oniguruma::ORegexp.new( 'c(.)t') =~ 'cat' )
+      assert_equal( "cat", Oniguruma::ORegexp.last_match(0) )
+      assert_equal( "a", Oniguruma::ORegexp.last_match(1) )
+      assert_equal( nil, Oniguruma::ORegexp.last_match(2) )
+   end
+
+   def test_bad_initialization
+      assert_raises(Exception) do
+         reg  = Oniguruma::ORegexp.new( "(3.)(.*)(3.))" )
+      end
+   end
+   
+   def test_match
+      reg  = Oniguruma::ORegexp.new( "(3.)(.*)(3.)" )
+      assert_not_nil( reg.match( "12345634" ) )
+   end
+   
+   def test_no_match
+      reg  = Oniguruma::ORegexp.new( "(3.)(.*)(3.)" )
+      assert_nil( reg.match( "12145614" ) )
+   end
+   
+   def test_sub
+      reg = Oniguruma::ORegexp.new( 'pe')
+      assert_equal( "**nelope", reg.sub( 'penelope', '**' ) )
+      assert_equal( "++nelope", reg.sub( 'penelope' ) { |m| '++' })
+   end
+   
+   def test_gsub
+      reg = Oniguruma::ORegexp.new( '\(\?#(\w+?)\)')
+      string = 'My favorite fruits are (?#fruit1), (?#fruit2), and (?#fruit3)'
+      assert_equal( "My favorite fruits are *, *, and *", reg.gsub( string, '*' ) )
+      fruits = { "fruit1" => "apples", "fruit2" => "bananas", "fruit3" => "grapes" }
+      assert_equal( "My favorite fruits are apples, bananas, and grapes", reg.gsub( string ) { |text, match| fruits[match[1]]} )
+   end
+   
+   def test_eql
+      assert_equal( Oniguruma::ORegexp.new( 'expression'),  Oniguruma::ORegexp.new( 'expression') )
+      assert_not_equal( Oniguruma::ORegexp.new( 'expression'),  Oniguruma::ORegexp.new( 'expresssion') )
+      assert_not_equal( Oniguruma::ORegexp.new( 'expression', :encoding => Oniguruma::ENCODING_ASCII ),  Oniguruma::ORegexp.new( 'expression', :encoding => Oniguruma::ENCODING_ISO_8859_1 ) )
+      assert_not_equal( Oniguruma::ORegexp.new( 'expression', :options => Oniguruma::OPTION_IGNORECASE ),  Oniguruma::ORegexp.new( 'expression', :options => Oniguruma::OPTION_NONE ) )
+   end
+   
+   def test_case_eql
+      a = "HELLO"
+      result = ""
+      case a
+      when Oniguruma::ORegexp.new('^[a-z]*$'); result =  "Lower case\n"
+      when Oniguruma::ORegexp.new('^[A-Z]*$'); result =  "Upper case\n"
+      else;                         result =  "Mixed case\n"
+      end
+      
+      assert_equal( "Upper case\n", result )
+   end
+   
+   def test_operator_match
+      assert_equal( nil, Oniguruma::ORegexp.new( 'SIT' ) =~ "insensitive" )
+      assert_equal( 5, Oniguruma::ORegexp.new( 'SIT', :options => Oniguruma::OPTION_IGNORECASE ) =~ "insensitive" )
+   end
+   
+#    def test_operator_match_2
+#       $_ = "input data"
+#       assert_equal( 7, ~Oniguruma::ORegexp.new( 'at' ) )
+#    end
+
+   def test_inspect
+      assert_equal( "/cat/im", Oniguruma::ORegexp.new( 'cat', :options => Oniguruma::OPTION_IGNORECASE | Oniguruma::OPTION_MULTILINE ).inspect )
+   end
+
+   def test_to_s
+      assert_equal( "(?im-x)cat", Oniguruma::ORegexp.new( 'cat', :options => Oniguruma::OPTION_IGNORECASE | Oniguruma::OPTION_MULTILINE ).to_s )
+   end
+   
+   def test_kcode
+      reg  = Oniguruma::ORegexp.new( "(3.)(.*)(3.)" )
+      assert_equal( Oniguruma::ENCODING_ASCII, reg.kcode )
+   end
+   
+   def test_options
+      assert_equal( 3, Oniguruma::ORegexp.new( 'abc', :options => Oniguruma::OPTION_IGNORECASE | Oniguruma::OPTION_EXTEND ).options )
+   end
+   
+   def test_source
+      string = '(?<=\n)\\.*ocatarinetabelachitchix'
+      assert_equal( string, Oniguruma::ORegexp.new( string ).source )
+   end
+end
+
+class MatchDataTestCase < Test::Unit::TestCase
+   def setup
+      @reg = Oniguruma::ORegexp.new( '(.)(.)(\d+)(\d)' )
+   end
+   
+   def test_square_brackets
+      matches = @reg.match( "THX1138." )
+      assert_equal( "HX1138", matches[0] )
+      assert_equal( ["H", "X"], matches[1, 2] )
+      assert_equal( ["H", "X", "113"], matches[1..3] )
+      assert_equal( ["X", "113"], matches[-3, 2] )
+   end
+   
+   def test_begin
+      matches = @reg.match( "THX1138." )
+      assert_equal( 1, matches.begin(0) )
+      assert_equal( 2, matches.begin(2) )
+   end
+   
+   def test_captures
+      matches = @reg.match( "THX1138." )
+      assert_equal( ["H", "X", "113", "8" ], matches.captures )
+   end
+   
+   def test_end
+      matches = @reg.match( "THX1138." )
+      assert_equal( 7, matches.end(0) )
+      assert_equal( 3, matches.end(2) )
+   end
+   
+   def test_size
+      matches = @reg.match( "THX1138." )
+      assert_equal( 5, matches.length )
+      assert_equal( 5, matches.size )
+   end
+   
+   def test_offset
+      matches = @reg.match( "THX1138." )
+      assert_equal( [1, 7], matches.offset(0) )
+      assert_equal( [6, 7], matches.offset(4) )
+   end
+   
+   def test_post_match
+      matches = @reg.match( "THX1138: The Movie" )
+      assert_equal( ": The Movie", matches.post_match )
+   end
+   
+   def test_pre_match
+      matches = @reg.match( "THX1138." )
+      assert_equal( "T", matches.pre_match )
+   end
+   
+   def test_select
+      matches = @reg.match( "THX1138: The Movie" )
+      assert_equal( ["HX1138", "113"], matches.select{ |v| v =~ /\d\d/} )
+   end
+   
+   def test_string
+      matches = @reg.match( "THX1138." )
+      assert_equal( "THX1138.", matches.string )
+      assert( matches.string.frozen? )
+   end
+   
+   def test_to_a
+      matches = @reg.match( "THX1138." )
+      assert_equal( ["HX1138", "H", "X", "113", "8" ], matches.to_a )
+   end
+   
+   def test_to_s
+      matches = @reg.match( "THX1138." )
+      assert_equal( "HX1138", matches.to_s )
+   end
+   
+   def test_values_at
+      matches = @reg.match( "THX1138: The Movie" )
+      assert_equal( ["HX1138", "X", "113"], matches.values_at( 0, 2, -2) )
+   end
+   
+   def test_match_all
+      reg = Oniguruma::ORegexp.new( 'ca' )
+      matches = reg.match_all( 'ocatacachaca' )
+      assert_equal( 3, matches.size )
+      assert_equal( 7, matches.position(2) )
+      assert_equal( "ca", matches.string[matches.begin(1)...matches.end(1)])
+   end
+   
+   def test_match_empty_string
+      reg = Oniguruma::ORegexp.new( '^\s*?(\n|\r)', :options => Oniguruma::OPTION_MULTILINE )
+      matches = reg.match( "\n\n\n\n\n" )
+      assert_not_nil( matches )
+      assert_equal( "\n\n\n\n", matches.post_match )
+   end
+   
+   def test_group_by_name
+      reg = Oniguruma::ORegexp.new( '(?<begin>\()(?<body>.*)(?<end>\))', :options => Oniguruma::OPTION_MULTILINE )
+      matches = reg.match( "blah (content) blah" )
+      assert_not_nil( matches )
+      assert_equal( '(', matches[:begin] )
+      assert_equal( 'content', matches[:body] )
+      assert_equal( ')', matches[:end] )
+      assert_equal( nil, matches[:inexistent])
+   end
+   
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: oniguruma
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+date: 2007-03-22 00:00:00 +01:00
+summary: Bindings for the oniguruma regular expression library
+require_paths: 
+- lib
+- ext
+email: dix_ans@yahoo.com
+homepage: http://oniguruma.rubyforge.org
+rubyforge_project: oniguruma
+description: Ruby bindings to the Oniguruma[http://www.geocities.jp/kosako3/oniguruma/] regular expression library (no need to recompile Ruby).
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Dizan Vasquez
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/oniguruma.rb
+- ext/oregexp.c
+- test/test_oniguruma.rb
+test_files: 
+- test/test_oniguruma.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+