amatch-rbx 0.2.12

data/ext/common.h

@@ -0,0 +1,25 @@
+#ifndef __COMMON_H__
+#  define __COMMON_H__
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) (RSTRING(str)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) (RSTRING(str)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ary) (RARRAY(ary)->ptr)
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(ary) (RARRAY(ary)->len)
+#endif
+
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(val) (RFLOAT(val)->value)
+#endif
+
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+require 'rbconfig'
+
+if CONFIG['CC'] =~ /gcc/
+  $CFLAGS << ' -Wall'
+  if ENV['DEBUG']
+    $CFLAGS << ' -O0 -ggdb'
+  else
+    $CFLAGS << ' -O3'
+  end
+else
+  $CFLAGS << ' -O3'
+end
+create_makefile 'amatch_ext'

data/ext/pair.c

@@ -0,0 +1,77 @@
+#include "pair.h"
+
+#define DEBUG 0
+
+static int predict_length(VALUE tokens)
+{
+    int i, l, result;
+    for (i = 0, result = 0; i < RARRAY_LEN(tokens); i++) {
+        VALUE t = rb_ary_entry(tokens, i);
+        l = (int) RSTRING_LEN(t) - 1;
+        if (l > 0) result += l;
+    }
+    return result;
+}
+
+PairArray *PairArray_new(VALUE tokens)
+{
+    int i, j, k, len = predict_length(tokens); 
+    PairArray *pair_array = ALLOC(PairArray);
+    Pair *pairs = ALLOC_N(Pair, len);
+    MEMZERO(pairs, Pair, len);
+    pair_array->pairs = pairs;
+    pair_array->len = len;
+    for (i = 0, k = 0; i < RARRAY_LEN(tokens); i++) {
+        VALUE t = rb_ary_entry(tokens, i);
+        char *string = RSTRING_PTR(t);
+        for (j = 0; j < RSTRING_LEN(t) - 1; j++) {
+            pairs[k].fst = string[j];
+            pairs[k].snd = string[j + 1];
+            pairs[k].status = PAIR_ACTIVE;
+            k++;
+        }
+    }
+    return pair_array;
+}
+
+void pair_array_reactivate(PairArray *self)
+{
+    int i;
+    for (i = 0; i < self->len; i++) { 
+        self->pairs[i].status = PAIR_ACTIVE;
+    }
+}
+
+double pair_array_match(PairArray *self, PairArray *other)
+{
+    int i, j, matches = 0;
+    int sum = self->len + other->len;
+    if (sum == 0) return 1.0;
+    for (i = 0; i < self->len; i++) {
+        for (j = 0; j < other->len; j++) {
+#if DEBUG
+            pair_print(self->pairs[i]);
+            putc(' ', stdout);
+            pair_print(other->pairs[j]);
+            printf(" -> %d\n", pair_equal(self->pairs[i], other->pairs[j]));
+#endif
+            if (pair_equal(self->pairs[i], other->pairs[j])) {
+                matches++;
+                other->pairs[j].status = PAIR_INACTIVE;
+                break;
+            }
+        }
+    }
+    return ((double) (2 * matches)) / sum;
+}
+
+void pair_print(Pair pair)
+{
+    printf("%c%c (%d)", pair.fst, pair.snd, pair.status);
+}
+
+void pair_array_destroy(PairArray *pair_array)
+{
+    xfree(pair_array->pairs);
+    xfree(pair_array);
+}

data/ext/pair.h

@@ -0,0 +1,29 @@
+#ifndef PAIR_H_INCLUDED
+#define PAIR_H_INCLUDED
+
+#include "ruby.h"
+#include "common.h"
+
+enum { PAIR_ACTIVE = 1, PAIR_INACTIVE = 2 };
+
+typedef struct PairStruct {
+    char fst;
+    char snd;
+    char status;
+    char __align;
+} Pair;
+
+typedef struct PairArrayStruct {
+    Pair *pairs;
+    int len;
+} PairArray;
+
+PairArray *PairArray_new(VALUE tokens);
+#define pair_equal(a, b) \
+    ((a).fst == (b).fst && (a).snd == (b).snd && ((a).status & (b).status & PAIR_ACTIVE))
+double pair_array_match(PairArray *self, PairArray *other);
+void pair_array_destroy(PairArray *pair_array);
+void pair_print(Pair pair);
+void pair_array_reactivate(PairArray *self);
+
+#endif

