text 1.2.3 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 990ce640247dc172ad5e84a54bec8349ccdf55bb
+  data.tar.gz: 25c46a8bfe4fd410959be538b10b2a288e70cbcb
+SHA512:
+  metadata.gz: 6d506f2ae153149a6ebd288ce61a540931fd5d944bc661a582ba8a1fffbdaaf454873e690308202826127d8849c3ec8892969100ad224c51cf61aa5d20fde48c
+  data.tar.gz: 5ffcc3933066fb5131f7da6b438f89fec87d047bc2703e5ad7b4d0ed3a433c4de8c1862c66b8ff7b6dbdcb7aa7e9646c9f8594cd3e6a0630e7a25b0b7bf8e7fb

data/COPYING.txt

@@ -0,0 +1,21 @@
+== Licence (MIT)
+
+Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.rdoc

@@ -12,6 +12,10 @@ A collection of text algorithms.
   # => 0
   Text::Levenshtein.distance('test', 'tent')
   # => 1
+  Text::Levenshtein.distance('test', 'testing')
+  # => 3
+  Text::Levenshtein.distance('test', 'testing', 2)
+  # => 2
 
 === Metaphone
 

data/Rakefile

@@ -7,4 +7,10 @@ Rake::TestTask.new do |t|
   t.verbose = false
 end
 
+desc "Run benchmark"
+task :benchmark do |t|
+  system "ruby -v"
+  system "ruby perf/benchmark.rb"
+end
+
 task :default => :test

data/lib/text/double_metaphone.rb

@@ -5,7 +5,7 @@
 #
 # Based on Stephen Woodbridge's PHP version - http://swoodbridge.com/DoubleMetaPhone/
 #
-# Author: Tim Fletcher (twoggle@gmail.com)
+# Author: Tim Fletcher (mail@tfletcher.com)
 #
 
 module Text # :nodoc:

data/lib/text/levenshtein.rb

@@ -16,29 +16,107 @@ module Levenshtein
 
   # Calculate the Levenshtein distance between two strings +str1+ and +str2+.
   #
+  # The optional argument max_distance can reduce the number of iterations by
+  # stopping if the Levenshtein distance exceeds this value. This increases
+  # performance where it is only necessary to compare the distance with a
+  # reference value instead of calculating the exact distance.
   #
-  # In Ruby 1.8, +str1+ and +str2+ should be ASCII, UTF-8, or a one-byte-per
-  # character encoding such as ISO-8859-*. They will be treated as UTF-8 if
-  # $KCODE is set appropriately (i.e. 'u').  Otherwise, the comparison will be
-  # performed byte-by-byte. There is no specific support for Shift-JIS or EUC
-  # strings.
+  # The distance is calculated in terms of Unicode codepoints. Be aware that
+  # this algorithm does not perform normalisation: if there is a possibility
+  # of different normalised forms being used, normalisation should be performed
+  # beforehand.
   #
-  # In Ruby 1.9+, the strings will be processed as UTF-8.
-  #
-  # When using Unicode text, be aware that this algorithm does not perform
-  # normalisation.  If there is a possibility of different normalised forms
-  # being used, normalisation should be performed beforehand.
-  #
-  def distance(str1, str2)
-    prepare =
-      if "ruby".respond_to?(:encoding)
-        lambda { |str| str.encode(Encoding::UTF_8).unpack("U*") }
+  def distance(str1, str2, max_distance = nil)
+    if max_distance
+      distance_with_maximum(str1, str2, max_distance)
+    else
+      distance_without_maximum(str1, str2)
+    end
+  end
+
+private
+  def distance_with_maximum(str1, str2, max_distance) # :nodoc:
+    s, t = [str1, str2].sort_by(&:length).
+                        map{ |str| str.encode(Encoding::UTF_8).unpack("U*") }
+    n = s.length
+    m = t.length
+    big_int = n * m
+    return m if n.zero?
+    return n if m.zero?
+    return 0 if s == t
+
+    # If the length difference is already greater than the max_distance, then
+    # there is nothing else to check
+    if (n - m).abs >= max_distance
+      return max_distance
+    end
+
+    # The values necessary for our threshold are written; the ones after must
+    # be filled with large integers since the tailing member of the threshold
+    # window in the bottom array will run min across them
+    d = (m + 1).times.map { |i|
+      if i < m || i < max_distance + 1
+        i
       else
-        rule = $KCODE.match(/^U/i) ? "U*" : "C*"
-        lambda { |str| str.unpack(rule) }
+        big_int
       end
+    }
+    x = nil
+    e = nil
+
+    n.times do |i|
+      # Since we're reusing arrays, we need to be sure to wipe the value left
+      # of the starting index; we don't have to worry about the value above the
+      # ending index as the arrays were initially filled with large integers
+      # and we progress to the right
+      if e.nil?
+        e = i + 1
+      else
+        e = big_int
+      end
+
+      diag_index = t.length - s.length + i
+
+      # If max_distance was specified, we can reduce second loop. So we set
+      # up our threshold window.
+      # See:
+      # Gusfield, Dan (1997). Algorithms on strings, trees, and sequences:
+      # computer science and computational biology.
+      # Cambridge, UK: Cambridge University Press. ISBN 0-521-58519-8.
+      # pp. 263–264.
+      min = [0, i - max_distance - 1].max
+      max = [m - 1, i + max_distance].min
+
+      (min .. max).each do |j|
+        # If the diagonal value is already greater than the max_distance
+        # then we can safety return: the diagonal will never go lower again.
+        # See: http://www.levenshtein.net/
+        if j == diag_index && d[j] >= max_distance
+          return max_distance
+        end
+
+        cost = s[i] == t[j] ? 0 : 1
+        x = [
+          d[j+1] + 1, # insertion
+          e + 1,      # deletion
+          d[j] + cost # substitution
+        ].min
+
+        d[j] = e
+        e = x
+      end
+      d[m] = x
+    end
+
+    if x > max_distance
+      return max_distance
+    else
+      return x
+    end
+  end
 
