loose_tight_dictionary 0.2.0 → 0.2.1

data/lib/loose_tight_dictionary.rb

@@ -76,10 +76,12 @@ class LooseTightDictionary
       end
     end
 
-    encompassed, unencompassed = if blockings.any?
+    joint, disjoint = if blockings.any?
       haystack.partition do |straw|
-        blockings.any? do |blocking|
-          blocking.encompass?(needle, straw) == true
+        if first_blocking_decides
+          blockings.detect { |blocking| blocking.match? needle }.try :join?, needle, straw
+        else
+          blockings.any? { |blocking| blocking.join? needle, straw }
         end
       end
     else
@@ -87,25 +89,25 @@ class LooseTightDictionary
     end
     
     # special case: the needle didn't fit anywhere, but must_match_blocking is false, so we'll try it against everything
-    if encompassed.none?
-      encompassed = unencompassed
-      unencompassed = []
+    if joint.none?
+      joint = disjoint
+      disjoint = []
     end
     
     if gather_last_result
-      last_result.encompassed = encompassed
-      last_result.unencompassed = unencompassed
+      last_result.joint = joint
+      last_result.disjoint = disjoint
     end
     
     possibly_identical, certainly_different = if identities.any?
-      encompassed.partition do |straw|
+      joint.partition do |straw|
         identities.all? do |identity|
           answer = identity.identical? needle, straw
           answer.nil? or answer == true
         end
       end
     else
-      [ encompassed.dup, [] ]
+      [ joint.dup, [] ]
     end
     
     if gather_last_result
@@ -117,9 +119,7 @@ class LooseTightDictionary
       return possibly_identical.map { |straw| straw.record }
     end
     
-    similarities = possibly_identical.map do |straw|
-      needle.similarity straw
-    end.sort
+    similarities = possibly_identical.map { |straw| needle.similarity straw }.sort
     
     best_similarity = similarities[-1]
     straw = best_similarity.wrapper2
@@ -164,13 +164,13 @@ class LooseTightDictionary
     log "-" * 150
     log last_result.identities.blank? ? '(none)' : last_result.identities.map { |blocking| blocking.inspect }.join("\n")
     log
-    log "Included"
+    log "Joint"
     log "-" * 150
-    log last_result.encompassed.blank? ? '(none)' : last_result.encompassed.map { |encompassed| encompassed.to_str }.join("\n")
+    log last_result.joint.blank? ? '(none)' : last_result.joint.map { |joint| joint.to_str }.join("\n")
     log
-    log "Ignored"
+    log "Disjoint"
     log "-" * 150
-    log last_result.unencompassed.blank? ? '(none)' : last_result.unencompassed.map { |unencompassed| unencompassed.to_str }.join("\n")
+    log last_result.disjoint.blank? ? '(none)' : last_result.disjoint.map { |disjoint| disjoint.to_str }.join("\n")
     log
     log "Possibly identical"
     log "-" * 150
@@ -196,6 +196,10 @@ class LooseTightDictionary
   def must_match_blocking
     options[:must_match_blocking] || false
   end
+  
+  def first_blocking_decides
+    options[:first_blocking_decides] || false
+  end
 
   def tighteners
     @tighteners ||= (options[:tighteners] || []).map do |regexp_or_str|

data/lib/loose_tight_dictionary/blocking.rb

@@ -10,18 +10,18 @@ class LooseTightDictionary
     attr_reader :regexp
     
     def initialize(regexp_or_str)
-      @regexp = regexp_or_str.is_a?(::Regexp) ? regexp_or_str : regexp_or_str.to_regexp
+      @regexp = regexp_or_str.to_regexp
     end
 
     def match?(str)
       !!(regexp.match(str))
     end
 
-    # If a blocking "encompasses" two strings, that means they both fit into it.
+    # 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 encompass?(str1, str2)
+    def join?(str1, str2)
       if str2_match_data = regexp.match(str2)
         if str1_match_data = regexp.match(str1)
           str2_match_data.captures == str1_match_data.captures

data/lib/loose_tight_dictionary/identity.rb

@@ -5,7 +5,7 @@ class LooseTightDictionary
     attr_reader :regexp
     
     def initialize(regexp_or_str)
-      @regexp = regexp_or_str.is_a?(::Regexp) ? regexp_or_str : regexp_or_str.to_regexp
+      @regexp = regexp_or_str.to_regexp
     end
     
     # Two strings are "identical" if they both match this identity and the captures are equal.

data/lib/loose_tight_dictionary/result.rb

