fts_fuzzy_match 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ae4ec8437fae32168ace83c701014d8ad3172a9e31abbf68c4501f5b33b59eb
-  data.tar.gz: e4ca65980fda174f25361290429f8ebadf1a859b91b6c0723342464c7888f6b6
+  metadata.gz: ffcb83f6d3c87cff136f4a58e5c0cf4765b9f3841f88dc655bd0eaa7dae0d2bf
+  data.tar.gz: 1794738cfbec5e7071703f12d06ab616ef7f1fc891563077fddd72bb16649443
 SHA512:
-  metadata.gz: e03afcccdf173c3106442247df9574aba34fe3b36fc9a3418a4b41c39714048f6e2f10314b53d66aaff10f7b101b657c4958efc97ba5f2b6178f2f0cd4d3ebc1
-  data.tar.gz: 952900929bfa9eb2282e81f47cb4ef0b65511f4d233f6ca99252f9050858b008d51f7486c61aebab2eeb28f3b0feb10c011683ca59e974604ceefda3ee105759
+  metadata.gz: a05b083ca4acc80980bcb74a9de129a0f77961e825efc417d78eb5024a3064b68be2f4185cc2a672f4e2a5aeaed1294fd9df1d4512d206162883be2d1329e875
+  data.tar.gz: 4a975a00538b977feeb0b446cda6f4a28368713da525f834d7bf9cfe915f48755fc8528b2baf75acf97ca6ecbbbfb9fe7dff7cee89467bb64bb195412a55b062

data/.github/dependabot.yml

@@ -5,22 +5,6 @@ updates:
     schedule:
       interval: "weekly"
   - package-ecosystem: "bundler"
-    directory: "/fuzzy_match"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "bundler"
-    directory: "/system"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "bundler"
-    directory: "/packaged_source"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "bundler"
-    directory: "/packaged_tarball"
-    schedule:
-      interval: "weekly"
-  - package-ecosystem: "bundler"
-    directory: "/precompiled"
+    directory: "/"
     schedule:
       interval: "weekly"

data/.github/workflows/{fuzzy_match.yml → fts_fuzzy_match.yml}

@@ -1,4 +1,4 @@
-name: fuzzy_match
+name: fts_fuzzy_match
 concurrency:
   group: "${{github.workflow}}-${{github.ref}}"
   cancel-in-progress: true
@@ -16,22 +16,22 @@ on:
     types: [opened, synchronize]
     branches:
       - '*'
-    paths: ["fuzzy_match/**/*", ".github/workflows/fuzzy_match.yml"]
+    paths: ["**/*"]
 
 jobs:
   fuzzy_match:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4", "head"]
+        ruby: ["3.3", "3.4", "head"]
         runs-on: ["ubuntu-latest", "macos-latest", "windows-latest"]
     runs-on: ${{matrix.runs-on}}
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1
         with:
-          working-directory: fuzzy_match
+          working-directory: .
           ruby-version: ${{matrix.ruby}}
           bundler-cache: true
       - run: bundle exec rake compile test
-        working-directory: fuzzy_match
+        working-directory: .

data/.gitignore

@@ -12,3 +12,4 @@
 *.a
 mkmf.log
 /fuzzy_match-*.gem
+/fts_fuzzy_match-*.gem

data/Gemfile

@@ -9,6 +9,7 @@ gem 'rake', '~> 13.0'
 gem 'rake-compiler'
 gem 'minitest', '~> 5.0'
 gem 'json'
+gem 'benchmark'
 
 gem 'rubocop-minitest'
 gem 'rubocop-performance'

data/Gemfile.lock

@@ -7,6 +7,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.3)
+    benchmark (0.4.1)
     json (2.12.2)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
@@ -57,6 +58,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  benchmark
   fts_fuzzy_match!
   json
   minitest (~> 5.0)

data/README.md

@@ -7,6 +7,29 @@ useful for sorting against each other.
 
 Add this line to your application's Gemfile:
 
+## Usage
+
+To find the score for a pattern and string, use the `fuzzy_match` method:
+
+```ruby
+subject = ::FtsFuzzyMatch.new
+result = subject.fuzzy_match("got", "game of thrones")
+```
+
+To sort strings based on their match scores, use the `sort` method:
+
+```ruby
+subject = ::FtsFuzzyMatch.new(sequential_bonus: 20, camel_bonus: 0, string_length_penalty: -1)
+sorted_strings = subject.sort("got", ["game of thrones", "got", "winter is coming"])
+```
+
+To sort strings based on their match scores, returning only the top 2 results, use the `sort` method:
+
+```ruby
+subject = ::FtsFuzzyMatch.new
+sorted_strings = subject.sort_n("got", ["game of thrones", "got", "winter is coming"], 2)
+```
+
 ## Credits
 
 - This gem was started by using the Ruby C Extensions Explained project at

data/ext/fts_fuzzy_match/fts_fuzzy_match.c

@@ -1,10 +1,33 @@
-#include "fts_fuzzy_match.h"
+#include "ruby.h"
 #define FTS_FUZZY_MATCH_IMPLEMENTATION
-#include "fts_fuzzy_match_impl.h"
+#include "fts_fuzzy_match.h"
 