-    s, t = [str1, str2].map(&prepare)
+  def distance_without_maximum(str1, str2) # :nodoc:
+    s, t = [str1, str2].map{ |str| str.encode(Encoding::UTF_8).unpack("U*") }
     n = s.length
     m = t.length
     return m if n.zero?

data/lib/text/metaphone.rb

@@ -45,7 +45,7 @@ module Metaphone
       [ /c(?=ia)/,        'X' ],
       [ /[st](?=i[ao])/,  'X' ],
       [ /s?c(?=[iey])/,   'S' ],
-      [ /[cq]/,           'K' ],
+      [ /(ck?|q)/,        'K' ],
       [ /dg(?=[iey])/,    'J' ],
       [ /d/,              'T' ],
       [ /g(?=h[^aeiou])/, ''  ],
@@ -94,4 +94,4 @@ private
   extend self
 
 end
-end
+end

data/lib/text/soundex.rb

@@ -27,9 +27,9 @@ module Soundex
   # do not change the parameter "str"
   #
   def soundex_str(str)
+    str = str.upcase.gsub(/[^A-Z]/, "")
     return nil if str.empty?
 
-    str = str.upcase
     last_code = get_code(str[0,1])
     soundex_code = str[0,1]
 
@@ -40,15 +40,13 @@ module Soundex
 
       if code == "0" then
         last_code = nil
-      elsif code == nil then
-        return nil
       elsif code != last_code then
         soundex_code += code
         last_code = code
       end
     end # for
 
-    return soundex_code + "000"[0,4-soundex_code.size]
+    return soundex_code.ljust(4, "0")
   end
   module_function :soundex_str
 

data/lib/text/version.rb

@@ -1,8 +1,8 @@
 module Text
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 2
-    TINY  = 3
+    MINOR = 3
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/data/{metaphone.txt → metaphone.yml}

@@ -26,6 +26,8 @@ CHUTE: XT
 SCHUSS: SXS
 OTTO: OT
 ERIC: ERK
+BUCK: BK
+COCK: KK
 DAVE: TF
 CATHERINE: K0RN
 KATHERINE: K0RN

data/test/data/soundex.yml

@@ -0,0 +1,14 @@
+Euler: E460
+Ellery: E460
+Gauss: G200
+Ghosh: G200
+Hilbert: H416
+Heilbronn: H416
+Knuth: K530
+Kant: K530
+Lloyd: L300
+Ladd: L300
+Lukasiewicz: L222
+Lissajous: L222
+SanFrancisco: S516
+"San Francisco": S516

data/test/double_metaphone_test.rb

@@ -0,0 +1,17 @@
+require_relative "./test_helper"
+require "text/double_metaphone"
+
+require 'csv'
+
+class DoubleMetaphoneTest < Test::Unit::TestCase
+
+  def test_cases
+    CSV.open(data_file_path('double_metaphone.csv'), 'r').to_a.each do |row|
+      primary, secondary = Text::Metaphone.double_metaphone(row[0])
+
+      assert_equal row[1], primary
+      assert_equal row[2], secondary.nil?? primary : secondary
+    end
+  end
+
+end

