mini-levenshtein 0.1.0

data/ext/mini_levenshtein/levenshtein.h

@@ -0,0 +1,146 @@
+/*
+ * This file has been altered to better fit fuzzywuzzy.
+ * To se all changes done, please diff this file with
+ * <https://github.com/Tmplt/python-Levenshtein/blob/master/Levenshtein.c>
+ *
+ * Summary:
+ *   - stripped all python-related code and data types;
+ */
+
+/* @(#) $Id: Levenshtein.h,v 1.22 2005/01/13 20:02:56 yeti Exp $ */
+#ifndef LEVENSHTEIN_H
+#define LEVENSHTEIN_H
+
+#ifndef size_t
+#include <stdlib.h>
+#endif
+
+/* A bit dirty. */
+#ifndef _LEV_STATIC_PY
+#define _LEV_STATIC_PY /* */
+#endif
+
+/* In C, this is just wchar_t and unsigned char, in Python, lev_wchar can
+ * be anything.  If you really want to cheat, define wchar_t to any integer
+ * type you like before including Levenshtein.h and recompile it. */
+#ifndef lev_wchar
+#ifndef wchar_t
+#include <wchar.h>
+#endif
+#define lev_wchar wchar_t
+#endif
+typedef char lev_byte;
+
+/* Edit opration type
+ * DON'T CHANGE! used ad arrays indices and the bits are occasionally used
+ * as flags */
+typedef enum
+{
+    LEV_EDIT_KEEP = 0,
+    LEV_EDIT_REPLACE = 1,
+    LEV_EDIT_INSERT = 2,
+    LEV_EDIT_DELETE = 3,
+    LEV_EDIT_LAST /* sometimes returned when an error occurs */
+} LevEditType;
+
+/* Error codes returned by editop check functions */
+typedef enum
+{
+    LEV_EDIT_ERR_OK = 0,
+    LEV_EDIT_ERR_TYPE,  /* nonexistent edit type */
+    LEV_EDIT_ERR_OUT,   /* edit out of string bounds */
+    LEV_EDIT_ERR_ORDER, /* ops are not ordered */
+    LEV_EDIT_ERR_BLOCK, /* inconsistent block boundaries (block ops) */
+    LEV_EDIT_ERR_SPAN,  /* sequence is not a full transformation (block ops) */
+    LEV_EDIT_ERR_LAST
+} LevEditOpError;
+
+/* string averaging method (UNUSED yet) */
+typedef enum
+{
+    LEV_AVG_HEAD = 0, /* take operations from the head */
+    LEV_AVG_TAIL,     /* take operations from the tail */
+    LEV_AVG_SPREAD,   /* take a equidistantly distributed subset */
+    LEV_AVG_BLOCK,    /* take a random continuous block */
+    LEV_AVG_RANDOM,   /* take a random subset */
+    LEV_AVG_LAST
+} LevAveragingType;
+
+/* Edit operation (atomic).
+ * This is the `native' atomic edit operation.  It differs from the difflib
+ * one's because it represents a change of one character, not a block.  And
+ * we usually don't care about LEV_EDIT_KEEP, though the functions can handle
+ * them.  The positions are interpreted as at the left edge of a character.
+ */
+typedef struct
+{
+    LevEditType type; /* editing operation type */
+    size_t spos;      /* source block position */
+    size_t dpos;      /* destination position */
+} LevEditOp;
+
+/* Edit operation (difflib-compatible).
+ * This is not `native', but conversion functions exist.  These fields exactly
+ * correspond to the codeops() tuples fields (and this method is also the
+ * source of the silly OpCode name).  Sequences must span over complete
+ * strings, subsequences are simply edit sequences with more (or larger)
+ * LEV_EDIT_KEEP blocks.
+ */
+typedef struct
+{
+    LevEditType type;  /* editing operation type */
+    size_t sbeg, send; /* source block begin, end */
+    size_t dbeg, dend; /* destination block begin, end */
+} LevOpCode;
+
+/* Matching block (difflib-compatible). */
+typedef struct
+{
+    size_t spos;
+    size_t dpos;
+    size_t len;
+} LevMatchingBlock;
+
+size_t
+lev_edit_distance(size_t len1,
+                  const lev_byte *string1,
+                  size_t len2,
+                  const lev_byte *string2,
+                  int xcost);
+
+size_t
+lev_u_edit_distance(size_t len1,
+                    const lev_wchar *string1,
+                    size_t len2,
+                    const lev_wchar *string2,
+                    int xcost);
+
+LevEditOp *
+lev_editops_find(size_t len1,
+                 const lev_byte *string1,
+                 size_t len2,
+                 const lev_byte *string2,
+                 size_t *n);
+
+LevOpCode *
+lev_editops_to_opcodes(size_t n,
+                       const LevEditOp *ops,
+                       size_t *nb,
+                       size_t len1,
+                       size_t len2);
+
+LevMatchingBlock *
+lev_opcodes_matching_blocks(size_t len1,
+                            __attribute__((unused)) size_t len2,
+                            size_t nb,
+                            const LevOpCode *bops,
+                            size_t *nmblocks);
+
+LevMatchingBlock *
+lev_editops_matching_blocks(size_t len1,
+                            size_t len2,
+                            size_t n,
+                            const LevEditOp *ops,
+                            size_t *nmblocks);
+
+#endif

