fzy 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d9b0ca699907c027e4cc3196971d3bb6cadd90e84d7cbb3e715ab6646560c0f
-  data.tar.gz: 52efaf9f44e76b5c15cd71e2b7b26aaa7364e290de28d0658bf149e282bed2d3
+  metadata.gz: 2a0619dd87bfc5809ad38b3de5c0e6feb9db98da06058ab43f1fe52639cfa6d1
+  data.tar.gz: ac58fc240875d7c0c35e18ef47fc9b8ec27812019845339b8995536c34f3941c
 SHA512:
-  metadata.gz: 6199c4ec774da59b321ca878d7bc60cd9109fd3ceb7b56b785a74e6ba43471dd65a972bb09705e93dc7612d750e2363171265cb4c57bde4d0b9db5ce2a5359db
-  data.tar.gz: bf7d4f1f30ad6fe4050dfed9407fc8e3ebb08f11e4d190dab69476c714819bd4212d9798b32f720a1ef9f1a6f50a418a8e73304d33441627d59a6aa6e49e530b
+  metadata.gz: a1f0e93c49d10c20fd3a3817fb6ad4b32b4cc4f5b14a7a68cd817e2cf2b4ef4cf21dd728b19be283cbe8cdb57d6a2c129cb349cda0987efce4cdac1563588199
+  data.tar.gz: ef8833e5a05e5d34f45e94b2aaca21db81801a06061ee2d42248b2f25189971df233f4dfefcca11cb8d058da706e65835352e1ec4069b58d5465c5ddae522029

data/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: Ruby
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Set up Ruby 2.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.6.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake

data/Gemfile.lock

@@ -1,25 +1,26 @@
 PATH
   remote: .
   specs:
