fuzzy_match 1.3.1 → 1.3.2

data/test/test_fuzzy_match_convoluted.rb.disabled

@@ -42,7 +42,7 @@ class TestFuzzyMatchConvoluted < MiniTest::Spec
     ]
     @tightenings = []
     @identities = []
-    @blockings = []
+    @groupings = []
     @positives = []
     @negatives = []
   end
@@ -55,23 +55,23 @@ class TestFuzzyMatchConvoluted < MiniTest::Spec
     @_ltd ||= FuzzyMatch.new  @haystack,
                                         :tightenings => @tightenings,
                                         :identities => @identities,
-                                        :blockings => @blockings,
+                                        :groupings => @groupings,
                                         :positives => @positives,
                                         :negatives => @negatives,
-                                        :blocking_only => @blocking_only,
+                                        :grouping_only => @grouping_only,
                                         :log => $log
   end
 
-  should "optionally only pay attention to things that match blockings" do
+  should "optionally only pay attention to things that match groupings" do
     assert_equal @a_haystack, ltd.improver.match(@a_needle)
 
     clear_ltd
-    @blocking_only = true
+    @grouping_only = true
     assert_equal nil, ltd.improver.match(@a_needle)
 
     clear_ltd
-    @blocking_only = true
-    @blockings.push ['/dash/i']
+    @grouping_only = true
+    @groupings.push ['/dash/i']
     assert_equal @a_haystack, ltd.improver.match(@a_needle)
   end
   
@@ -111,7 +111,7 @@ class TestFuzzyMatchConvoluted < MiniTest::Spec
     end
   end
   
-  should "have a false match without blocking" do
+  should "have a false match without grouping" do
     # @d_needle will be our victim
     @haystack.push @d_lookalike
     @tightenings.push @t_1
@@ -119,19 +119,19 @@ class TestFuzzyMatchConvoluted < MiniTest::Spec
     assert_equal @d_lookalike, ltd.improver.match(@d_needle)
   end
   
-  should "do blocking if the needle matches a block" do
+  should "do grouping if the needle matches a group" do
     # @d_needle will be our victim
     @haystack.push @d_lookalike
     @tightenings.push @t_1
-    @blockings.push ['/(bombardier|de ?havilland)/i']
+    @groupings.push ['/(bombardier|de ?havilland)/i']
     
     assert_equal @d_haystack, ltd.improver.match(@d_needle)
   end
   
-  should "treat blocks as exclusive" do
+  should "treat groups as exclusive" do
     @haystack = [ @d_needle ]
     @tightenings.push @t_1
-    @blockings.push ['/(bombardier|de ?havilland)/i']
+    @groupings.push ['/(bombardier|de ?havilland)/i']
 
     assert_equal nil, ltd.improver.match(@d_lookalike)
   end

data/test/{test_blocking.rb → test_grouping.rb}

@@ -1,28 +1,28 @@
 require 'helper'
 
-class TestBlocking < MiniTest::Spec
+describe FuzzyMatch::Rule::Grouping do
   it %{matches a single string argument} do
-    b = FuzzyMatch::Blocking.new %r{apple}
+    b = FuzzyMatch::Rule::Grouping.new %r{apple}
     b.match?('2 apples').must_equal true
   end
 
   it %{embraces case insensitivity} do
-    b = FuzzyMatch::Blocking.new %r{apple}i
+    b = FuzzyMatch::Rule::Grouping.new %r{apple}i
     b.match?('2 Apples').must_equal true
   end
   
   it %{joins two string arguments} do
-    b = FuzzyMatch::Blocking.new %r{apple}
+    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::Blocking.new %r{apple}
+    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::Blocking.new %r{apple}
+    b = FuzzyMatch::Rule::Grouping.new %r{apple}
     b.join?('orange', 'orange').must_be_nil
   end
 end

data/test/test_identity.rb

@@ -1,36 +1,36 @@
 require 'helper'
 
-class TestIdentity < MiniTest::Spec
+describe FuzzyMatch::Rule::Identity do
   it %{determines whether two records COULD be identical} do