-VALUE rb_mFtsFuzzyMatch;
+VALUE rb_cFtsFuzzyMatch;
 VALUE rb_cFtsFuzzyMatchExtension;
 
+int get_num_from_self(VALUE self, char *name, int default_value) {
+  VALUE val = rb_iv_get(self, name);
+  switch TYPE(val) {
+      case 7: return NUM2INT(RARRAY_AREF(val, 0));
+      case 21: return NUM2INT(val);
+      default: return default_value;
+  }
+}
+
+struct FtsConfig fts_config(VALUE self) {
+    struct FtsConfig config = {
+        .sequential_bonus = get_num_from_self(self, (char*)"@sequential_bonus", 15),
+        .separator_bonus = get_num_from_self(self, (char*)"@separator_bonus", 30),
+        .camel_bonus = get_num_from_self(self, (char*)"@camel_bonus", 30),
+        .first_letter_bonus = get_num_from_self(self, (char*)"@first_letter_bonus", 15),
+        .leading_letter_penalty = get_num_from_self(self, (char*)"@leading_letter_penalty", -5),
+        .max_leading_letter_penalty = get_num_from_self(self, (char*)"@max_leading_letter_penalty", -15),
+        .unmatched_letter_penalty = get_num_from_self(self, (char*)"@unmatched_letter_penalty", -1),
+        .string_length_penalty = get_num_from_self(self, (char*)"@string_length_penalty", 0)
+    };
+    return config;
+}
+
 static VALUE
 rb_fts_fuzzy_match_extension_class_fuzzy_match(VALUE self, VALUE pattern, VALUE str)
 {
@@ -13,8 +36,9 @@ rb_fts_fuzzy_match_extension_class_fuzzy_match(VALUE self, VALUE pattern, VALUE
   char* strPtr;
   strPtr = StringValueCStr(str);
 
+  struct FtsConfig config = fts_config(self);
   int outScore;
-  int matched = fts_fuzzy_match_simple(patternPtr, strPtr, &outScore);
+  int matched = fts_fuzzy_match_simple(patternPtr, strPtr, &config, &outScore);
   // return rb_sprintf("Matched: %d\nScore: %d\n", matched, outScore);
   if (matched) {
       return INT2FIX(outScore);
@@ -24,7 +48,8 @@ rb_fts_fuzzy_match_extension_class_fuzzy_match(VALUE self, VALUE pattern, VALUE
 }
 
 struct StringScore {
-  VALUE str;
+  VALUE rbStr;
+  char *cStr;
   bool matched;
   int score;
 };
@@ -39,7 +64,12 @@ int comp(const void *a, const void *b) {
   } else if (!aa->matched && bb->matched) {
     return 1;
   }
-  return bb->score - aa->score;
+  if (aa->score != bb->score) {
+    return bb->score - aa->score;
+  } else {
+      // Given the score is the same, sort alphabetically to keep the order consistent
+      return strcasecmp(aa->cStr, bb->cStr);
+  }
 }
 
 static VALUE
@@ -49,12 +79,14 @@ rb_fts_fuzzy_match_extension_class_sort_n(VALUE self, VALUE pattern, VALUE strin
   patternPtr = StringValueCStr(pattern);
   long stringsLen = RARRAY_LEN(strings);
 
+  struct FtsConfig config = fts_config(self);
+
   struct StringScore *scores = (struct StringScore *)malloc(stringsLen * sizeof(struct StringScore));
   for (long i=0; i<stringsLen; i++) {
-    const VALUE str = RARRAY_AREF(strings, i);
-    const char* strPtr = StringValueCStr(str);
-    scores[i].str = str;
-    scores[i].matched = fts_fuzzy_match_simple(patternPtr, strPtr, &scores[i].score);
+    volatile VALUE str = RARRAY_AREF(strings, i);
+    scores[i].rbStr = str;
+    scores[i].cStr = StringValueCStr(str);
+    scores[i].matched = fts_fuzzy_match_simple(patternPtr, scores[i].cStr, &config, &scores[i].score);
   }
 
   qsort(scores, stringsLen, sizeof(struct StringScore), comp);
@@ -64,7 +96,7 @@ rb_fts_fuzzy_match_extension_class_sort_n(VALUE self, VALUE pattern, VALUE strin
 
   VALUE result = rb_ary_new_capa(n2);
   for (long i=0; i<n2; i++) {
-    rb_ary_push(result, scores[i].str);
+    rb_ary_push(result, scores[i].rbStr);
   }
 
   return result;
@@ -73,10 +105,10 @@ rb_fts_fuzzy_match_extension_class_sort_n(VALUE self, VALUE pattern, VALUE strin
 void
 Init_fts_fuzzy_match(void)
 {
-    rb_mFtsFuzzyMatch = rb_define_module("FtsFuzzyMatch");
-    rb_cFtsFuzzyMatchExtension = rb_define_class_under(rb_mFtsFuzzyMatch, "Extension", rb_cObject);
-    rb_define_singleton_method(rb_cFtsFuzzyMatchExtension, "fuzzy_match",
+    rb_cFtsFuzzyMatch = rb_define_class("FtsFuzzyMatch", rb_cObject);
+    rb_cFtsFuzzyMatchExtension = rb_define_class_under(rb_cFtsFuzzyMatch, "Extension", rb_cObject);
+    rb_define_method(rb_cFtsFuzzyMatchExtension, "fuzzy_match",
         rb_fts_fuzzy_match_extension_class_fuzzy_match, 2);
-    rb_define_singleton_method(rb_cFtsFuzzyMatchExtension, "sort_n",
+    rb_define_method(rb_cFtsFuzzyMatchExtension, "sort_n",
         rb_fts_fuzzy_match_extension_class_sort_n, 3);
 }

data/ext/fts_fuzzy_match/fts_fuzzy_match.h

@@ -1,6 +1,206 @@
-#ifndef FUZZY_MATCH_H
-#define FUZZY_MATCH_H 1
+// LICENSE
+//
+//   This software is dual-licensed to the public domain and under the following
+//   license: you are granted a perpetual, irrevocable license to copy, modify,
+//   publish, and distribute this file as you see fit.
+//
+// VERSION
+//   0.2.0  (2017-02-18)  Scored matches perform exhaustive search for best score
+//   0.1.0  (2016-03-28)  Initial release
+//
+// AUTHOR
+//   Forrest Smith
+//
+// NOTES
+//   Compiling
+//     You MUST add '#define FTS_FUZZY_MATCH_IMPLEMENTATION' before including this header in ONE source file to create implementation.
+//
+//   fts_fuzzy_match_simple(...)
+//     Simplified version of fts_fuzzy_match
+//
+//   fts_fuzzy_match(...)
+//     Returns true if pattern is found AND calculates a score.
+//     Performs exhaustive search via recursion to find all possible matches and match with highest score.
+//     Scores values have no intrinsic meaning. Possible score range is not normalized and varies with pattern.
+//     Recursion is limited internally (default=10) to prevent degenerate cases (pattern="aaaaaa" str="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+//     Uses uint8_t for match indices. Therefore patterns are limited to 256 characters.
+//     Score system should be tuned for YOUR use case. Words, sentences, file names, or method names all prefer different tuning.
 
-#include "ruby.h"
 
-#endif /* FUZZY_MATCH_H */
+#ifndef FTS_FUZZY_MATCH_H
+#define FTS_FUZZY_MATCH_H
+
+
+#include <ctype.h> // tolower, toupper
+
+// Public interface
+struct FtsConfig {
+    int sequential_bonus;            // bonus for adjacent matches (DEFAULT: 15)
+    int separator_bonus;             // bonus if match occurs after a separator
+    int camel_bonus;                  // bonus if match is uppercase and prev is lower (DEFAULT: 30)
+    int first_letter_bonus;          // bonus if the first letter is matched
+
+    int leading_letter_penalty;      // penalty applied for every letter in str before the first match
+    int max_leading_letter_penalty; // maximum penalty for leading letters
+    int unmatched_letter_penalty;    // penalty for every letter that doesn't matter
+    int string_length_penalty;       // (DEFAULT: 0)
+};
+
+
+static bool fts_fuzzy_match_simple(char const * pattern, char const * str, struct FtsConfig const * config, int * outScore);
+static bool fts_fuzzy_match(char const * pattern, char const * str, struct FtsConfig const * config, int * outScore, uint8_t * matches, int maxMatches);
+
+#ifdef FTS_FUZZY_MATCH_IMPLEMENTATION
+
+// Private interface
+static bool fts_fuzzy_match_recursive(const char * pattern, const char * str, struct FtsConfig const * config, int * outScore,
+    const char * strBegin, uint8_t const * srcMatches, uint8_t * matches, int maxMatches,
+    int nextMatch, int * recursionCount, int recursionLimit);
+
+static bool fts_fuzzy_match_simple(char const * pattern, char const * str, struct FtsConfig const * config, int * outScore) {
+    uint8_t matches[256];
+    return fts_fuzzy_match(pattern, str, config, outScore, matches, sizeof(matches));
+}
+
+static bool fts_fuzzy_match(char const * pattern, char const * str, struct FtsConfig const * config, int * outScore, uint8_t * matches, int maxMatches) {
+    int recursionCount = 0;
+    int recursionLimit = 10;
+
+    return fts_fuzzy_match_recursive(pattern, str, config, outScore, str, NULL, matches, maxMatches, 0, &recursionCount, recursionLimit);
+}
+
+// Private implementation
+static bool fts_fuzzy_match_recursive(const char * pattern, const char * str, struct FtsConfig const * config, int * outScore,
+    const char * strBegin, uint8_t const * srcMatches, uint8_t * matches, int maxMatches,
+    int nextMatch, int * recursionCount, int recursionLimit)
+{
+    // Count recursions
+    ++*recursionCount;
+    if (*recursionCount >= recursionLimit)
+        return false;
+
+    // Detect end of strings
+    if (*pattern == '\0' || *str == '\0')
+        return false;
+
+    unsigned long stringLength = strlen(str);
+
+    // Recursion params
+    bool recursiveMatch = false;
+    uint8_t bestRecursiveMatches[256];
+    int bestRecursiveScore = 0;
+
+    // Loop through pattern and str looking for a match
+    bool first_match = true;
+    while (*pattern != '\0' && *str != '\0') {
+
+        // Found match
+        if (tolower(*pattern) == tolower(*str)) {
+
+            // Supplied matches buffer was too short
+            if (nextMatch >= maxMatches)
+                return false;
+
+            // "Copy-on-Write" srcMatches into matches
+            if (first_match && srcMatches) {
+                memcpy(matches, srcMatches, nextMatch);
+                first_match = false;
+            }
+
+            // Recursive call that "skips" this match
+            uint8_t recursiveMatches[256];
+            int recursiveScore;
+            if (fts_fuzzy_match_recursive(pattern, str + 1, config, &recursiveScore, strBegin, matches, recursiveMatches, sizeof(recursiveMatches), nextMatch, recursionCount, recursionLimit)) {
+
+                // Pick best recursive score
+                if (!recursiveMatch || recursiveScore > bestRecursiveScore) {
+                    memcpy(bestRecursiveMatches, recursiveMatches, 256);
+                    bestRecursiveScore = recursiveScore;
+                }
+                recursiveMatch = true;
+            }
+
+            // Advance
+            matches[nextMatch++] = (uint8_t)(str - strBegin);
+            ++pattern;
+        }
+        ++str;
+    }
+
+    // Determine if full pattern was matched
+    bool matched = *pattern == '\0' ? true : false;
+
+    // Calculate score
+    if (matched) {
+        // Iterate str to end
+        while (*str != '\0')
+            ++str;
+
+        // Initialize score
+        *outScore = 100;
+
+        // Apply length penalty
+        *outScore += stringLength * config->string_length_penalty;
+
+        // Apply leading letter penalty
+        int penalty = config->leading_letter_penalty * matches[0];
+        if (penalty < config->max_leading_letter_penalty)
+            penalty = config->max_leading_letter_penalty;
+        *outScore += penalty;
+
+        // Apply unmatched penalty
+        int unmatched = (int)(str - strBegin) - nextMatch;
+        *outScore += config->unmatched_letter_penalty * unmatched;
+
+        // Apply ordering bonuses
+        for (int i = 0; i < nextMatch; ++i) {
+            uint8_t currIdx = matches[i];
+
+            if (i > 0) {
+                uint8_t prevIdx = matches[i - 1];
+
+                // Sequential
+                if (currIdx == (prevIdx + 1))
+                    *outScore += config->sequential_bonus;
+            }
+
+            // Check for bonuses based on neighbor character value
+            if (currIdx > 0) {
+                // Camel case
+                char neighbor = strBegin[currIdx - 1];
+                char curr = strBegin[currIdx];
+                if (islower(neighbor) && isupper(curr))
+                    *outScore += config->camel_bonus;
+
+                // Separator
+                bool neighborSeparator = neighbor == '_' || neighbor == ' ';
+                if (neighborSeparator)
+                    *outScore += config->separator_bonus;
+            }
+            else {
+                // First letter
+                *outScore += config->first_letter_bonus;
+            }
+        }
+    }
+
+    // Return best result
+    if (recursiveMatch && (!matched || bestRecursiveScore > *outScore)) {
+        // Recursive score is better than "this"
+        memcpy(matches, bestRecursiveMatches, maxMatches);
+        *outScore = bestRecursiveScore;
+        return true;
+    }
+    else if (matched) {
+        // "this" score is better than recursive
+        return true;
+    }
+    else {
+        // no match
+        return false;
+    }
+}
+
+#endif // FTS_FUZZY_MATCH_IMPLEMENTATION
+
+#endif // FTS_FUZZY_MATCH_H

data/lib/fts_fuzzy_match/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module FtsFuzzyMatch
-  VERSION = "0.1.0"
+class FtsFuzzyMatch
+  VERSION = "0.2.0"
 end

data/lib/fts_fuzzy_match.rb

@@ -4,19 +4,40 @@ require_relative "fts_fuzzy_match/version"
 require_relative "fts_fuzzy_match/fts_fuzzy_match"
 
 # FTS Fuzzy Match module. Can score or sort
-module FtsFuzzyMatch
+class FtsFuzzyMatch
   class Error < StandardError; end
 
-  def self.sort_in_ruby(pattern, strings)
+  def initialize(...)
+    @extension = ::FtsFuzzyMatch::Extension.new(...)
+  end
+
+  def fuzzy_match(pattern, string)
+    @extension.fuzzy_match(pattern, string)
+  end
+
+  def sort_in_ruby(pattern, strings)
     # fuzzy_match is -50..50 so -200 is the lowest possible score
-    strings.sort_by { |string| -1 * (::FtsFuzzyMatch::Extension.fuzzy_match(pattern, string) || -200) }
+    strings.sort_by { |string| -1 * (fuzzy_match(pattern, string) || -200) }
+  end
+
+  def sort_n(pattern, strings, n)
+    @extension.sort_n(pattern, strings, n)
   end
 
-  def self.sort_n(pattern, strings, n)
-    ::FtsFuzzyMatch::Extension.sort_n(pattern, strings, n)
+  def sort(pattern, strings)
+    @extension.sort_n(pattern, strings, strings.length)
   end
 
-  def self.sort(pattern, strings)
-    ::FtsFuzzyMatch::Extension.sort_n(pattern, strings, strings.length)
+  class Extension
+    def initialize(**args)
+      @sequential_bonus = args[:sequential_bonus]
+      @separator_bonus = args[:separator_bonus]
+      @camel_bonus = args[:camel_bonus]
+      @first_letter_bonus = args[:first_letter_bonus]
+      @leading_letter_penalty = args[:leading_letter_penalty]
+      @max_leading_letter_penalty = args[:max_leading_letter_penalty]
+      @unmatched_letter_penalty = args[:unmatched_letter_penalty]
+      @string_length_penalty = args[:string_length_penalty]
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fts_fuzzy_match
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Dave Goddard
@@ -18,11 +18,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/dependabot.yml"
-- ".github/workflows/fuzzy_match.yml"
-- ".github/workflows/packaged_source.yml"
-- ".github/workflows/packaged_tarball.yml"
-- ".github/workflows/precompiled.yml"
-- ".github/workflows/system.yml"
+- ".github/workflows/fts_fuzzy_match.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -32,7 +28,6 @@ files:
 - ext/fts_fuzzy_match/extconf.rb
 - ext/fts_fuzzy_match/fts_fuzzy_match.c
 - ext/fts_fuzzy_match/fts_fuzzy_match.h
-- ext/fts_fuzzy_match/fts_fuzzy_match_impl.h
 - fts_fuzzy_match.gemspec
 - lib/fts_fuzzy_match.rb
 - lib/fts_fuzzy_match/version.rb

data/.github/workflows/packaged_source.yml

@@ -1,37 +0,0 @@
-name: packaged_source
-concurrency:
-  group: "${{github.workflow}}-${{github.ref}}"
-  cancel-in-progress: true
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 8 * * 3" # At 08:00 on Wednesday # https://crontab.guru/#0_8_*_*_3
-  push:
-    branches:
-      - main
-      - v*.*.x
-    tags:
-      - v*.*.*
-  pull_request:
-    types: [opened, synchronize]
-    branches:
-      - '*'
-    paths: ["packaged_source/**/*", ".github/workflows/packaged_source.yml"]
-
-jobs:
-  packaged_source:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4", "head"]
-        runs-on: ["ubuntu-latest", "macos-latest", "windows-latest"]
-    runs-on: ${{matrix.runs-on}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: packaged_source
-          ruby-version: ${{matrix.ruby}}
-          bundler-cache: true
-      - run: bundle exec rake compile test
-        working-directory: packaged_source

data/.github/workflows/packaged_tarball.yml

@@ -1,41 +0,0 @@
-name: packaged_tarball
-concurrency:
-  group: "${{github.workflow}}-${{github.ref}}"
-  cancel-in-progress: true
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 8 * * 3" # At 08:00 on Wednesday # https://crontab.guru/#0_8_*_*_3
-  push:
-    branches:
-      - main
-      - v*.*.x
-    tags:
-      - v*.*.*
-  pull_request:
-    types: [opened, synchronize]
-    branches:
-      - '*'
-    paths: ["packaged_tarball/**/*", ".github/workflows/packaged_tarball.yml"]
-
-jobs:
-  packaged_tarball:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4", "head"]
-        runs-on: ["ubuntu-latest", "macos-13", "windows-latest"]
-    runs-on: ${{matrix.runs-on}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: packaged_tarball
-          ruby-version: ${{matrix.ruby}}
-          bundler-cache: true
-      - uses: actions/cache@v4
-        with:
-          path: packaged_tarball/ports
-          key: packaged_tarball-ports-${{matrix.runs-on}}-${{hashFiles('packaged_tarball/ext/packaged_tarball/extconf.rb')}}
-      - run: bundle exec rake compile test
-        working-directory: packaged_tarball

data/.github/workflows/precompiled.yml

@@ -1,232 +0,0 @@
-name: precompiled
-concurrency:
-  group: "${{github.workflow}}-${{github.ref}}"
-  cancel-in-progress: true
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 8 * * 3" # At 08:00 on Wednesday # https://crontab.guru/#0_8_*_*_3
-  push:
-    branches:
-      - main
-      - v*.*.x
-    tags:
-      - v*.*.*
-  pull_request:
-    types: [opened, synchronize]
-    branches:
-      - '*'
-    paths: ["precompiled/**/*", ".github/workflows/precompiled.yml"]
-
-jobs:
-  ruby_versions:
-    outputs:
-      setup_ruby: "['3.1', '3.2', '3.3', '3.4']"
-      image_tag: "['3.1', '3.2', '3.3', '3.4']"
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo "generating rubies ..."
-
-  rcd_image_version:
-    runs-on: ubuntu-latest
-    outputs:
-      rcd_image_version: ${{steps.rcd_image_version.outputs.rcd_image_version}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: precompiled
-          ruby-version: "3.3"
-          bundler-cache: true
-          bundler: latest
-      - id: rcd_image_version
-        run: bundle exec ruby -e 'require "rake_compiler_dock"; puts "rcd_image_version=#{RakeCompilerDock::IMAGE_VERSION}"' >> $GITHUB_OUTPUT
-        working-directory: precompiled
-
-  test:
-    needs: ["ruby_versions"]
-    strategy:
-      fail-fast: false
-      matrix:
-        runs-on: ["ubuntu-latest", "macos-13", "windows-latest"]
-        ruby: ${{ fromJSON(needs.ruby_versions.outputs.setup_ruby) }}
-    runs-on: ${{matrix.runs-on}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: precompiled
-          ruby-version: ${{matrix.ruby}}
-          bundler-cache: true
-      - uses: actions/cache@v4
-        with:
-          path: precompiled/ports
-          key: precompiled-ports-${{matrix.runs-on}}-${{hashFiles('precompiled/ext/precompiled/extconf.rb')}}
-      - run: bundle exec rake compile test
-        working-directory: precompiled
-
-  generic-package:
-    runs-on: "ubuntu-latest"
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
-        with:
-          path: precompiled/ports/archives
-          key: archives-ubuntu-${{hashFiles('precompiled/ext/precompiled/extconf.rb')}}
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: precompiled
-          ruby-version: "3.3"
-          bundler-cache: true
-      - run: ./bin/test-gem-build gems ruby
-        working-directory: precompiled
-      - uses: actions/upload-artifact@v4
-        with:
-          name: cruby-gem
-          path: precompiled/gems
-          retention-days: 1
-
-  generic-install:
-    needs: ["generic-package", "ruby_versions"]
-    strategy:
-      fail-fast: false
-      matrix:
-        os: ["ubuntu-latest", "macos-13", "windows-latest"]
-        ruby: ${{ fromJSON(needs.ruby_versions.outputs.setup_ruby) }}
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          working-directory: precompiled
-          ruby-version: "${{ matrix.ruby }}"
-      - uses: actions/download-artifact@v4
-        with:
-          name: cruby-gem
-          path: precompiled/gems
-      - run: ./bin/test-gem-install gems
-        working-directory: precompiled
-        shell: bash
-
-  native-package:
-    needs: ["rcd_image_version"]
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - "aarch64-linux-gnu"
-          - "aarch64-linux-musl"
-          - "arm-linux-gnu"
-          - "arm-linux-musl"
-          - "x86-linux-gnu"
-          - "x86-linux-musl"
-          - "x86_64-linux-gnu"
-          - "x86_64-linux-musl"
-          - "arm64-darwin"
-          - "x86_64-darwin"
-          - "x64-mingw-ucrt"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/cache@v4
-        with:
-          path: precompiled/ports/archives
-          key: archives-ubuntu-${{hashFiles('precompiled/ext/precompiled/extconf.rb')}}
-      - run: |
-          docker run --rm -v $PWD/precompiled:/precompiled -w /precompiled \
-            ghcr.io/rake-compiler/rake-compiler-dock-image:${{ needs.rcd_image_version.outputs.rcd_image_version }}-mri-${{ matrix.platform }} \
-            ./bin/test-gem-build gems ${{ matrix.platform }}
-      - uses: actions/upload-artifact@v4
-        with:
-          name: "cruby-${{ matrix.platform }}-gem"
-          path: precompiled/gems
-          retention-days: 1
-
-  linux-install:
-    needs: ["native-package", "ruby_versions"]
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - "aarch64-linux-gnu"
-          - "aarch64-linux-musl"
-          - "arm-linux-gnu"
-          - "arm-linux-musl"
-          - "x86-linux-gnu"
-          - "x86-linux-musl"
-          - "x86_64-linux-gnu"
-          - "x86_64-linux-musl"
-        ruby: ${{ fromJSON(needs.ruby_versions.outputs.image_tag) }}
-        include:
-          # declare docker image for each platform
-          - { platform: aarch64-linux-musl, docker_tag: "-alpine", bootstrap: "apk add bash &&" }
-          - { platform: arm-linux-musl, docker_tag: "-alpine", bootstrap: "apk add bash &&" }
-          - { platform: x86-linux-musl, docker_tag: "-alpine", bootstrap: "apk add bash &&" }
-          - { platform: x86_64-linux-musl, docker_tag: "-alpine", bootstrap: "apk add bash &&" }
-          # declare docker platform for each platform
-          - { platform: aarch64-linux-gnu, docker_platform: "--platform=linux/arm64" }
-          - { platform: aarch64-linux-musl, docker_platform: "--platform=linux/arm64" }
-          - { platform: arm-linux-gnu, docker_platform: "--platform=linux/arm/v7" }
-          - { platform: arm-linux-musl, docker_platform: "--platform=linux/arm/v7" }
-          - { platform: x86-linux-gnu, docker_platform: "--platform=linux/386" }
-          - { platform: x86-linux-musl, docker_platform: "--platform=linux/386" }
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v4
-        with:
-          name: cruby-${{ matrix.platform }}-gem
-          path: precompiled/gems
-      - run: |
-          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-          docker run --rm -v $PWD/precompiled:/precompiled -w /precompiled \
-            ${{ matrix.docker_platform }} ruby:${{ matrix.ruby }}${{ matrix.docker_tag }} \
-            sh -c "
-              gem update --system &&
-              ${{ matrix.bootstrap }}
-              ./bin/test-gem-install gems
-            "
-
-  darwin-install:
-    needs: ["native-package", "ruby_versions"]
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - arm64-darwin
-          - x86_64-darwin
-        ruby: ${{ fromJSON(needs.ruby_versions.outputs.setup_ruby) }}
-        include:
-          - { platform: arm64-darwin, os: macos-14 }
-          - { platform: x86_64-darwin, os: macos-13 }
-    runs-on: ${{matrix.os}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "${{matrix.ruby}}"
-      - uses: actions/download-artifact@v4
-        with:
-          name: cruby-${{matrix.platform}}-gem
-          path: precompiled/gems
-      - run: ./bin/test-gem-install gems
-        working-directory: precompiled
-
-  windows-install:
-    needs: ["native-package", "ruby_versions"]
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ${{ fromJSON(needs.ruby_versions.outputs.setup_ruby) }}
-    runs-on: windows-2022
-    steps:
-      - uses: actions/checkout@v4
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: "${{matrix.ruby}}"
-      - uses: actions/download-artifact@v4
-        with:
-          name: cruby-x64-mingw-ucrt-gem
-          path: precompiled/gems
-      - run: ./bin/test-gem-install gems
-        working-directory: precompiled

data/.github/workflows/system.yml

@@ -1,40 +0,0 @@
-name: system
-concurrency:
-  group: "${{github.workflow}}-${{github.ref}}"
-  cancel-in-progress: true
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: "0 8 * * 3" # At 08:00 on Wednesday # https://crontab.guru/#0_8_*_*_3
-  push:
-    branches:
-      - main
-      - v*.*.x
-    tags:
-      - v*.*.*
-  pull_request:
-    types: [opened, synchronize]
-    branches:
-      - '*'
-    paths: ["system/**/*", ".github/workflows/system.yml"]
-
-jobs:
-  system:
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["3.0", "3.1", "3.2", "3.3", "3.4", "head"]
-        runs-on: ["ubuntu-latest", "macos-13", "windows-latest"]
-    runs-on: ${{matrix.runs-on}}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: MSP-Greg/setup-ruby-pkgs@v1
-        with:
-          working-directory: system
-          ruby-version: ${{matrix.ruby}}
-          bundler-cache: true
-          mingw: "libyaml" # windows
-          apt-get: "libyaml-dev" # linux
-          brew: "libyaml" # macos
-      - run: bundle exec rake compile test
-        working-directory: system

data/ext/fts_fuzzy_match/fts_fuzzy_match_impl.h

@@ -1,203 +0,0 @@
-// LICENSE
-//
-//   This software is dual-licensed to the public domain and under the following
-//   license: you are granted a perpetual, irrevocable license to copy, modify,
-//   publish, and distribute this file as you see fit.
-//
-// VERSION
-//   0.2.0  (2017-02-18)  Scored matches perform exhaustive search for best score
-//   0.1.0  (2016-03-28)  Initial release
-//
-// AUTHOR
-//   Forrest Smith
-//
-// NOTES
-//   Compiling
-//     You MUST add '#define FTS_FUZZY_MATCH_IMPLEMENTATION' before including this header in ONE source file to create implementation.
-//
-//   fts_fuzzy_match_simple(...)
-//     Simplified version of fts_fuzzy_match
-//
-//   fts_fuzzy_match(...)
-//     Returns true if pattern is found AND calculates a score.
-//     Performs exhaustive search via recursion to find all possible matches and match with highest score.
-//     Scores values have no intrinsic meaning. Possible score range is not normalized and varies with pattern.
-//     Recursion is limited internally (default=10) to prevent degenerate cases (pattern="aaaaaa" str="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
-//     Uses uint8_t for match indices. Therefore patterns are limited to 256 characters.
-//     Score system should be tuned for YOUR use case. Words, sentences, file names, or method names all prefer different tuning.
-
-
-#ifndef FTS_FUZZY_MATCH_H
-#define FTS_FUZZY_MATCH_H
-
-
-#include <ctype.h> // tolower, toupper
-
-// Public interface
-static bool fts_fuzzy_match_simple(char const * pattern, char const * str, int * outScore);
-static bool fts_fuzzy_match(char const * pattern, char const * str, int * outScore, uint8_t * matches, int maxMatches);
-
-#ifdef FTS_FUZZY_MATCH_IMPLEMENTATION
-
-// Private interface
-static bool fts_fuzzy_match_recursive(const char * pattern, const char * str, int * outScore,
-    const char * strBegin, uint8_t const * srcMatches, uint8_t * matches, int maxMatches,
-    int nextMatch, int * recursionCount, int recursionLimit);
-
-static bool fts_fuzzy_match_simple(char const * pattern, char const * str, int * outScore) {
-    uint8_t matches[256];
-    return fts_fuzzy_match(pattern, str, outScore, matches, sizeof(matches));
-}
-
-static bool fts_fuzzy_match(char const * pattern, char const * str, int * outScore, uint8_t * matches, int maxMatches) {
-    int recursionCount = 0;
-    int recursionLimit = 10;
-
-    return fts_fuzzy_match_recursive(pattern, str, outScore, str, NULL, matches, maxMatches, 0, &recursionCount, recursionLimit);
-}
-
-// Private implementation
-static bool fts_fuzzy_match_recursive(const char * pattern, const char * str, int * outScore,
-    const char * strBegin, uint8_t const * srcMatches, uint8_t * matches, int maxMatches,
-    int nextMatch, int * recursionCount, int recursionLimit)
-{
-    // Count recursions
-    ++*recursionCount;
-    if (*recursionCount >= recursionLimit)
-        return false;
-
-    // Detect end of strings
-    if (*pattern == '\0' || *str == '\0')
-        return false;
-
-    unsigned long stringLength = strlen(str);
-
-    // Recursion params
-    bool recursiveMatch = false;
-    uint8_t bestRecursiveMatches[256];
-    int bestRecursiveScore = 0;
-
-    // Loop through pattern and str looking for a match
-    bool first_match = true;
-    while (*pattern != '\0' && *str != '\0') {
-
-        // Found match
-        if (tolower(*pattern) == tolower(*str)) {
-
-            // Supplied matches buffer was too short
-            if (nextMatch >= maxMatches)
-                return false;
-
-            // "Copy-on-Write" srcMatches into matches
-            if (first_match && srcMatches) {
-                memcpy(matches, srcMatches, nextMatch);
-                first_match = false;
-            }
-
-            // Recursive call that "skips" this match
-            uint8_t recursiveMatches[256];
-            int recursiveScore;
-            if (fts_fuzzy_match_recursive(pattern, str + 1, &recursiveScore, strBegin, matches, recursiveMatches, sizeof(recursiveMatches), nextMatch, recursionCount, recursionLimit)) {
-
-                // Pick best recursive score
-                if (!recursiveMatch || recursiveScore > bestRecursiveScore) {
-                    memcpy(bestRecursiveMatches, recursiveMatches, 256);
-                    bestRecursiveScore = recursiveScore;
-                }
-                recursiveMatch = true;
-            }
-
-            // Advance
-            matches[nextMatch++] = (uint8_t)(str - strBegin);
-            ++pattern;
-        }
-        ++str;
-    }
-
-    // Determine if full pattern was matched
-    bool matched = *pattern == '\0' ? true : false;
-
-    // Calculate score
-    if (matched) {
-        const int sequential_bonus = 20;            // bonus for adjacent matches (DEFAULT: 15)
-        const int separator_bonus = 30;             // bonus if match occurs after a separator
-        const int camel_bonus = 0;                  // bonus if match is uppercase and prev is lower (DEFAULT: 30)
-        const int first_letter_bonus = 15;          // bonus if the first letter is matched
-
-        const int leading_letter_penalty = -5;      // penalty applied for every letter in str before the first match
-        const int max_leading_letter_penalty = -15; // maximum penalty for leading letters
-        const int unmatched_letter_penalty = -1;    // penalty for every letter that doesn't matter
-        const int string_length_penalty = -1;       // (DEFAULT: 0)
-
-        // Iterate str to end
-        while (*str != '\0')
-            ++str;
-
-        // Initialize score
-        *outScore = 100;
-
-        // Apply length penalty
-        *outScore += stringLength * string_length_penalty;
-
-        // Apply leading letter penalty
-        int penalty = leading_letter_penalty * matches[0];
-        if (penalty < max_leading_letter_penalty)
-            penalty = max_leading_letter_penalty;
-        *outScore += penalty;
-
-        // Apply unmatched penalty
-        int unmatched = (int)(str - strBegin) - nextMatch;
-        *outScore += unmatched_letter_penalty * unmatched;
-
-        // Apply ordering bonuses
-        for (int i = 0; i < nextMatch; ++i) {
-            uint8_t currIdx = matches[i];
-
-            if (i > 0) {
-                uint8_t prevIdx = matches[i - 1];
-
-                // Sequential
-                if (currIdx == (prevIdx + 1))
-                    *outScore += sequential_bonus;
-            }
-
-            // Check for bonuses based on neighbor character value
-            if (currIdx > 0) {
-                // Camel case
-                char neighbor = strBegin[currIdx - 1];
-                char curr = strBegin[currIdx];
-                if (islower(neighbor) && isupper(curr))
-                    *outScore += camel_bonus;
-
-                // Separator
-                bool neighborSeparator = neighbor == '_' || neighbor == ' ';
-                if (neighborSeparator)
-                    *outScore += separator_bonus;
-            }
-            else {
-                // First letter
-                *outScore += first_letter_bonus;
-            }
-        }
-    }
-
-    // Return best result
-    if (recursiveMatch && (!matched || bestRecursiveScore > *outScore)) {
-        // Recursive score is better than "this"
-        memcpy(matches, bestRecursiveMatches, maxMatches);
-        *outScore = bestRecursiveScore;
-        return true;
-    }
-    else if (matched) {
-        // "this" score is better than recursive
-        return true;
-    }
-    else {
-        // no match
-        return false;
-    }
-}
-
-#endif // FTS_FUZZY_MATCH_IMPLEMENTATION
-
-#endif // FTS_FUZZY_MATCH_H