data/ext/mini_levenshtein/mini_levenshtein.c

@@ -0,0 +1,32 @@
+#include <string.h>
+#include <math.h>
+#include <wchar.h>
+#include <stdlib.h>
+
+#include "ruby.h"
+#include "levenshtein.h"
+
+VALUE MiniLevenshteinInternal = Qnil;
+
+VALUE method_internal_distance(VALUE self, VALUE s1, VALUE s2, VALUE xcost);
+
+void Init_mini_levenshtein()
+{
+  MiniLevenshteinInternal = rb_define_module("MiniLevenshteinInternal");
+  rb_define_method(MiniLevenshteinInternal, "internal_distance", method_internal_distance, 3);
+}
+
+VALUE method_internal_distance(VALUE self, VALUE s1, VALUE s2, VALUE xcost)
+{
+  size_t len1 = RSTRING_LEN(s1);
+  size_t len2 = RSTRING_LEN(s2);
+
+  const lev_byte *str1 = StringValuePtr(s1);
+  const lev_byte *str2 = StringValuePtr(s2);
+
+  int cost = FIX2INT(xcost);
+
+  long distance = lev_edit_distance(len1, str1, len2, str2, cost);
+
+  return INT2NUM(distance);
+}

data/lib/mini-levenshtein/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MiniLevenshtein
+  VERSION = '0.1.0'
+end

data/lib/mini-levenshtein.rb

@@ -0,0 +1,33 @@
+require 'mini-levenshtein/mini_levenshtein'
+
+module MiniLevenshtein
+  extend MiniLevenshteinInternal
+
+  class << self
+    def distance(string1, string2)
+      validate_string!(string1)
+      validate_string!(string2)
+      
+      internal_distance(string1, string2, 0)
+    end
+  
+    def ratio(string1, string2)
+      validate_string!(string1)
+      validate_string!(string2)
+
+      lensum = string1.length + string2.length
+      return 1.0 if lensum.zero?
+  
+      distance = internal_distance(string1, string2, 1)
+      return 1.0 if distance.zero?
+  
+      (lensum - distance) / lensum.to_f
+    end
+
+    private
+
+    def validate_string!(string)
+      raise TypeError, "no implicit conversion of #{string.class} to String" unless string.is_a?(String)
+    end
+  end
+end

data/mini-levenshtein.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mini-levenshtein/version'
+
+Gem::Specification.new do |s|
+  s.name = 'mini-levenshtein'
+  s.version = MiniLevenshtein::VERSION
+  s.authors = ['Delon Newman']
+  s.email = 'contact@delonnewman.name'
+
+  s.summary = 'Simple, fast, levenshtein distance'
+  s.description = s.summary
+  s.homepage = 'https://github.com/delonnewman/mini-levenshtein'
+  s.license = 'MIT'
+
+  if s.respond_to?(:metadata)
+    s.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+    s.metadata['homepage_uri'] = s.homepage
+    s.metadata['source_code_uri'] = s.homepage
+    s.metadata['changelog_uri'] = "#{s.homepage}#changelog"
+    s.metadata['documentation_uri'] = "https://www.rubydoc.info/gems/#{s.name}"
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.extensions = ['ext/mini_levenshtein/extconf.rb']
+  s.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: mini-levenshtein
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Delon Newman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-04-29 00:00:00.000000000 Z
+dependencies: []
+description: Simple, fast, levenshtein distance
+email: contact@delonnewman.name
+executables: []
+extensions:
+- ext/mini_levenshtein/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/ruby.yml"
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- ext/mini_levenshtein/extconf.rb
+- ext/mini_levenshtein/levenshtein.c
+- ext/mini_levenshtein/levenshtein.h
+- ext/mini_levenshtein/mini_levenshtein.c
+- lib/mini-levenshtein.rb
+- lib/mini-levenshtein/version.rb
+- mini-levenshtein.gemspec
+homepage: https://github.com/delonnewman/mini-levenshtein
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/delonnewman/mini-levenshtein
+  source_code_uri: https://github.com/delonnewman/mini-levenshtein
+  changelog_uri: https://github.com/delonnewman/mini-levenshtein#changelog
+  documentation_uri: https://www.rubydoc.info/gems/mini-levenshtein
+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: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Simple, fast, levenshtein distance
+test_files: []