fuzzy_match 1.5.0 → 2.0.0

data/test/test_fuzzy_match.rb

@@ -1,304 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'helper'
-
-describe FuzzyMatch do
-  describe '#find' do
-    it %{identifies the best match based on string similarity} do
-      d = FuzzyMatch.new %w{ RATZ CATZ }
-      d.find('RITZ').must_equal 'RATZ'
-      d.find('RíTZ').must_equal 'RATZ'
-
-      d = FuzzyMatch.new [ 'X' ]
-      d.find('X').must_equal 'X'
-      d.find('A').must_be_nil
-    end
-  
-    it %{not return any result if the maximum score is zero} do
-      FuzzyMatch.new(['a']).find('b').must_be_nil
-    end
-  end
-  
-  describe '#find_all' do
-    it %{return all records in sorted order} do
-      d = FuzzyMatch.new [ 'X', 'X22', 'Y', 'Y4' ], :groupings => [ /X/, /Y/ ], :must_match_grouping => true
-      d.find_all('X').must_equal ['X', 'X22' ]
-      d.find_all('A').must_equal []
-    end
-  end
-
-  describe '#find_best' do
-    it %{returns one or more records with the best score} do
-      d = FuzzyMatch.new [ 'X', 'X', 'X22', 'Y', 'Y', 'Y4' ], :groupings => [ /X/, /Y/ ], :must_match_grouping => true
-      d.find_best('X').must_equal ['X', 'X' ]
-      d.find_best('A').must_equal []
-    end
-  end
-
-  describe '#find_all_with_score' do
-    it %{return records with 2 scores} do
-      d = FuzzyMatch.new [ 'X', 'X22', 'Y', 'Y4' ], :groupings => [ /X/, /Y/ ], :must_match_grouping => true
-      d.find_all_with_score('X').must_equal [ ['X', 1, 1], ['X22', 0, 0.33333333333333337] ]
-      d.find_all_with_score('A').must_equal []
-    end
-  end
-
-  describe '#explain' do
-    before do
-      require 'stringio'
-      @capture = StringIO.new
-      @old_stdout = $stdout
-      $stdout = @capture
-    end
-    after do
-      $stdout = @old_stdout
-    end
-      
-    it %{print a basic explanation to stdout} do
-      d = FuzzyMatch.new %w{ RATZ CATZ }
-      d.explain('RITZ')
-      @capture.rewind
-      @capture.read.must_include 'CATZ'
-    end
-    
-    it %{explains match failures} do
-      FuzzyMatch.new(['aaa']).explain('bbb')
-      @capture.rewind
-      @capture.read.must_match %r{No winner assigned.*aaa.*bbb}
-    end
-  end
-
-  describe "normalizers" do
-    it %{sometimes gets false results without them} do
-      d = FuzzyMatch.new ['BOEING 737-100/200', 'BOEING 737-900']
-      d.find('BOEING 737100 number 900').must_equal 'BOEING 737-900'
-    end
-
-    it %{can be used to improve results} do
-      normalizers = [
-        %r{(7\d)(7|0)-?(\d{1,3})} # tighten 737-100/200 => 737100, which will cause it to win over 737-900
-      ]
-      d = FuzzyMatch.new ['BOEING 737-100/200', 'BOEING 737-900'], :normalizers => normalizers
-      d.find('BOEING 737100 number 900').must_equal 'BOEING 737-100/200'
-    end
-  end
-
-  describe "identities" do
-    it %{sometimes gets false results without them} do
-      # false positive without identity
-      d = FuzzyMatch.new %w{ foo bar }
-      d.find('baz').must_equal 'bar'
-    end
-
-    it %{can be used to improve results} do
-      d = FuzzyMatch.new %w{ foo bar }, :identities => [ /ba(.)/ ]
-      d.find('baz').must_be_nil
-    end
-  end
-
-  describe 'groupings' do
-    it %{sometimes gets false results without them} do
-      d = FuzzyMatch.new [ 'Barack Obama', 'George Bush' ]
-      d.find('Barack Bush').must_equal 'Barack Obama' # luke i am your father
-      d.find('George Obama').must_equal 'George Bush' # nooooooooooooooooooo
-    end
-    
-    it %{can be used to improve results} do
-      d = FuzzyMatch.new [ 'Barack Obama', 'George Bush' ], :groupings => [ /Obama/, /Bush/ ]
-      d.find('Barack Bush').must_equal 'George Bush'
-      d.find('George Obama').must_equal 'Barack Obama'
-    end
-  end
-  
-  describe "the :must_match_grouping option" do
-    it %{optionally only attempt matches with records that fit into a grouping} do
-      d = FuzzyMatch.new [ 'Barack Obama', 'George Bush' ], :groupings => [ /Obama/, /Bush/ ], :must_match_grouping => true
-      d.find('George Clinton').must_be_nil
-
-      d = FuzzyMatch.new [ 'Barack Obama', 'George Bush' ], :groupings => [ /Obama/, /Bush/ ]
-      d.find('George Clinton', :must_match_grouping => true).must_be_nil
-    end
-  end
-  
-  describe "the :first_grouping_decides option" do
-    it %{optionally force the first grouping to decide} do
-      d = FuzzyMatch.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :groupings => [ /(boeing \d{3})/i, /boeing/i ]
-      d.find_all('Boeing 747').must_equal [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ]
-
-      d = FuzzyMatch.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :groupings => [ /(boeing \d{3})/i, /boeing/i ], :first_grouping_decides => true
-      d.find_all('Boeing 747').must_equal [ 'Boeing 747', 'Boeing 747SR' ]
-
-      # first_grouping_decides refers to the needle
-      d = FuzzyMatch.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :groupings => [ /(boeing \d{3})/i, /boeing/i ], :first_grouping_decides => true
-      d.find_all('Boeing ER6').must_equal ["Boeing ER6", "Boeing 747", "Boeing 747SR"]
-
-      d = FuzzyMatch.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :groupings => [ /(boeing \d{3})/i, /boeing (7|E)/i, /boeing/i ], :first_grouping_decides => true
-      d.find_all('Boeing ER6').must_equal [ 'Boeing ER6' ]
-
-      # or equivalently with an identity
-      d = FuzzyMatch.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :groupings => [ /(boeing \d{3})/i, /boeing/i ], :first_grouping_decides => true, :identities => [ /boeing (7|E)/i ]
-      d.find_all('Boeing ER6').must_equal [ 'Boeing ER6' ]
-    end
-  end
-
-  describe "the :read option" do
-    it %{interpret a Numeric as an array index} do
-      ab = ['a', 'b']
-      ba = ['b', 'a']
-      haystack = [ab, ba]
-      by_first = FuzzyMatch.new haystack, :read => 0
-      by_last = FuzzyMatch.new haystack, :read => 1
-      by_first.find('a').must_equal ab
-      by_last.find('b').must_equal ab
-      by_first.find('b').must_equal ba
-      by_last.find('a').must_equal ba
-    end
-
-    it %{interpret a Symbol, etc. as hash key} do
-      ab = { :one => 'a', :two => 'b' }
-      ba = { :one => 'b', :two => 'a' }
-      haystack = [ab, ba]
-      by_first = FuzzyMatch.new haystack, :read => :one
-      by_last = FuzzyMatch.new haystack, :read => :two
-      by_first.find('a').must_equal ab
-      by_last.find('b').must_equal ab
-      by_first.find('b').must_equal ba
-      by_last.find('a').must_equal ba
-    end
-
-    MyStruct = Struct.new(:one, :two)
-    it %{interpret a Symbol as a method id (if the object responds to it)} do
-      ab = MyStruct.new('a', 'b')
-      ba = MyStruct.new('b', 'a')
-      haystack = [ab, ba]
-      by_first = FuzzyMatch.new haystack, :read => :one
-      by_last = FuzzyMatch.new haystack, :read => :two
-      by_first.read.must_equal :one
-      by_last.read.must_equal :two
-      by_first.find('a').must_equal ab
-      by_last.find('b').must_equal ab
-      by_first.find('b').must_equal ba
-      by_last.find('a').must_equal ba
-    end
-  end
-  
-  describe 'the :must_match_at_least_one_word option' do
-    it %{optionally require that the matching record share at least one word with the needle} do
-      d = FuzzyMatch.new %w{ RATZ CATZ }, :must_match_at_least_one_word => true
-      d.find('RITZ').must_be_nil
-
-      d = FuzzyMatch.new ["Foo's Bar"], :must_match_at_least_one_word => true
-      d.find("Foo's").must_equal "Foo's Bar"
-      d.find("'s").must_be_nil
-      d.find("Foo").must_be_nil
-
-      d = FuzzyMatch.new ["Bolivia, Plurinational State of"], :must_match_at_least_one_word => true
-      d.find("Bolivia").must_equal "Bolivia, Plurinational State of"
-    end
-
-    it %{use STOP WORDS} do
-      d = FuzzyMatch.new [ 'A HOTEL', 'B HTL' ]
-      d.find('A HTL', :must_match_at_least_one_word => true).must_equal 'B HTL'
-
-      d = FuzzyMatch.new [ 'A HOTEL', 'B HTL' ], :must_match_at_least_one_word => true
-      d.find('A HTL').must_equal 'B HTL'
-
-      d = FuzzyMatch.new [ 'A HOTEL', 'B HTL' ], :must_match_at_least_one_word => true, :stop_words => [ %r{HO?TE?L} ]
-      d.find('A HTL').must_equal 'A HOTEL'
-    end
-    
-    it %{not be fooled by substrings (but rather compare whole words to whole words)} do
-      d = FuzzyMatch.new [ 'PENINSULA HOTELS' ], :must_match_at_least_one_word => true
-      d.find('DOLCE LA HULPE BXL FI').must_be_nil
-    end
-
-    it %{not be case-sensitive when checking for sharing of words} do
-      d = FuzzyMatch.new [ 'A', 'B' ]
-      d.find('a', :must_match_at_least_one_word => true).must_equal 'A'
-    end
-  end
-  
-  describe "the :gather_last_result option" do
-    it %{not gather metadata about the last result by default} do
-      d = FuzzyMatch.new %w{ NISSAN HONDA }
-      d.find('MISSAM')
-      lambda do
-        d.last_result
-      end.must_raise ::RuntimeError, /gather_last_result/
-    end
-
-    it %{optionally gather metadata about the last result} do
-      d = FuzzyMatch.new %w{ NISSAN HONDA }
-      d.find 'MISSAM', :gather_last_result => true
-      d.last_result.score.must_equal 0.6
-      d.last_result.winner.must_equal 'NISSAN'
-    end
-  end
-  
-  describe 'quirks' do
-    it %{should not return false negatives because of one-letter similarities} do
-      # dices coefficient doesn't think these two are similar at all because it looks at pairs
-      FuzzyMatch.score_class.new('X foo', 'X bar').dices_coefficient_similar.must_equal 0
-      # so we must compensate for that somewhere
-      d = FuzzyMatch.new ['X foo', 'randomness']
-      d.find('X bar').must_equal 'X foo'
-      # without making false positives
-      d.find('Y bar').must_be_nil
-    end
-
-    it %{finds possible matches even when pair distance fails} do
-      d = FuzzyMatch.new ['XX', '2 A']
-      d.find('2A').must_equal '2 A'
-      d = FuzzyMatch.new ['XX', '2A']
-      d.find('2 A').must_equal '2A'
-    end
-
-    it %{weird blow ups} do
-      d = FuzzyMatch.new ['XX', '2 A']
-      d.find('A').must_equal '2 A'
-      d = FuzzyMatch.new ['XX', 'A']
-      d.find('2 A').must_equal 'A'
-    end
-
-  end
-
-  describe 'deprecations' do
-    it %{takes :must_match_blocking as :must_match_grouping} do
-      d = FuzzyMatch.new [], :must_match_blocking => :a
-      d.default_options[:must_match_grouping].must_equal :a
-    end
-
-    it %{takes :first_blocking_decides as :first_grouping_decides} do
-      d = FuzzyMatch.new [], :first_blocking_decides => :b
-      d.default_options[:first_grouping_decides].must_equal :b
-    end
-
-    it %{takes :haystack_reader as :read} do
-      d = FuzzyMatch.new [], :haystack_reader => :c
-      d.read.must_equal :c
-    end
-
-    it %{takes :blockings as :groupings} do
-      d = FuzzyMatch.new [], :blockings => [ /X/, /Y/ ]
-      d.groupings.must_equal [ FuzzyMatch::Rule::Grouping.new(/X/), FuzzyMatch::Rule::Grouping.new(/Y/) ]
-    end
-
-    it %{takes :tighteners as :normalizers} do
-      d = FuzzyMatch.new [], :tighteners => [ /X/, /Y/ ]
-      d.normalizers.must_equal [ FuzzyMatch::Rule::Normalizer.new(/X/), FuzzyMatch::Rule::Normalizer.new(/Y/) ]
-    end
-
-    it %{receives #free method, but doesn't do anything} do
-      d = FuzzyMatch.new %w{ A B }
-      d.free
-      d.find('A').wont_be_nil
-    end
-  end
-  
-  it %{defaults to a pure-ruby engine, but also has amatch} do
-    if defined?($testing_amatch) and $testing_amatch
-      FuzzyMatch.engine.must_equal :amatch
-    else
-      FuzzyMatch.engine.must_equal :pure_ruby
-    end
-  end
-end

data/test/test_fuzzy_match_convoluted.rb.disabled

@@ -1,268 +0,0 @@
-require 'helper'
-
-require 'shoulda'
-
-$log = false
-
-class TestFuzzyMatchConvoluted < MiniTest::Spec
-  def setup
-    clear_ltd
-    
-    # dh 8 400
-    @a_needle = ['DE HAVILLAND CANADA DHC8400 Dash 8']
-    @a_haystack = ['DEHAVILLAND DEHAVILLAND DHC8-400 DASH-8']
-    # dh 88
-    @b_needle = ['ABCDEFG DH88 HIJKLMNOP']
-    # dh 89
-    @c_haystack = ['ABCDEFG DH89 HIJKLMNOP']
-    # dh 8 200
-    @d_needle = ['DE HAVILLAND CANADA DHC8200 Dash 8']
-    @d_haystack = ['BOMBARDIER DEHAVILLAND DHC8-200Q DASH-8']
-    @d_lookalike = ['ABCD DHC8200 Dash 8']
-    
-    @t_1 = [ '/(dh)c?-?(\d{0,2})-?(\d{0,4})(?:.*?)(dash|\z)/i', 'good tightening for de havilland' ]
-    
-    @r_1 = [ '/(dh)c?-?(\d{0,2})-?(\d{0,4})(?:.*?)(dash|\z)/i', 'good identity for de havilland' ]
-    
-    @needle = [
-      @a_needle,
-      @b_needle,
-      ['DE HAVILLAND DH89 Dragon Rapide'],
-      ['DE HAVILLAND CANADA DHC8100 Dash 8 (E9, CT142, CC142)'],
-      @d_needle,
-      ['DE HAVILLAND CANADA DHC8300 Dash 8'],
-      ['DE HAVILLAND DH90 Dragonfly']
-    ]
-    @haystack = [
-      @a_haystack,
-      @c_haystack,
-      @d_haystack,
-      ['DEHAVILLAND DEHAVILLAND DHC8-100 DASH-8'],
-      ['DEHAVILLAND DEHAVILLAND TWIN OTTER DHC-6']
-    ]
-    @tightenings = []
-    @identities = []
-    @groupings = []
-    @positives = []
-    @negatives = []
-  end
-
-  def clear_ltd
-    @_ltd = nil
-  end
-  
-  def ltd
-    @_ltd ||= FuzzyMatch.new  @haystack,
-                                        :tightenings => @tightenings,
-                                        :identities => @identities,
-                                        :groupings => @groupings,
-                                        :positives => @positives,
-                                        :negatives => @negatives,
-                                        :grouping_only => @grouping_only,
-                                        :log => $log
-  end
-
-  should "optionally only pay attention to things that match groupings" do
-    assert_equal @a_haystack, ltd.improver.match(@a_needle)
-
-    clear_ltd
-    @grouping_only = true
-    assert_equal nil, ltd.improver.match(@a_needle)
-
-    clear_ltd
-    @grouping_only = true
-    @groupings.push ['/dash/i']
-    assert_equal @a_haystack, ltd.improver.match(@a_needle)
-  end
-  
-  # the example from the readme, considerably uglier here
-  should "check a simple table" do
-    @haystack = [ 'seamus', 'andy', 'ben' ]
-    @positives = [ [ 'seamus', 'Mr. Seamus Abshere' ] ]
-    needle = [ 'Mr. Seamus Abshere', 'Sr. Andy Rossmeissl', 'Master BenT' ]
-  
-    assert_nothing_raised do
-      ltd.improver.check needle
-    end
-  end
-  
-  should "treat a String as a full record if passed through" do
-    dash = 'DHC8-400'
-    b747 = 'B747200/300'
-    dc9 = 'DC-9-10'
-    haystack_records = [ dash, b747, dc9 ]
-    simple_ltd = FuzzyMatch.new haystack_records, :log => $log
-    assert_equal dash, simple_ltd.improver.match('DeHavilland Dash-8 DHC-400')
-    assert_equal b747, simple_ltd.improver.match('Boeing 747-300')
-    assert_equal dc9, simple_ltd.improver.match('McDonnell Douglas MD81/DC-9')
-  end
-  
-  should "call it a mismatch if you hit a blank positive" do
-    @positives.push [@a_needle[0], '']
-    assert_raises(FuzzyMatch::Improver::Mismatch) do
-      ltd.improver.match @a_needle
-    end
-  end
-
-  should "call it a false positive if you hit a blank negative" do
-    @negatives.push [@a_needle[0], '']
-    assert_raises(FuzzyMatch::Improver::FalsePositive) do
-      ltd.improver.match @a_needle
-    end
-  end
-  
-  should "have a false match without grouping" do
-    # @d_needle will be our victim
-    @haystack.push @d_lookalike
-    @tightenings.push @t_1
-    
-    assert_equal @d_lookalike, ltd.improver.match(@d_needle)
-  end
-  
-  should "do grouping if the needle matches a group" do
-    # @d_needle will be our victim
-    @haystack.push @d_lookalike
-    @tightenings.push @t_1
-    @groupings.push ['/(bombardier|de ?havilland)/i']
-    
-    assert_equal @d_haystack, ltd.improver.match(@d_needle)
-  end
-  
-  should "treat groups as exclusive" do
-    @haystack = [ @d_needle ]
-    @tightenings.push @t_1
-    @groupings.push ['/(bombardier|de ?havilland)/i']
-
-    assert_equal nil, ltd.improver.match(@d_lookalike)
-  end
-  
-  should "only use identities if they stem from the same regexp" do
-    @identities.push @r_1
-    @identities.push [ '/(cessna)(?:.*?)(citation)/i' ]
-    @identities.push [ '/(cessna)(?:.*?)(\d\d\d)/i' ]
-    x_needle = [ 'CESSNA D-333 CITATION V']
-    x_haystack = [ 'CESSNA D-333' ]
-    @haystack.push x_haystack
-    
-    assert_equal x_haystack, ltd.improver.match(x_needle)
-  end
-  
-  should "use the best score from all of the tightenings" do
-    x_needle = ["BOEING 737100"]
-    x_haystack = ["BOEING BOEING 737-100/200"]
-    x_haystack_wrong = ["BOEING BOEING 737-900"]
-    @haystack.push x_haystack
-    @haystack.push x_haystack_wrong
-    @tightenings.push ['/(7\d)(7|0)-?\d{1,3}\/(\d\d\d)/i']
-    @tightenings.push ['/(7\d)(7|0)-?(\d{1,3}|[A-Z]{0,3})/i']
-    
-    assert_equal x_haystack, ltd.improver.match(x_needle)
-  end
-  
-  should "compare using prefixes if tightened key is shorter than correct match" do
-    x_needle = ["BOEING 720"]
-    x_haystack = ["BOEING BOEING 720-000"]
-    x_haystack_wrong = ["BOEING BOEING 717-200"]
-    @haystack.push x_haystack
-    @haystack.push x_haystack_wrong
-    @tightenings.push @t_1
-    @tightenings.push ['/(7\d)(7|0)-?\d{1,3}\/(\d\d\d)/i']
-    @tightenings.push ['/(7\d)(7|0)-?(\d{1,3}|[A-Z]{0,3})/i']
-    
-    assert_equal x_haystack, ltd.improver.match(x_needle)
-  end
-  
-  should "use the shortest original input" do
-    x_needle = ['De Havilland DHC8-777 Dash-8 Superstar']
-    x_haystack = ['DEHAVILLAND DEHAVILLAND DHC8-777 DASH-8 Superstar']
-    x_haystack_long = ['DEHAVILLAND DEHAVILLAND DHC8-777 DASH-8 Superstar/Supernova']
-    
-    @haystack.push x_haystack_long
-    @haystack.push x_haystack
-    @tightenings.push @t_1
-    
-    assert_equal x_haystack, ltd.improver.match(x_needle)
-  end
-  
-  should "perform lookups needle to haystack" do
-    assert_equal @a_haystack, ltd.improver.match(@a_needle)
-  end
-
-  should "succeed if there are no checks" do
-    assert_nothing_raised do
-      ltd.improver.check @needle
-    end
-  end
-
-  should "succeed if the positive checks just work" do
-    @positives.push [ @a_needle[0], @a_haystack[0] ]
-  
-    assert_nothing_raised do
-      ltd.improver.check @needle
-    end
-  end
-
-  should "fail if positive checks don't work" do
-    @positives.push [ @d_needle[0], @d_haystack[0] ]
-
-    assert_raises(FuzzyMatch::Improver::Mismatch) do
-      ltd.improver.check @needle
-    end
-  end
-
-  should "succeed if proper tightening is applied" do
-    @positives.push [ @d_needle[0], @d_haystack[0] ]
-    @tightenings.push @t_1
-
-    assert_nothing_raised do
-      ltd.improver.check @needle
-    end
-  end
-
-  should "use a Google Docs spreadsheet as a source of tightenings" do
-    @positives.push [ @d_needle[0], @d_haystack[0] ]
-    @tightenings = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=0&output=csv', :headers => false
-  
-    # sabshere 9/30/10 this shouldn't raise anything
-    # but the tightenings have been changed... we should be using test-only tightenings, not production ones
-    # assert_nothing_raised do
-    assert_raises(FuzzyMatch::Improver::Mismatch) do
-      ltd.improver.check @needle
-    end
-  end
-  
-  should "fail if negative checks don't work" do
-    @negatives.push [ @b_needle[0], @c_haystack[0] ]
-  
-    assert_raises(FuzzyMatch::Improver::FalsePositive) do
-      ltd.improver.check @needle
-    end
-  end
-  
-  should "do inline checking" do
-    @negatives.push [ @b_needle[0], @c_haystack[0] ]
-  
-    assert_raises(FuzzyMatch::Improver::FalsePositive) do
-      ltd.improver.match @b_needle
-    end
-  end
-
-  should "fail if negative checks don't work, even with tightening" do
-    @negatives.push [ @b_needle[0], @c_haystack[0] ]
-    @tightenings.push @t_1
-  
-    assert_raises(FuzzyMatch::Improver::FalsePositive) do
-      ltd.improver.check @needle
-    end
-  end
-
-  should "succeed if proper identity is applied" do
-    @negatives.push [ @b_needle[0], @c_haystack[0] ]
-    @positives.push [ @d_needle[0], @d_haystack[0] ]
-    @identities.push @r_1
-  
-    assert_nothing_raised do
-      ltd.improver.check @needle
-    end
-  end
-end

data/test/test_grouping.rb

@@ -1,28 +0,0 @@
-require 'helper'
-
-describe FuzzyMatch::Rule::Grouping do
-  it %{matches a single string argument} do
-    b = FuzzyMatch::Rule::Grouping.new %r{apple}
-    b.match?('2 apples').must_equal true
-  end
-
-  it %{embraces case insensitivity} do
-    b = FuzzyMatch::Rule::Grouping.new %r{apple}i
-    b.match?('2 Apples').must_equal true
-  end
-  
-  it %{joins two string arguments} do
-    b = FuzzyMatch::Rule::Grouping.new %r{apple}
-    b.join?('apple', '2 apples').must_equal true
-  end
-  
-  it %{fails to join two string arguments} do
-    b = FuzzyMatch::Rule::Grouping.new %r{apple}
-    b.join?('orange', '2 apples').must_equal false
-  end
-  
-  it %{returns nil instead of false when it has no information} do
-    b = FuzzyMatch::Rule::Grouping.new %r{apple}
-    b.join?('orange', 'orange').must_be_nil
-  end
-end

data/test/test_identity.rb

@@ -1,34 +0,0 @@
-require 'helper'
-
-describe FuzzyMatch::Rule::Identity do
-  it %{determines whether two records COULD be identical} do
-    i = FuzzyMatch::Rule::Identity.new %r{(A)[ ]*(\d)}
-    i.identical?('A1', 'A     1foobar').must_equal true
-  end
-  
-  it %{determines that two records MUST NOT be identical} do
-    i = FuzzyMatch::Rule::Identity.new %r{(A)[ ]*(\d)}
-    i.identical?('A1', 'A     2foobar').must_equal false
-  end
-  
-  it %{returns nil indicating no information} do
-    i = FuzzyMatch::Rule::Identity.new %r{(A)[ ]*(\d)}
-    i.identical?('B1', 'A     2foobar').must_equal nil
-  end
-
-  it %{can be initialized with a regexp} do
-    i = FuzzyMatch::Rule::Identity.new %r{\A\\?/(.*)etc/mysql\$$}
-    i.regexp.must_equal %r{\A\\?/(.*)etc/mysql\$$}
-  end
-  
-  it %{does not automatically convert strings to regexps} do
-    lambda do
-      FuzzyMatch::Rule::Identity.new '%r{\A\\\?/(.*)etc/mysql\$$}'
-    end.must_raise ArgumentError, /regexp/i
-  end
-  
-  it %{embraces case insensitivity} do
-    i = FuzzyMatch::Rule::Identity.new %r{(A)[ ]*(\d)}i
-    i.identical?('A1', 'a     1foobar').must_equal true
-  end
-end

data/test/test_normalizer.rb

@@ -1,10 +0,0 @@
-require 'helper'
-
-describe FuzzyMatch::Rule::Normalizer do
-  it %{applies itself to a string argument} do
-    t = FuzzyMatch::Rule::Normalizer.new %r{(Ford )[ ]*(F)[\- ]*(\d\d\d)}i
-    t.apply('Ford F-350').must_equal 'Ford F350'
-    t.apply('Ford F150').must_equal 'Ford F150'
-    t.apply('Ford F 350').must_equal 'Ford F350'
-  end
-end