fuzzy_match 1.0.5 → 1.1.0

data/README.rdoc

@@ -2,7 +2,7 @@
 
 Find a needle in a haystack based on string similarity (using the Pair Distance algorithm and Levenshtein distance) and regular expressions.
 
-Replaces [loose_tight_dictionary](https://github.com/seamusabshere/loose_tight_dictionary) because that was a confusing name.
+Replaces {loose_tight_dictionary}[https://github.com/seamusabshere/loose_tight_dictionary] because that was a confusing name.
 
 == Quickstart
 

data/lib/fuzzy_match/cached_result.rb

@@ -24,7 +24,7 @@ class FuzzyMatch
       # required options:
       # :primary_key - what to call on this class
       # :foreign_key - what to call on the other class
-      def cache_fuzzy_match_matches_with(other_active_record_class, options)
+      def cache_fuzzy_match_with(other_active_record_class, options)
         other = other_active_record_class.to_s.singularize.camelcase
         me = name
         if me < other

data/lib/fuzzy_match/result.rb

@@ -1,17 +1,41 @@
+require 'erb'
+
 class FuzzyMatch
   class Result #:nodoc: all
+    EXPLANATION = <<-ERB
+You looked for <%= needle.render.inspect %>
+
+<% if winner %>It was matched with "<%= winner %>"<% else %>No match was found<% end %>
+
+# THE HAYSTACK
+
+The haystack reader was <%= read.inspect %>.
+
+The haystack contained <%= haystack.length %> records like <%= haystack[0, 3].map(&:render).map(&:inspect).join(', ') %>
+
+# HOW IT WAS MATCHED
+<% timeline.each_with_index do |event, index| %>
+(<%= index+1 %>) <%= event %>
+<% end %>
+ERB
+
+    def timeline
+      @timeline ||= []
+    end
+
     attr_accessor :needle
+    attr_accessor :read
+    attr_accessor :haystack
+    attr_accessor :options
     attr_accessor :tighteners
     attr_accessor :blockings
     attr_accessor :identities
     attr_accessor :stop_words
-    attr_accessor :candidates
-    attr_accessor :joint
-    attr_accessor :disjoint
-    attr_accessor :possibly_identical
-    attr_accessor :certainly_different
-    attr_accessor :similarities
-    attr_accessor :record
+    attr_accessor :winner
     attr_accessor :score
+    
+    def explain
+      $stdout.puts ::ERB.new(EXPLANATION, 0, '%<').result(binding)
+    end
   end
 end

data/lib/fuzzy_match/score.rb

@@ -14,13 +14,13 @@ class FuzzyMatch
     end
     
     def inspect
-      %{#<Score: dices_coefficient=#{dices_coefficient} levenshtein=#{levenshtein}>}
+      %{#<Score: dices_coefficient=#{dices_coefficient_similar} levenshtein=#{levenshtein_similar}>}
     end
     
     def <=>(other)
-      by_dices_coefficient = (dices_coefficient <=> other.dices_coefficient)
+      by_dices_coefficient = (dices_coefficient_similar <=> other.dices_coefficient_similar)
       if by_dices_coefficient == 0
-        levenshtein <=> other.levenshtein
+        levenshtein_similar <=> other.levenshtein_similar
       else
         by_dices_coefficient
       end
@@ -32,11 +32,11 @@ class FuzzyMatch
     
     if defined?(::Amatch)
       
-      def dices_coefficient
+      def dices_coefficient_similar
         str1.pair_distance_similar str2
       end
       
-      def levenshtein
+      def levenshtein_similar
         str1.levenshtein_similar str2
       end
       
@@ -44,7 +44,7 @@ class FuzzyMatch
       
       SPACE = ' '
       # http://stackoverflow.com/questions/653157/a-better-similarity-ranking-algorithm-for-variable-length-strings
-      def dices_coefficient
+      def dices_coefficient_similar
         if str1 == str2
           return 1.0
         elsif str1.length == 1 and str2.length == 1
@@ -77,7 +77,7 @@ class FuzzyMatch
       # extracted/adapted from the text gem version 1.0.2
       # normalization added for utf-8 strings
       # lib/text/levenshtein.rb
-      def levenshtein
+      def levenshtein_similar
         if utf8?
           unpack_rule = 'U*'
         else
@@ -118,8 +118,8 @@ class FuzzyMatch
     end
     
     extend ::ActiveSupport::Memoizable
-    memoize :dices_coefficient
-    memoize :levenshtein
+    memoize :dices_coefficient_similar
+    memoize :levenshtein_similar
     memoize :utf8?
   end
 end

data/lib/fuzzy_match/version.rb

@@ -1,3 +1,3 @@
 class FuzzyMatch
-  VERSION = '1.0.5'
+  VERSION = '1.1.0'
 end

data/lib/fuzzy_match/wrapper.rb

@@ -3,20 +3,25 @@ class FuzzyMatch
   class Wrapper #:nodoc: all
     attr_reader :fuzzy_match
     attr_reader :record
-    attr_reader :read
+    attr_reader :literal
+    attr_reader :rendered
 
-    def initialize(fuzzy_match, record, read = nil)
+    def initialize(fuzzy_match, record, literal = false)
       @fuzzy_match = fuzzy_match
       @record = record
-      @read = read
+      @literal = literal
     end
 
     def inspect
       "#<Wrapper render=#{render} variants=#{variants.length}>"
     end
+    
+    def read
+      fuzzy_match.read unless literal
+    end
 
     def render
-      return @render if rendered?
+      return @render if rendered
       str = case read
       when ::Proc
         read.call record
@@ -42,7 +47,8 @@ class FuzzyMatch
 
     alias :to_str :render
 
-    WORD_BOUNDARY = %r{\s*\b\s*}
+    # "Foo's Bar" should be treated as [ "Foo's", "Bar" ], so we don't use traditional regexp word boundaries (\b)
+    WORD_BOUNDARY = %r{\s+}
     def words
       @words ||= render.split(WORD_BOUNDARY)
     end
@@ -59,9 +65,5 @@ class FuzzyMatch
         memo
       end.uniq
     end
-    
-    def rendered?
-      @rendered == true
-    end
   end
 end

data/lib/fuzzy_match.rb

@@ -17,33 +17,72 @@ class FuzzyMatch
   autoload :Score, 'fuzzy_match/score'
   autoload :CachedResult, 'fuzzy_match/cached_result'
   
+  DEFAULT_OPTIONS = {
+    :first_blocking_decides => false,
+    :must_match_blocking => false,
+    :must_match_at_least_one_word => false,
+    :gather_last_result => false,
+    :find_all => false
+  }
+  
   attr_reader :haystack
   attr_reader :blockings
   attr_reader :identities
   attr_reader :tighteners
   attr_reader :stop_words
-  attr_reader :default_first_blocking_decides
-  attr_reader :default_must_match_blocking
-  attr_reader :default_must_match_at_least_one_word
+  attr_reader :read
+  attr_reader :default_options
 
-  # haystack - a bunch of records
-  # options
+  # haystack - a bunch of records that will compete to see who best matches the needle
+  #
+  # rules (can only be specified at initialization or by using a setter)
   # * tighteners: regexps (see readme)
   # * identities: regexps
   # * blockings: regexps
   # * stop_words: regexps
   # * read: how to interpret each entry in the 'haystack', either a Proc or a symbol
-  def initialize(records, options = {})
-    options = options.symbolize_keys
-    @default_first_blocking_decides = options[:first_blocking_decides]
-    @default_must_match_blocking = options[:must_match_blocking]
-    @default_must_match_at_least_one_word = options[:must_match_at_least_one_word]
-    @blockings = options.fetch(:blockings, []).map { |regexp_or_str| Blocking.new regexp_or_str }
-    @identities = options.fetch(:identities, []).map { |regexp_or_str| Identity.new regexp_or_str }
-    @tighteners = options.fetch(:tighteners, []).map { |regexp_or_str| Tightener.new regexp_or_str }
-    @stop_words = options.fetch(:stop_words, []).map { |regexp_or_str| StopWord.new regexp_or_str }
-    read = options[:read] || options[:haystack_reader]
-    @haystack = records.map { |record| Wrapper.new self, record, read }
+  #
+  # options (can be specified at initialization or when calling #find)
+  # * first_blocking_decides
+  # * must_match_blocking
+  # * must_match_at_least_one_word
+  # * gather_last_result
+  # * find_all
+  def initialize(competitors, options_and_rules = {})
+    options_and_rules = options_and_rules.symbolize_keys
+
+    # rules
+    self.blockings = options_and_rules.delete(:blockings) || []
+    self.identities = options_and_rules.delete(:identities) || []
+    self.tighteners = options_and_rules.delete(:tighteners) || []
+    self.stop_words = options_and_rules.delete(:stop_words) || []
+    @read = options_and_rules.delete(:read) || options_and_rules.delete(:haystack_reader)
+
+    # options
+    @default_options = options_and_rules.reverse_merge(DEFAULT_OPTIONS).freeze
+
+    # do this last
+    self.haystack = competitors
+  end
+  
+  def blockings=(ary)
+    @blockings = ary.map { |regexp_or_str| Blocking.new regexp_or_str }
+  end
+  
+  def identities=(ary)
+    @identities = ary.map { |regexp_or_str| Identity.new regexp_or_str }
+  end
+  
+  def tighteners=(ary)
+    @tighteners = ary.map { |regexp_or_str| Tightener.new regexp_or_str }
+  end
+  
+  def stop_words=(ary)
+    @stop_words = ary.map { |regexp_or_str| StopWord.new regexp_or_str }
+  end
+  
+  def haystack=(ary)
+    @haystack = ary.map { |competitor| Wrapper.new self, competitor }
   end
   
   def last_result
@@ -58,16 +97,24 @@ class FuzzyMatch
   def find(needle, options = {})
     raise ::RuntimeError, "[fuzzy_match] Dictionary has already been freed, can't perform more finds" if freed?
     
-    options = options.symbolize_keys
-    gather_last_result = options.fetch(:gather_last_result, false)
-    is_find_all = options.fetch(:find_all, false)
-    first_blocking_decides = options.fetch(:first_blocking_decides, default_first_blocking_decides)
-    must_match_blocking = options.fetch(:must_match_blocking, default_must_match_blocking)
-    must_match_at_least_one_word = options.fetch(:must_match_at_least_one_word, default_must_match_at_least_one_word)
+    options = options.symbolize_keys.reverse_merge default_options
+    
+    gather_last_result = options[:gather_last_result]
+    is_find_all = options[:find_all]
+    first_blocking_decides = options[:first_blocking_decides]
+    must_match_blocking = options[:must_match_blocking]
+    must_match_at_least_one_word = options[:must_match_at_least_one_word]
     
     if gather_last_result
       free_last_result
       @last_result = Result.new
+      last_result.read = read
+      last_result.haystack = haystack
+      last_result.options = options
+      last_result.timeline << <<-EOS
+Options were set, either by you or by falling back to defaults.
+\tOptions: #{options.inspect}
+EOS
     end
     
     if gather_last_result
@@ -77,13 +124,24 @@ class FuzzyMatch
       last_result.stop_words = stop_words
     end
     
-    needle = Wrapper.new self, needle
+    needle = Wrapper.new self, needle, true
     
     if gather_last_result
       last_result.needle = needle
+      last_result.timeline << <<-EOS
+The needle's #{needle.variants.length} variants were enumerated.
+\tVariants: #{needle.variants.map(&:inspect).join(', ')}
+EOS
     end
     
     if must_match_blocking and blockings.any? and blockings.none? { |blocking| blocking.match? needle }
+      if gather_last_result
+        last_result.timeline << <<-EOS
+The needle didn't match any of the #{blockings.length} blocking, which was a requirement.
+\tBlockings (first 3): #{blockings[0,3].map(&:inspect).join(', ')}
+EOS
+      end
+      
       if is_find_all
         return []
       else
@@ -91,83 +149,109 @@ class FuzzyMatch
       end
     end
 
-    candidates = if must_match_at_least_one_word
-      haystack.select do |straw|
+    if must_match_at_least_one_word
+      passed_word_requirement = haystack.select do |straw|
         (needle.words & straw.words).any?
       end
+      if gather_last_result
+        last_result.timeline << <<-EOS
+Since :must_match_at_least_one_word => true, the competition was reduced to records sharing at least one word with the needle.
+\tNeedle words: #{needle.words.map(&:inspect).join(', ')}
+\tPassed (first 3): #{passed_word_requirement[0,3].map(&:render).map(&:inspect).join(', ')}
+\tFailed (first 3): #{(haystack-passed_word_requirement)[0,3].map(&:render).map(&:inspect).join(', ')}
+EOS
+      end
     else
-      haystack
-    end
-    
-    if gather_last_result
-      last_result.candidates = candidates
+      passed_word_requirement = haystack
     end
     
-    joint, disjoint = if blockings.any?
-      candidates.partition do |straw|
+    if blockings.any?
+      joint = passed_word_requirement.select do |straw|
         if first_blocking_decides
           blockings.detect { |blocking| blocking.match? needle }.try :join?, needle, straw
         else
           blockings.any? { |blocking| blocking.join? needle, straw }
         end
       end
+      if gather_last_result
+        last_result.timeline << <<-EOS
+Since there were blockings, the competition was reduced to records in the same block as the needle.
+\tBlockings (first 3): #{blockings[0,3].map(&:inspect).join(', ')}
+\tPassed (first 3): #{joint[0,3].map(&:render).map(&:inspect).join(', ')}
+\tFailed (first 3): #{(passed_word_requirement-joint)[0,3].map(&:render).map(&:inspect).join(', ')}
+EOS
+      end
     else
-      [ candidates.dup, [] ]
+      joint = passed_word_requirement.dup
     end
     
     if joint.none?
       if must_match_blocking
+        if gather_last_result
+          last_result.timeline << <<-EOS
+Since :must_match_at_least_one_word => true and none of the competition was in the same block as the needle, the search stopped.
+EOS
+        end
         if is_find_all
           return []
         else
           return nil
         end
       else
-        # special case: the needle didn't fit anywhere, but must_match_blocking is false, so we'll try it against everything
-        joint = disjoint
-        disjoint = []
+        joint = passed_word_requirement.dup
       end
     end
-    
-    if gather_last_result
-      last_result.joint = joint
-      last_result.disjoint = disjoint
-    end
-    
-    possibly_identical, certainly_different = if identities.any?
-      joint.partition do |straw|
+        
+    if identities.any?
+      possibly_identical = joint.select do |straw|
         identities.all? do |identity|
           answer = identity.identical? needle, straw
           answer.nil? or answer == true
         end
       end
+      if gather_last_result
+        last_result.timeline << <<-EOS
+Since there were identities, the competition was reduced to records that might be identical to the needle (in other words, are not certainly different)
+\Identities (first 3): #{identities[0,3].map(&:inspect).join(', ')}
+\tPassed (first 3): #{possibly_identical[0,3].map(&:render).map(&:inspect).join(', ')}
+\tFailed (first 3): #{(joint-possibly_identical)[0,3].map(&:render).map(&:inspect).join(', ')}
+EOS
+      end
     else
-      [ joint.dup, [] ]
+      possibly_identical = joint.dup
     end
-    
+        
+    similarities = possibly_identical.map { |straw| needle.similarity straw }.sort.reverse
+        
     if gather_last_result
-      last_result.possibly_identical = possibly_identical
-      last_result.certainly_different = certainly_different
+        last_result.timeline << <<-EOS
+The competition was sorted in order of similarity to the needle.
+\tSimilar (first 3): #{(similarities)[0,3].map(&:wrapper2).map(&:render).map(&:inspect).join(', ')}
+EOS
     end
     
     if is_find_all
-      return possibly_identical.map { |straw| straw.record }
-    end
-    
-    similarities = possibly_identical.map { |straw| needle.similarity straw }.sort
-    
-    if gather_last_result
-      last_result.similarities = similarities
+      return similarities.map { |similarity| similarity.wrapper2.record }
     end
     
-    if best_similarity = similarities[-1] and best_similarity.best_score.dices_coefficient > 0
-      record = best_similarity.wrapper2.record
+    winner = nil
+
+    if best_similarity = similarities.first and best_similarity.best_score.dices_coefficient_similar > 0
+      winner = best_similarity.wrapper2.record
       if gather_last_result
-        last_result.record = record
-        last_result.score = best_similarity.best_score.dices_coefficient
+        last_result.winner = winner
+        last_result.score = best_similarity.best_score.dices_coefficient_similar
+        last_result.timeline << <<-EOS
+A winner was determined because the similarity score #{best_similarity.best_score.dices_coefficient_similar} is greater than zero.
+EOS
       end
-      record
+    elsif gather_last_result
+        last_result.timeline << <<-EOS
+No winner assigned because similarity score was zero.
+EOS
     end
+    
+    winner
   end
   
   # Explain is like mysql's EXPLAIN command. You give it a needle and it tells you about how it was located (successfully or not) in the haystack.
@@ -175,63 +259,10 @@ class FuzzyMatch
   #     d = FuzzyMatch.new ['737', '747', '757' ]
   #     d.explain 'boeing 737-100'
   def explain(needle, options = {})
-    record = find needle, options.merge(:gather_last_result => true)
-    log "#" * 150
-    log "# Match #{needle.inspect} => #{record.inspect}"
-    log "#" * 150
-    log
-    log "Needle"
-    log "-" * 150
-    log last_result.needle.render
-    log
-    log "Stop words"
-    log last_result.stop_words.blank? ? '(none)' : last_result.stop_words.map { |stop_word| stop_word.inspect }.join("\n")
-    log
-    log "Candidates"
-    log "-" * 150
-    log last_result.candidates.map { |record| record.render }.join("\n")
-    log
-    log "Tighteners"
-    log "-" * 150
-    log last_result.tighteners.blank? ? '(none)' : last_result.tighteners.map { |tightener| tightener.inspect }.join("\n")
-    log
-    log "Blockings"
-    log "-" * 150
-    log last_result.blockings.blank? ? '(none)' : last_result.blockings.map { |blocking| blocking.inspect }.join("\n")
-    log
-    log "Identities"
-    log "-" * 150
-    log last_result.identities.blank? ? '(none)' : last_result.identities.map { |blocking| blocking.inspect }.join("\n")
-    log
-    log "Joint"
-    log "-" * 150
-    log last_result.joint.blank? ? '(none)' : last_result.joint.map { |joint| joint.render }.join("\n")
-    log
-    log "Disjoint"
-    log "-" * 150
-    log last_result.disjoint.blank? ? '(none)' : last_result.disjoint.map { |disjoint| disjoint.render }.join("\n")
-    log
-    log "Possibly identical"
-    log "-" * 150
-    log last_result.possibly_identical.blank? ? '(none)' : last_result.possibly_identical.map { |possibly_identical| possibly_identical.render }.join("\n")
-    log
-    log "Certainly different"
-    log "-" * 150
-    log last_result.certainly_different.blank? ? '(none)' : last_result.certainly_different.map { |certainly_different| certainly_different.render }.join("\n")
-    log
-    log "Similarities"
-    log "-" * 150
-    log last_result.similarities.blank? ? '(none)' : last_result.similarities.reverse[0..9].map { |similarity| similarity.inspect }.join("\n")
-    log
-    log "Match"
-    log "-" * 150
-    log record.inspect
-  end
-  
-  def log(str = '') #:nodoc:
-    $stderr.puts str
+    find needle, options.merge(:gather_last_result => true)
+    last_result.explain
   end
-    
+
   def freed?
     @freed == true
   end

data/test/test_cache.rb

@@ -26,7 +26,7 @@ require 'fuzzy_match/cached_result'
 class Aircraft < ActiveRecord::Base
   set_primary_key :icao_code
   
-  cache_fuzzy_match_matches_with :flight_segments, :primary_key => :aircraft_description, :foreign_key => :aircraft_description
+  cache_fuzzy_match_with :flight_segments, :primary_key => :aircraft_description, :foreign_key => :aircraft_description
     
   def aircraft_description
     [manufacturer_name, model_name].compact.join(' ')
@@ -53,7 +53,7 @@ end
 class FlightSegment < ActiveRecord::Base
   set_primary_key :row_hash
   
-  cache_fuzzy_match_matches_with :aircraft, :primary_key => :aircraft_description, :foreign_key => :aircraft_description
+  cache_fuzzy_match_with :aircraft, :primary_key => :aircraft_description, :foreign_key => :aircraft_description
   
   extend CohortScope
   self.minimum_cohort_size = 1

data/test/test_fuzzy_match.rb

@@ -24,7 +24,7 @@ class TestFuzzyMatch < Test::Unit::TestCase
     d = FuzzyMatch.new %w{ NISSAN HONDA }
     d.find 'MISSAM', :gather_last_result => true
     assert_equal 0.6, d.last_result.score
-    assert_equal 'NISSAN', d.last_result.record
+    assert_equal 'NISSAN', d.last_result.winner
   end
   
   def test_004_false_positive_without_tightener
@@ -91,7 +91,7 @@ class TestFuzzyMatch < Test::Unit::TestCase
     
     # first_blocking_decides refers to the needle
     d = FuzzyMatch.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')
+    assert_equal ["Boeing ER6", "Boeing 747", "Boeing 747SR"], d.find_all('Boeing ER6')
     
     d = FuzzyMatch.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')
@@ -108,6 +108,8 @@ class TestFuzzyMatch < Test::Unit::TestCase
     haystack = [ab, ba]
     by_first = FuzzyMatch.new haystack, :read => :one
     by_last = FuzzyMatch.new haystack, :read => :two
+    assert_equal :one, by_first.read
+    assert_equal :two, by_last.read
     assert_equal ab, by_first.find('a')
     assert_equal ab, by_last.find('b')
     assert_equal ba, by_first.find('b')
@@ -154,6 +156,10 @@ class TestFuzzyMatch < Test::Unit::TestCase
   def test_019_must_match_at_least_one_word
     d = FuzzyMatch.new %w{ RATZ CATZ }, :must_match_at_least_one_word => true
     assert_equal nil, d.find('RITZ')
+    
+    d = FuzzyMatch.new ["Foo's Bar"], :must_match_at_least_one_word => true
+    assert_equal nil, d.find("Jacob's")
+    assert_equal "Foo's Bar", d.find("Foo's")
   end
   
   def test_020_stop_words
@@ -167,20 +173,19 @@ class TestFuzzyMatch < Test::Unit::TestCase
     assert_equal 'A HOTEL', d.find('A HTL')
   end
   
-  def test_021_explain
+  def test_021_explain_prints_to_stdout
     require 'stringio'
     capture = StringIO.new
     begin
-      old_stderr = $stderr
-      $stderr = capture
+      old_stdout = $stdout
+      $stdout = capture
       d = FuzzyMatch.new %w{ RATZ CATZ }
       d.explain('RITZ')
     ensure
-      $stderr = old_stderr
+      $stdout = old_stdout
     end
     capture.rewind
     assert capture.read.include?('CATZ')
-    capture.close
   end
   
   def test_022_compare_words_with_words

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fuzzy_match
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-13 00:00:00.000000000Z
+date: 2012-01-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2155828460 !ruby/object:Gem::Requirement
+  requirement: &2153333800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155828460
+  version_requirements: *2153333800
 - !ruby/object:Gem::Dependency
   name: remote_table
-  requirement: &2155827960 !ruby/object:Gem::Requirement
+  requirement: &2153333320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155827960
+  version_requirements: *2153333320
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2155827320 !ruby/object:Gem::Requirement
+  requirement: &2153332560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '3'
   type: :development
   prerelease: false
-  version_requirements: *2155827320
+  version_requirements: *2153332560
 - !ruby/object:Gem::Dependency
   name: mysql
-  requirement: &2155826780 !ruby/object:Gem::Requirement
+  requirement: &2153331800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155826780
+  version_requirements: *2153331800
 - !ruby/object:Gem::Dependency
   name: cohort_scope
-  requirement: &2155826080 !ruby/object:Gem::Requirement
+  requirement: &2153325800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155826080
+  version_requirements: *2153325800
 - !ruby/object:Gem::Dependency
   name: weighted_average
-  requirement: &2155825480 !ruby/object:Gem::Requirement
+  requirement: &2153325220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155825480
+  version_requirements: *2153325220
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2155825060 !ruby/object:Gem::Requirement
+  requirement: &2153322620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2155825060
+  version_requirements: *2153322620
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2155824520 !ruby/object:Gem::Requirement
+  requirement: &2153322100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2155824520
+  version_requirements: *2153322100
 - !ruby/object:Gem::Dependency
   name: to_regexp
-  requirement: &2155819080 !ruby/object:Gem::Requirement
+  requirement: &2153321580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,7 +109,7 @@ dependencies:
         version: 0.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *2155819080
+  version_requirements: *2153321580
 description: Find a needle in a haystack using string similarity and (optionally)
   regexp rules. Replaces loose_tight_dictionary.
 email: