vladlev 1.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef4a27d86e0e99dc06744c8978b02a8b21764690
+  data.tar.gz: e25a238dddd9e9fec5d4a3ac711ab130a78bdcd0
+SHA512:
+  metadata.gz: e987312d3687d68e2e0311ec74fd888486999d70a46c769d35bc0c8919576d464b0b61b081fc67fc862c5134274be925787c42c267a3bc783bebd6482dcd36ad
+  data.tar.gz: cfbdc192c0f479680e3059b756971b499fc7ef3eea8eeac1e86cc7e0d60a9eea71fe55abb000026691fdbba0322b96676834951399ba8d7988959b2cbe6f3ab6

data/.gitignore

@@ -0,0 +1,8 @@
+*.out
+*.so
+*.swp
+.bundle
+Gemfile.lock
+coverage
+pkg/*
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--colour
+--order rand
+--format RSpec::Pride

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,43 @@
+Vladlev
+===========
+
+An implementation of the levenshtein distance algorithm for ruby using FFI
+
+## Installation
+
+Add this line to your gemfile and then run `bundle` to install
+
+    gem 'vladlev'
+
+## Usage
+
+Vladlev will calculate the levenshtein distance between two strings.  The levenshtein distance is the number of transforms necessary to transform one string to be idential to the other.  A transform is defined as an addition, deletion, or alteration of a single character in a string.
+
+In order to calculate the distance
+
+    Vladlev.distance("string1", "string2")
+    >> 1
+
+Vladlev also includes a 3 parameter version of the distance method.  The third parameter is "maximum distance", which tells Vladlev to stop calculation once the distance becomes greater than this parameter.
+
+In order to use this optimization
+  
+    Vladlev.distance("string1234567890", "string1", 1)
+    >> 16
+
+    Vladlev.distance("string1234567890", "string1", 999)
+    >> 9
+
+When given a pair of strings such that the distance between the two strings is greater than the "maximum distance" paramter, Vladlev will return the length of the longest string rather than spend the effort of calculating the distance when you know that you are not interested in the result.
+
+## Development
+
+Vladlev uses rake-compiler for a build tool
+
+    bundle exec rake compile
+
+    bundle exec rake clean
+
+For an agressive clean of compiled files, you can do this
+
+    bundle exec rake clobber

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'bundler/gem_tasks'
+require 'rake/clean'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+spec = Gem::Specification.load('vladlev.gemspec')
+
+Gem::PackageTask.new(spec) do |pkg|
+end
+
+if RUBY_PLATFORM =~ /java/
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new('levenshtein', spec)
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('levenshtein', spec)
+end
+
+task :default => :spec

data/ext/levenshtein/LevenshteinDistance.java

@@ -0,0 +1,66 @@
+public class LevenshteinDistance {
+  private static int minimum(int a, int b, int c) {
+    return Math.min(Math.min(a, b), c);
+  }
+
+  public static int distance(String str1, String str2, long maximumDistance) {
+    boolean brokeMax = false;
+    int rowMinimum;
+    int cost;
+    String longestString = (str1.length() > str2.length()) ? str1 : str2;
+    String shortestString = (str1.length() > str2.length()) ? str2 : str1;
+
+    if (shortestString.equals(longestString)) { 
+      return 0;
+    } else if (longestString.length() - shortestString.length() > maximumDistance) {
+      return longestString.length();
+    } else if (shortestString.length() == 0 || longestString.length() == 0) {
+      return longestString.length();
+    }
+
+    int[] workingGrid = new int[shortestString.length() + 1];
+    int[] calculationGrid = new int[shortestString.length() + 1];
+    int[] tempGrid;
+
+    for (int i = 0; i <= shortestString.length(); i++) {
+      calculationGrid[i] = i;
+    }
+
+    for (int i = 1; i <= longestString.length(); i++) {
+      rowMinimum = workingGrid[0] = calculationGrid[0] + 1;
+
+      for (int j = 1; j <= shortestString.length(); j++) {
+        cost = (shortestString.charAt(j-1) == longestString.charAt(i-1)) ? 0 : 1;
+        workingGrid[j] = minimum(calculationGrid[j]+1, workingGrid[j-1]+1, calculationGrid[j-1]+cost);
+        rowMinimum = (workingGrid[j] < rowMinimum) ? workingGrid[j] : rowMinimum;
+      }
+
+      if (rowMinimum > maximumDistance) { 
+        brokeMax = true;
+        break;
+      }
+
+      tempGrid = workingGrid;
+      workingGrid = calculationGrid;
+      calculationGrid = tempGrid;
+    }
+
+    return brokeMax ? longestString.length() : calculationGrid[shortestString.length()];
+  }
+
+  public static int distance(String str1, String str2) {
+    return distance(str1, str2, 9999);
+  }
+
+  public static float normalized_distance(String str1, String str2) {
+   return normalized_distance(str1, str2, 9999); 
+  }
+
+  public static float normalized_distance(String str1, String str2, long maximumDistance) {
+    int maxStringLength = (str1.length() > str2.length()) ? str1.length() : str2.length();
+    if(maxStringLength == 0) {
+      return 0;
+    }
+    return distance(str1, str2, maximumDistance) / (float)maxStringLength;
+  }
+}

data/ext/levenshtein/extconf.rb

@@ -0,0 +1,5 @@
+unless RUBY_PLATFORM =~ /java/
+  require 'mkmf'
+
+  create_makefile('levenshtein')
+end

data/ext/levenshtein/levenshtein.c

@@ -0,0 +1,118 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef TRUE
+#define TRUE 1  
+#define FALSE 0
+#endif
+
+#define ALLOC malloc
+#define FREE free
+
+/* Used to swap calc and work grids while looping */
+#define LV_SWAP(t, a, b) { t = a; a = b; b = t;}
+#define LV_MIN(a, b, c) ((a <= b) ? ((a <= c) ? a : c) : ((b <= c) ? b : c));
+
+/* using a structure that will be filled on init with the variables that will makeup the distance constraints */
+typedef struct{
+  char* a; 
+  char* b; 
+  int a_length;
+  int b_length;
+  int maximum_allowable_distance;
+} LevenConstraints;
+
+int levenshtein_intern(LevenConstraints* leven)
+{
+  /* Check the minimum distance to keep from calculating anything when it isn't really needed
+   * Efficient use of the levenshtein call includes a maximum_allowable_distance (or distance threshold) */
+  if ((leven->b_length - leven->a_length) > leven->maximum_allowable_distance || (leven->a_length == 0 || leven->b_length == 0)) {
+    return (int)leven->b_length;
+  }
+
+  /* no reason to run levenshtein when equal */
+  if (leven->a_length == leven->b_length && strcmp(leven->a, leven->b) == 0) {
+    return (int)0;
+  }
+
+  leven->a_length++;
+  leven->b_length++;
+
+  int x, *grid_odd, *grid_even, i, j, cost, row_min, distance, *work_grid, *calc_grid, *tmp;
+  unsigned int broke_max = FALSE;
+
+  grid_even = ALLOC(sizeof(int) * (leven->a_length));
+  grid_odd = ALLOC(sizeof(int) * (leven->a_length));
+
+  if(grid_even == NULL || grid_odd == NULL) {
+    return (int)9999;   /* error occured - cannot allocate memory */
+  }  
+
+  work_grid = grid_odd;
+  calc_grid = grid_even;
+
+  for(x = 0; x < leven->a_length; x++)
+    grid_even[x] = x;
+
+  for(i = 1; i < leven->b_length; i++) {     
+    row_min = work_grid[0] = calc_grid[0] + 1;
+
+    for(j = 1; j < leven->a_length; j++) {
+      cost = (leven->a[j-1] == leven->b[i-1]) ? 0 : 1;
+      work_grid[j] = LV_MIN(calc_grid[j]+1, work_grid[j-1]+1, calc_grid[j-1] + cost);
+      row_min = (work_grid[j] < row_min) ? work_grid[j] : row_min;            
+    }
+
+    if(row_min > leven->maximum_allowable_distance) { 
+      broke_max = TRUE; 
+      break;
+    }
+
+    LV_SWAP(tmp, work_grid, calc_grid);
+  }
+
+  distance = (broke_max == TRUE) ? (leven->b_length - 1) : calc_grid[leven->a_length-1];  
+
+  FREE(grid_odd);
+  FREE(grid_even);  
+
+  return (int) distance;
+}
+
+int levenshtein_extern(char* a, char* b, int max_distance)
+{
+  int a_len = (a == NULL) ? 0 : strlen(a);
+  int b_len = (b == NULL) ? 0 : strlen(b);
+
+  LevenConstraints* leven = malloc(sizeof(LevenConstraints));
+  leven->a = (a_len > b_len) ? b : a;
+  leven->b = (a_len > b_len) ? a : b;
+  leven->a_length = strlen(leven->a);
+  leven->b_length = strlen(leven->b);
+
+  int distance = leven->b_length;
+
+  if(max_distance < 0) {
+    max_distance = (a_len > b_len) ? a_len : b_len;
+  }
+
+  leven->maximum_allowable_distance = max_distance;
+
+  distance = levenshtein_intern(leven);  
+  FREE(leven);
+
+  return distance;
+}
+
+float normalized_levenshtein_extern(char* a, char* b, int max_distance)
+{
+  int a_len = (a == NULL) ? 0 : strlen(a);
+  int b_len = (b == NULL) ? 0 : strlen(b);
+
+  int max_string_length = (a_len > b_len) ? a_len : b_len;
+  if(max_string_length == 0) {
+    return 0;
+  }
+  return (float)levenshtein_extern(a, b, max_distance) / max_string_length;
+}