@@ -4,8 +4,8 @@ class LooseTightDictionary
     attr_accessor :tighteners
     attr_accessor :blockings
     attr_accessor :identities
-    attr_accessor :encompassed
-    attr_accessor :unencompassed
+    attr_accessor :joint
+    attr_accessor :disjoint
     attr_accessor :possibly_identical
     attr_accessor :certainly_different
     attr_accessor :similarities
@@ -13,7 +13,7 @@ class LooseTightDictionary
     attr_accessor :score
     
     def haystack
-      encompassed + unencompassed
+      joint + disjoint
     end
     
     def free

data/lib/loose_tight_dictionary/tightener.rb

@@ -4,7 +4,7 @@ class LooseTightDictionary
     attr_reader :regexp
     
     def initialize(regexp_or_str)
-      @regexp = regexp_or_str.is_a?(::Regexp) ? regexp_or_str : regexp_or_str.to_regexp
+      @regexp = regexp_or_str.to_regexp
     end
     
     # A tightener applies when its regexp matches and captures a new (shorter) string

data/lib/loose_tight_dictionary/version.rb

@@ -1,3 +1,3 @@
 class LooseTightDictionary
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/loose_tight_dictionary.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "remote_table"
   s.add_dependency 'activesupport', '>=2.3.4'
   s.add_dependency 'amatch'
-  s.add_dependency 'to_regexp'
+  s.add_dependency 'to_regexp', '>=0.0.3'
 end

data/test/test_blocking.rb

@@ -6,18 +6,18 @@ class TestBlocking < Test::Unit::TestCase
     assert_equal true, b.match?('2 apples')
   end
   
-  def test_002_encompass_both
+  def test_002_join_both
     b = LooseTightDictionary::Blocking.new %r{apple}
-    assert_equal true, b.encompass?('apple', '2 apples')    
+    assert_equal true, b.join?('apple', '2 apples')    
   end
   
-  def test_002_doesnt_encompass_both
+  def test_002_doesnt_join_both
     b = LooseTightDictionary::Blocking.new %r{apple}
-    assert_equal false, b.encompass?('orange', '2 apples')
+    assert_equal false, b.join?('orange', '2 apples')
   end
   
   def test_003_no_information
     b = LooseTightDictionary::Blocking.new %r{apple}
-    assert_equal nil, b.encompass?('orange', 'orange')
+    assert_equal nil, b.join?('orange', 'orange')
   end
 end

data/test/test_loose_tight_dictionary.rb

@@ -78,4 +78,23 @@ class TestLooseTightDictionary < Test::Unit::TestCase
     assert_equal ['X', 'X22' ], d.find_all('X')
     assert_equal [], d.find_all('A')
   end
+  
+  def test_013_first_blocking_decides
+    d = LooseTightDictionary.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :blockings => [ /(boeing \d{3})/i, /boeing/i ]
+    assert_equal [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], d.find_all('Boeing 747')
+    
+    d = LooseTightDictionary.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :blockings => [ /(boeing \d{3})/i, /boeing/i ], :first_blocking_decides => true
+    assert_equal [ 'Boeing 747', 'Boeing 747SR' ], d.find_all('Boeing 747')
+    
+    # first_blocking_decides refers to the needle
+    d = LooseTightDictionary.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :blockings => [ /(boeing \d{3})/i, /boeing/i ], :first_blocking_decides => true
+    assert_equal [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], d.find_all('Boeing ER6')
+    
+    d = LooseTightDictionary.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :blockings => [ /(boeing \d{3})/i, /boeing (7|E)/i, /boeing/i ], :first_blocking_decides => true
+    assert_equal [ 'Boeing ER6' ], d.find_all('Boeing ER6')
+
+    # or equivalently with an identity
+    d = LooseTightDictionary.new [ 'Boeing 747', 'Boeing 747SR', 'Boeing ER6' ], :blockings => [ /(boeing \d{3})/i, /boeing/i ], :first_blocking_decides => true, :identities => [ /boeing (7|E)/i ]
+    assert_equal [ 'Boeing ER6' ], d.find_all('Boeing ER6')
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: loose_tight_dictionary
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-27 00:00:00 Z
+date: 2011-04-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: shoulda
@@ -83,10 +83,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 25
         segments: 
         - 0
-        version: "0"
+        - 0
+        - 3
+        version: 0.0.3
   type: :runtime
   version_requirements: *id005
 description: Create dictionaries that link rows between two tables using loose matching (string similarity) by default and tight matching (regexp) by request.