damerau-levenshtein 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acbd86c82aab23d17130fda4d7e05aa39d10571d
-  data.tar.gz: 8421eaf8a995a2b217ca77a703b0ac328a729202
+  metadata.gz: 67c6faa0317240defb0210ab642c514942855fdb
+  data.tar.gz: 4ad7bd77b1eb7fec82c489e78d572fa75f25c2c9
 SHA512:
-  metadata.gz: 3ad4824365414744893442e7c64698f9c0bd0ca4b948b52d53b55f107a89fc5e96971e1bf81ac50a051ed63bf68dcb33493e08af96fbe16aa9d10bd030b0cae6
-  data.tar.gz: e1e72f50b29be357115bdf666bb7c7a57c9b88bd1eecf0457d25dba469ebe20cdd65e8b4b58c153d947041ff2dd5f2593743787257bd575d4689416a31065ee3
+  metadata.gz: fd15b89736839baa55d4023c15a5ff8511364b55b4e585c3bf68dcd4bb75e62e9e5dfdff1505691694c502c875f19b74c996691dec7261d184be97e0b0636ede
+  data.tar.gz: ae7e131dcd30ed4f3d98c78bfbe4359a63392c34f301c76aef975fbf94ec9f60abd9e61f500f71c0a1bfe9e493080eb6291c50a736d2c68802681524ad580f47

data/.gitignore

@@ -5,6 +5,10 @@ tmp
 *.o
 *.bundle
 *.gem
+.nvimlog
+.vim.custom
+.byebug_history
+
 # rcov generated
 coverage
 

data/.ruby-version

@@ -1 +1 @@
-2.2.4
+2.4.1

data/.travis.yml

@@ -2,7 +2,8 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
-  - 2.3.1
+  - 2.3
+  - 2.4
 before_install: "gem update bundler"
 script:
   - "bundle exec rake"

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 damerau-levenshtein CHANGELOG
 =============================
 
+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

data/Gemfile

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

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2011-2016 Dmitry Mozzherin
+Copyright (c) 2011-2017 Dmitry Mozzherin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,13 +1,12 @@
-damerau-levenshtein
-===================
+# damerau-levenshtein #
 
 [![Gem Version][gem_svg]][gem]
 [![Continuous Integration Status][ci_svg]][ci]
 [![Dependency Status][dep_svg]][dep]
 [![Coverage Status][cov_svg]][cov]
 
-The damerau-levenshtein gem allows to find edit distance between two UTF-8
-or ASCII encoded strings with O(N\*M) efficiency.
+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
@@ -20,21 +19,28 @@ 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>`
+
+```ruby
+require "damerau-levenshtein"
+differ = DamerauLevenshtein::Differ.new
+differ.run("corn", "cron")
+# output: ["c<subst>or</subst>n", "c<subst>ro</subst>n"]
+```
+
 Gem damerau-levenshtein is compatible with ruby versions 1.8.7
 and 1.9.2 and higher, as well as 2.0.0 and higher
 
-Dependencies
--------------
+## Dependencies ##
 
     sudo apt-get install build-essential libgmp3-dev
 
-Installation
-------------
+## Installation ##
 
     gem install damerau-levenshtein
 
-Examples
---------
+## Examples ##
 
 ```ruby
 require "damerau-levenshtein"
@@ -65,25 +71,55 @@ dl.distance("Something", "meSothing", 2) #returns 2 instead of 4
 dl.distance("Sjöstedt", "Sjostedt") #returns 1
 ```
 
-API Description
------------
+* 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")
+```
 
-Gem defines two methods
+* 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][ed] between 2 strings
-```
+#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 takes 4 arguments:
+`DamerauLevenshtein.distance` and `.array_distance` take 4 arguments:
 
-* `string1`
-* `string2`
+* `string1` (`array1` for `.array_distance`)
+* `string2` (`array2` for `.array_distance`)
 * `block_size` (default is 1)
 * `max_distance` (default is 10)
 
@@ -113,57 +149,63 @@ 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.string_distance` is an alias of
-`DamerauLevenshtein.distance`
+#### 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`
 