data/test/levenshtein_test.rb

@@ -1,93 +1,363 @@
-require "test_helper"
+# coding: UTF-8
+
+require_relative "./test_helper"
 require "text/levenshtein"
 
 class LevenshteinTest < Test::Unit::TestCase
-
   include Text::Levenshtein
 
-  TEST_CASES = {
-    :easy => [
-      ['test', 'test', 0],
-      ['test', 'tent', 1],
-      ['gumbo', 'gambol', 2],
-      ['kitten', 'sitting', 3]
-    ],
-    :empty => [
-      ['foo', '', 3],
-      ['', '', 0],
-      ['a', '', 1]
-    ],
-    :utf8 => [
-      ["f\303\266o", 'foo', 1],
-      ["fran\303\247ais", 'francais', 1],
-      ["fran\303\247ais", "fran\303\246ais", 1],
-      [
-        "\347\247\201\343\201\256\345\220\215\345\211\215\343\201\257"<<
-        "\343\203\235\343\203\274\343\203\253\343\201\247\343\201\231",
-        "\343\201\274\343\201\217\343\201\256\345\220\215\345\211\215\343\201"<<
-        "\257\343\203\235\343\203\274\343\203\253\343\201\247\343\201\231",
-        2
-      ] # Japanese
-    ],
-    :iso_8859_1 => [
-      ["f\366o", 'foo', 1],
-      ["fran\347ais", 'francais', 1],
-      ["fran\347ais", "fran\346ais", 1]
-    ],
-    :edge => [
-      ['a', 'a', 0],
-      ['0123456789', 'abcdefghijklmnopqrstuvwxyz', 26]
-    ]
-  }
-
-  def assert_set(name)
-    TEST_CASES[name].each do |s, t, x|
-      if defined?(Encoding) && Encoding.default_internal # Change the encoding if in 1.9
-        t.force_encoding(Encoding.default_internal)
-        s.force_encoding(Encoding.default_internal)
-      end
+  def iso_8859_1(s)
+    s.force_encoding(Encoding::ISO_8859_1)
+  end
 
