fast_fuzzy_matcher 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e10b6a2b5f47c25d479a1a3623db229ecbc24f79176c3d6ae879ce6767e931b0
+  data.tar.gz: c4c910d1e4a462fab8819f2d406d2affe1c872d58f2943c7be196d25c439a7b6
+SHA512:
+  metadata.gz: 3cef0e3e2a233385a0daf2c882002be8af28e38df4c58c500bbee29fd3b319d904b9ee918f6fbeb44c3557602562b7b0f3d1f53c3b03c1c197f2824f6caf81fd
+  data.tar.gz: 78c6671ffaad4807137977cc90100be0214e241b0895ab71955baf96500db286b235b62e121c9c13f00134a86f3138b92e652af597a37ed9bb0dfca559215069

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-10-16
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 wowinter13
+
+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,66 @@
+# FuzzyMatch
+
+This library is a work in progress. 
+
+The fastest Fuzzy Matcher in the wild west. FFI-based.
+
+Find a needle in a haystack based on string similarity and regular expression rules.
+
+
+### Basic usage
+
+Just pass an array of strings to the matcher and it will return the best match(es) for the given needle.
+
+```ruby
+require 'fast_fuzzy_matcher'
+
+FuzzyMatcher.find("whl", ["cartwheel", "foobar", "wheel", "baz"])
+=> ["cartwheel", "wheel"]
+
+```
+
+### Advanced usage
+
+Better documentation is coming soon. For now, please refer to the specs.
+
+
+
+# Benchmarks
+
+To be done.
+
+Approximately 10-60x faster than the fastest Ruby implementation. The difference is more pronounced for longer strings and larger dictionaries.
+
+
+## Documentation
+
+Detailed documentation is available at [rubydoc](https://rubydoc.info/gems/fast_fuzzy_matcher).
+
+## Installation
+
+fast_fuzzy_matcher is available as a gem, to install it just install the gem:
+
+    gem install fast_fuzzy_matcher
+
+If you're using Bundler, add the gem to Gemfile.
+
+    gem 'fast_fuzzy_matcher'
+
+Run `bundle install`.
+
+## Running tests
+
+    bundle exec rspec spec/
+
+
+## Contributing
+
+1. Fork it ( https://github.com/wowinter13/fast_fuzzy_matcher/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 a new Pull Request
+
+## License
+
+MIT License. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/ext/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

data/ext/.idea/ext.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

data/ext/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/ext.iml" filepath="$PROJECT_DIR$/.idea/ext.iml" />
+    </modules>
+  </component>
+</project>

data/ext/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

data/ext/fuzzy.go

@@ -0,0 +1,416 @@
+// Fuzzy searching allows for flexibly matching a string with partial input,
+// useful for filtering data very quickly based on lightweight user input.
+package main
+
+import (
+	"unicode"
+	"unicode/utf8"
+	"unsafe"
+
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+/*
+#include <stdlib.h>  // for C.free
+*/
+import "C"
+
+func noopTransformer() transform.Transformer {
+	return nopTransformer{}
+}
+
+func foldTransformer() transform.Transformer {
+	return unicodeFoldTransformer{}
+}
+
+func normalizeTransformer() transform.Transformer {
+	return transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+}
+
+func normalizedFoldTransformer() transform.Transformer {
+	return transform.Chain(normalizeTransformer(), foldTransformer())
+}
+
+// Match returns true if source matches target using a fuzzy-searching
+// algorithm. Note that it doesn't implement Levenshtein distance (see
+// RankMatch instead), but rather a simplified version where there's no
+// approximation. The method will return true only if each character in the
+// source can be found in the target and occurs after the preceding matches.
+
+// TODO: export Match
+func Match(source, target string) bool {
+	return match(source, target, noopTransformer())
+}
+
+// MatchFold is a case-insensitive version of Match.
+
+// TODO: export MatchFold
+func MatchFold(source, target string) bool {
+	return match(source, target, foldTransformer())
+}
+
+// MatchNormalized is a unicode-normalized version of Match.
+
+// TODO: export MatchNormalized
+func MatchNormalized(source, target string) bool {
+	return match(source, target, normalizeTransformer())
+}
+
+// MatchNormalizedFold is a unicode-normalized and case-insensitive version of Match.
+
+// TODO: export MatchNormalizedFold
+func MatchNormalizedFold(source, target string) bool {
+	return match(source, target, normalizedFoldTransformer())
+}
+
+func match(source, target string, transformer transform.Transformer) bool {
+	sourceT := stringTransform(source, transformer)
+	targetT := stringTransform(target, transformer)
+	return matchTransformed(sourceT, targetT)
+}
+
+func matchTransformed(source, target string) bool {
+	lenDiff := len(target) - len(source)
+
+	if lenDiff < 0 {
+		return false
+	}
+
+	if lenDiff == 0 && source == target {
+		return true
+	}
+
+Outer:
+	for _, r1 := range source {
+		for i, r2 := range target {
+			if r1 == r2 {
+				target = target[i+utf8.RuneLen(r2):]
+				continue Outer
+			}
+		}
+		return false
+	}
+
+	return true
+}
+
+// Find will return a list of strings in targets that fuzzy matches source.
+//
+// The returned list will be ordered by best matches first, or nil if there are
+// no matches. The algorithm is optimized for matches where the target string
+// has a prefix that matches the source.
+//
+// FFI note: the returned list is allocated using malloc and must be freed using
+// free_cstrings.
+//
+//export Find
+func Find(source *C.char, targets **C.char, targetsLen C.int) **C.char {
+	goSource := C.GoString(source)
+	sliceHeaders := (*[1 << 30]*C.char)(unsafe.Pointer(targets))[:targetsLen:targetsLen]
+
+	goTargets := make([]string, int(targetsLen))
+	for i := 0; i < int(targetsLen); i++ {
+		goTargets[i] = C.GoString(sliceHeaders[i])
+	}
+
+	results := find(goSource, goTargets, noopTransformer())
+
+	cResults := C.malloc(C.size_t(targetsLen) * C.size_t(unsafe.Sizeof(uintptr(0))))
+	cArray := (*[1 << 30]*C.char)(cResults)
+
+	for i := 0; i < int(targetsLen); i++ {
+		cArray[i] = C.CString("")
+	}
+
+	for i, s := range results {
+		C.free(unsafe.Pointer(cArray[i]))
+		cArray[i] = C.CString(s)
+	}
+
+	return (**C.char)(cResults)
+}
+
+//export free_cstrings
+func free_cstrings(strs **C.char, len C.int) {
+	slice := (*[1 << 30]*C.char)(unsafe.Pointer(strs))[:len:len]
+	for i := 0; i < int(len); i++ {
+		C.free(unsafe.Pointer(slice[i]))
+	}
+	C.free(unsafe.Pointer(strs))
+}
+
+// FindFold is a case-insensitive version of Find.
+
+// TODO: export FindFold
+func FindFold(source string, targets []string) []string {
+	return find(source, targets, foldTransformer())
+}
+
+// FindNormalized is a unicode-normalized version of Find.
+
+// TODO: export FindNormalized
+func FindNormalized(source string, targets []string) []string {
+	return find(source, targets, normalizeTransformer())
+}
+
+// FindNormalizedFold is a unicode-normalized and case-insensitive version of Find.
+
+// TODO: export FindNormalizedFold
+func FindNormalizedFold(source string, targets []string) []string {
+	return find(source, targets, normalizedFoldTransformer())
+}
+
+func find(source string, targets []string, transformer transform.Transformer) []string {
+	sourceT := stringTransform(source, transformer)
+
+	var matches []string
+
+	for _, target := range targets {
+		targetT := stringTransform(target, transformer)
+		if matchTransformed(sourceT, targetT) {
+			matches = append(matches, target)
+		}
+	}
+
+	return matches
+}
+
+// RankMatch is similar to Match except it will measure the Levenshtein
+// distance between the source and the target and return its result. If there
+// was no match, it will return -1.
+// Given the requirements of match, RankMatch only needs to perform a subset of
+// the Levenshtein calculation, only deletions need be considered, required
+// additions and substitutions would fail the match test.
+
+// TODO: export RankMatch
+func RankMatch(source, target string) int {
+	return rank(source, target, noopTransformer())
+}
+
+// RankMatchFold is a case-insensitive version of RankMatch.
+
+// TODO: export RankMatchFold
+func RankMatchFold(source, target string) int {
+	return rank(source, target, foldTransformer())
+}
+
+// RankMatchNormalized is a unicode-normalized version of RankMatch.
+
+// TODO: export RankMatchNormalized
+func RankMatchNormalized(source, target string) int {
+	return rank(source, target, normalizeTransformer())
+}
+
+// RankMatchNormalizedFold is a unicode-normalized and case-insensitive version of RankMatch.
+
+// TODO: export RankMatchNormalizedFold
+func RankMatchNormalizedFold(source, target string) int {
+	return rank(source, target, normalizedFoldTransformer())
+}
+
+func rank(source, target string, transformer transform.Transformer) int {
+	lenDiff := len(target) - len(source)
+
+	if lenDiff < 0 {
+		return -1
+	}
+
+	source = stringTransform(source, transformer)
+	target = stringTransform(target, transformer)
+
+	if lenDiff == 0 && source == target {
+		return 0
+	}
+
+	runeDiff := 0
+
+Outer:
+	for _, r1 := range source {
+		for i, r2 := range target {
+			if r1 == r2 {
+				target = target[i+utf8.RuneLen(r2):]
+				continue Outer
+			} else {
+				runeDiff++
+			}
+		}
+		return -1
+	}
+
+	// Count up remaining char
+	runeDiff += utf8.RuneCountInString(target)
+
+	return runeDiff
+}
+
+// RankFind is similar to Find, except it will also rank all matches using
+// Levenshtein distance.
+
+// TODO: export RankFind
+func RankFind(source string, targets []string) Ranks {
+	return rankFind(source, targets, noopTransformer())
+}
+
+// RankFindFold is a case-insensitive version of RankFind.
+
+// TODO: export RankFindFold
+func RankFindFold(source string, targets []string) Ranks {
+	return rankFind(source, targets, foldTransformer())
+}
+
+// RankFindNormalized is a unicode-normalized version of RankFind.
+
+// TODO: export RankFindNormalized
+func RankFindNormalized(source string, targets []string) Ranks {
+	return rankFind(source, targets, normalizeTransformer())
+}
+
+// RankFindNormalizedFold is a unicode-normalized and case-insensitive version of RankFind.
+
+// TODO: export RankFindNormalizedFold
+func RankFindNormalizedFold(source string, targets []string) Ranks {
+	return rankFind(source, targets, normalizedFoldTransformer())
+}
+
+func rankFind(source string, targets []string, transformer transform.Transformer) Ranks {
+	sourceT := stringTransform(source, transformer)
+
+	var r Ranks
+
+	for index, target := range targets {
+		targetT := stringTransform(target, transformer)
+		if matchTransformed(sourceT, targetT) {
+			distance := LevenshteinDistance(source, target)
+			r = append(r, Rank{source, target, distance, index})
+		}
+	}
+	return r
+}
+
+type Rank struct {
+	// Source is used as the source for matching.
+	Source string
+
+	// Target is the word matched against.
+	Target string
+
+	// Distance is the Levenshtein distance between Source and Target.
+	Distance int
+
+	// Location of Target in original list
+	OriginalIndex int
+}
+
+type Ranks []Rank
+
+func (r Ranks) Len() int {
+	return len(r)
+}
+
+func (r Ranks) Swap(i, j int) {
+	r[i], r[j] = r[j], r[i]
+}
+
+func (r Ranks) Less(i, j int) bool {
+	return r[i].Distance < r[j].Distance
+}
+
+func stringTransform(s string, t transform.Transformer) (transformed string) {
+	// Fast path for the nop transformer to prevent unnecessary allocations.
+	if _, ok := t.(nopTransformer); ok {
+		return s
+	}
+
+	var err error
+	transformed, _, err = transform.String(t, s)
+	if err != nil {
+		transformed = s
+	}
+
+	return
+}
+
+type unicodeFoldTransformer struct{ transform.NopResetter }
+
+func (unicodeFoldTransformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	// Converting src to a string allocates.
+	// In theory, it need not; see https://go.dev/issue/27148.
+	// It is possible to write this loop using utf8.DecodeRune
+	// and thereby avoid allocations, but it is noticeably slower.
+	// So just let's wait for the compiler to get smarter.
+	for _, r := range string(src) {
+		if r == utf8.RuneError {
+			// Go spec for ranging over a string says:
+			// If the iteration encounters an invalid UTF-8 sequence,
+			// the second value will be 0xFFFD, the Unicode replacement character,
+			// and the next iteration will advance a single byte in the string.
+			nSrc++
+		} else {
+			nSrc += utf8.RuneLen(r)
+		}
+		r = unicode.ToLower(r)
+		x := utf8.RuneLen(r)
+		if x > len(dst[nDst:]) {
+			err = transform.ErrShortDst
+			break
+		}
+		nDst += utf8.EncodeRune(dst[nDst:], r)
+	}
+	return nDst, nSrc, err
+}
+
+type nopTransformer struct{ transform.NopResetter }
+
+func (nopTransformer) Transform(dst []byte, src []byte, atEOF bool) (int, int, error) {
+	return 0, len(src), nil
+}
+
+// LevenshteinDistance measures the difference between two strings.
+// The Levenshtein distance between two words is the minimum number of
+// single-character edits (i.e. insertions, deletions or substitutions)
+// required to change one word into the other.
+//
+// This implemention is optimized to use O(min(m,n)) space and is based on the
+// optimized C version found here:
+// http://en.wikibooks.org/wiki/Algorithm_implementation/Strings/Levenshtein_distance#C
+
+// export LevenshteinDistance
+func LevenshteinDistance(s, t string) int {
+	r1, r2 := []rune(s), []rune(t)
+	column := make([]int, 1, 64)
+
+	for y := 1; y <= len(r1); y++ {
+		column = append(column, y)
+	}
+
+	for x := 1; x <= len(r2); x++ {
+		column[0] = x
+
+		for y, lastDiag := 1, x-1; y <= len(r1); y++ {
+			oldDiag := column[y]
+			cost := 0
+			if r1[y-1] != r2[x-1] {
+				cost = 1
+			}
+			column[y] = min(column[y]+1, column[y-1]+1, lastDiag+cost)
+			lastDiag = oldDiag
+		}
+	}
+
+	return column[len(r1)]
+}
+
+func min2(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func min(a, b, c int) int {
+	return min2(min2(a, b), c)
+}
+
+func main() {}

data/ext/fuzzy.h

@@ -0,0 +1,87 @@
+/* Code generated by cmd/cgo; DO NOT EDIT. */
+
+/* package command-line-arguments */
+
+
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h>
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 15 "fuzzy.go"
+
+#include <stdlib.h>  // for C.free
+
+#line 1 "cgo-generated-wrapper"
+
+
+/* End of preamble from import "C" comments.  */
+
+
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoInt64 GoInt;
+typedef GoUint64 GoUint;
+typedef size_t GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+#ifdef _MSC_VER
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#else
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+#endif
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern char** Find(char* source, char** targets, int targetsLen);
+extern void free_cstrings(char** strs, int len);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/go.mod

@@ -0,0 +1,5 @@
+module github.com/wowinter13/fast_fuzzy_matcher
+
+go 1.19
+
+require golang.org/x/text v0.13.0

data/ext/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=

data/fast_fuzzy_matcher.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/fuzzy_matcher/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "fast_fuzzy_matcher"
+  spec.version = FuzzyMatcher::VERSION
+  spec.authors = ["Vlad Dyachenko"]
+  spec.email = ["vla-dy@yandex.ru"]
+
+  spec.summary = "fast_fuzzy_matcher is the fastest fuzzy search library for Ruby."
+  spec.description = "A tiny and blazing-fast fuzzy search in pure Ruby with FFI bindings to Go."\
+                     "Fuzzy searching allows for flexibly matching a string with partial input, " \
+                     "useful for filtering data very quickly based on lightweight user input."
+  spec.homepage = "https://github.com/wowinter13/fast_fuzzy_matcher"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata    = {
+    'bug_tracker_uri'   => 'https://github.com/wowinter13/fast_fuzzy_matcher/issues',
+    'changelog_uri'     => "https://github.com/wowinter13/fast_fuzzy_matcher/blob/master/CHANGELOG.md",
+    'documentation_uri' => "https://www.rubydoc.info/github/wowinter13/fast_fuzzy_matcher",
+    'source_code_uri'   => "https://github.com/wowinter13/fast_fuzzy_matcher"
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.test_files = Dir['spec/**/*']
+
+  spec.add_dependency "ffi"
+end

data/lib/fuzzy_matcher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FuzzyMatcher
+  VERSION = "0.2.0"
+end

data/lib/fuzzy_matcher.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "fuzzy_matcher/version"
+
+require 'ffi'
+
+module FuzzyMatcher
+  class Error < StandardError; end
+
+  # find() will return a list of strings in targets that fuzzy matches source.
+  #
+  # @param [String] source The string to match against.
+  # @param [Array<String>] targets The strings to match.
+  # 
+  # @return [Array<String>] The strings in targets that fuzzy match source.
+  #
+  # @example
+  #  require 'fast_fuzzy_matcher'
+  #  FuzzyMatch.find("whl", ["cartwheel", "foobar", "wheel", "baz"])
+  #  => ["cartwheel", "wheel"]
+  #
+  # @note This method possibly is not thread safe.
+  # @note This method is case sensitive. For case insensitive matching, downcase targets/source or use a case insensitive matcher (#find_fold)
+  #
+  # @see ext/fuzzy.go#Find for the implementation of this method.
+  def self.find(source, targets)
+    pointers = targets.map { |t| FFI::MemoryPointer.from_string(t) }
+    targets_ptr = FFI::MemoryPointer.new(:pointer, targets.size)
+    targets_ptr.write_array_of_pointer(pointers)
+  
+    result_ptr = FuzzyBinding.Find(source, targets_ptr, targets.size)
+
+    return [] if result_ptr.null?
+
+    pointers_array = result_ptr.read_array_of_pointer(targets.size)
+  
+    result_array = pointers_array.each_with_object([]) do |ptr, arr|
+      if ptr && !ptr.null?
+        value = ptr.read_string_to_null
+        arr << value unless value.nil? || value == ""
+      end
+    end
+
+    FuzzyBinding.free_cstrings(result_ptr, targets.size)
+  
+    FFI::MemoryPointer.new(:pointer).write_pointer(result_ptr).free
+  
+    result_array
+  end
+
+  module FuzzyBinding
+    extend FFI::Library
+    ffi_lib File.expand_path("../ext/fuzzy.so", File.dirname(__FILE__))
+  
+    attach_function :Find, [:string, :pointer, :int], :pointer
+    attach_function :free_cstrings, [:pointer, :int], :void
+  end
+end

data/spec/fuzzy_matcher_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FuzzyMatcher do
+  it "has a version number" do
+    expect(FuzzyMatcher::VERSION).not_to be nil
+  end
+
+  describe "#find" do
+    it "responds with an empty array when no matches are found" do
+      expect(FuzzyMatcher.find("foo", ["bar", "baz"])).to eq([])
+    end
+    
+    it "responds with an empty array when no targets are given" do
+      expect(FuzzyMatcher.find("foo", [])).to eq([])
+    end
+
+    it "responds with matches when the source is a substring of a target" do
+      expect(FuzzyMatcher.find("whl", ["cartwheel", "foobar", "wheel", "baz"])).to eq(["cartwheel", "wheel"])
+    end
+
+    it "does not respond with matches when the source is a substring of a target and the source is uppercase" do
+      expect(FuzzyMatcher.find("WHL", ["cartwheel", "foobar", "wheel", "baz"])).to eq([])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "fuzzy_matcher"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: fast_fuzzy_matcher
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Vlad Dyachenko
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A tiny and blazing-fast fuzzy search in pure Ruby with FFI bindings to
+  Go.Fuzzy searching allows for flexibly matching a string with partial input, useful
+  for filtering data very quickly based on lightweight user input.
+email:
+- vla-dy@yandex.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/.idea/.gitignore
+- ext/.idea/ext.iml
+- ext/.idea/modules.xml
+- ext/.idea/vcs.xml
+- ext/fuzzy.go
+- ext/fuzzy.h
+- ext/fuzzy.so
+- ext/go.mod
+- ext/go.sum
+- fast_fuzzy_matcher.gemspec
+- lib/fuzzy_matcher.rb
+- lib/fuzzy_matcher/version.rb
+- spec/fuzzy_matcher_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/wowinter13/fast_fuzzy_matcher
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/wowinter13/fast_fuzzy_matcher/issues
+  changelog_uri: https://github.com/wowinter13/fast_fuzzy_matcher/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/github/wowinter13/fast_fuzzy_matcher
+  source_code_uri: https://github.com/wowinter13/fast_fuzzy_matcher
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: fast_fuzzy_matcher is the fastest fuzzy search library for Ruby.
+test_files:
+- spec/fuzzy_matcher_spec.rb
+- spec/spec_helper.rb