-    i = FuzzyMatch::Identity.new %r{(A)[ ]*(\d)}
+    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::Identity.new %r{(A)[ ]*(\d)}
+    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::Identity.new %r{(A)[ ]*(\d)}
+    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::Identity.new %r{\A\\?/(.*)etc/mysql\$$}
+    i = FuzzyMatch::Rule::Identity.new %r{\A\\?/(.*)etc/mysql\$$}
     i.regexp.must_equal %r{\A\\?/(.*)etc/mysql\$$}
   end
   
   it %{can be initialized from a string (via to_regexp gem)} do
-    i = FuzzyMatch::Identity.new '%r{\A\\\?/(.*)etc/mysql\$$}'
+    i = FuzzyMatch::Rule::Identity.new '%r{\A\\\?/(.*)etc/mysql\$$}'
     i.regexp.must_equal %r{\A\\?/(.*)etc/mysql\$$}
 
-    i = FuzzyMatch::Identity.new '/\A\\\?\/(.*)etc\/mysql\$$/'
+    i = FuzzyMatch::Rule::Identity.new '/\A\\\?\/(.*)etc\/mysql\$$/'
     i.regexp.must_equal %r{\A\\?/(.*)etc/mysql\$$}
   end
   
   it %{embraces case insensitivity} do
-    i = FuzzyMatch::Identity.new %r{(A)[ ]*(\d)}i
+    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,8 +1,8 @@
 require 'helper'
 
-class TestNormalizer < MiniTest::Spec
+describe FuzzyMatch::Rule::Normalizer do
   it %{applies itself to a string argument} do
-    t = FuzzyMatch::Normalizer.new %r{(Ford )[ ]*(F)[\- ]*(\d\d\d)}i
+    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'

data/test/test_wrapper.rb

@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestWrapper < MiniTest::Spec
+describe FuzzyMatch::Wrapper do
   it %{does not treat "'s" as a word} do
     assert_split ["foo's", "bar"], "Foo's Bar"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fuzzy_match
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,99 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-14 00:00:00.000000000 Z
+date: 2012-02-24 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: &2165315840 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165315840
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: &2165314740 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :development
-  prerelease: false
-  version_requirements: *2165314740
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: &2165314140 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165314140
-- !ruby/object:Gem::Dependency
-  name: cohort_scope
-  requirement: &2165313620 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165313620
-- !ruby/object:Gem::Dependency
-  name: weighted_average
-  requirement: &2165312980 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165312980
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2165312300 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165312300
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: &2165311320 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165311320
-- !ruby/object:Gem::Dependency
-  name: amatch
-  requirement: &2165310720 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2165310720
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2165310000 !ruby/object:Gem::Requirement
+  requirement: &2151876580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +21,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2165310000
+  version_requirements: *2151876580
 - !ruby/object:Gem::Dependency
   name: to_regexp
-  requirement: &2165309100 !ruby/object:Gem::Requirement
+  requirement: &2151871760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,7 +32,7 @@ dependencies:
         version: 0.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *2165309100
+  version_requirements: *2151871760
 description: Find a needle in a haystack using string similarity and (optionally)
   regexp rules. Replaces loose_tight_dictionary.
 email:
@@ -132,6 +44,7 @@ files:
 - .document
 - .gitignore
 - Gemfile
+- History.txt
 - LICENSE
 - README.markdown
 - Rakefile
@@ -145,7 +58,7 @@ files:
 - examples/bts_aircraft/5-2-D.htm
 - examples/bts_aircraft/5-2-E.htm
 - examples/bts_aircraft/5-2-G.htm
-- examples/bts_aircraft/blockings.csv
+- examples/bts_aircraft/groupings.csv
 - examples/bts_aircraft/identities.csv
 - examples/bts_aircraft/negatives.csv
 - examples/bts_aircraft/normalizers.csv
@@ -156,24 +69,25 @@ files:
 - examples/icao-bts.xls
 - fuzzy_match.gemspec
 - lib/fuzzy_match.rb
-- lib/fuzzy_match/blocking.rb
 - lib/fuzzy_match/cached_result.rb
-- lib/fuzzy_match/identity.rb
-- lib/fuzzy_match/normalizer.rb
 - lib/fuzzy_match/result.rb