-      assert_equal x, distance(s, t)
-      assert_equal x, distance(t, s)
-    end
+  def test_should_calculate_lengths_for_basic_examples
+    assert_equal 0, distance("test", "test")
+    assert_equal 1, distance("test", "tent")
+    assert_equal 2, distance("gumbo", "gambol")
+    assert_equal 3, distance("kitten", "sitting")
+  end
+
+  def test_should_give_full_distances_for_empty_strings
+    assert_equal 3, distance("foo", "")
+    assert_equal 0, distance("", "")
+    assert_equal 1, distance("a", "")
+  end
+
+  def test_should_treat_utf_8_codepoints_as_one_element
+    assert_equal 1, distance("föo", "foo")
+    assert_equal 1, distance("français", "francais")
+    assert_equal 1, distance("français", "franæais")
+    assert_equal 2, distance("私の名前はポールです", "ぼくの名前はポールです")
+  end
+
+  def test_should_process_single_byte_encodings
+    assert_equal 1, distance(iso_8859_1("f\xF6o"), iso_8859_1("foo"))
+    assert_equal 1, distance(iso_8859_1("fran\xE7ais"), iso_8859_1("francais"))
+    assert_equal 1, distance(iso_8859_1("fran\xE7ais"), iso_8859_1("fran\xE6ais"))
+  end
+
+  def test_should_process_edge_cases_as_expected
+    assert_equal 0, distance("a", "a")
+    assert_equal 26, distance("0123456789", "abcdefghijklmnopqrstuvwxyz")
+  end
+
+  def test_should_return_calculated_distance_when_less_than_maximum
+    assert_equal 0, distance("test", "test", 1)
+    assert_equal 1, distance("test", "tent", 2)
+    assert_equal 2, distance("gumbo", "gambol", 3)
+    assert_equal 3, distance("kitten", "sitting", 4)
+  end
+
+  def test_should_return_calculated_distance_when_same_as_maximum
+    assert_equal 0, distance("test", "test", 0)
+    assert_equal 1, distance("test", "tent", 1)
+    assert_equal 2, distance("gumbo", "gambol", 2)
+    assert_equal 3, distance("kitten", "sitting", 3)
+  end
+
+  def test_should_return_specified_maximum_if_distance_is_more
+    assert_equal 1, distance("gumbo", "gambol", 1)
+    assert_equal 2, distance("kitten", "sitting", 2)
+    assert_equal 1, distance("test", "tasf", 1)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start
+    assert_equal 1, distance("1234", "01234")
+    assert_equal 0, distance("1234", "01234", 0)
+    assert_equal 1, distance("1234", "01234", 1)
+    assert_equal 1, distance("1234", "01234", 2)
+    assert_equal 1, distance("1234", "01234", 3)
+    assert_equal 1, distance("1234", "01234", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_end
+    assert_equal 2, distance("1234", "123400")
+    assert_equal 0, distance("1234", "123400", 0)
+    assert_equal 1, distance("1234", "123400", 1)
+    assert_equal 2, distance("1234", "123400", 2)
+    assert_equal 2, distance("1234", "123400", 3)
+    assert_equal 2, distance("1234", "123400", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_in_the_middle
+    assert_equal 1, distance("1234", "12034")
+    assert_equal 0, distance("1234", "12034", 0)
+    assert_equal 1, distance("1234", "12034", 1)
+    assert_equal 1, distance("1234", "12034", 2)
+    assert_equal 1, distance("1234", "12034", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start_and_in_the_middle
+    assert_equal 2, distance("1234", "012034")
+    assert_equal 0, distance("1234", "012034", 0)
+    assert_equal 1, distance("1234", "012034", 1)
+    assert_equal 2, distance("1234", "012034", 2)
+    assert_equal 2, distance("1234", "012034", 3)
+    assert_equal 2, distance("1234", "012034", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_end_and_in_the_middle
+    assert_equal 2, distance("1234", "120340")
+    assert_equal 0, distance("1234", "120340", 0)
+    assert_equal 1, distance("1234", "120340", 1)
+    assert_equal 2, distance("1234", "120340", 2)
+    assert_equal 2, distance("1234", "120340", 3)
+    assert_equal 2, distance("1234", "120340", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start_at_end_and_in_the_middle
+    assert_equal 3, distance("1234", "0120340")
+    assert_equal 0, distance("1234", "0120340", 0)
+    assert_equal 3, distance("1234", "0120340", 3)
+    assert_equal 3, distance("1234", "0120340", 4)
+    assert_equal 3, distance("1234", "0120340", 6)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start_and_char_changes
+    assert_equal 3, distance("1234", "001233")
+    assert_equal 0, distance("1234", "001233", 0)
+    assert_equal 2, distance("1234", "001233", 2)
+    assert_equal 3, distance("1234", "001233", 3)
+    assert_equal 3, distance("1234", "001233", 4)
+    assert_equal 3, distance("1234", "001233", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_deletions_at_end
+    assert_equal 1, distance("1234", "123")
+    assert_equal 0, distance("1234", "123", 0)
+    assert_equal 1, distance("1234", "123", 1)
+    assert_equal 1, distance("1234", "123", 2)
+    assert_equal 1, distance("1234", "123", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_deletions_at_start
+    assert_equal 1, distance("1234", "234")
+    assert_equal 0, distance("1234", "234", 0)
+    assert_equal 1, distance("1234", "234", 1)
+    assert_equal 1, distance("1234", "234", 2)
+    assert_equal 1, distance("1234", "234", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_deletions_at_start_and_in_the_middle
+    assert_equal 2, distance("1234", "24")
+    assert_equal 0, distance("1234", "24", 0)
+    assert_equal 1, distance("1234", "24", 1)
+    assert_equal 2, distance("1234", "24", 2)
+    assert_equal 2, distance("1234", "24", 3)
+    assert_equal 2, distance("1234", "24", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_deletions_at_end_and_in_the_middle
+    assert_equal 2, distance("1234", "13")
+    assert_equal 0, distance("1234", "13", 0)
+    assert_equal 1, distance("1234", "13", 1)
+    assert_equal 2, distance("1234", "13", 2)
+    assert_equal 2, distance("1234", "13", 3)
+    assert_equal 2, distance("1234", "13", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_deletions_at_start_at_end_and_in_the_middle
+    assert_equal 3, distance("12345", "24")
+    assert_equal 0, distance("12345", "24", 0)
+    assert_equal 2, distance("12345", "24", 2)
+    assert_equal 3, distance("12345", "24", 3)
+    assert_equal 3, distance("12345", "24", 4)
+    assert_equal 3, distance("12345", "24", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start_and_deletions_in_the_middle
+    assert_equal 2, distance("1234", "0124")
+    assert_equal 0, distance("1234", "0124", 0)
+    assert_equal 1, distance("1234", "0124", 1)
+    assert_equal 2, distance("1234", "0124", 2)
+    assert_equal 2, distance("1234", "0124", 3)
+    assert_equal 2, distance("1234", "0124", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_start_and_deletions_at_end
+    assert_equal 2, distance("1234", "0123")
+    assert_equal 0, distance("1234", "0123", 0)
+    assert_equal 1, distance("1234", "0123", 1)
+    assert_equal 2, distance("1234", "0123", 2)
+    assert_equal 2, distance("1234", "0123", 3)
+    assert_equal 2, distance("1234", "0123", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_in_the_middle_and_deletions_at_end
+    assert_equal 2, distance("1234", "1293")
+    assert_equal 0, distance("1234", "1293", 0)
+    assert_equal 1, distance("1234", "1293", 1)
+    assert_equal 2, distance("1234", "1293", 2)
+    assert_equal 2, distance("1234", "1293", 3)
+    assert_equal 2, distance("1234", "1293", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_in_the_middle_and_deletions_at_start
+    assert_equal 2, distance("1234", "2934")
+    assert_equal 0, distance("1234", "2934", 0)
+    assert_equal 1, distance("1234", "2934", 1)
+    assert_equal 2, distance("1234", "2934", 2)
+    assert_equal 2, distance("1234", "2934", 3)
+    assert_equal 2, distance("1234", "2934", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_end_and_deletions_at_start
+    assert_equal 2, distance("1234", "2345")
+    assert_equal 0, distance("1234", "2345", 0)
+    assert_equal 1, distance("1234", "2345", 1)
+    assert_equal 2, distance("1234", "2345", 2)
+    assert_equal 2, distance("1234", "2345", 3)
+    assert_equal 2, distance("1234", "2345", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_at_end_and_deletions_in_the_middle
+    assert_equal 2, distance("1234", "1245")
+    assert_equal 0, distance("1234", "1245", 0)
+    assert_equal 1, distance("1234", "1245", 1)
+    assert_equal 2, distance("1234", "1245", 2)
+    assert_equal 2, distance("1234", "1245", 3)
+    assert_equal 2, distance("1234", "1245", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_in_the_middle_and_deletions_in_the_middle
+    assert_equal 2, distance("12345", "12035")
+    assert_equal 0, distance("12345", "12035", 0)
+    assert_equal 1, distance("12345", "12035", 1)
+    assert_equal 2, distance("12345", "12035", 2)
+    assert_equal 2, distance("12345", "12035", 3)
+    assert_equal 2, distance("12345", "12035", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_additions_deletions_and_char_changes
+    assert_equal 3, distance("1234", "0193")
+    assert_equal 0, distance("1234", "0193", 0)
+    assert_equal 1, distance("1234", "0193", 1)
+    assert_equal 2, distance("1234", "0193", 2)
+    assert_equal 3, distance("1234", "0193", 3)
+    assert_equal 3, distance("1234", "0193", 4)
+    assert_equal 3, distance("1234", "0193", 5)
+
+    assert_equal 3, distance("1234", "2395")
+    assert_equal 0, distance("1234", "2395", 0)
+    assert_equal 1, distance("1234", "2395", 1)
+    assert_equal 2, distance("1234", "2395", 2)
+    assert_equal 3, distance("1234", "2395", 3)
+    assert_equal 3, distance("1234", "2395", 4)
+    assert_equal 3, distance("1234", "2395", 5)
+  end
+
+  def test_should_return_maximum_distance_for_strings_with_only_one_char
+    assert_equal 1, distance("t", "a")
+    assert_equal 0, distance("t", "a", 0)
+    assert_equal 1, distance("t", "a", 1)
+    assert_equal 1, distance("t", "a", 2)
+    assert_equal 1, distance("t", "a", 10)
+
+    assert_equal 0, distance("t", "t")
+    assert_equal 0, distance("t", "t", 1)
+    assert_equal 0, distance("t", "t", 4)
+
+    assert_equal 1, distance("te", "t")
+    assert_equal 0, distance("te", "t", 0)
+    assert_equal 1, distance("te", "t", 1)
+    assert_equal 1, distance("te", "t", 2)
+    assert_equal 1, distance("te", "t", 4)
+  end
+
+  def test_should_return_maximum_distance_for_a_long_string
+    assert_equal 440, distance( "Having a catchy name, easy reminder for all is fundamental when choosing the name for a new product. A bad name can be the beginning of the end product and immediately forget this.</p> <p>Primary keys to choose a good brand name are, first: choose a name that only has one word and at most three, such being the optimum. Try to make it easier to read and pronounce, as this will be easier to remember for all the time to talk about your product. Remember, too, that the use of capitalization also influence, you should treat the name of your product as if it were the same logo. And finally, you should avoid using numbers in your product name, unless it is a very easy to remember because this number were tied deeply with your product. Always think globally, independent of which only sell locally, you never know when it can come out in sales and need to make a point.",
+                                "All product lines work with tags that identify its products and differentiate it from the others or with labels for packaged, or perhaps labels to be placed in the envelopes that you send to your customers. There are thousands options, shapes, designs and colors that you can use and advantage of these is that they can also be adhesive. If you need a label that serve you and that you identify will have your order. You will receive many proposals that you can discard if they don't like you or you keep it if you like and fits your needs. Don't miss the opportunity to innovate and use all the tools that allow you to continue to grow as a company. REMEMBER! a good label, with a good design can increase your sales by 20% just by its appearance.",
+                                440 )
   end
 
-  def with_encoding(kcode, encoding)
-    if "ruby".respond_to?(:encoding)
-      old_encoding = Encoding.default_internal
-      Encoding.default_internal = encoding
-      yield
-      Encoding.default_internal = old_encoding
-    else # 1.8 backwards compat
-      old_kcode = $KCODE
-      $KCODE = kcode
-      yield
-      $KCODE = old_kcode
+end
+
+class LevenshteinGeneratedDataTest < Test::Unit::TestCase
+  Element = Struct.new(:char, :added) do
+    def to_s
+      char
     end
   end
 
-  def test_easy_cases
-    assert_set(:easy)
+  def one_of(str)
+    str[rand(str.length)]
+  end
+
+  def letter
+    one_of "abcdefghijklmnopqrstuvwxyzáéíóúあいうえお日月火水木"
+  end
+
+  def word
+    (rand(10) + 2).times.map { letter }.join("")
+  end
+
+  def sentence
+    (rand(10) + 2).times.map { word }.join(" ")
   end
 
-  def test_empty_cases
-    assert_set(:empty)
+  def sequence
+    sentence.scan(/./).map { |c| Element.new(c, true) }
   end
 
-  def test_edge_cases
-    assert_set(:edge)
+  def insert(seq)
+    elem = Element.new(letter, true)
+    pos = rand(seq.length)
+    return [seq[0, pos] + [elem] + seq[pos .. -1], 1]
   end
 
-  def test_utf8_cases
-    with_encoding('U', 'UTF-8') do
-      assert_set(:utf8)
+  # Delete an element, but only if we didn't add it - that would make the
+  # calculations complicated
+  def delete(seq)
+    pos = rand(seq.length)
+    if seq[pos].added
+      return [seq, 0]
+    else
+      return [seq[0, pos] + seq[(pos + 1) .. -1], 1]
     end
   end
 
-  def test_iso_8859_1_cases
-    with_encoding('NONE', 'ISO-8859-1') do
-      assert_set(:iso_8859_1)
+  def substitute(seq)
+    pos = rand(seq.length)
+    if seq[pos].added
+      return [seq, 0]
+    else
+      elem = Element.new(letter, false)
+      return [seq[0, pos] + [elem] + se[(pos + 1) .. -1], 1]
     end
   end
 
+  def mutate(seq)
+    distance = 0
+    rand(seq.length).times do
+      method = [:insert, :delete, :substitute][rand(2)]
+      seq, d = send(method, seq)
+      distance += d
+    end
+    return [seq, distance]
+  end
+
+  def test_generated_samples
+    100.times do
+      input = sequence
+      output, distance = mutate(input)
+      a = input.map(&:to_s).join("")
+      b = output.map(&:to_s).join("")
+      assert_equal distance, Text::Levenshtein.distance(a, b)
+    end
+  end
+
+  def test_generated_samples_with_maximum_distance
+    100.times do
+      input = sequence
+      output, distance = mutate(input)
+      a = input.map(&:to_s).join("")
+      b = output.map(&:to_s).join("")
+      (0 .. distance).each do |d|
+        assert_equal d, Text::Levenshtein.distance(a, b, d)
+      end
+      (distance .. sequence.length).each do |d|
+        assert_equal distance, Text::Levenshtein.distance(a, b, d)
+      end
+    end
+  end
 end