-`DamerauLevenshtein.array_distance` has the same parameters as
-`DamerauLevenshtein.distance`, but operates on arrays of Integers.
+`differ.run("String1", "String2")` returns difference between two strings.
+
+For example:
 
 ```ruby
-DamerauLevenshtein.array_distance([1,2,4], [1,2,3])
-# output: 1
+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"]
+
 ```
 
-Contributing to damerau-levenshtein
------------------------------------
+
+## 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
+  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
+  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.
+  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.
+  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
-----------
+## Versioning ##
 
 This gem is following practices of [Semantic Versioning][semver]
 
-Authors
--------
+## Authors ##
 
 [Dmitry Mozzherin][dimus]
 
-Contributors
-------------
+## Contributors ##
 
-[lazylester][lazylester], [Ran Xie][skarlit], [Alexey Zapparov][ixti],
-[azhi][azhi]
+[lazylester][lazylester], [Ran Xie][skarlit], [Alexey Zapparov][ixti], [azhi][azhi]
 
-Copyright
----------
+## Copyright ##
 
-Copyright (c) 2011-2016 Dmitry Mozzherin. See LICENSE.txt for
+Copyright (c) 2011-2017 Dmitry Mozzherin. See LICENSE.txt for
 further details.
 
 [gem_svg]: https://badge.fury.io/rb/damerau-levenshtein.svg

data/Rakefile

@@ -1,25 +1,32 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require 'cucumber/rake/task'
+require "cucumber/rake/task"
 require "rubocop/rake_task"
-require 'rake/dsl_definition'
-require 'rake'
-require 'rake/extensiontask'
-require 'rspec'
+require "rake/dsl_definition"
+require "rake"
+require "rake/extensiontask"
+require "rspec"
 
 RSpec::Core::RakeTask.new(:spec) do |rspec|
-  rspec.pattern = FileList['spec/**/*_spec.rb']
+  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'
+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 => [:rubocop, :spec]
+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

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.push File.expand_path("../lib", __FILE__)
 
 require "damerau-levenshtein/version"
 
+# rubocop:disable Metrics/BlockLength
+
 Gem::Specification.new do |s|
   s.name = "damerau-levenshtein"
   s.version = DamerauLevenshtein::VERSION
@@ -25,6 +29,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec", "~> 3.5"
   # activesupport >= 5.0 does not support Ruby < 2.2
   s.add_development_dependency "activesupport", "~> 4.2"
+  s.add_development_dependency "byebug", "~> 9.0"
   s.add_development_dependency "cucumber", "~> 2.4"
   s.add_development_dependency "ruby-prof", "~> 0.15"
   s.add_development_dependency "shoulda", "~> 3.5"
@@ -34,3 +39,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake", "~> 11.2"
   s.add_development_dependency "rake-compiler", "~> 1.0"
 end
+
+# rubocop:enable all

data/ext/damerau_levenshtein/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Loads mkmf which is used to make makefiles for Ruby extensions
 require "mkmf"
 

data/lib/damerau-levenshtein.rb

@@ -1,7 +1,10 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
-require "damerau-levenshtein/version"
-require "damerau-levenshtein/damerau_levenshtein"
+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

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_accessor :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("</%s>", data[:type]) 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("<%s>", e[:type]) if e[:type] != :same
+        end
+        insert_letter(e, i, data)
+      end
+
+      def insert_tags(entry, data)
+        data[:res] << format("</%s>", data[:type]) if data[:type] != :same
+        data[:res] << format("<%s>", entry[:type]) 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

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 # Damerau Levenshtein algorithm
 module DamerauLevenshtein
-  VERSION = "1.2.0".freeze
+  VERSION = "1.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: damerau-levenshtein
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Dmitry Mozzherin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-15 00:00:00.000000000 Z
+date: 2017-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
@@ -176,6 +190,8 @@ files:
 - 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:
@@ -198,7 +214,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Calculation of editing distance for 2 strings using Levenshtein or Damerau-Levenshtein