-    fzy (0.1.0)
+    fzy (0.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    minitest (5.13.0)
-    rake (10.5.0)
-    rake-compiler (1.0.8)
+    minitest (5.25.4)
+    rake (13.2.1)
+    rake-compiler (1.2.8)
       rake
 
 PLATFORMS
+  arm64-darwin-23
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
+  bundler
   fzy!
   minitest
-  rake (~> 10.0)
+  rake
   rake-compiler
 
 BUNDLED WITH
-   1.17.3
+   2.5.17

data/ext/fzy/match.c

@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <float.h>
 #include <math.h>
+#include <stdlib.h>
 
 #include "match.h"
 #include "bonus.h"
@@ -27,122 +28,177 @@ int has_match(const char *needle, const char *haystack) {
 	return 1;
 }
 
+#define SWAP(x, y, T) do { T SWAP = x; x = y; y = SWAP; } while (0)
+
 #define max(a, b) (((a) > (b)) ? (a) : (b))
 
-#ifdef DEBUG_VERBOSE
-/* print one of the internal matrices */
-void mat_print(score_t *mat, char name, const char *needle, const char *haystack) {
-	int n = strlen(needle);
-	int m = strlen(haystack);
-	int i, j;
-	fprintf(stderr, "%c   ", name);
-	for (j = 0; j < m; j++) {
-		fprintf(stderr, "     %c", haystack[j]);
-	}
-	fprintf(stderr, "\n");
-	for (i = 0; i < n; i++) {
-		fprintf(stderr, " %c |", needle[i]);
-		for (j = 0; j < m; j++) {
-			score_t val = mat[i * m + j];
-			if (val == SCORE_MIN) {
-				fprintf(stderr, "    -\u221E");
-			} else {
-				fprintf(stderr, " %.3f", val);
-			}
-		}
-		fprintf(stderr, "\n");
-	}
-	fprintf(stderr, "\n\n");
-}
-#endif
+struct match_struct {
+	int needle_len;
+	int haystack_len;
+
+	char lower_needle[MATCH_MAX_LEN];
+	char lower_haystack[MATCH_MAX_LEN];
+
+	score_t match_bonus[MATCH_MAX_LEN];
+};
 
 static void precompute_bonus(const char *haystack, score_t *match_bonus) {
 	/* Which positions are beginning of words */
-	int m = strlen(haystack);
 	char last_ch = '/';
-	for (int i = 0; i < m; i++) {
+	for (int i = 0; haystack[i]; i++) {
 		char ch = haystack[i];
 		match_bonus[i] = COMPUTE_BONUS(last_ch, ch);
 		last_ch = ch;
 	}
 }
 
-score_t match_positions(const char *needle, const char *haystack, size_t *positions) {
+static void setup_match_struct(struct match_struct *match, const char *needle, const char *haystack) {
+	match->needle_len = strlen(needle);
+	match->haystack_len = strlen(haystack);
+
+	if (match->haystack_len > MATCH_MAX_LEN || match->needle_len > match->haystack_len) {
+		return;
+	}
+
+	for (int i = 0; i < match->needle_len; i++)
+		match->lower_needle[i] = tolower(needle[i]);
+
+	for (int i = 0; i < match->haystack_len; i++)
+		match->lower_haystack[i] = tolower(haystack[i]);
+
+	precompute_bonus(haystack, match->match_bonus);
+}
+
+static inline void match_row(const struct match_struct *match, int row, score_t *curr_D, score_t *curr_M, const score_t *last_D, const score_t *last_M) {
+	int n = match->needle_len;
+	int m = match->haystack_len;
+	int i = row;
+
+	const char *lower_needle = match->lower_needle;
+	const char *lower_haystack = match->lower_haystack;
+	const score_t *match_bonus = match->match_bonus;
+
+	score_t prev_score = SCORE_MIN;
+	score_t gap_score = i == n - 1 ? SCORE_GAP_TRAILING : SCORE_GAP_INNER;
+
+	for (int j = 0; j < m; j++) {
+		if (lower_needle[i] == lower_haystack[j]) {
+			score_t score = SCORE_MIN;
+			if (!i) {
+				score = (j * SCORE_GAP_LEADING) + match_bonus[j];
+			} else if (j) { /* i > 0 && j > 0*/
+				score = max(
+						last_M[j - 1] + match_bonus[j],
+
+						/* consecutive match, doesn't stack with match_bonus */
+						last_D[j - 1] + SCORE_MATCH_CONSECUTIVE);
+			}
+			curr_D[j] = score;
+			curr_M[j] = prev_score = max(score, prev_score + gap_score);
+		} else {
+			curr_D[j] = SCORE_MIN;
+			curr_M[j] = prev_score = prev_score + gap_score;
+		}
+	}
+}
+
+score_t match(const char *needle, const char *haystack) {
 	if (!*needle)
 		return SCORE_MIN;
 
-	int n = strlen(needle);
-	int m = strlen(haystack);
+	struct match_struct match;
+	setup_match_struct(&match, needle, haystack);
 
-	if (n == m) {
+	int n = match.needle_len;
+	int m = match.haystack_len;
+
+	if (m > MATCH_MAX_LEN || n > m) {
+		/*
+		 * Unreasonably large candidate: return no score
+		 * If it is a valid match it will still be returned, it will
+		 * just be ranked below any reasonably sized candidates
+		 */
+		return SCORE_MIN;
+	} else if (n == m) {
 		/* Since this method can only be called with a haystack which
 		 * matches needle. If the lengths of the strings are equal the
 		 * strings themselves must also be equal (ignoring case).
 		 */
-		if (positions)
-			for (int i = 0; i < n; i++)
-				positions[i] = i;
 		return SCORE_MAX;
 	}
 
-	if (m > 1024) {
+	/*
+	 * D[][] Stores the best score for this position ending with a match.
+	 * M[][] Stores the best possible score at this position.
+	 */
+	score_t D[2][MATCH_MAX_LEN], M[2][MATCH_MAX_LEN];
+
+	score_t *last_D, *last_M;
+	score_t *curr_D, *curr_M;
+
+	last_D = D[0];
+	last_M = M[0];
+	curr_D = D[1];
+	curr_M = M[1];
+
+	for (int i = 0; i < n; i++) {
+		match_row(&match, i, curr_D, curr_M, last_D, last_M);
+
+		SWAP(curr_D, last_D, score_t *);
+		SWAP(curr_M, last_M, score_t *);
+	}
+
+	return last_M[m - 1];
+}
+
+score_t match_positions(const char *needle, const char *haystack, size_t *positions) {
+	if (!*needle)
+		return SCORE_MIN;
+
+	struct match_struct match;
+	setup_match_struct(&match, needle, haystack);
+
+	int n = match.needle_len;
+	int m = match.haystack_len;
+
+	if (m > MATCH_MAX_LEN || n > m) {
 		/*
 		 * Unreasonably large candidate: return no score
 		 * If it is a valid match it will still be returned, it will
 		 * just be ranked below any reasonably sized candidates
 		 */
 		return SCORE_MIN;
+	} else if (n == m) {
+		/* Since this method can only be called with a haystack which
+		 * matches needle. If the lengths of the strings are equal the
+		 * strings themselves must also be equal (ignoring case).
+		 */
+		if (positions)
+			for (int i = 0; i < n; i++)
+				positions[i] = i;
+		return SCORE_MAX;
 	}
 
-	char lower_needle[n];
-	char lower_haystack[m];
-
-	for (int i = 0; i < n; i++)
-		lower_needle[i] = tolower(needle[i]);
-
-	for (int i = 0; i < m; i++)
-		lower_haystack[i] = tolower(haystack[i]);
-
-	score_t match_bonus[m];
-	score_t D[n][m], M[n][m];
-
 	/*
 	 * D[][] Stores the best score for this position ending with a match.
 	 * M[][] Stores the best possible score at this position.
 	 */
-	precompute_bonus(haystack, match_bonus);
+	score_t (*D)[MATCH_MAX_LEN], (*M)[MATCH_MAX_LEN];
+	M = malloc(sizeof(score_t) * MATCH_MAX_LEN * n);
+	D = malloc(sizeof(score_t) * MATCH_MAX_LEN * n);
+
+	score_t *last_D = NULL, *last_M = NULL;
+	score_t *curr_D, *curr_M;
 
 	for (int i = 0; i < n; i++) {
-		score_t prev_score = SCORE_MIN;
-		score_t gap_score = i == n - 1 ? SCORE_GAP_TRAILING : SCORE_GAP_INNER;
-
-		for (int j = 0; j < m; j++) {
-			if (lower_needle[i] == lower_haystack[j]) {
-				score_t score = SCORE_MIN;
-				if (!i) {
-					score = (j * SCORE_GAP_LEADING) + match_bonus[j];
-				} else if (j) { /* i > 0 && j > 0*/
-					score = max(
-					    M[i - 1][j - 1] + match_bonus[j],
-
-					    /* consecutive match, doesn't stack with match_bonus */
-					    D[i - 1][j - 1] + SCORE_MATCH_CONSECUTIVE);
-				}
-				D[i][j] = score;
-				M[i][j] = prev_score = max(score, prev_score + gap_score);
-			} else {
-				D[i][j] = SCORE_MIN;
-				M[i][j] = prev_score = prev_score + gap_score;
-			}
-		}
-	}
+		curr_D = &D[i][0];
+		curr_M = &M[i][0];
 
-#ifdef DEBUG_VERBOSE
-	fprintf(stderr, "\"%s\" =~ \"%s\"\n", needle, haystack);
-	mat_print(&D[0][0], 'D', needle, haystack);
-	mat_print(&M[0][0], 'M', needle, haystack);
-	fprintf(stderr, "\n");
-#endif
+		match_row(&match, i, curr_D, curr_M, last_D, last_M);
+
+		last_D = curr_D;
+		last_M = curr_M;
+	}
 
 	/* backtrace to find the positions of optimal matching */
 	if (positions) {
@@ -173,9 +229,10 @@ score_t match_positions(const char *needle, const char *haystack, size_t *positi
 		}
 	}
 
-	return M[n - 1][m - 1];
-}
+	score_t result = M[n - 1][m - 1];
 
-score_t match(const char *needle, const char *haystack) {
-	return match_positions(needle, haystack, NULL);
+	free(M);
+	free(D);
+
+	return result;
 }

data/ext/fzy/match.h

@@ -3,12 +3,22 @@
 
 #include <math.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef double score_t;
 #define SCORE_MAX INFINITY
 #define SCORE_MIN -INFINITY
 
+#define MATCH_MAX_LEN 1024
+
 int has_match(const char *needle, const char *haystack);
 score_t match_positions(const char *needle, const char *haystack, size_t *positions);
 score_t match(const char *needle, const char *haystack);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

data/fzy.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/fzy/extconf.rb"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "minitest"
 end

data/lib/fzy/version.rb

@@ -1,3 +1,3 @@
 module Fzy
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: fzy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - John Hawthorn
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-11-09 00:00:00.000000000 Z
+date: 2024-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -74,6 +74,7 @@ extensions:
 - ext/fzy/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -97,7 +98,7 @@ homepage: https://github.com/jhawthorn/fzy.js
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: A better fuzzy finder
 test_files: []