string_metric 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 32870ce170c62b4036f6b8eaf3f92e43280a0246
+  data.tar.gz: a7f38c88be3211f6ef1d82c71d701a0655081570
+SHA512:
+  metadata.gz: 8668f405e8568c4254ef7856660a87bd4488d8e4ddbcea95f185575562787ad072696868a831431b821d95f868a8a1f67e1f2b057272375dbda3f0fbe73a6ccb
+  data.tar.gz: 9e9b25912b3f695161262fb331cc8f043fe8b269b29f1880ee9d8bce8dbf367c339de18b9c3756d15d9ee0e5ba677e1ff5b2837909869c0b1984797b75638f5b

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.ruby-version
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format doc

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.0"
+  - "jruby-19mode"
+
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "coveralls", require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Skroutz S.A.
+
+MIT License
+
+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,134 @@
+# StringMetric
+
+[![Build Status](https://travis-ci.org/skroutz/string_metric.png?branch=master)](https://travis-ci.org/skroutz/string_metric)
+[![Code Climate](https://codeclimate.com/github/skroutz/string_metric.png)](https://codeclimate.com/github/skroutz/string_metric)
+[![Coverage Status](https://coveralls.io/repos/skroutz/string_metric/badge.png?branch=master)](https://coveralls.io/r/skroutz/string_metric?branch=master)
+
+A simple library with String Metric algorithms. If you want to read more about
+String Metric algorithms please read [here](https://en.wikipedia.org/wiki/String_metric).
+
+This library wants to support __MRI__ (1.9.3, 2.0.0, 2.1.0), __JRuby__ and
+__Rubinious__.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'string_metric'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install string_metric
+
+## Usage
+
+### Levenshtein Distance
+
+The public api for Levenshtein Distance is the method
+`StringMetric::Levenshtein.distance`.
+
+__Options__
+
+* `:max_distance`: It sets an upper limit for the calculated distance. Can be
+  `Fixnum` or `Float`.
+
+* `:insertion_cost`: It overrides the default (equals to 1) insertion penalty.
+   Can be `Fixnum` or `Float`.
+
+* `:deletion_cost`: It overrides the default (equals to 1) deletion penanty.
+  Can be `Fixnum` or `Float`.
+
+* `:subsctitution_cost`: It overrides the default (equals to 1) substitution
+  penalty. Can be `Fixum` or `Float`.
+
+* `:strategy`: The desired strategy for Levenshtein distance. Supported
+  strategies are `:recursive`, `:two_matrix_rows`, `:full_matrix` and
+  `:experiment`. The default strategy is `:two_matrix_rows`. One should not
+  depend on `:experiment` strategy.
+
+__Examples__
+
+```ruby
+
+  require 'string_metric'
+
+  StringMetric::Levenshtein.distance("kitten", "sitting")
+  # Generates: 3
+
+  # Trim distance to :max_distance
+  StringMetric::Levenshtein.distance("kitten", "sitting",
+    max_distance: 2)
+  # Generates: 2
+
+  # Pass different costs for increase, delete or substitute actions
+  StringMetric::Levenshtein.distance("kitten", "sitting",
+    insertion_cost: 2,
+    deletion_cost:  2,
+    substitution_cost: 2)
+  # Generates: 6
+
+```
+
+## References
+
+* [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance)
+* [String Metric](https://en.wikipedia.org/wiki/String_metric)
+
+## Benchmarks
+
+You can run benchmarks with
+
+```
+  $ bundle exec ruby benchmarks/*
+```
+
+or you can choose to benchmark a specific algorithm like:
+
+```
+  $ bundle exec ruby benchmarks/levenshtein.rb
+```
+
+## Current Benchmarks status
+
+__Levenshtein__
+
+
+Implementation                              | User      | Real
+--------------------------------------------|-----------|-----------
+Levenshtein::IterativeWithFullMatrix        | 0.480000  | 0.475662
+Levenshtein::IterativeWithTwoMatrixRows     | 0.350000  | 0.352388
+Levenshtein::Experiment                     | 0.420000  | 0.420000
+Text::Levenshtein (from gem text)           | 0.400000  | 0.400346
+
+_Currently the set of fixtures is very small_
+
+## Other implementations
+
+__Levenshtein__
+
+* this beautiful gem, [text](https://github.com/threedaymonk/text)
+* ffi implementations, like [this](https://github.com/dbalatero/levenshtein-ffi) or check [The Ruby Toolbox](https://www.ruby-toolbox.com/projects/levenshtein-ffi)
+
+__Various__
+* Approximate String matching [library](https://github.com/flori/amatch)
+
+## Tools
+
+* Try to use [SemVer](http://semver.org/)
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/string_metric/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Licence
+
+string_metric is licensed under MIT. See [License](LICENSE.txt)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/benchmarks/levenshtein.rb

@@ -0,0 +1,42 @@
+require "benchmark"
+require "string_metric"
+require "text"
+require "csv"
+
+if RUBY_ENGINE == "ruby"
+  require "pry"
+end
+
+Benchmark.bmbm(7) do |x|
+
+  iterations = 10_000
+  options = { insertion_cost: 2 }
+
+  fixtures = []
+  CSV.foreach("spec/fixtures/levenshtein.csv") do |row|
+    from, to, _ = row
+
+    fixtures.push [from.to_s.strip, to.to_s.strip]
+  end
+
+  StringMetric::Levenshtein::STRATEGIES.each do |strategy, implementation|
+    next if strategy == :recursive
+
+    x.report("#{implementation.to_s} implementation") do
+      iterations.times do |i|
+
+        fixtures.each do |from, to|
+          implementation.distance(from, to, options)
+        end
+      end
+    end
+  end
+
+  x.report("Text::Levenshtein implementation") do
+    iterations.times do |i|
+      fixtures.each do |from, to|
+        Text::Levenshtein.distance(from, to)
+      end
+    end
+  end
+end

data/lib/string_metric.rb

@@ -0,0 +1,5 @@
+require "string_metric/version"
+require "string_metric/levenshtein"
+
+module StringMetric
+end

data/lib/string_metric/levenshtein.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+require_relative "levenshtein/experiment"
+require_relative "levenshtein/iterative_with_two_matrix_rows"
+require_relative "levenshtein/iterative_with_two_matrix_rows_optimized"
+require_relative "levenshtein/iterative_with_full_matrix"
+require_relative "levenshtein/recursive"
+
+module StringMetric
+  # Levenshtein Distance implementation
+  #
+  # @see https://en.wikipedia.org/wiki/Levenshtein_distance
+  module Levenshtein
+
+    STRATEGIES = {
+      experiment:   Experiment,
+      full_matrix:  IterativeWithFullMatrix,
+      recursive:    Recursive,
+      two_matrix_rows:    IterativeWithTwoMatrixRows,
+      two_matrix_rows_v2: IterativeWithTwoMatrixRowsOptimized
+    }
+
+    # Levenshtein Distance of two strings
+    #
+    # @param from [String] the first string
+    # @param to [String] the second string
+    # @param options [Hash] options
+    # @option options [Fixnum, Float] :max_distance If this option is passed then
+    #   levenstein distance is trimmed to this value (if greater)
+    # @option options [Fixnum, Float] :insertion_cost If this option is passed then
+    #   new insertion cost is taken into account (by default is 1)
+    # @option options [Fixnum, Float] :deletion_cost If this option is passed then
+    #   new deletion cost is taken into account (by default is 1)
+    # @option options [Fixnum, Float] :substitution_cost If this option is passed then
+    #   new substitution cost is taken into account (be default is 1)
+    # @option options [Symbol] :strategy The desired strategy for Levenshtein
+    #   distance. Supported strategies are :recursive, :two_matrix_rows,
+    #   :full_matrix and :experiment. The default strategy is :two_matrix_rows.
+    #   One should not depend on :experiment strategy.
+    # @return [Fixnum, Float] the Levenshtein Distance
+    def distance(from, to, options = {})
+      strategy = pick_strategy(options[:strategy]) || Levenshtein.default_strategy
+      args = [from, to, options]
+
+      strategy.distance(*args)
+    end
+    module_function :distance
+
+    # Currently the default strategy is set to IterativeWithTwoMatrixRows
+    def default_strategy
+      if RUBY_ENGINE == "ruby"
+        pick_strategy(:two_matrix_rows_v2)
+      else
+        pick_strategy(:two_matrix_rows)
+      end
+    end
+    module_function :default_strategy
+
+    def pick_strategy(symbol)
+      STRATEGIES[symbol]
+    end
+    module_function :pick_strategy
+    private_class_method :pick_strategy
+  end
+end

data/lib/string_metric/levenshtein/experiment.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+module StringMetric
+  module Levenshtein
+    class Experiment
+      def self.distance(from, to, options = {})
+        return 0 if from == to
+        return to.size if from.size.zero?
+        return from.size if to.size.zero?
+
+        m = from.length
+        n = to.length
+
+        [m, n].min.times do |i|
+          if from[i] == to[i]
+            from.slice!(i)
+            to.slice!(i)
+          end
+        end
+
+        options.delete(:strategy)
+
+        # Call default distance implementation
+        Levenshtein.distance(from, to, options)
+      end
+    end
+  end
+end

data/lib/string_metric/levenshtein/iterative_with_full_matrix.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+module StringMetric
+  module Levenshtein
+    class IterativeWithFullMatrix
+      def self.distance(from, to, options = {})
+        return 0 if from == to
+        return to.size if from.size.zero?
+        return from.size if to.size.zero?
+
+        max_distance      = options[:max_distance]
+        insertion_cost    = options.fetch(:insertion_cost, 1)
+        deletion_cost     = options.fetch(:deletion_cost, 1)
+        substitution_cost = options.fetch(:substitution_cost, 1)
+
+        d = (0..to.size).map do |i|
+          [0] * (from.size + 1)
+        end
+
+        (1..from.size).each { |j| d[0][j] = j }
+        (1..to.size).each { |i| d[i][0] = i }
+
+        (1..from.size).each do |j|
+          (1..to.size).each do |i|
+            if from[j-1] == to[i-1]
+              d[i][j] = d[i -1][j-1]
+            else
+              d[i][j] = [d[i-1][j]   + insertion_cost,    # insertion
+                         d[i][j-1]   + deletion_cost,     # deletion
+                         d[i-1][j-1] + substitution_cost  # substitution
+                        ].min
+            end
+          end
+
+          break if max_distance and d[j][j] > max_distance
+        end
+
+        x = d[to.size][from.size]
+        if max_distance && x > max_distance
+          max_distance
+        else
+          x
+        end
+      end
+    end
+  end
+end

data/lib/string_metric/levenshtein/iterative_with_two_matrix_rows.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+module StringMetric
+  module Levenshtein
+    class IterativeWithTwoMatrixRows
+      def self.distance(from, to, options = {})
+        return 0 if from == to
+        return to.size if from.size.zero?
+        return from.size if to.size.zero?
+
+        max_distance      = options[:max_distance]
+        insertion_cost    = options.fetch(:insertion_cost, 1)
+        deletion_cost     = options.fetch(:deletion_cost, 1)
+        substitution_cost = options.fetch(:substitution_cost, 1)
+
+        m = from.length
+        n = to.length
+
+        v0 = (0..m).to_a
+        v1 = []
+        x = 0
+
+        n.times do |i|
+          x = v1[0] = i + 1
+
+          sub_cell = v0[0]
+
+          m.times do |j|
+            cost = (from[j] == to[i]) ? 0 : substitution_cost
+
+            ins_cell = v0[j+1]
+
+            x = [x + deletion_cost,         # deletion
+                 ins_cell + insertion_cost, # insertion
+                 sub_cell + cost            # substitution
+                ].min
+
+
+            v1[j + 1] = x
+
+            sub_cell = ins_cell
+          end
+
+          break if max_distance && v0[i] > max_distance
+
+          v0 = v1.dup
+        end
+
+        if max_distance && x > max_distance
+          max_distance
+        else
+          x
+        end
+      end
+    end
+  end
+end

data/lib/string_metric/levenshtein/iterative_with_two_matrix_rows_optimized.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module StringMetric
+  module Levenshtein
+    class IterativeWithTwoMatrixRowsOptimized
+      def self.distance(from, to, options = {})
+        return 0 if from == to
+        return to.size if from.size.zero?
+        return from.size if to.size.zero?
+
+        max_distance      = options[:max_distance]
+        insertion_cost    = options.fetch(:insertion_cost, 1)
+        deletion_cost     = options.fetch(:deletion_cost, 1)
+        substitution_cost = options.fetch(:substitution_cost, 1)
+
+        m = from.length
+        n = to.length
+
+        v0 = (0..m).to_a
+        v1 = []
+        x = 0
+
+        n.times do |i|
+          x = v1[0] = i + 1
+
+          sub_cell = v0[0]
+
+          m.times do |j|
+            cost = (from[j] == to[i]) ? 0 : substitution_cost
+
+            ins_cell = v0[j+1]
+
+            x = [x + deletion_cost,         # deletion
+                 ins_cell + insertion_cost, # insertion
+                 sub_cell + cost            # substitution
+                ].sort!
+
+            x = x[0]
+
+            v1[j + 1] = x
+
+            sub_cell = ins_cell
+          end
+
+          break if max_distance && v0[i] > max_distance
+
+          v0 = v1.dup
+        end
+
+        if max_distance && x > max_distance
+          max_distance
+        else
+          x
+        end
+      end
+    end
+  end
+end

data/lib/string_metric/levenshtein/recursive.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+module StringMetric
+  module Levenshtein
+    class Recursive
+      def self.distance(from, to, options = {})
+        return 0 if from == to
+        return to.size if from.size.zero?
+        return from.size if to.size.zero?
+
+        max_distance      = options[:max_distance]
+        insertion_cost    = options.fetch(:insertion_cost, 1)
+        deletion_cost     = options.fetch(:deletion_cost, 1)
+        substitution_cost = options.fetch(:substitution_cost, 1)
+
+        if from.chars.to_a.last == to.chars.to_a.last
+          cost = 0
+        else
+          cost = substitution_cost
+        end
+
+        if max_distance
+          return [distance(from.chop, to, options) + deletion_cost,
+                  distance(from, to.chop, options) + insertion_cost,
+                  distance(from.chop, to.chop, options) + cost,
+                  max_distance
+                 ].min
+        else
+          return [distance(from.chop, to, options) + deletion_cost,
+                  distance(from, to.chop, options) + insertion_cost,
+                  distance(from.chop, to.chop, options) + cost
+                 ].min
+
+        end
+      end
+    end
+  end
+end

data/lib/string_metric/version.rb

@@ -0,0 +1,3 @@
+module StringMetric
+  VERSION = "0.1.0"
+end

data/spec/fixtures/levenshtein.csv

@@ -0,0 +1,11 @@
+hello, hello, 0
+hello, helo, 1
+hello, jello, 1
+hello, helol, 2
+hello, hellol, 1
+hello, heloll, 2
+hello, cheese, 4
+hello, saint, 5
+hello,, 5
+sitting, kitten, 3
+αλφα, βητα, 3

data/spec/lib/levenshtein/experiment_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require "spec_helper"
+
+describe StringMetric::Levenshtein::Experiment do
+  it_behaves_like "Levenshtein Distance"
+end

data/spec/lib/levenshtein/iterative_with_full_matric_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require "spec_helper"
+
+describe StringMetric::Levenshtein::IterativeWithFullMatrix do
+  it_behaves_like "Levenshtein Distance"
+end

data/spec/lib/levenshtein/iterative_with_two_matrix_rows_optimized_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require "spec_helper"
+
+describe StringMetric::Levenshtein::IterativeWithTwoMatrixRowsOptimized do
+  it_behaves_like "Levenshtein Distance", { strategy: :two_matrix_rows_v2 }
+end

data/spec/lib/levenshtein/iterative_with_two_matrix_rows_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require "spec_helper"
+
+describe StringMetric::Levenshtein::IterativeWithTwoMatrixRows do
+  it_behaves_like "Levenshtein Distance", { strategy: :two_matrix_rows }
+end

data/spec/lib/levenshtein/recursive_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+require "spec_helper"
+
+describe StringMetric::Levenshtein::Recursive do
+  it_behaves_like "Levenshtein Distance"
+end

data/spec/lib/levenshtein_spec.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+require "spec_helper"
+
+describe StringMetric::Levenshtein do
+  it_behaves_like "Levenshtein Distance"
+
+  describe '#default_strategy' do
+    it "has a default strategy" do
+      expect(described_class.default_strategy).to be
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require "string_metric"
+
+if RUBY_ENGINE == "ruby"
+  require "pry"
+end
+
+require 'coveralls'
+Coveralls.wear!
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/levenshtein.rb

@@ -0,0 +1,53 @@
+require "csv"
+
+shared_examples "Levenshtein Distance" do |options|
+  options ||= {}
+
+  describe ".distance" do
+    context "when the two strings are equal" do
+      it "is 0" do
+        expect(described_class.distance("kitten", "kitten", options)).to eq 0
+      end
+    end
+
+    context "when the first string is empty" do
+      it "is the size of the second string" do
+        expect(described_class.distance("","kitten", options)).to eq("kitten".size)
+      end
+    end
+
+    context "when the second string is empty" do
+      it "is the size of the first string" do
+        expect(described_class.distance("kitten","", options)).to eq("kitten".size)
+      end
+    end
+
+    context "when max_distance is passed as option" do
+      context "and normal distance is greater than max_distance" do
+        let(:max_distance) { 2 }
+
+        it "is trimmed to max_distance" do
+          expect(described_class.distance("kitten", "sitting",
+            max_distance: max_distance)).to eq max_distance
+        end
+      end
+    end
+
+    CSV.foreach("spec/fixtures/levenshtein.csv") do |row|
+      from, to, distance = row
+      from = from.to_s.strip
+      to   = to.to_s.strip
+
+      it "calculates the distance from '#{from}' to '#{to}' correctly" do
+        expect(described_class.distance(from, to, options)).to eq distance.to_i
+      end
+    end
+
+    context "when insertion_cost is passed" do
+      it "takes this cost into account" do
+        expect(described_class.distance("kitten", "sitting", insertion_cost: 1)).not_to eq(
+        described_class.distance("kitten", "sitting", insertion_cost: 2))
+      end
+    end
+  end
+end

data/string_metric.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'string_metric/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "string_metric"
+  spec.version       = StringMetric::VERSION
+  spec.authors       = ["Giorgos Tsiftsis"]
+  spec.email         = ["giorgos.tsiftsis@skroutz.gr"]
+  spec.summary       = %q{A simple library with String Metric algorithms}
+  spec.description   = %q{A simple library with String Metric algorithms}
+  spec.homepage      = "https://github.com/chief/string_metric"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.1.1"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+  spec.add_development_dependency "text", "~> 1.2.3"
+
+  if RUBY_ENGINE == "ruby"
+    if RUBY_VERSION > "1.9.3"
+      spec.add_development_dependency "pry-byebug", "~> 1.2.1"
+    else
+      spec.add_development_dependency "pry", "~> 0.9.12.4"
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: string_metric
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Giorgos Tsiftsis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: text
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description: A simple library with String Metric algorithms
+email:
+- giorgos.tsiftsis@skroutz.gr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/levenshtein.rb
+- lib/string_metric.rb
+- lib/string_metric/levenshtein.rb
+- lib/string_metric/levenshtein/experiment.rb
+- lib/string_metric/levenshtein/iterative_with_full_matrix.rb
+- lib/string_metric/levenshtein/iterative_with_two_matrix_rows.rb
+- lib/string_metric/levenshtein/iterative_with_two_matrix_rows_optimized.rb
+- lib/string_metric/levenshtein/recursive.rb
+- lib/string_metric/version.rb
+- spec/fixtures/levenshtein.csv
+- spec/lib/levenshtein/experiment_spec.rb
+- spec/lib/levenshtein/iterative_with_full_matric_spec.rb
+- spec/lib/levenshtein/iterative_with_two_matrix_rows_optimized_spec.rb
+- spec/lib/levenshtein/iterative_with_two_matrix_rows_spec.rb
+- spec/lib/levenshtein/recursive_spec.rb
+- spec/lib/levenshtein_spec.rb
+- spec/spec_helper.rb
+- spec/support/levenshtein.rb
+- string_metric.gemspec
+homepage: https://github.com/chief/string_metric
+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.2.0
+signing_key: 
+specification_version: 4
+summary: A simple library with String Metric algorithms
+test_files:
+- spec/fixtures/levenshtein.csv
+- spec/lib/levenshtein/experiment_spec.rb
+- spec/lib/levenshtein/iterative_with_full_matric_spec.rb
+- spec/lib/levenshtein/iterative_with_two_matrix_rows_optimized_spec.rb
+- spec/lib/levenshtein/iterative_with_two_matrix_rows_spec.rb
+- spec/lib/levenshtein/recursive_spec.rb
+- spec/lib/levenshtein_spec.rb
+- spec/spec_helper.rb
+- spec/support/levenshtein.rb