data/install.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+include Config
+require 'fileutils'
+include FileUtils::Verbose
+
+MAKE = ENV['MAKE'] || %w[gmake make].find { |c| system(c, '-v') }
+
+bindir  = CONFIG['bindir']
+archdir = CONFIG['sitearchdir']
+libdir  = CONFIG['sitelibdir']
+dlext   = CONFIG['DLEXT']
+cd 'ext' do
+  system 'ruby extconf.rb' or exit 1
+  system "#{MAKE}" or exit 1
+  mkdir_p archdir
+  install "amatch.#{dlext}", archdir
+end
+cd 'bin' do
+  filename = 'edit_json.rb'
+  install('agrep.rb', bindir)
+end
+cd 'lib/amatch' do
+  mkdir_p d = File.join(libdir, 'amatch')
+  install 'version.rb', d
+end
+warn " *** Installed amatch extension."

data/lib/amatch.rb

@@ -0,0 +1,3 @@
+module Amatch
+end
+require 'amatch/rude'

data/lib/amatch/polite.rb

@@ -0,0 +1,7 @@
+module Amatch
+end
+require 'amatch_ext'
+module Amatch
+  # alias
+  DiceCoefficient = PairDistance
+end

data/lib/amatch/rude.rb

@@ -0,0 +1,7 @@
+require 'amatch_ext'
+module Amatch
+  DiceCoefficient = PairDistance
+end
+class ::String
+  include ::Amatch::StringMethods
+end

data/lib/amatch/version.rb

@@ -0,0 +1,8 @@
+module Amatch
+  # Amatch version
+  VERSION         = '0.2.12'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/tests/test_hamming.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'amatch'
+
+class TestHamming < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @small   = Hamming.new('test')
+    @empty   = Hamming.new('')
+    @long    = Hamming.new('A' * 160)
+  end
+
+  def test_empty
+    assert_in_delta 0, @empty.match(''), D
+    assert_in_delta 9, @empty.match('not empty'), D
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+  end
+
+  def test_small_match
+    assert_in_delta 4, @small.match(''), D
+    assert_in_delta 0, @small.match('test'), D
+    assert_in_delta 1, @small.match('testa'), D
+    assert_in_delta 5, @small.match('atest'), D
+    assert_in_delta 3, @small.match('teast'), D
+    assert_in_delta 4, @small.match('est'), D
+    assert_in_delta 1, @small.match('tes'), D
+    assert_in_delta 3, @small.match('tst'), D
+    assert_in_delta 1, @small.match('best'), D
+    assert_in_delta 1, @small.match('tost'), D
+    assert_in_delta 1, @small.match('tesa'), D
+    assert_in_delta 3, @small.match('taex'), D
+    assert_in_delta 9, @small.match('aaatestbbb'), D
+  end
+
+  def test_small_similar
+    assert_in_delta 0.0, @small.similar(''), D
+    assert_in_delta 1.0, @small.similar('test'), D
+    assert_in_delta 0.8, @small.similar('testa'), D
+    assert_in_delta 0.0, @small.similar('atest'), D
+    assert_in_delta 0.4, @small.similar('teast'), D
+    assert_in_delta 0, @small.similar('est'), D
+    assert_in_delta 0.75, @small.similar('tes'), D
+    assert_in_delta 0.25, @small.similar('tst'), D
+    assert_in_delta 0.75, @small.similar('best'), D
+    assert_in_delta 0.75, @small.similar('tost'), D
+    assert_in_delta 0.75, @small.similar('tesa'), D
+    assert_in_delta 0.25, @small.similar('taex'), D
+    assert_in_delta 0.1, @small.similar('aaatestbbb'), D
+    assert_in_delta 0.8, @small.pattern.hamming_similar('testa'), D
+  end
+
+  def test_long
+    assert_in_delta 1.0, @long.similar(@long.pattern), D
+  end
+end

