tre-ruby 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  gem "rake-compiler", ">= 0.7.7"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Junegunn Choi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,159 @@
+= tre-ruby
+
+tre-ruby is a Ruby binding for TRE library which is "a lightweight, robust, and
+efficient POSIX compliant regexp matching library with some exciting features
+such as approximate (fuzzy) matching." Since Ruby has builtin regexp support,
+this gem will only provide the interface for approximate matching, which is
+missing in Ruby.
+
+== Prerequisite
+
+* TRE library (http://laurikari.net/tre/)
+  * Download http://laurikari.net/tre/download/
+
+== Installation
+
+  gem install tre-ruby
+
+== Setting up
+TRE is an extension module for String. You can extend a String object with it, or include it into String class
+
+  require 'tre-ruby'
+
+  # A string object extended to have approximate matching features
+  "Clamshell".extend(TRE).ascan /shll/, TRE.fuzziness(2)
+
+  # Or you can patch the String class so that every String object can have the extended features.
+  # (if you think it's appropriate)
+  class String
+    include TRE
+  end
+
+  "Clamshell".ascan /shll/, TRE.fuzziness(2)
+
+== Approximate matching
+TRE module provides the following instance methods.
+
+=== Methods
+
+TRE#axxx methods behave similar to their String#xxx counterparts,
+except that you cannot make use of virtual global variables ($&, $`, $', ...)
+
+* aindex
+  * Returns the Range (n...m) of the first match
+* afind
+  * Returns the first matching substring
+* ascan
+  * Approximate scan. Similar to String#scan.
+  * Just like String#scan, TRE#ascan returns Array of Strings or Array of Array of Strings when the given Regexp pattern contains captures.
+* ascan_r
+  * Same as ascan, but Range instead of String
+* asub
+  * Substitute the first match.
+* agsub
+  * Substitute every match.
+
+=== TRE::AParams
+
+Every `a-method' of TRE takes a TRE::AParams object as its last parameter.
+TRE::AParams controls the approximate matching.
+
+  params = TRE::AParams.new
+  params.max_err = 3
+
+  str.extend(TRE).ascan /abracadabra/, params
+
+There is a shortcut class method TRE.fuzziness(n) which is good enough for most cases. It returns a frozen TRE::AParams object with max_err of n.
+
+  str.extend(TRE).ascan /abracadabra/, TRE.fuzziness(3)
+
+== Examples
+
+=== TRE#aindex, TRE#afind
+You can locate the pattern (String or Regexp) in the string with aindex and afind.
+When the pattern is not found, nil is returned.
+
+  str = <<-EOF
+  She sells sea shells by the sea shore.
+  The shells she sells are surely seashells.
+  So if she sells shells on the seashore,
+  I'm sure she sells seashore shells.
+  EOF
+
+  # Returns the first matching range
+  # - TRE.fuzziness(n) returns frozen TRE::AParams object with max_err of n
+  str.aindex 'shll', 0, TRE.fuzziness(1)
+    # (4...8)
+  
+  # Returns the first matching substring
+  str.afind 'shll', 0,  TRE.fuzziness(1)
+    # "sell"
+  
+  # afind from offset 10
+  str.afind 'shll', 10, TRE.fuzziness(1)
+    # "shell"
+
+  # Same for Regexp patterns
+  str.aindex /s[hx]ll/, 0,   TRE.fuzziness(1)
+    # (4...8)
+
+=== TRE#ascan
+When the pattern is not found, an empty Array is returned.
+
+  # Scan
+  str.ascan /SSELL/i,     TRE.fuzziness(2)
+    # [" sell", "shell", "shell", " sell", "shell", " sell", "shell", " sell"]
+
+  str.ascan /(SS)(E)LL/i, TRE.fuzziness(2)
+    # [[" sell", " s", "e"], ["shell", "sh", "e"], ["shell", "sh", "e"], 
+    #  [" sell", " s", "e"], ["shell", "sh", "e"], [" sell", " s", "e"], 
+    #  ["shell", "sh", "e"], [" sell", " s", "e"]]
+
+  # Scan with block
+  str.ascan /SSELL/i, TRE.fuzziness(2) do | match_string |
+    puts match_string
+  end
+
+  str.ascan /(SS)(E)LL/i, TRE.fuzziness(2) do | first, second |
+    puts "#{first} => #{second}"
+  end
+
+=== TRE#asub, TRE#agsub
+
+Substitutions.
+
+  str.asub  'shll', '______', TRE.fuzziness(2)
+
+  # Blocks are not supported but you can use back references
+  str.asub  /(SS)(E)LL/i, "___(\\2 / \\1)__", TRE.fuzziness(2)
+  str.agsub /(SS)(E)LL/i, "___(\\2 / \\1)__", TRE.fuzziness(2)
+
+=== Fine-grained control of approximate matching parameters
+
+  aparams = TRE::AParams.new { |ap|
+    ap.cost_ins = 1 
+    ap.cost_del = 1
+    ap.cost_subst = 2
+
+    ap.max_ins = 10
+    ap.max_del = 20
+    ap.max_subst = 15
+    ap.max_err  = 30
+    ap.max_cost = 50
+  }
+  str.ascan(/sea shells/, aparams)
+
+== Contributing to tre-ruby
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+jeweler_tasks = Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "tre-ruby"
+  gem.homepage = "http://github.com/junegunn/tre-ruby"
+  gem.license = "MIT"
+  gem.summary = %Q{Approximate regular expression matching using TRE}
+  gem.description = %Q{Ruby binding for TRE library. Provides interface for approximate regular expression matching.}
+  gem.email = "junegunn.c@gmail.com"
+  gem.authors = ["Junegunn Choi"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+
+  # For extensions
+  #  http://karottenreibe.github.com/2009/10/25/jeweler-interlude/
+  gem.extensions = FileList['ext/**/extconf.rb']
+  gem.files.include 'ext/**/*.c'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+# For rake-compiler
+#  http://karottenreibe.github.com/2009/10/25/jeweler-interlude/
+require 'rake/extensiontask'
+#jeweler_tasks.gemspec.version = jeweler_tasks.jeweler.version
+Rake::ExtensionTask.new('tre', jeweler_tasks.gemspec) do |ext|
+	ext.lib_dir = 'lib/tre-ruby'
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tre-ruby #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/tre/extconf.rb

@@ -0,0 +1,39 @@
+require 'mkmf'
+
+def x d
+	abort "** #{d} is missing."
+end
+
+def xtre
+	abort <<-MISSING
+**
+**
+** TRE library is missing !!
+** *************************
+**
+** You can download the source or the binaries from http://laurikari.net/tre/
+**
+** = e.g. To install TRE from the source code
+**
+**     tar -xvjf tre-0.8.0.tar.bz2
+**     cd tre-0.8.0
+**     ./configure
+**     make
+**     sudo make install
+**
+**
+	MISSING
+end
+
+# TRE
+xtre unless have_library('tre')
+xtre unless have_header('tre/tre.h')
+
+# Multi-byte support
+# TRE_WCHAR
+%w[TRE_MULTIBYTE TRE_APPROX].each do | macro |
+	x "Macro #{macro}" unless have_macro macro, 'tre/tre.h'
+end
+
+create_makefile('tre-ruby/tre')
+

data/ext/tre/tre.c

@@ -0,0 +1,194 @@
+#include "ruby.h"
+#include "tre/tre.h"
+
+VALUE mTRE;
+
+#define _TRE_RUBY_APARAM_OVERRIDE(P) \
+	VALUE P = rb_funcall(params, rb_intern(#P), 0); \
+	if (P != Qnil) aparams->P = NUM2INT(P)
+static void
+tre_build_aparams(regaparams_t* aparams, VALUE params) {
+	// Sets to default
+	tre_regaparams_default(aparams);
+
+	// Then override
+	_TRE_RUBY_APARAM_OVERRIDE(cost_ins);
+	_TRE_RUBY_APARAM_OVERRIDE(cost_del);
+	_TRE_RUBY_APARAM_OVERRIDE(cost_subst);
+	_TRE_RUBY_APARAM_OVERRIDE(max_cost);
+	_TRE_RUBY_APARAM_OVERRIDE(max_ins);
+	_TRE_RUBY_APARAM_OVERRIDE(max_del);
+	_TRE_RUBY_APARAM_OVERRIDE(max_subst);
+	_TRE_RUBY_APARAM_OVERRIDE(max_err);
+}
+#undef _TRE_RUBY_APARAM_OVERRIDE
+
+static void
+tre_compile_regex(regex_t* preg, VALUE pattern, VALUE ignore_case, VALUE multi_line) {
+	Check_Type(pattern, T_STRING);
+
+	int cflags = REG_EXTENDED;
+	if (ignore_case == Qtrue) cflags = cflags | REG_ICASE;
+	if (multi_line == Qfalse) cflags = cflags | REG_NEWLINE;
+
+	reg_errcode_t result = tre_regncomp(preg, StringValuePtr(pattern), RSTRING_LEN(pattern), cflags);
+
+	if (result == REG_OK) return;
+
+	switch (result) {
+		case REG_NOMATCH:
+			rb_raise(rb_eRuntimeError, "No match.");
+			break;
+		case REG_BADPAT:
+			rb_raise(rb_eRuntimeError, "Invalid regexp.");
+			break;
+		case REG_ECOLLATE:
+			rb_raise(rb_eRuntimeError, "Unknown collating element.");
+			break;
+		case REG_ECTYPE:
+			rb_raise(rb_eRuntimeError, "Unknown character class name.");
+			break;
+		case REG_EESCAPE:
+			rb_raise(rb_eRuntimeError, "Trailing backslash.");
+			break;
+		case REG_ESUBREG:
+			rb_raise(rb_eRuntimeError, "Invalid back reference.");
+			break;
+		case REG_EBRACK:
+			rb_raise(rb_eRuntimeError, "\"[]\" imbalance");
+			break;
+		case REG_EPAREN:
+			rb_raise(rb_eRuntimeError, "\"\\(\\)\" or \"()\" imbalance");
+			break;
+		case REG_EBRACE:
+			rb_raise(rb_eRuntimeError, "\"\\{\\}\" or \"{}\" imbalance");
+			break;
+		case REG_BADBR:
+			rb_raise(rb_eRuntimeError, "Invalid content of {}");
+			break;
+		case REG_ERANGE:
+			rb_raise(rb_eRuntimeError, "Invalid use of range operator");
+			break;
+		case REG_ESPACE:
+			rb_raise(rb_eRuntimeError, "Out of memory.");
+			break;
+		case REG_BADRPT:
+           	rb_raise(rb_eRuntimeError, "Invalid use of repetition operators.");
+			break;
+		default:
+			rb_raise(rb_eRuntimeError, "Unknown Error");
+			break;
+	}
+}
+
+static VALUE
+tre_traverse(VALUE pattern, VALUE string, long char_offset, VALUE params,
+		VALUE ignore_case, VALUE multi_line, int num_captures, VALUE repeat) {
+
+	// Compile once
+	regex_t preg;
+	tre_compile_regex(&preg, pattern, ignore_case, multi_line);
+
+	// Build regaparams
+	regaparams_t aparams;
+	tre_build_aparams(&aparams, params);
+
+	// Match data
+	regamatch_t match;
+	regmatch_t pmatch[num_captures + 1];
+	// memset(&match, 0, sizeof(match));
+	match.nmatch = num_captures + 1;
+	match.pmatch = pmatch;
+
+	// Scan
+	VALUE arr = rb_ary_new();
+	long char_offset_acc = char_offset;
+	// rb_global_variable(&arr);
+
+	while (1) {
+		// Get substring to start with
+		long len = RSTRING_LEN(string) - char_offset;
+		if (char_offset >= len) break;
+		string = rb_str_substr(string, char_offset, len);
+
+		int result = tre_reganexec(&preg, StringValuePtr(string), len, &match, aparams, 0);
+
+		if (result == REG_NOMATCH) break;
+
+		// Fill in array with ranges
+		VALUE subarr;
+		if (match.nmatch == 1) 
+			subarr = arr;	// Fake
+		else {
+			subarr = rb_ary_new();
+			// rb_global_variable(&subarr);
+		}
+
+		unsigned int i;
+		for (i = 0; i < match.nmatch; ++i)
+			if (match.pmatch[i].rm_so == -1)
+				rb_ary_push(subarr, Qnil);
+			else {
+				VALUE range = rb_range_new(
+						LONG2NUM( char_offset_acc + rb_str_sublen(string, match.pmatch[i].rm_so) ),
+						LONG2NUM( char_offset_acc + rb_str_sublen(string, match.pmatch[i].rm_eo) ),
+						1);
+				// rb_global_variable(&range);
+
+				rb_ary_push(subarr, range);
+			}
+		if (match.nmatch > 1) rb_ary_push(arr, subarr);
+
+		// Stop or proceed
+		if (repeat == Qfalse)
+			break;
+		else {
+			char_offset = rb_str_sublen(string, match.pmatch[0].rm_eo);
+			if (char_offset == 0) char_offset = 1; // Weird case
+			char_offset_acc += char_offset;
+		}
+	}
+
+	// Free once
+	tre_regfree(&preg);
+
+	return arr;
+}
+
+static VALUE
+tre_aindex(int argc, VALUE *argv, VALUE self) {
+	VALUE pattern, string, char_offset, params, ignore_case, multi_line;
+	rb_scan_args(argc, argv, "60", &pattern, &string, &char_offset, &params, &ignore_case, &multi_line);
+
+	Check_Type(string, T_STRING);
+
+	VALUE rarray = tre_traverse(pattern, string, NUM2LONG(char_offset), params,
+			ignore_case, multi_line, 0, Qfalse);
+
+	if (RARRAY_LEN(rarray) == 0)
+		return Qnil;
+	else
+		return rb_ary_entry(rarray, 0);
+}
+
+static VALUE
+tre_ascan(int argc, VALUE *argv, VALUE self) {
+	VALUE pattern, string, char_offset, params, ignore_case, multi_line, num_captures, repeat;
+	rb_scan_args(argc, argv, "80", &pattern, &string, &char_offset, &params,
+			&ignore_case, &multi_line, &num_captures, &repeat);
+
+	Check_Type(string, T_STRING);
+
+	VALUE rarray = tre_traverse(pattern, string, NUM2LONG(char_offset), params,
+			ignore_case, multi_line, NUM2INT(num_captures), repeat);
+
+	return rarray;
+}
+
+void
+Init_tre() {
+	mTRE = rb_define_module("TRE");
+	rb_define_private_method(mTRE, "__aindex", tre_aindex, -1);
+	rb_define_private_method(mTRE, "__ascan",  tre_ascan, -1);
+}
+

data/lib/tre-ruby.rb

@@ -0,0 +1,227 @@
+# encoding: UTF-8
+
+require 'tre-ruby/tre'
+
+module TRE
+	# Returns a TRE::AParams object with the given fuzziness (max_err)
+	# @param [Fixnum] max_err
+	# @return [TRE::AParams]
+	def TRE.fuzziness max_err
+		@@fuzzies ||= {}
+		return @@fuzzies[max_err] if @@fuzzies.has_key? max_err
+
+		param = TRE::AParams.new
+		param.max_err = max_err
+		param.freeze
+		@@fuzzies[max_err] = param
+	end
+
+	# Locates the pattern in the string and returns the Range object for the first match
+	# @param [String/Regexp] pattern
+	# @param [Fixnum] offset
+	# @param [TRE::AParams] params
+	# @return [Range]
+	def aindex pattern, offset = 0, params = TRE.fuzziness(0)
+		raise ArgumentError.new("Invalid parameter") unless params.is_a? TRE::AParams
+		raise ArgumentError.new("Invalid offset parameter") unless offset.is_a? Fixnum
+
+		input = parse_pattern pattern
+		__aindex(input[:source], self, offset, params, 
+				input[:ignore_case], input[:multi_line])
+	end
+
+	# Locates the pattern in the string and returns the first matching substring.
+	# @param [String/Regexp] pattern
+	# @param [Fixnum] offset
+	# @param [TRE::AParams] params
+	# @return [String]
+	def afind pattern, offset = 0, params = TRE.fuzziness(0)
+		range = aindex pattern, offset, params
+
+		range && self[range]
+	end
+
+	# Scans for the pattern in the String and returns Array of matching substrings 
+	# or Array of Array of Strings when the given pattern contains Regexp captures.
+	# @param [String/Regexp] pattern
+	# @param [TRE::AParams] params
+	# @return [Array]
+	def ascan pattern, params = TRE.fuzziness(0), &block
+		result = ascan_r(pattern, params).map { |e|
+			case e
+			when Array
+				e.map { |ee| self[ee] }.take_while { |ee| ee }
+			when Range
+				self[e]
+			else
+				raise RuntimeError.new
+			end
+		}
+		return result unless block_given?
+		yield_scan_result result, &block
+	end
+	
+	# Same as TRE#ascan, but returns Array of Range objects instead of String objects.
+	# @param [String/Regexp] pattern
+	# @param [TRE::AParams] params
+	# @return [Array]
+	def ascan_r pattern, params = TRE.fuzziness(0), &block
+		ascan_r_impl pattern, params, true, &block
+	end
+
+	# Returns a copy of the String with the first match substituted
+	# @param [String/Regexp] pattern
+	# @param [String] replacement
+	# @param [TRE::AParams] params
+	# @return [String]
+	def asub pattern, replacement, params = TRE.fuzziness(0), &block
+		asub_impl pattern, replacement, params, false, &block
+	end
+
+	# Substitutes the first match
+	# @param [String/Regexp] pattern
+	# @param [String] replacement
+	# @param [TRE::AParams] params
+	# @return [String]
+	def asub! pattern, replacement, params = TRE.fuzziness(0), &block
+		self.replace asub(pattern, replacement, params, &block)
+	end
+
+	# Returns a copy of the String with every match substituted
+	# @param [String/Regexp] pattern
+	# @param [String] replacement
+	# @param [TRE::AParams] params
+	# @return [String]
+	def agsub pattern, replacement, params = TRE.fuzziness(0), &block
+		asub_impl pattern, replacement, params, true, &block
+	end
+
+	# Substitutes every match
+	# @param [String/Regexp] pattern
+	# @param [String] replacement
+	# @param [TRE::AParams] params
+	# @return [String]
+	def agsub! pattern, replacement, params = TRE.fuzziness(0), &block
+		self.replace agsub(pattern, replacement, params, &block)
+	end
+
+	# Parameters for approximate matching.
+	class AParams
+		# Default cost of an inserted character.
+		attr_accessor :cost_ins  
+		# Default cost of a deleted character.
+		attr_accessor :cost_del  
+		# Default cost of a substituted character.
+		attr_accessor :cost_subst
+
+		# Maximum allowed cost of a match.
+		attr_accessor :max_cost
+		# Maximum allowed number of inserts.
+		attr_accessor :max_ins
+		# Maximum allowed number of deletes.
+		attr_accessor :max_del
+		# Maximum allowed number of substitutes.
+		attr_accessor :max_subst
+		# Maximum allowed number of errors total.
+		attr_accessor :max_err
+
+		# Creates a AParams object with default values
+		def initialize
+			self.cost_ins = 1
+			self.cost_del = 1
+			self.cost_subst = 1
+			self.max_cost = nil
+			self.max_ins = nil
+			self.max_del = nil
+			self.max_del = nil
+			self.max_subst = nil
+			self.max_err = 0
+
+			yield self if block_given?
+		end
+	end
+
+private
+	# TODO
+	def amatch pattern, offset = 0, params = TRE.fuzziness(0)
+		raise NotImplementedError
+
+		raise ArgumentError.new("Invalid parameter") unless params.is_a? TRE::AParams
+		raise ArgumentError.new("Invalid offset parameter") unless offset.is_a? Fixnum
+	end
+	def parse_pattern pattern
+		ret = {}
+		case pattern
+		when Regexp
+			ret[:source] = pattern.source
+
+			opts = pattern.options
+			ret[:multi_line] = (opts & Regexp::MULTILINE) > 0
+			opts &= ~Regexp::MULTILINE
+			ret[:ignore_case] = (opts & Regexp::IGNORECASE) > 0
+			opts &= ~Regexp::IGNORECASE
+			opts &= ~Regexp::FIXEDENCODING # FIXME
+			raise ArgumentError.new("Unsupported Regexp flag provided") if opts > 0
+
+			# Pessimistic estimation of the number of captures
+			ret[:num_captures] = ret[:source].each_char.count { |c| c == '(' }
+		when String
+			ret[:source] = Regexp.escape pattern
+			ret[:num_captures] = 0
+		end
+
+		ret
+	end
+
+	def ascan_r_impl pattern, params, repeat, &block
+		raise ArgumentError.new("Invalid parameter") unless params.is_a? TRE::AParams
+
+		input = parse_pattern pattern
+		result = __ascan(input[:source], self, 0, params, 
+				input[:ignore_case], input[:multi_line], input[:num_captures], repeat)
+
+		return result unless block_given?
+		yield_scan_result result, &block
+	end
+
+	def asub_impl pattern, replacement, params, repeat, &block
+		raise NotImplementedError.new if block_given?
+		raise NotImplementedError.new unless replacement.is_a? String
+
+		ret = self.dup
+
+		ascan_r_impl(pattern, params, repeat, &block).each do | ranges |
+			# Captures
+			if ranges.is_a? Array
+				repl = replacement.dup
+				ranges[1..-1].each_with_index do | range, idx |
+					repl.gsub!("\\#{idx + 1}", self[range])
+				end
+				ret[ranges[0]] = repl
+			else
+				ret[ranges] = replacement
+			end
+		end
+
+		ret
+	end
+
+	def yield_scan_result result, &block
+		return self if result.empty?
+
+		# With captures
+		if result.first.is_a?(Array)
+			# arity == 1
+			if block.arity == 1
+				result.each { |r| yield r[1..-1] }
+			else
+				result.each { |r| yield *r[1..-1] }
+			end
+		# Without captures
+		else
+			result.each { |r| yield r }
+		end
+		self
+	end
+end
+

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'tre-ruby'
+
+class Test::Unit::TestCase
+end

data/test/test_tre-ruby.rb

@@ -0,0 +1,210 @@
+# encoding: UTF-8
+
+$LOAD_PATH.unshift File.dirname(__FILE__) # FIXME
+require 'helper'
+
+class TestTRE < Test::Unit::TestCase
+	class TREString < String
+		include TRE
+	end
+
+	def test_extend
+		assert_equal 2...4, "aaba".extend(TRE).aindex('ba')
+		assert_equal [2...4], "aaba".extend(TRE).ascan_r(/ba/)
+		assert_equal ["ba"], "aaba".extend(TRE).ascan(/ba/)
+	end
+
+	def test_include
+		# String including TRE module would affect the subsequent tests
+		#   String.send :include, TRE
+		# So, we use TREString here.
+
+		str = TREString.new "aaba"
+		assert_equal 2...4,   str.aindex('ba')
+		assert_equal [2...4], str.ascan_r(/ba/)
+		assert_equal ["ba"], str.ascan(/ba/)
+	end
+
+	def test_privacy
+		str = TREString.new "aaba"
+		assert_raise(NoMethodError) { str.__ascan 1,1,1,1,1,1,1 }
+		assert_raise(NoMethodError) { str.__aindex 1,1,1,1,1,1 }
+	end
+
+	def test_aparams
+		aparams = TRE::AParams.new
+		assert_equal 0, aparams.max_err
+		aparams.max_err = 5
+		assert_equal 5, aparams.max_err
+	end
+
+	def test_fuzziness
+		fuzz1 = TRE.fuzziness 1
+		assert_equal TRE::AParams, fuzz1.class
+		assert_equal 1, fuzz1.max_err
+		assert fuzz1.frozen?
+
+		fuzz2 = TRE.fuzziness 2
+		assert_equal TRE::AParams, fuzz2.class
+		assert_equal 2, fuzz2.max_err
+		assert fuzz2.frozen?
+
+		# Same frozen object for same fuzziness
+		assert_equal fuzz1.object_id, TRE.fuzziness(1).object_id
+		assert_equal fuzz2.object_id, TRE.fuzziness(2).object_id
+		assert_not_equal fuzz1.object_id, fuzz2.object_id
+	end
+
+	def test_aindex_string
+		params = TRE::AParams.new
+
+		# String patterns
+		params.max_err = 1
+		assert_equal 'would', TWISTER[ TWISTER.aindex('tould', 0, params) ]
+		assert_equal nil, TWISTER.aindex('toult', 0, params)
+
+		params.max_err = 2
+		assert_equal 'would', TWISTER[ TWISTER.aindex('toult', 0, params) ]
+		assert_equal 'could', TWISTER[ TWISTER.aindex('toult', 400, params) ]
+	end
+
+	def test_aindex_regex
+		params = TRE.fuzziness 1
+
+		# Regex pattenrs
+		assert_equal 'would', TWISTER[ TWISTER.aindex /TOULD/i, 0, params ]
+		assert_equal nil, TWISTER.aindex(/toult/i, 0, params)
+
+		# Frozen: cannot modify
+		assert_raise(RuntimeError) { params.max_err = 2 }
+
+		# Warm AParams
+		params = TRE::AParams.new
+		params.max_err = 2
+
+		assert_equal nil, TWISTER.aindex(/TOULT/, 0, params)
+		assert_equal 'would', TWISTER[ TWISTER.aindex(/TOULT/i, 0, params) ]
+		assert_equal 'could', TWISTER[ TWISTER.aindex(/TOULT/i, 400, params) ]
+		assert_equal 'could', TWISTER[ TWISTER.aindex(/TOULT/i, 400, params) ]
+		assert_equal 'could', TWISTER[ TWISTER.aindex(/T((O)U(L))T/i, 400, params) ]
+
+		# afind shortcut
+		assert_equal 'would', TWISTER.afind(/TOULT/i, 0, params)
+		assert_equal 'could', TWISTER.afind(/TOULT/i, 400, params)
+		assert_equal 'could', TWISTER.afind(/TOULT/i, 400, params)
+		assert_equal 'could', TWISTER.afind(/T((O)U(L))T/i, 400, params)
+	end
+
+	def test_regex_flags
+		# Test for case-insensitivity
+		str = TREString.new "A\nB"
+		assert_equal nil, str.aindex(/b/)
+		assert_equal (2...3), str.aindex(/b/i)
+
+		# Test for multiline
+		assert_equal (0...1), str.aindex(/.*/)
+		assert_equal (0...3), str.aindex(/.*/m)
+
+		# Test for multiline and case-insensitivity
+		assert_equal (0...1), str.aindex(/a.*?b?/i)
+		assert_equal (0...3), str.aindex(/a.*?b?/im)
+
+		# Test for unsupported x flag
+		assert_raise(ArgumentError) { TWISTER.aindex(/a/x) }
+	end
+
+	def test_ascan_r
+		result = TWISTER.ascan_r(/peck/, TRE.fuzziness(2))
+		assert_equal Array, result.class
+		assert_equal Range, result.first.class
+
+		result = TWISTER.ascan_r(/p(e)ck/, TRE.fuzziness(2)) 
+		assert_equal Array, result.class
+		assert_equal Array, result.first.class
+		assert_equal Range, result.first.first.class
+		assert_equal Range, result.first.last.class
+	end
+
+	def test_ascan
+		# Without blocks
+		assert_equal 4, TWISTER.ascan(/peck/,      TRE.fuzziness(0)).length
+		assert_equal 6, TWISTER.ascan(/peck/,      TRE.fuzziness(1)).length
+		assert_equal 15, TWISTER.ascan(/peck/,     TRE.fuzziness(2)).length
+		assert_equal 15, TWISTER.ascan(/(p(e)c)k/, TRE.fuzziness(2)).length
+
+		# Block given
+		TWISTER.ascan(/peck/, TRE.fuzziness(2)) do | a |
+			assert a.is_a?(String)
+		end
+		TWISTER.ascan(/((p)e)ck/, TRE.fuzziness(2)) do | a |
+			assert a.is_a?(Array)
+			assert_equal 2, a.length
+		end
+		TWISTER.ascan(/((p)e)ck/, TRE.fuzziness(2)) do | a, b |
+			assert a.is_a?(String)
+			assert b.is_a?(String)
+		end
+	end
+
+	def test_asub
+		assert_equal 1, TWISTER.asub(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(3)).scan('ckckpepe').length
+	end
+
+	def test_asub!
+		copy = TWISTER.dup
+		rep = TWISTER.asub(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(3))
+		copy.         asub!(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(3))
+
+		assert_equal copy, rep
+		assert_not_equal copy, TWISTER
+	end
+
+	def test_agsub
+		assert_equal 15, TWISTER.ascan(/(pe)(ck)/, TRE.fuzziness(2)).length
+		assert_equal 4, TWISTER.ascan(/(pe)(ck)/, TRE.fuzziness(2)).select { |m| m[0] == 'peck' }.length
+		assert_equal 4, TWISTER.agsub(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(2)).scan('ckckpepe').length
+
+		# TODO: More rigorous tests
+	end
+
+	def test_agsub!
+		copy = TWISTER.dup
+		rep = TWISTER.agsub(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(3))
+		copy.         agsub!(/(pe)(ck)/, '\2\2\1\1', TRE.fuzziness(3))
+
+		assert_equal copy, rep
+		assert_not_equal copy, TWISTER
+	end
+
+	TWISTER = TREString.new <<-EOF
+		She sells sea shells by the sea shore.
+		The shells she sells are surely seashells.
+		So if she sells shells on the seashore,
+		I'm sure she sells seashore shells.
+
+		Peter Piper picked a peck of pickled peppers.
+		Did Peter Piper pick a peck of pickled peppers?
+		If Peter Piper picked a peck of pickled peppers,
+		where's the peck of pickled peppers Peter Piper picked?
+
+		How much wood would a woodchuck chuck
+		if a woodchuck could chuck wood?
+		He would chuck, he would, as much as he could,
+		and chuck as much wood as a woodchuck would
+		if a woodchuck could chuck wood.
+
+		Betty Botter had some butter,
+		"But," she said, "this butter's bitter.
+		If I bake this bitter butter,
+		it would make my batter bitter.
+		But a bit of better butter--
+		that would make my batter better."
+
+		So she bought a bit of butter,
+		better than her bitter butter,
+		and she baked it in her batter,
+		and the batter was not bitter.
+		So 'twas better Betty Botter
+		bought a bit of better butter.
+	EOF
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: tre-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Junegunn Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2153038680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2153038680
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2153037520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *2153037520
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &2153036080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153036080
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &2153024580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+  type: :development
+  prerelease: false
+  version_requirements: *2153024580
+description: Ruby binding for TRE library. Provides interface for approximate regular
+  expression matching.
+email: junegunn.c@gmail.com
+executables: []
+extensions:
+- ext/tre/extconf.rb
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/tre/extconf.rb
+- ext/tre/tre.c
+- lib/tre-ruby.rb
+- test/helper.rb
+- test/test_tre-ruby.rb
+homepage: http://github.com/junegunn/tre-ruby
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2920886793274010137
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Approximate regular expression matching using TRE
+test_files:
+- test/helper.rb
+- test/test_tre-ruby.rb