+- lib/fuzzy_match/rule.rb
+- lib/fuzzy_match/rule/grouping.rb
+- lib/fuzzy_match/rule/identity.rb
+- lib/fuzzy_match/rule/normalizer.rb
+- lib/fuzzy_match/rule/stop_word.rb
 - lib/fuzzy_match/score.rb
 - lib/fuzzy_match/score/amatch.rb
 - lib/fuzzy_match/score/pure_ruby.rb
 - lib/fuzzy_match/similarity.rb
-- lib/fuzzy_match/stop_word.rb
 - lib/fuzzy_match/version.rb
 - lib/fuzzy_match/wrapper.rb
 - test/helper.rb
 - test/test_amatch.rb
-- test/test_blocking.rb
 - test/test_cache.rb
 - test/test_fuzzy_match.rb
 - test/test_fuzzy_match_convoluted.rb.disabled
+- test/test_grouping.rb
 - test/test_identity.rb
 - test/test_normalizer.rb
 - test/test_wrapper.rb
@@ -205,10 +119,10 @@ summary: Find a needle in a haystack using string similarity and (optionally) re
 test_files:
 - test/helper.rb
 - test/test_amatch.rb
-- test/test_blocking.rb
 - test/test_cache.rb
 - test/test_fuzzy_match.rb
 - test/test_fuzzy_match_convoluted.rb.disabled
+- test/test_grouping.rb
 - test/test_identity.rb
 - test/test_normalizer.rb
 - test/test_wrapper.rb

data/lib/fuzzy_match/blocking.rb

@@ -1,36 +0,0 @@
-class FuzzyMatch
-  # "Record linkage typically involves two main steps: blocking and scoring..."
-  # http://en.wikipedia.org/wiki/Record_linkage
-  #
-  # Blockings effectively divide up the haystack into groups that match a pattern
-  #
-  # A blocking (as in a grouping) comes into effect when a str matches.
-  # Then the needle must also match the blocking's regexp.
-  class Blocking
-    attr_reader :regexp
-    
-    def initialize(regexp_or_str)
-      @regexp = regexp_or_str.to_regexp
-    end
-
-    def match?(str)
-      !!(regexp.match(str))
-    end
-
-    # If a blocking "joins" two strings, that means they both fit into it.
-    #
-    # Returns false if they certainly don't fit this blocking.
-    # Returns nil if the blocking doesn't apply, i.e. str2 doesn't fit the blocking.
-    def join?(str1, str2)
-      if str2_match_data = regexp.match(str2)
-        if str1_match_data = regexp.match(str1)
-          str2_match_data.captures.join.downcase == str1_match_data.captures.join.downcase
-        else
-          false
-        end
-      else
-        nil
-      end
-    end
-  end
-end

data/lib/fuzzy_match/identity.rb

@@ -1,23 +0,0 @@
-class FuzzyMatch
-  # Identities take effect when needle and haystack both match a regexp
-  # Then the captured part of the regexp has to match exactly
-  class Identity
-    attr_reader :regexp
-    
-    def initialize(regexp_or_str)
-      @regexp = regexp_or_str.to_regexp
-    end
-    
-    # Two strings are "identical" if they both match this identity and the captures are equal.
-    #
-    # Only returns true/false if both strings match the regexp.
-    # Otherwise returns nil.
-    def identical?(str1, str2)
-      if str1_match_data = regexp.match(str1) and match_data = regexp.match(str2)
-        str1_match_data.captures.join.downcase == match_data.captures.join.downcase
-      else
-        nil
-      end
-    end
-  end
-end

data/lib/fuzzy_match/normalizer.rb

@@ -1,28 +0,0 @@
-class FuzzyMatch
-  # A normalizer just strips a string down to its core
-  class Normalizer
-    attr_reader :regexp
-    
-    def initialize(regexp_or_str)
-      @regexp = regexp_or_str.to_regexp
-    end
-    
-    # A normalizer applies when its regexp matches and captures a new (shorter) string
-    def apply?(str)
-      !!(regexp.match(str))
-    end
-    
-    # The result of applying a normalizer is just all the captures put together.
-    def apply(str)
-      if match_data = regexp.match(str)
-        match_data.captures.join
-      else
-        str
-      end
-    end
-    
-    def inspect
-      "#<FuzzyMatch::Normalizer regexp=#{regexp.inspect}>"
-    end
-  end
-end