data/tests/test_jaro.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'amatch'
+
+class TestJaro < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.0005
+
+  def setup
+    @martha = Jaro.new('Martha')
+    @dwayne = Jaro.new('dwayne')
+    @dixon  = Jaro.new('DIXON')
+    @one    = Jaro.new('one')
+  end
+
+  def test_case
+    @martha.ignore_case = true
+    assert_in_delta 0.944, @martha.match('MARHTA'), D
+    @martha.ignore_case = false
+    assert_in_delta 0.444, @martha.match('MARHTA'), D
+  end
+
+  def test_match
+    assert_in_delta 0.944, @martha.match('MARHTA'), D
+    assert_in_delta 0.822, @dwayne.match('DUANE'), D
+    assert_in_delta 0.767, @dixon.match('DICKSONX'), D
+    assert_in_delta 0.667, @one.match('orange'), D
+  end
+end

data/tests/test_jaro_winkler.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require 'amatch'
+
+class TestJaroWinkler < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.0005
+
+  def setup
+    @martha = JaroWinkler.new('Martha')
+    @dwayne = JaroWinkler.new('dwayne')
+    @dixon  = JaroWinkler.new('DIXON')
+    @one    = JaroWinkler.new("one")
+  end
+
+  def test_case
+    @martha.ignore_case = true
+    assert_in_delta 0.961, @martha.match('MARHTA'), D
+    @martha.ignore_case = false
+    assert_in_delta 0.500, @martha.match('MARHTA'), D
+  end
+
+  def test_match
+    assert_in_delta 0.961, @martha.match('MARHTA'), D
+    assert_in_delta 0.840, @dwayne.match('DUANE'), D
+    assert_in_delta 0.813, @dixon.match('DICKSONX'), D
+    assert_in_delta 0, @one.match('two'), D
+    assert_in_delta 0.700, @one.match('orange'), D
+  end
+
+  def test_scaling_factor
+    assert_in_delta 0.1, @martha.scaling_factor, 0.0000001
+    @martha.scaling_factor = 0.2
+    assert_in_delta 0.978, @martha.match('MARHTA'), D
+    @martha.scaling_factor = 0.5 # this is far too high
+    assert_in_delta 1.028, @martha.match('MARHTA'), D
+  end
+end

data/tests/test_levenshtein.rb

@@ -0,0 +1,86 @@
+require 'test/unit'
+require 'amatch'
+
+class TestLevenshtein < Test::Unit::TestCase
+  include Amatch
+
+  def setup
+    @d        = 0.000001
+    @empty    = Levenshtein.new('')
+    @simple   = Levenshtein.new('test')
+    @long     = Levenshtein.new('A' * 160)
+  end
+
+  def test_version
+    assert_kind_of String, Amatch::VERSION
+  end
+
+  def test_match
+    assert_equal 4,     @simple.match('')
+    assert_equal 0,     @simple.match('test')
+    assert_equal 1,     @simple.match('testa')
+    assert_equal 1,     @simple.match('atest')
+    assert_equal 1,     @simple.match('teast')
+    assert_equal 1,     @simple.match('est')
+    assert_equal 1,     @simple.match('tes')
+    assert_equal 1,     @simple.match('tst')
+    assert_equal 1,     @simple.match('best')
+    assert_equal 1,     @simple.match('tost')
+    assert_equal 1,     @simple.match('tesa')
+    assert_equal 3,     @simple.match('taex')
+    assert_equal 6,     @simple.match('aaatestbbb')
+  end
+
+  def test_search
+    assert_equal 4,     @simple.search('')
+    assert_equal 0,     @empty.search('')
+    assert_equal 0,     @empty.search('test')
+    assert_equal 0,     @simple.search('aaatestbbb')
+    assert_equal 3,     @simple.search('aaataexbbb')
+    assert_equal 4,     @simple.search('aaaaaaaaa')
+  end
+
+  def test_array_result
+    assert_equal [2, 0],    @simple.match(["tets", "test"])
+    assert_equal [1, 0],    @simple.search(["tetsaaa", "testaaa"])
+    assert_raises(TypeError) { @simple.match([:foo, "bar"]) }
+  end
+
+  def test_pattern_setting
+    assert_raises(TypeError) { @simple.pattern = :something }
+    assert_equal 0, @simple.match('test')
+    @simple.pattern = ''
+    assert_equal 4, @simple.match('test')
+    @simple.pattern = 'test'
+    assert_equal 0, @simple.match('test')
+  end
+
+  def test_similar
+    assert_in_delta 1, @empty.similar(''), @d
+    assert_in_delta 0, @empty.similar('not empty'), @d
+    assert_in_delta 0.0, @simple.similar(''), @d
+    assert_in_delta 1.0, @simple.similar('test'), @d
+    assert_in_delta 0.8, @simple.similar('testa'), @d
+    assert_in_delta 0.8, @simple.similar('atest'), @d
+    assert_in_delta 0.8, @simple.similar('teast'), @d
+    assert_in_delta 0.75, @simple.similar('est'), @d
+    assert_in_delta 0.75, @simple.similar('tes'), @d
+    assert_in_delta 0.75, @simple.similar('tst'), @d
+    assert_in_delta 0.75, @simple.similar('best'), @d
+    assert_in_delta 0.75, @simple.similar('tost'), @d
+    assert_in_delta 0.75, @simple.similar('tesa'), @d
+    assert_in_delta 0.25, @simple.similar('taex'), @d
+    assert_in_delta 0.4, @simple.similar('aaatestbbb'), @d
+    assert_in_delta 0.75, @simple.pattern.levenshtein_similar('est'), @d
+  end
+
+  def test_long
+    assert_in_delta 1.0, @long.similar(@long.pattern), @d
+  end
+
+  def test_long2
+    a = "lost this fantasy,  this fantasy,  this  fantasy,  this fantasy,  this fantasy,  this fantasy\r\n\r\nGood love  Neat work\r\n\r\nSuper job Fancy work\r\n\r\nPants job Cool work"
+    b = "lost\r\n\r\nGood love Neat work\r\n\r\nSuper  job Fancy work\r\n\r\nPants job Cool work"
+    assert a.levenshtein_similar(b)
+  end
+end

