levenstein_with_path 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ac652def9cc19e91d929d8564d8c149cf5a7d76bfffa64a5a1c33f4916c2da2
+  data.tar.gz: 8ef661698b9ac965abf7ecac94db5eb10e383660ec6404a586a966bf06b67995
+SHA512:
+  metadata.gz: 45450cf22c284ccae072c7c6ac87318497072f15f62a113749ffc2e624b9d8bbd8c96f61955ada897ae999564aef8d00c77201a5e0288fa5925e8e4a14335f91
+  data.tar.gz: 32f95bf400659442b39c5ef626ed7465e1d09e3536a8190650adfc9a7e3f8c285eba63af1b5e4b21004f9fc98534f42745088ef811f4df0dddba563cfbb2ac5c

data/.gitignore

@@ -0,0 +1,9 @@
+.*.swp
+.*.swo
+/.ruby-version
+/.ruby-gemset
+/pkg
+/tmp
+/README.html
+/coverage
+/Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,81 @@
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Exclude:
+    - "Rakefile"
+  Max: 120
+
+Metrics/MethodLength:
+  Exclude:
+    - "spec/**/*"
+  Max: 35
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 12
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Style/BlockDelimiters:
+  EnforcedStyle: line_count_based
+  Exclude:
+    - "spec/**/*"
+
+Style/Documentation:
+  Exclude:
+    - "spec/**/*"
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    "%w": "[]"
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/ExpandPathArguments:
+  Enabled: false
+
+Gemspec/OrderedDependencies:
+  Enabled: false
+
+Naming/HeredocDelimiterNaming:
+  Enabled: false
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Layout/IndentHeredoc:
+  Enabled: false
+
+Style/Encoding:
+  Enabled: false
+
+Lint/AmbiguousBlockAssociation:
+  Enabled: false
+
+Layout/SpaceBeforeBlockBraces:
+  Enabled: false
+
+Layout/SpaceInsideBlockBraces:
+  Enabled: false
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Layout/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/TernaryParentheses:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - 1.9
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - jruby
+
+matrix:
+  include:
+  # Only run rubocop on the latest Ruby:
+  - rvm: 2.5
+    env: SUITE="rubocop"

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2018 Paul A. Jungwirth
+
+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,79 @@
+levenstein_with_path
+====================
+
+[![Build Status](https://travis-ci.org/pjungwir/levenstein_with_path.svg?branch=master)](https://travis-ci.org/pjungwir/levenstein_with_path)
+
+Ruby gem to find the Levenstein distance *and its sequence of edits*
+between two strings or arrays of tokens (like words, lines, etc.).
+
+Based on the [Wagner-Fischer algorithm](https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm),
+which is `O(n^2)` but lets you retain the history of edits.
+
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'levenstein_with_path'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install levenstein_with_path
+
+
+Usage
+-----
+
+```ruby
+p = LevensteinWithPath::Path.new('kitten', 'sitting')
+p.score
+# => 3
+p.edits
+# => [
+#   LevensteinWithPath::Swap.new('k', 's'),
+#   LevensteinWithPath::Keep.new('i'),
+#   LevensteinWithPath::Keep.new('t'),
+#   LevensteinWithPath::Keep.new('t'),
+#   LevensteinWithPath::Swap.new('e', 'i'),
+#   LevensteinWithPath::Keep.new('n'),
+#   LevensteinWithPath::Insert.new('g'),
+# ]
+```
+
+
+Tests
+-----
+
+Say `rake` to run rspec tests plus Rubocop,
+or `rspec spec` to run just the tests.
+
+
+Contributing
+------------
+ 
+* 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 hasn't already requested and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make be 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, that is fine, but please isolate that change to its own commit so I can cherry-pick around it.
+
+Commands for building/releasing/installing:
+
+* `rake build`
+* `rake install`
+* `rake release`
+
+Copyright
+---------
+
+Copyright (c) 2018 Paul A. Jungwirth.
+See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task readme: [] do
+  system %q{jq --slurp --raw-input '{"text": "\(.)", "mode": "gfm", "context": "pjungwir/levenstein_with_path"}' < README.md | curl --data @- https://api.github.com/markdown > README.html}
+end
+
+if ENV['CI'].nil?
+  task default: %w[spec rubocop]
+else
+  case ENV['SUITE']
+  when 'rubocop' then task default: :rubocop
+  else                task default: :spec
+  end
+end

data/levenstein_with_path.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'levenstein_with_path/version'
+
+Gem::Specification.new do |s|
+  s.name = 'levenstein_with_path'
+  s.version = LevensteinWithPath::VERSION
+
+  s.summary = 'Computes Levenstein distance between arrays of tokens, and gives the list of edits'
+  s.description = 'Computes Levenstein distance between arrays of tokens, and gives the list of edits'
+
+  s.authors = ['Paul A. Jungwirth']
+  s.homepage = 'https://github.com/pjungwir/levenstein_with_path'
+  s.email = ['pj@illuminatedcomputing.com']
+
+  s.licenses = ['MIT']
+
+  s.require_paths = ['lib']
+  s.executables = []
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,fixtures}/*`.split("\n")
+
+  s.add_development_dependency 'rspec', '>= 3.2.0'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rubocop'
+end

data/lib/levenstein_with_path.rb

@@ -0,0 +1,139 @@
+module LevensteinWithPath
+
+  # Computes the levenstein distance between two sequences.
+  #
+  # Unlike other Ruby libraries, this one:
+  #
+  #   - Can tell you not just the optimal score, but the sequence of operations to get it.
+  #     This is useful if you want to present a nice diff.
+  #   - Lets you pass either strings or array of some other atomic tokens
+  #     (like words, lines, nucleobases, etc.).
+  #
+  # It is based on the [Wagner-Fischer algorithm](https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm),
+  # which is `O(n^2)` but lets you retain the history of edits.
+  # See also [that algorithm applied to Levenstein distance](https://en.wikipedia.org/wiki/Levenshtein_distance#Computing_Levenshtein_distance).
+  class Path
+    attr_reader :tokens1, :tokens2
+    attr_reader :scores, :score
+
+    def initialize(tokens1, tokens2)
+      @tokens1 = if tokens1.is_a?(String)
+                   tokens1.chars
+                 else
+                   tokens1
+                 end.to_a
+      @tokens2 = if tokens2.is_a?(String)
+                   tokens2.chars
+                 else
+                   tokens2
+                 end.to_a
+
+      s = @tokens1
+      t = @tokens2
+      m = s.size
+      n = t.size
+      d = 0.upto(m).map { [0] * (n + 1)}
+      1.upto(m) {|i| d[i][0] = i}
+      1.upto(n) {|j| d[0][j] = j}
+
+      # rubocop:disable Layout/SpaceInsideReferenceBrackets
+      1.upto(n) do |j|
+        1.upto(m) do |i|
+          cost = s[i - 1] == t[j - 1] ? 0 : 1
+          d[i][j] = [
+            d[i - 1][j    ] + 1,    # delete
+            d[i    ][j - 1] + 1,    # insert
+            d[i - 1][j - 1] + cost  # keep/swap
+          ].min
+        end
+      end
+      # rubocop:enable Layout/SpaceInsideReferenceBrackets
+
+      @scores = d
+      @score = d[m][n]
+    end
+
+    def edits
+      return @edits if @edits
+      @edits = []
+      s = @tokens1
+      t = @tokens2
+      m = s.size
+      n = t.size
+      i = m
+      j = n
+      d = @scores
+      while i > 0 or j > 0
+        cur_score = d[i][j]
+        insert_score = j > 0 ? d[i][j - 1] : cur_score + 1
+        delete_score = i > 0 ? d[i - 1][j] : cur_score + 1
+        keep_or_swap_score = (i > 0 and j > 0) ? d[i - 1][j - 1] : cur_score + 1
+        best_score = [insert_score, delete_score, keep_or_swap_score].min
+        if best_score == keep_or_swap_score
+          if cur_score == keep_or_swap_score
+            @edits << Keep.new(s[i - 1])
+          else
+            @edits << Swap.new(s[i - 1], t[j - 1])
+          end
+          i -= 1
+          j -= 1
+        elsif best_score == insert_score
+          @edits << Insert.new(t[j - 1])
+          j -= 1
+        else
+          @edits << Delete.new(s[i - 1])
+          i -= 1
+        end
+      end
+      @edits.reverse!
+    end
+
+  end
+
+  # rubocop:disable Layout/EmptyLineBetweenDefs
+  class Edit
+  end
+
+  class Keep < Edit #:nodoc:
+    attr_reader :token
+    def initialize(token)
+      @token = token
+    end
+    def ==(other)
+      other.is_a?(Keep) and other.token == token
+    end
+  end
+
+  class Delete < Edit #:nodoc:
+    attr_reader :token
+    def initialize(token)
+      @token = token
+    end
+    def ==(other)
+      other.is_a?(Delete) and other.token == token
+    end
+  end
+
+  class Insert < Edit #:nodoc:
+    attr_reader :token
+    def initialize(token)
+      @token = token
+    end
+    def ==(other)
+      other.is_a?(Edit) and other.token == token
+    end
+  end
+
+  class Swap < Edit #:nodoc:
+    attr_reader :token1, :token2
+    def initialize(token1, token2)
+      @token1 = token1
+      @token2 = token2
+    end
+    def ==(other)
+      other.is_a?(Swap) and other.token1 == token1 and other.token2 == token2
+    end
+  end
+  # rubocop:enable Layout/EmptyLineBetweenDefs
+
+end

data/lib/levenstein_with_path/version.rb

@@ -0,0 +1,3 @@
+module LevensteinWithPath
+  VERSION = '1.0.0'.freeze
+end

data/spec/levenstein_with_path_spec.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+describe 'LevensteinWithPath' do
+  # Some real tests:
+  let(:kitten_to_sitting) { LevensteinWithPath::Path.new('kitten', 'sitting') }
+  let(:saturday_to_sunday) { LevensteinWithPath::Path.new('Saturday', 'Sunday') }
+
+  # Non-ascii:
+  let(:eye_to_navel) { LevensteinWithPath::Path.new("ὀφθαλμός", "ὀμφαλός") }
+
+  # Some degenerate cases:
+  let(:cat_to_empty) { LevensteinWithPath::Path.new('cat', '') }
+  let(:empty_to_cat) { LevensteinWithPath::Path.new('', 'cat') }
+  let(:empty_to_empty) { LevensteinWithPath::Path.new('', '') }
+  let(:a_to_a) { LevensteinWithPath::Path.new('a', 'a') }
+  let(:cat_to_cat) { LevensteinWithPath::Path.new('cat', 'cat') }
+
+  # Arrays of words:
+  let(:vita_ad_spes) { LevensteinWithPath::Path.new(%w[Dum vita est], %w[spes est]) }
+
+  it "computes the score" do
+    expect(kitten_to_sitting.score).to eq 3
+    expect(saturday_to_sunday.score).to eq 3
+
+    expect(eye_to_navel.score).to eq 3
+
+    expect(cat_to_empty.score).to eq 3
+    expect(empty_to_cat.score).to eq 3
+    expect(empty_to_empty.score).to eq 0
+    expect(a_to_a.score).to eq 0
+    expect(cat_to_cat.score).to eq 0
+
+    expect(vita_ad_spes.score).to eq 2
+  end
+
+  it "lists the edits" do
+    expect(kitten_to_sitting.edits).to eq [
+      LevensteinWithPath::Swap.new('k', 's'),
+      LevensteinWithPath::Keep.new('i'),
+      LevensteinWithPath::Keep.new('t'),
+      LevensteinWithPath::Keep.new('t'),
+      LevensteinWithPath::Swap.new('e', 'i'),
+      LevensteinWithPath::Keep.new('n'),
+      LevensteinWithPath::Insert.new('g'),
+    ]
+    expect(saturday_to_sunday.edits).to eq [
+      LevensteinWithPath::Keep.new('S'),
+      LevensteinWithPath::Delete.new('a'),
+      LevensteinWithPath::Delete.new('t'),
+      LevensteinWithPath::Keep.new('u'),
+      LevensteinWithPath::Swap.new('r', 'n'),
+      LevensteinWithPath::Keep.new('d'),
+      LevensteinWithPath::Keep.new('a'),
+      LevensteinWithPath::Keep.new('y'),
+    ]
+
+    expect(eye_to_navel.edits).to eq [
+      LevensteinWithPath::Keep.new('ὀ'),
+      LevensteinWithPath::Swap.new('φ', 'μ'),
+      LevensteinWithPath::Swap.new('θ', 'φ'),
+      LevensteinWithPath::Keep.new('α'),
+      LevensteinWithPath::Keep.new('λ'),
+      LevensteinWithPath::Delete.new('μ'),
+      LevensteinWithPath::Keep.new('ό'),
+      LevensteinWithPath::Keep.new('ς'),
+    ]
+
+    expect(cat_to_empty.edits).to eq %w[c a t].map{|x| LevensteinWithPath::Delete.new(x)}
+    expect(empty_to_cat.edits).to eq %w[c a t].map{|x| LevensteinWithPath::Insert.new(x)}
+    expect(empty_to_empty.edits).to eq []
+    expect(a_to_a.edits).to eq [LevensteinWithPath::Keep.new('a')]
+    expect(cat_to_cat.edits).to eq %w[c a t].map{|x| LevensteinWithPath::Keep.new(x)}
+
+    expect(vita_ad_spes.edits).to eq [
+      LevensteinWithPath::Delete.new('Dum'),
+      LevensteinWithPath::Swap.new('vita', 'spes'),
+      LevensteinWithPath::Keep.new('est'),
+    ]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'levenstein_with_path'
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: levenstein_with_path
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Paul A. Jungwirth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Computes Levenstein distance between arrays of tokens, and gives the
+  list of edits
+email:
+- pj@illuminatedcomputing.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- levenstein_with_path.gemspec
+- lib/levenstein_with_path.rb
+- lib/levenstein_with_path/version.rb
+- spec/levenstein_with_path_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/pjungwir/levenstein_with_path
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Computes Levenstein distance between arrays of tokens, and gives the list
+  of edits
+test_files: []