data/lib/vladlev/levenshtein.rb

@@ -0,0 +1,49 @@
+module Vladlev
+  class Levenshtein
+    def self.distance(str1, str2, maximum_allowable_distance = 9999)
+      shortest_string = (str1.size > str2.size) ? str1 : str2
+      longest_string = (str1.size > str2.size) ? str2 : str1
+      broke_max = false
+
+      if longest_string == shortest_string
+        return 0
+      elsif longest_string.size - shortest_string.size > maximum_allowable_distance
+        return shortest_string.size
+      elsif longest_string.size == 0 || shortest_string.size == 0
+        return shortest_string.size
+      end
+
+      calculation_grid = Array.new(longest_string.size)
+      working_grid = Array.new(longest_string.size)
+
+      longest_string.size.times { |position| calculation_grid[position] = position }
+
+      (1...shortest_string.size).each do |i|
+        row_minimum = working_grid[0] = calculation_grid[0] + 1
+        
+        (1...longest_string.size).each do |j|
+          cost = (longest_string[j - 1] == shortest_string[i - 1]) ? 0 : 1
+          working_grid[j] = [calculation_grid[j] + 1, working_grid[j - 1] + 1, calculation_grid[j - 1] + cost].min
+          row_minimum = (working_grid[j] < row_minimum) ? working_grid[j] : row_minimum
+        end
+
+        if row_minimum > maximum_allowable_distance
+          broke_max = true
+          break
+        end
+
+        temp_grid = working_grid
+        working_grid = calculation_grid
+        calculation_grid = temp_grid
+      end
+
+      return broke_max ? shortest_string.size : calculation_grid[longest_string.size - 1]
+    end
+
+    def self.normalized_distance(str1, str2, maximum_allowable_distance = 9999)
+      longest_string_length = (str1 > str2) ? str1.length : str2.length
+      return 0 if longest_string_length == 0 
+      distance / longest_string_length
+    end
+  end
+end

