loose_tight_dictionary 0.0.1 → 0.0.2

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/examples/icao-bts.rb

@@ -28,7 +28,7 @@ $tee = STDOUT
 
 @tightenings = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=0&output=csv', :headers => false
 
-@restrictions = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=3&output=csv', :headers => false
+@identities = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=3&output=csv', :headers => false
 
 @blockings = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=4&output=csv', :headers => false
 
@@ -36,7 +36,7 @@ $tee = STDOUT
 
 @negatives = RemoteTable.new :url => 'http://spreadsheets.google.com/pub?key=tiS_6CCDDM_drNphpYwE_iw&single=true&gid=2&output=csv', :headers => false
 
-%w{ tightenings restrictions blockings }.each do |name|
+%w{ tightenings identities blockings }.each do |name|
   $logger.info name
   $logger.info "\n" + instance_variable_get("@#{name}").to_a.map { |record| record[0] }.join("\n")
   $logger.info "\n"
@@ -49,7 +49,7 @@ end
                           :row_xpath => '//table/tr[2]/td/table/tr',
                           :column_xpath => 'td'
 
-  d = LooseTightDictionary.new @right, :tightenings => @tightenings, :restrictions => @restrictions, :blockings => @blockings, :logger => $logger, :tee => $tee
+  d = LooseTightDictionary.new @right, :tightenings => @tightenings, :identities => @identities, :blockings => @blockings, :logger => $logger, :tee => $tee
   d.left_reader = lambda { |record| record['Manufacturer'] + ' ' + record['Model'] }
   d.right_reader = lambda { |record| record['Manufacturer'] + ' ' + record['Long Name'] }
   d.positives = @positives

data/lib/loose_tight_dictionary.rb

@@ -40,7 +40,7 @@ class LooseTightDictionary
 
   attr_reader :right_records
   attr_reader :tightenings
-  attr_reader :restrictions
+  attr_reader :identities
   attr_reader :blockings
   attr_reader :logger
   attr_reader :tee
@@ -54,7 +54,7 @@ class LooseTightDictionary
   def initialize(right_records, options = {})
     @right_records = right_records
     @tightenings = options[:tightenings] || Array.new
-    @restrictions = options[:restrictions] || Array.new
+    @identities = options[:identities] || Array.new
     @blockings = options[:blockings] || Array.new
     @left_reader = options[:left_reader]
     @right_reader = options[:right_reader]
@@ -100,29 +100,33 @@ class LooseTightDictionary
       return
     end
     left_records.each do |left_record|
-      right_record = left_to_right left_record
-      inline_check left_record, right_record
-      tee.andand.puts [ read_left(left_record), read_right(right_record), $ltd_1 ].flatten.to_csv
+      begin
+        right_record = left_to_right left_record
+      ensure
+        tee.andand.puts [ read_left(left_record), read_right(right_record), $ltd_1 ].flatten.to_csv
+      end
     end
   end
   
   def left_to_right(left_record)
     left = read_left left_record
-    restricted_left = restrict left
+    i_options_left = i_options left
     blocking_left = blocking left
     t_options_left = t_options left
     history = Hash.new
     right_record = right_records.select { |record| blocking_left.nil? or blocking_left.match(read_right(record)) }.max do |a_record, b_record|
       a = read_right a_record
       b = read_right b_record
-      restricted_a = restrict a
-      restricted_b = restrict b
-      if restricted_left and restricted_a and restricted_b and restricted_left != restricted_a and restricted_left != restricted_b
+      i_options_a = i_options a
+      i_options_b = i_options b
+      collision_a = collision? i_options_left, i_options_a
+      collision_b = collision? i_options_left, i_options_b
+      if collision_a and collision_b
         # neither would ever work, so randomly rank one over the other
         rand(2) == 1 ? -1 : 1
-      elsif restricted_left and restricted_a and restricted_left != restricted_a
+      elsif collision_a
         -1
-      elsif restricted_left and restricted_b and restricted_left != restricted_b
+      elsif collision_b
         1
       else
         t_left_a, t_right_a = optimize t_options_left, t_options(a)
@@ -157,11 +161,11 @@ class LooseTightDictionary
     end
     $ltd_1 = history[right_record]
     right = read_right right_record
-    restricted_right = restrict right
+    i_options_right = i_options right
     z = 1
     debugger if $ltd_left.andand.match(left) or $ltd_right.andand.match(right)
     z = 1
-    return if restricted_left and restricted_right and restricted_left != restricted_right
+    return if collision? i_options_left, i_options_right
     inline_check left_record, right_record
     right_record
   end
@@ -205,14 +209,45 @@ class LooseTightDictionary
     @_t_options ||= Hash.new
     ary = Array.new
     ary << T.new(str, str)