data/tests/test_longest_subsequence.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'amatch'
+
+class TestLongestSubsequence < Test::Unit::TestCase
+  include Amatch
+
+  D = 0.000001
+
+  def setup
+    @small   = LongestSubsequence.new('test')
+    @empty   = LongestSubsequence.new('')
+    @long    = LongestSubsequence.new('A' * 160)
+  end
+
+  def test_empty_subsequence
+    assert_equal 0, @empty.match('')
+    assert_equal 0, @empty.match('a')
+    assert_equal 0, @small.match('')
+    assert_equal 0, @empty.match('not empty')
+  end
+
+  def test_small_subsequence
+    assert_equal 4, @small.match('test')
+    assert_equal 4, @small.match('testa')
+    assert_equal 4, @small.match('atest')
+    assert_equal 4, @small.match('teast')
+    assert_equal 3, @small.match('est')
+    assert_equal 3, @small.match('tes')
+    assert_equal 3, @small.match('tst')
+    assert_equal 3, @small.match('best')
+    assert_equal 3, @small.match('tost')
+    assert_equal 3, @small.match('tesa')
+    assert_equal 2, @small.match('taex')
+    assert_equal 1, @small.match('aaatbbb')
+    assert_equal 1, @small.match('aaasbbb')
+    assert_equal 4, @small.match('aaatestbbb')
+  end
+
+  def test_similar
+    assert_in_delta 1, @empty.similar(''), D
+    assert_in_delta 0, @empty.similar('not empty'), D
+    assert_in_delta 0.0, @small.similar(''), D
+    assert_in_delta 1.0, @small.similar('test'), D
+    assert_in_delta 0.8, @small.similar('testa'), D
+    assert_in_delta 0.8, @small.similar('atest'), D
+    assert_in_delta 0.8, @small.similar('teast'), D
+    assert_in_delta 0.75, @small.similar('est'), D
+    assert_in_delta 0.75, @small.similar('tes'), D
+    assert_in_delta 0.75, @small.similar('tst'), D
+    assert_in_delta 0.75, @small.similar('best'), D
+    assert_in_delta 0.75, @small.similar('tost'), D
+    assert_in_delta 0.75, @small.similar('tesa'), D
+    assert_in_delta 0.50, @small.similar('taex'), D
+    assert_in_delta 0.4, @small.similar('aaatestbbb'), D
+    assert_in_delta 0.75, @small.pattern.longest_subsequence_similar('est'), D
+  end
+
+  def test_long
+    assert_in_delta 1.0, @long.similar(@long.pattern), D
+  end
+end