data/lib/vladlev/version.rb

@@ -0,0 +1,3 @@
+module Vladlev
+  VERSION = '1.0.0'
+end

data/lib/vladlev.rb

@@ -0,0 +1,86 @@
+module Vladlev
+  def self.relative_exists?(filename)
+    File.exists?(File.join(File.dirname(__FILE__), filename))
+  end
+
+  JRUBY_NATIVE = RUBY_PLATFORM =~ /java/ && relative_exists?('levenshtein.jar')
+  C_EXT_NATIVE = !JRUBY_NATIVE && 
+    (relative_exists?('levenshtein.bundle') || relative_exists?('levenshtein.so'))
+
+  if JRUBY_NATIVE
+    require 'java'
+    require File.join(File.dirname(__FILE__), 'levenshtein.jar')
+
+    # Calculate the levenshtein distance between two strings
+    #
+    # @param [String] first string to compare
+    # @param [String] second string to compare
+    # @return [Integer] the levenshtein distance between the strings
+    def self._internal_distance(str1, str2, max)
+      Java::LevenshteinDistance.distance(str1, str2, max)
+    end
+
+    def self._normalized_distance(str1, str2, max)
+      Java::LevenshteinDistance.normalized_distance(str1, str2, max)
+    end
+  elsif C_EXT_NATIVE
+    require 'ffi'
+    extend ::FFI::Library
+
+    native_file_path = case
+                       when relative_exists?('levenshtein.bundle') then
+                         File.join(File.dirname(__FILE__), 'levenshtein.bundle')
+                       else
+                         File.join(File.dirname(__FILE__), 'levenshtein.so')
+                       end
+
+    ffi_lib native_file_path
+    attach_function :levenshtein_extern, [:pointer, :pointer, :int32], :int32
+    attach_function :normalized_levenshtein_extern, [:pointer, :pointer, :int32], :float
+
+    # Calculate the levenshtein distance between two strings
+    #
+    # @param [String] first string to compare
+    # @param [String] second string to compare
+    # @return [Integer] the levenshtein distance between the strings
+    def self._internal_distance(str1, str2, max)
+      self.levenshtein_extern(str1, str2, max)
+    end
+
+    def self._normalized_distance(str1, str2, max)
+      self.normalized_levenshtein_extern(str1, str2, max)
+    end
+  else
+    require 'vladlev/levenshtein'
+    warn <<-PURE_RUBY
+      Could not load C extension or Java Extension for Vladlev
+      Will utilize pure ruby version which is significantly 
+      slower for many comparisons.
+    PURE_RUBY
+
+    # Calculate the levenshtein distance between two strings
+    #
+    # @param [String] first string to compare
+    # @param [String] second string to compare
+    # @return [Integer] the levenshtein distance between the strings
+    def self._internal_distance(str1, str2, max)
+      ::Vladlev::Levenshtein.distance(str1, str2, max)
+    end
+  end
+
+  def self.distance(str1, str2, max = 9999)
+    return 0 if str1.nil? && str2.nil?
+    return str2.size if str1.nil?
+    return str1.size if str2.nil?
+
+    self._internal_distance(str1, str2, max)
+  end
+
+  def self.get_normalized_distance(str1, str2, max = 9999)
+    return 0 if str1.nil? && str2.nil?
+    return str2.size if str1.nil?
+    return str1.size if str2.nil?
+
+    self._normalized_distance(str1, str2, max)
+  end
+end