-    tightenings.each do |tightening|
-      if literal_regexp(tightening[0]).match str
-        ary << T.new(str, $~.captures.compact.join)
+    tightenings.each do |i|
+      if match_data = literal_regexp(i[0]).match(str)
+        ary.push T.new(str, match_data.captures.compact.join)
       end
     end
     @_t_options[str] = ary
   end
   
+  class I
+    attr_reader :regexp, :str, :case_sensitive, :identity
+    def initialize(regexp, str, case_sensitive)
+      @regexp = regexp
+      @str = str
+      @identity = regexp.match(str).captures.compact.join
+      @identity = @identity.downcase if case_sensitive
+    end
+  end
+  
+  def collision?(i_options_left, i_options_right)
+    i_options_left.any? do |r_left|
+      i_options_right.any? do |r_right|
+        r_left.regexp == r_right.regexp and r_left.identity != r_right.identity
+      end
+    end
+  end
+  
+  def i_options(str)
+    return @_i_options[str] if @_i_options.andand.has_key?(str)
+    @_i_options ||= Hash.new
+    ary = Array.new
+    identities.each do |i|
+      regexp = literal_regexp i[0]
+      if regexp.match str
+        ary.push I.new(regexp, str, case_sensitive)
+      end
+    end
+    @_i_options[str] = ary
+  end
+  
   def blocking(str)
     return @_blocking[str] if @_blocking.andand.has_key?(str)
     @_blocking ||= Hash.new
@@ -225,19 +260,6 @@ class LooseTightDictionary
     @_blocking[str] = nil
   end
   
-  def restrict(str)
-    return @_restrict[str] if @_restrict.andand.has_key?(str)
-    @_restrict ||= Hash.new
-    restrictions.each do |restriction|
-      if literal_regexp(restriction[0]).match str
-        retval = $~.captures.compact.join
-        retval = retval.downcase unless case_sensitive
-        return @_restrict[str] = retval
-      end
-    end
-    @_restrict[str] = nil
-  end
-  
   def literal_regexp(str)
     return @_literal_regexp[str] if @_literal_regexp.andand.has_key? str
     @_literal_regexp ||= Hash.new

data/test/test_loose_tight_dictionary.rb

@@ -24,7 +24,7 @@ class TestLooseTightDictionary < Test::Unit::TestCase
     
     @t_1 = [ '/(dh)c?-?(\d{0,2})-?(\d{0,4})(?:.*?)(dash|\z)/i', 'good tightening for de havilland' ]
     
-    @d_1 = [ '/(dh)c?-?(\d{0,2})-?(\d{0,4})(?:.*?)(dash|\z)/i', 'good restriction for de havilland' ]
+    @r_1 = [ '/(dh)c?-?(\d{0,2})-?(\d{0,4})(?:.*?)(dash|\z)/i', 'good identity for de havilland' ]
     
     @left = [
       @a_left,
@@ -43,7 +43,7 @@ class TestLooseTightDictionary < Test::Unit::TestCase
       ['DEHAVILLAND DEHAVILLAND TWIN OTTER DHC-6']
     ]
     @tightenings = []
-    @restrictions = []
+    @identities = []
     @blockings = []
     @positives = []
     @negatives = []
@@ -56,7 +56,7 @@ class TestLooseTightDictionary < Test::Unit::TestCase
   def ltd
     @_ltd ||= LooseTightDictionary.new  @right,
                                         :tightenings => @tightenings,
-                                        :restrictions => @restrictions,
+                                        :identities => @identities,
                                         :blockings => @blockings,
                                         :positives => @positives,
                                         :negatives => @negatives,
@@ -68,6 +68,17 @@ class TestLooseTightDictionary < Test::Unit::TestCase
   end
   
   if ENV['OLD'] == 'true' or ENV['ALL'] == 'true'
+    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_left = [ 'CESSNA D-333 CITATION V']
+      x_right = [ 'CESSNA D-333' ]
+      @right.push x_right
+      
+      assert_equal x_right, ltd.left_to_right(x_left)
+    end
+    
     should "have a false match without blocking" do
       # @d_left will be our victim
       @right.push @d_lookalike
@@ -198,10 +209,10 @@ class TestLooseTightDictionary < Test::Unit::TestCase
       end
     end
   
-    should "succeed if proper restriction is applied" do
+    should "succeed if proper identity is applied" do
       @negatives.push [ @b_left[0], @c_right[0] ]
       @positives.push [ @d_left[0], @d_right[0] ]
-      @restrictions.push @d_1
+      @identities.push @r_1
     
       assert_nothing_raised do
         ltd.check @left

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Seamus Abshere