damerau-levenshtein-al2023 1.3.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5a4a54093309c3077a0affe8a605f3f3e55d1ad870ff99d3bf8f91966fe9a5c9
+  data.tar.gz: 4ec4ece71534c0a54524c59b43ed31be47796d2afd48a2e20b24e11959f448d8
+SHA512:
+  metadata.gz: 0f9ea4c8034d0ef76b9fc994495c2e7698e573e758bbf988e6fd994e639ed93608e3ef2d12a01c23483be97ea76be02f7d733a8b25544382d73b76dfad7cb39a
+  data.tar.gz: 9972dead690fec119bcba5d80c4fe02d21dcb0fa6ce3d88fff3bb085cd982d31c439cbe90b162c32ccd8920b5c075475eccb09a3e7b4a045ada7a4417619a325

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+damerau-levenshtein CHANGELOG
+=============================
+
+1.3.1 -- gems update
+
+1.3.0 -- (issue #10) shows difference between two strings
+
+1.2.0 -- add edit distance for array of integers (by @azhi)
+
+1.1.3 -- add ruby 2.3.1 to travis tests by request from @greysteil
+
+1.1.2 -- remove unnecessary production dependencies (by @ixti)
+
+1.1.1 -- fix random negative distance bug (by @Skarlit)
+
+1.1.0 -- relax and update gem dependencies, update specs
+
+1.0.3 -- gems update
+
+1.0.2 -- includes refactoring by https://github.com/luislavena to remove
+         dependency on jeweler
+
+1.0.1 -- fixed gem dependencies
+
+1.0.0 -- stable version

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2011-2019 Dmitry Mozzherin
+
+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.md

@@ -0,0 +1,273 @@
+# damerau-levenshtein
+
+[![DOI](https://zenodo.org/badge/2085407.svg)](https://zenodo.org/badge/latestdoi/2085407)
+[![Gem Version][gem_svg]][gem]
+[![Continuous Integration Status][ci_svg]][ci]
+[![Coverage Status][cov_svg]][cov]
+
+The damerau-levenshtein gem allows to find [edit distance][ed] between two
+UTF-8 or ASCII encoded strings with O(N\*M) efficiency.
+
+This gem implements pure Levenshtein algorithm, Damerau modification of it
+(where 2 character transposition counts as 1 edit distance). It also includes
+Boehmer & Rees 2008 modification of Damerau algorithm, where transposition
+of bigger than 1 character blocks is taken in account as well
+[(Rees 2014)][rees2014].
+
+```ruby
+require "damerau-levenshtein"
+DamerauLevenshtein.distance("Something", "Smoething") #returns 1
+```
+
+It also returns a diff between two strings according to Levenshtein alrorithm.
+The diff is expressed by tags `<ins>`, `<del>`, and `<subst>`. Such tags make
+it possible to highlight differnce between strings in a flexible way.
+
+```ruby
+require "damerau-levenshtein"
+differ = DamerauLevenshtein::Differ.new
+differ.run("corn", "cron")
+# output: ["c<subst>or</subst>n", "c<subst>ro</subst>n"]
+```
+
+## Dependencies
+
+```bash
+sudo apt-get install build-essential libgmp3-dev
+```
+
+## Installation
+
+```bash
+gem install damerau-levenshtein
+```
+
+## Examples
+
+```ruby
+require "damerau-levenshtein"
+dl = DamerauLevenshtein
+```
+
+* compare using Damerau Levenshtein algorithm
+
+```ruby
+dl.distance("Something", "Smoething") #returns 1
+```
+
+* compare using Levensthein algorithm
+
+```ruby
+dl.distance("Something", "Smoething", 0) #returns 2
+```
+
+* compare using Boehmer & Rees modification
+
+```ruby
+dl.distance("Something", "meSothing", 2) #returns 2 instead of 4
+```
+
+* comparison of words with UTF-8 characters should work fine:
+
+```ruby
+dl.distance("Sjöstedt", "Sjostedt") #returns 1
+```
+
+* compare two arrays
+
+```ruby
+dl.array_distance([1,2,3,5], [1,2,3,4]) #returns 1
+```
+
+* return diff between two strings
+
+```ruby
+differ = DamerauLevenshtein::Differ.new
+differ.run("Something", "smthg")
+```
+
+* return diff between two strings in raw format
+
+```ruby
+differ = DamerauLevenshtein::Differ.new
+differ.format = :raw
+differ.run("Something", "smthg")
+```
+
+## API Description
+
+### Methods
+
+#### DamerauLevenshtein.version
+
+```ruby
+DamerauLevenshtein.version
+#returns version number of the gem
+```
+
+#### DamerauLevenshtein.distance
+
+```ruby
+DamerauLevenshtein.distance(string1, string2, block_size, max_distance)
+#returns edit distance between 2 strings
+
+DamerauLevenshtein.string_distance(string1, string2, block_size, max_distance)
+# an alias for .distance
+
+DamerauLevenshtein.array_distance(array1, array2, block_size, max_distance)
+# returns edit distance between 2 arrays of integers
+```
+
+`DamerauLevenshtein.distance` and `.array_distance` take 4 arguments:
+
+* `string1` (`array1` for `.array_distance`)
+* `string2` (`array2` for `.array_distance`)
+* `block_size` (default is 1)
+* `max_distance` (default is 10)
+
+`block_size` determines maximum number of characters in a transposition block:
+
+```bash
+block_size = 0
+(transposition does not count -- it is a pure Levenshtein algorithm)
+
+block_size = 1
+(transposition between 2 adjustent characters --
+it is pure Damerau-Levenshtein algorithm)
+
+block_size = 2
+(transposition between blocks as big as 2 characters -- so abcd and cdab
+counts as edit distance 2, not 4)
+
+block_size = 3
+(transposition between blocks as big as 3 characters --
+so abcdef and defabc counts as edit distance 3, not 6)
+
+etc.
+```
+
+`max_distance` -- is a threshold after which algorithm gives up and
+returns `max_distance` instead of real edit distance.
+
+Levenshtein algorithm is expensive, so it makes sense to give up when edit
+distance is becoming too big. The argument max_distance does just that.
+
+```ruby
+
+DamerauLevenshtein.distance("abcdefg", "1234567", 0, 3)
+# output: 4 -- it gave up when edit distance exceeded 3
+
+```
+
+#### DamerauLevenshtein::Differ
+
+`differ = DamerauLevenshtein::Differ.new` creates an instance of new differ
+class to return difference between two strings
+
+`differ.format` shows current format for diff. Default is `:tag` format
+
+`differ.format = :raw` changes current format for diffs. Possible values
+are `:tag` and `:raw`
+
+`differ.run("String1", "String2")` returns difference between two strings.
+
+For example:
+
+```ruby
+differ = DamerauLevenshtein::Differ.new
+differ.run("Something", "smthng")
+# output: ["<ins>S</ins><subst>o</subst>m<ins>e</ins>th<ins>i</ins>ng",
+#          "<del>S</del><subst>s</subst>m<del>e</del>th<del>i</del>ng"]
+
+```
+
+Or with parsing:
+
+```ruby
+require "damerau-levenshtein"
+require "nokogiri"
+
+differ = DamerauLevenshtein::Differ.new
+res = differ.run("Something", "Smothing!")
+nodes = Nokogiri::XML("<root>#{res.first}</root>")
+
+markup = nodes.root.children.map do |n|
+  case n.name
+  when "text"
+    n.text
+  when "del"
+    "~~#{n.children.first.text}~~"
+  when "ins"
+    "*#{n.children.first.text}*"
+  when "subst"
+    "**#{n.children.first.text}**"
+  end
+end.join("")
+
+puts markup
+```
+
+Output
+
+```text
+S*o*m**e**thing~~!~~
+```
+
+## Contributing to damerau-levenshtein
+
+* Check out the latest master to make sure the feature hasn't been
+  implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested
+  it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it
+  in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want
+  to have your own version, or is otherwise necessary, that is fine, but please
+  isolate to its own commit so I can cherry-pick around it.
+
+## Versioning
+
+This gem is following practices of [Semantic Versioning][semver]
+
+## Authors
+
+[Dmitry Mozzherin][dimus]
+
+## Contributors
+
+[Alexey Zapparov][ixti],
+[azhi][azhi],
+[Fabian Winkler][wynksaiddestroy]
+[Josephine Wright][jozr],
+[lazylester][lazylester],
+[Ran Xie][skarlit],
+[Victor Maslov][Nakilon],
+[Masafumi Koba][ybiquitous]
+
+## Copyright
+
+Copyright (c) 2011-2019 Dmitry Mozzherin. See LICENSE.txt for
+further details.
+
+[gem_svg]: https://badge.fury.io/rb/damerau-levenshtein.svg
+[gem]: http://badge.fury.io/rb/damerau-levenshtein
+[ci_svg]: https://github.com/GlobalNamesArchitecture/damerau-levenshtein/actions/workflows/ci.yml/badge.svg
+[ci]: https://github.com/GlobalNamesArchitecture/damerau-levenshtein/actions/workflows/ci.yml
+[dep_svg]: https://gemnasium.com/GlobalNamesArchitecture/damerau-levenshtein.svg
+[cov_svg]: https://coveralls.io/repos/GlobalNamesArchitecture/damerau-levenshtein/badge.svg?branch=master
+[cov]: https://coveralls.io/r/GlobalNamesArchitecture/damerau-levenshtein?branch=master
+[ed]: http://en.wikipedia.org/wiki/Edit_distance
+[semver]: http://semver.org/
+[dimus]: https://github.com/dimus
+[lazylester]: https://github.com/lazylester
+[skarlit]: https://github.com/Skarlit
+[ixti]: https://github.com/ixti
+[azhi]: https://github.com/azhi
+[jozr]: https://github.com/jozr
+[rees2014]: https://dx.doi.org/10.1371/journal.pone.0107510
+[Nakilon]: https://github.com/Nakilon
+[wynksaiddestroy]: https://github.com/wynksaiddestroy
+[ybiquitous]: https://github.com/ybiquitous

data/Rakefile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "cucumber/rake/task"
+require "rubocop/rake_task"
+require "rake/dsl_definition"
+require "rake"
+require "rake/extensiontask"
+require "rspec"
+
+RSpec::Core::RakeTask.new(:spec) do |rspec|
+  rspec.pattern = FileList["spec/**/*_spec.rb"]
+end
+
+Cucumber::Rake::Task.new(:features)
+
+Rake::ExtensionTask.new("damerau_levenshtein") do |extension|
+  extension.ext_dir = "ext/damerau_levenshtein"
+  extension.lib_dir = "lib/damerau-levenshtein"
+end
+
+Rake::Task[:spec].prerequisites << :compile
+Rake::Task[:features].prerequisites << :compile
+
+RuboCop::RakeTask.new
+task default: %i[rubocop spec]
+
+desc "open an irb session preloaded with this gem"
+task :console do
+  sh "irb -r pp -r ./lib/damerau-levenshtein.rb"
+end

data/damerau-levenshtein.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path("lib", __dir__)
+
+require "damerau-levenshtein/version"
+
+Gem::Specification.new do |s|
+  s.required_ruby_version = ">= 3.0"
+  s.name = "damerau-levenshtein-al2023"
+  s.version = DamerauLevenshtein::VERSION
+  s.homepage = "https://github.com/GlobalNamesArchitecture/damerau-levenshtein"
+  s.authors = ["Dmitry Mozzherin"]
+  s.email = "dmozzherin@gmail.com"
+  s.license = "MIT"
+  s.summary = "Calculation of editing distance for 2 strings " \
+              "using Levenshtein or Damerau-Levenshtein algorithms"
+  s.description = "This gem implements pure Levenshtein algorithm, " \
+                  "Damerau modification (where 2 character " \
+                  "transposition counts as 1 edit distance). It also " \
+                  "includes Boehmer & Rees 2008 modification, " \
+                  "to handle transposition in blocks with more than " \
+                  "2 characters (Boehmer & Rees 2008)."
+  s.files = `git ls-files -z`.split("\x0").
+            reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.extensions = ["ext/damerau_levenshtein/extconf.rb"]
+  s.require_paths = ["lib", "lib/damerau-levenshtein"]
+
+  s.add_development_dependency "bundler", "~> 2.1"
+  s.add_development_dependency "byebug", "~> 11.0"
+  s.add_development_dependency "coveralls", "~> 0.8"
+  s.add_development_dependency "cucumber", "~> 4.1"
+  s.add_development_dependency "rake", "~> 13.0"
+  s.add_development_dependency "rake-compiler", "~> 1.2.7"
+  s.add_development_dependency "rspec", "~> 3.9"
+  s.add_development_dependency "rubocop", "~> 0.88"
+  s.add_development_dependency "ruby-prof", "~> 1.4"
+  s.add_development_dependency "shoulda", "~> 4.0"
+  s.add_development_dependency "solargraph", "~> 0.39"
+end

data/ext/damerau_levenshtein/damerau_levenshtein.c

@@ -0,0 +1,116 @@
+#include "ruby.h"
+
+VALUE DamerauLevenshteinBinding = Qnil;
+
+void Init_damerau_levenshtein();
+
+VALUE method_internal_distance(VALUE self, VALUE _s, VALUE _t, VALUE _block_size, VALUE _max_distance);
+
+void Init_damerau_levenshtein() {
+	DamerauLevenshteinBinding = rb_define_module("DamerauLevenshteinBinding");
+	rb_define_method(DamerauLevenshteinBinding, "internal_distance", method_internal_distance, 4);
+}
+
+VALUE method_internal_distance(VALUE self, VALUE _s, VALUE _t, VALUE _block_size, VALUE _max_distance){
+  VALUE *sv = RARRAY_PTR(_s);
+  VALUE *tv = RARRAY_PTR(_t);
+  int i, i1, j, j1, k, half_tl, cost, *d, distance, del, ins, subs, transp, block;
+  int half_sl;
+  int stop_execution = 0;
+  int min = 0;
+  int current_distance = 0;
+  int pure_levenshtein = 0;
+  int block_size = NUM2INT(_block_size);
+  int max_distance = NUM2INT(_max_distance);
+  int sl = (int) RARRAY_LEN(_s);
+  int tl = (int) RARRAY_LEN(_t);
+  long long s[sl];
+  long long t[tl];
+  
+  if (block_size == 0) {
+    pure_levenshtein = 1;
+    block_size = 1;
+  }
+
+
+  if (sl == 0) return INT2NUM(tl);
+  if (tl == 0) return INT2NUM(sl);
+  //case of lengths 1 must present or it will break further in the code
+  if (sl == 1 && tl == 1 && sv[0] != tv[0]) return INT2NUM(1);
+
+
+  for (i=0; i < sl; i++) s[i] = NUM2LL(sv[i]);
+  for (i=0; i < tl; i++) t[i] = NUM2LL(tv[i]);
+
+  sl++;
+  tl++;
+
+  //one-dimentional representation of 2 dimentional array len(s)+1 * len(t)+1
+  d = malloc((sizeof(int))*(sl)*(tl));
+  //populate 'vertical' row starting from the 2nd position (first one is filled already)
+  for(i = 0; i < tl; i++){
+    d[i*sl] = i;
+  }
+
+  //fill up array with scores
+  for(i = 1; i<sl; i++){
+    d[i] = i;
+    if (stop_execution == 1) break;
+    current_distance = 10000;
+    for(j = 1; j<tl; j++){
+
+      cost = 1;
+      if(s[i-1] == t[j-1]) cost = 0;
+
+      half_sl = (sl - 1)/2;
+      half_tl = (tl - 1)/2;
+
+      block = block_size < half_sl || half_sl == 0 ? block_size : half_sl;
+      block = block < half_tl || half_tl == 0 ? block : half_tl;
+
+      while (block >= 1){
+        int swap1 = 1;
+        int swap2 = 1;
+        i1 = i - (block * 2);
+        j1 = j - (block * 2);
+        for (k = i1; k < i1 + block; k++) {
+          if (s[k] != t[k + block]){
+            swap1 = 0;
+            break;
+          }
+        }
+        for (k = j1; k < j1 + block; k++) {
+          if (t[k] != s[k + block]){
+            swap2 = 0;
+            break;
+          }
+        }
+
+        del = d[j*sl + i - 1] + 1;
+        ins = d[(j-1)*sl + i] + 1;
+        min = del;
+        if (ins < min) min = ins;
+        //if (i == 2 && j==2) return INT2NUM(swap2+5);
+        if (pure_levenshtein == 0 && i >= 2*block && j >= 2*block && swap1 == 1 && swap2 == 1){
+          transp = d[(j - block * 2) * sl + i - block * 2] + cost + block -1;
+          if (transp < min) min = transp;
+          block = 0;
+        } else if (block == 1) {
+          subs = d[(j-1)*sl + i - 1] + cost;
+          if (subs < min) min = subs;
+        }
+        block--;
+      }
+      d[j*sl+i]=min;
+      if (current_distance > d[j*sl+i]) current_distance = d[j*sl+i];
+    }
+    if (current_distance > max_distance) {
+      stop_execution = 1;
+    }
+  }
+  distance=d[sl * tl - 1];
+  if (stop_execution == 1) distance = current_distance;
+
+  free(d);
+  return INT2NUM(distance);
+}

data/ext/damerau_levenshtein/extconf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require "mkmf"
+require 'fileutils'
+
+# The destination
+dir_config("damerau-levenshtein/damerau_levenshtein")
+
+# Do the work
+create_makefile("damerau-levenshtein/damerau_levenshtein")
+
+# Determine the path to the 'lib' directory of your gem
+gem_lib_dir = File.expand_path('../../../lib/damerau-levenshtein', __FILE__)
+
+# Path to the .so file
+so_file = File.join(File.dirname(__FILE__), 'damerau_levenshtein.so')
+
+if File.exist?(so_file)
+  # At program exit, copy the 'damerau_levenshtein.so' file to the gem's 'lib' directory
+  at_exit do
+    # Combine the current directory of this file and the 'damerau_levenshtein.so' file, then copy it to the gem's 'lib' directory
+    FileUtils.cp(so_file, gem_lib_dir)
+  end
+else
+  puts "Error: The 'damerau_levenshtein.so' file was not generated."
+end

data/lib/damerau-levenshtein/differ.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module DamerauLevenshtein
+  # Shows the difference between two strings in character by character
+  # resolution
+  class Differ
+    FORMATS = %i[raw tag].freeze
+    attr_reader :format
+
+    def initialize
+      @format = :tag
+      @matrix = []
+    end
+
+    def format=(new_format)
+      new_format = new_format.to_sym
+      @format = new_format if FORMATS.include?(new_format)
+    end
+
+    def run(str1, str2)
+      @len1 = str1.size.freeze
+      @len2 = str2.size.freeze
+      prepare_matrix
+      edit_distance(str1, str2)
+      raw = trace_back
+      formatter_factory.show(raw, str1, str2)
+    end
+
+    private
+
+    def formatter_factory
+      formatter =
+        case @format
+        when :tag
+          DamerauLevenshtein::FormatterTag
+        when :raw
+          DamerauLevenshtein::FormatterRaw
+        end
+      Formatter.new(formatter)
+    end
+
+    def edit_distance(str1, str2)
+      (1..@len2).each do |i|
+        (1..@len1).each do |j|
+          no_change(i, j) && next if str2[i - 1] == str1[j - 1]
+          @matrix[i][j] = [del(i, j), ins(i, j), subst(i, j)].min + 1
+        end
+      end
+    end
+
+    def trace_back
+      res = []
+      cell = [@len2, @len1]
+      while cell != [0, 0]
+        cell, char = char_data(cell)
+        res.unshift char
+      end
+      res
+    end
+
+    def char_data(cell)
+      char = { distance: @matrix[cell[0]][cell[1]] }
+      val = find_previous(cell)
+      previous_value = val[0][0]
+      char[:type] = previous_value == char[:distance] ? :same : val[1]
+      cell = val.pop
+      [cell, char]
+    end
+
+    def find_previous(cell)
+      candidates = [[[ins(*cell), 1], :ins, [cell[0], cell[1] - 1]],
+                    [[del(*cell), 2], :del, [cell[0] - 1, cell[1]]],
+                    [[subst(*cell), 0], :subst, [cell[0] - 1, cell[1] - 1]]]
+      select_cell(candidates)
+    end
+
+    def select_cell(candidates)
+      candidates.select { |e| e[-1][0] >= 0 && e[-1][1] >= 0 }.
+        sort_by(&:first).first
+    end
+
+    def del(i, j)
+      @matrix[i - 1][j]
+    end
+
+    def ins(i, j)
+      @matrix[i][j - 1]
+    end
+
+    def subst(i, j)
+      @matrix[i - 1][j - 1]
+    end
+
+    def no_change(i, j)
+      @matrix[i][j] = @matrix[i - 1][j - 1]
+    end
+
+    def prepare_matrix
+      @matrix = []
+      @matrix << (0..@len1).to_a
+      @len2.times do |i|
+        ary = [i + 1] + (1..@len1).map { nil }
+        @matrix << ary
+      end
+    end
+  end
+end

data/lib/damerau-levenshtein/formatter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DamerauLevenshtein
+  # Formats supplied strings according to their differences
+  class Formatter
+    def initialize(formatter)
+      @formatter = formatter
+    end
+
+    def show(raw_format, str1, str2)
+      @formatter.show(raw_format, str1, str2)
+    end
+  end
+
+  # Outputs raw format for two strings
+  module FormatterRaw
+    def self.show(raw_format, _, _)
+      raw_format
+    end
+  end
+
+  # Outputs strings marked with tags
+  module FormatterTag
+    class << self
+      def show(raw_format, str1, str2)
+        inverted_raw_format = raw_format.map do |e|
+          type = invert_type(e[:type])
+          { distance: e[:distance], type: type }
+        end
+        [show_string(raw_format, str1, str2),
+         show_string(inverted_raw_format, str2, str1)]
+      end
+
+      private
+
+      def invert_type(type)
+        case type
+        when :del
+          :ins
+        when :ins
+          :del
+        else
+          type
+        end
+      end
+
+      def show_string(raw, str1, str2)
+        data = { res: [], type: nil, deletes: 0, inserts: 0,
+                 str1: str1, str2: str2 }
+        raw.each_with_index do |e, i|
+          process_entry(e, i, data)
+        end
+        data[:res] << format("</%<type>s>", data) if data[:type] != :same
+        data[:res].join("")
+      end
+
+      def process_entry(e, i, data)
+        if data[:type] && e[:type] != data[:type]
+          insert_tags(e, data)
+        elsif data[:type].nil?
+          data[:res] << format("<%<type>s>", e) if e[:type] != :same
+        end
+        insert_letter(e, i, data)
+      end
+
+      def insert_tags(entry, data)
+        data[:res] << format("</%<type>s>", data) if data[:type] != :same
+        data[:res] << format("<%<type>s>", entry) if entry[:type] != :same
+      end
+
+      def insert_letter(entry, index, data)
+        if entry[:type] == :del
+          insert_del(index, data)
+        else
+          insert_others(index, data)
+        end
+        data[:inserts] += 1 if entry[:type] == :ins
+        data[:type] = entry[:type]
+      end
+
+      def insert_del(i, data)
+        data[:res] << data[:str2][i - data[:inserts]]
+        data[:deletes] += 1
+      end
+
+      def insert_others(i, data)
+        data[:res] << data[:str1][i - data[:deletes]]
+      end
+    end
+  end
+end

data/lib/damerau-levenshtein/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Damerau Levenshtein algorithm
+module DamerauLevenshtein
+  VERSION = "1.3.6"
+end

data/lib/damerau-levenshtein.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "damerau-levenshtein/version"
+require_relative "damerau-levenshtein/damerau_levenshtein"
+require_relative "damerau-levenshtein/formatter"
+require_relative "damerau-levenshtein/differ"
+
+# Damerau-Levenshtein algorithm
+module DamerauLevenshtein
+  extend DamerauLevenshteinBinding
+
+  def self.version
+    VERSION
+  end
+
+  def self.distance(str1, str2, block_size = 1, max_distance = 10)
+    internal_distance(
+      str1.unpack("U*"), str2.unpack("U*"),
+      block_size, max_distance
+    )
+  end
+
+  def self.string_distance(*args)
+    distance(*args)
+  end
+
+  def self.array_distance(array1, array2, block_size = 1, max_distance = 10)
+    internal_distance(array1, array2, block_size, max_distance)
+  end
+
+  # keep backward compatibility - internal_distance was called distance_utf
+  # before
+  def self.distance_utf(*args)
+    internal_distance(*args)
+  end
+end

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: damerau-levenshtein-al2023
+version: !ruby/object:Gem::Version
+  version: 1.3.6
+platform: ruby
+authors:
+- Dmitry Mozzherin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.88'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.88'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+description: This gem implements pure Levenshtein algorithm, Damerau modification
+  (where 2 character transposition counts as 1 edit distance). It also includes Boehmer
+  & Rees 2008 modification, to handle transposition in blocks with more than 2 characters
+  (Boehmer & Rees 2008).
+email: dmozzherin@gmail.com
+executables: []
+extensions:
+- ext/damerau_levenshtein/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- damerau-levenshtein.gemspec
+- ext/damerau_levenshtein/damerau_levenshtein.c
+- ext/damerau_levenshtein/extconf.rb
+- lib/damerau-levenshtein.rb
+- lib/damerau-levenshtein/damerau_levenshtein.so
+- lib/damerau-levenshtein/differ.rb
+- lib/damerau-levenshtein/formatter.rb
+- lib/damerau-levenshtein/version.rb
+homepage: https://github.com/GlobalNamesArchitecture/damerau-levenshtein
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- lib/damerau-levenshtein
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Calculation of editing distance for 2 strings using Levenshtein or Damerau-Levenshtein
+  algorithms
+test_files: []