data/spec/lib/levenshtein_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Vladlev do
+  specify{ Vladlev.distance("hello", "hello").should equal(0) }
+  specify{ Vladlev.distance("", "").should equal(0) }
+  specify{ Vladlev.distance("hello", "jello").should equal(1) }
+  specify{ Vladlev.distance("hella", "hello").should equal(1) }
+  specify{ Vladlev.distance("hello", "jell").should equal(2) }
+  specify{ Vladlev.distance("lo", "jello").should equal(3) }
+  specify{ Vladlev.distance("jello", "lo").should equal(3) }
+  specify{ Vladlev.distance("", "jello").should equal("jello".length) }
+  specify{ Vladlev.distance("jello", "").should equal("jello".length) }
+  specify{ Vladlev.distance("hello"*2, "jello"*2).should equal(2) }
+  specify{ Vladlev.distance("hello"*2, "jelo"*2).should equal(4) }
+  specify{ Vladlev.distance("hello"*2, "jell"*2).should equal(4) }
+  specify{ Vladlev.distance("hello"*4, "jello"*4).should equal(4) }
+  specify{ Vladlev.distance("hello"*8, "jello"*8).should equal(8) }  
+  specify{ Vladlev.distance("hello"*16, "jello"*16).should equal(16) }
+  specify{ Vladlev.distance("hello"*32, "jello"*32).should equal(32) }
+  specify{ Vladlev.distance("hello"*64, "jello"*64).should equal(64) }
+  specify{ Vladlev.distance("hello"*128, "jello"*128).should equal(128) }
+  specify{ Vladlev.distance("hello"*256, "jello"*256).should equal(256) }
+  specify{ Vladlev.distance("hello"*512, "jello"*512).should equal(512) }  
+          
+  describe "threshold" do 
+    specify{ Vladlev.distance("hello"*100, "jello"*100, 10).should equal(500) }
+    specify{ Vladlev.distance("hello"*100, "jello"*100, 99).should equal(500) }
+    specify{ Vladlev.distance("hello"*100, "jello"*100, 100).should equal(100) }        
+    specify{ Vladlev.distance("hello"*100, "jello"*100, 1000).should equal(100) }    
+  end
+
+  describe "long strings" do 
+    specify{ Vladlev.distance("hello"*200, "jello"*200).should equal(200) }
+    specify{ Vladlev.distance("hello"*500, "jello"*500).should equal(500) }
+    specify{ Vladlev.distance("hello"*750, "jello"*750).should equal(750) }
+    specify{ Vladlev.distance("hello"*950, "jello"*950).should equal(950) }    
+  end
+
+  describe "threshold long strings" do 
+    specify{ Vladlev.distance("hello"*2000, "jello"*2000, 10).should equal(5*2000) }
+    specify{ Vladlev.distance("hello"*5000, "jello"*5000, 10).should equal(5*5000) }
+    specify{ Vladlev.distance("hello"*7500, "jello"*7500, 10).should equal(5*7500) }
+    specify{ Vladlev.distance("hello"*9500, "jello"*9500, 10).should equal(5*9500) }    
+  end
+
+  describe "special chars" do 
+    specify{ Vladlev.distance("*&^%$", "").should equal(5) }
+    specify{ Vladlev.distance("", ",./>?").should equal(5) }
+    specify{ Vladlev.distance('*&^%$+_=-)(*&^%$#@!~123456789', '*&^%$+_=-)(*&^%$#@!~').should equal(9) }
+    specify{ Vladlev.distance('*&^%$+_=-)(*&^%$#@!~', "").should equal(20) }
+  end
+
+  describe "normalized distance" do
+    specify{ expect(Vladlev.get_normalized_distance("hi", "high", 1)).to eq(1.0) }
+    specify{ expect(Vladlev.get_normalized_distance("hi", "high")).to eq(0.5) }
+    specify{ expect(Vladlev.get_normalized_distance("hello", "hello")).to eq(0.0) }
+    specify{ expect(Vladlev.get_normalized_distance("goodnight", "goodnite")).to eq(0.3333333432674408) }
+    specify{ expect(Vladlev.get_normalized_distance("", "goodbye")).to eq(1.0) }
+    specify{ expect(Vladlev.get_normalized_distance("goodbye", "")).to eq(1.0) }
+    specify{ expect(Vladlev.get_normalized_distance("", "")).to eq(0.0) }
+  end
+  
+  describe '#distance' do
+    context "when given two strings to match" do
+      it "returns the distance" do
+        string1 = "lorem ipsum"
+        string2 = "borem ipsum"
+        described_class.distance(string1, string2).should eq(1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler'
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+Bundler.require(:default, :development, :test)
+
+require 'pry'

data/vladlev.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'vladlev/version'
+
+Gem::Specification.new do |s|
+  s.name         = 'vladlev'
+  s.version      = Vladlev::VERSION
+  s.summary      = 'Levenshtein matching algorithm for ruby using C'
+  s.description  = 'Levenshtein matching algorithm for ruby using C with an FFI extension'
+  s.authors      = ["Brian Stien"]
+  s.email        = 'dev@moneydesktop.com'
+  s.homepage     = 'https://git.moneydesktop.com/dev/vladlev.git'
+  
+  if defined?(JRUBY_VERSION)
+    s.platform = 'java'
+  else
+    s.extensions   = ['ext/levenshtein/extconf.rb']
+    s.add_runtime_dependency 'ffi'
+  end
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec-pride'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'geminabox'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rake-compiler'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths - ["lib"]
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: vladlev
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: java
+authors:
+- Brian Stien
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec-pride
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: pry
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: geminabox
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: simplecov
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rake-compiler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Levenshtein matching algorithm for ruby using C with an FFI extension
+email: dev@moneydesktop.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- ext/.DS_Store
+- ext/levenshtein/LevenshteinDistance.java
+- ext/levenshtein/extconf.rb
+- ext/levenshtein/levenshtein.c
+- lib/levenshtein.bundle
+- lib/levenshtein.jar
+- lib/vladlev.rb
+- lib/vladlev/levenshtein.rb
+- lib/vladlev/version.rb
+- spec/lib/levenshtein_spec.rb
+- spec/spec_helper.rb
+- vladlev.gemspec
+homepage: https://git.moneydesktop.com/dev/vladlev.git
+licenses: []
+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.4.5
+signing_key:
+specification_version: 4
+summary: Levenshtein matching algorithm for ruby using C
+test_files:
+- spec/lib/levenshtein_spec.rb
+- spec/spec_helper.rb