command-t 3.0.2 → 4.0

data/ruby/command-t/heap.h

@@ -0,0 +1,22 @@
+// Copyright 2016-present Greg Hurrell. All rights reserved.
+// Licensed under the terms of the BSD 2-clause license.
+
+/**
+ * A fixed size min-heap implementation.
+ */
+
+typedef int (*heap_compare_entries)(const void *a, const void *b);
+
+typedef struct {
+    long count;
+    long capacity;
+    void **entries;
+    heap_compare_entries comparator;
+} heap_t;
+
+#define HEAP_PEEK(heap) (heap->entries[0])
+
+heap_t *heap_new(long capacity, heap_compare_entries comparator);
+void heap_free(heap_t *heap);
+void heap_insert(heap_t *heap, void *value);
+void *heap_extract(heap_t *heap);

data/ruby/command-t/match.c

@@ -6,171 +6,238 @@
 #include "ext.h"
 #include "ruby_compat.h"
 
-// use a struct to make passing params during recursion easier
+#define UNSET_SCORE FLT_MAX
+
+// Use a struct to make passing params during recursion easier.
 typedef struct {
-    char    *haystack_p;            // pointer to the path string to be searched
-    long    haystack_len;           // length of same
-    char    *needle_p;              // pointer to search string (needle)
-    long    needle_len;             // length of same
-    double  max_score_per_char;
-    int     always_show_dot_files;  // boolean
-    int     never_show_dot_files;   // boolean
-    int     case_sensitive;         // boolean
-    int     recurse;                // boolean
-    double  *memo;                  // memoization
+    char    *haystack_p;            // Pointer to the path string to be searched.
+    long    haystack_len;           // Length of same.
+    char    *needle_p;              // Pointer to search string (needle).
+    long    needle_len;             // Length of same.
+    long    *rightmost_match_p;     // Rightmost match for each char in needle.
+    float   max_score_per_char;
+    int     always_show_dot_files;  // Boolean.
+    int     never_show_dot_files;   // Boolean.
+    int     case_sensitive;         // Boolean.
+    int     recurse;                // Boolean.
+    float   *memo;                  // Memoization.
 } matchinfo_t;
 
-double recursive_match(matchinfo_t *m,    // sharable meta-data
-                       long haystack_idx, // where in the path string to start
-                       long needle_idx,   // where in the needle string to start
-                       long last_idx,     // location of last matched character
-                       double score)      // cumulative score so far
-{
-    double score_for_char;
-    double seen_score = 0;  // remember best score seen via recursion
-    int found;
-    long i, j, distance;
-    long memo_idx = haystack_idx;
-
-    // do we have a memoized result we can return?
-    double memoized = m->memo[needle_idx * m->needle_len + memo_idx];
-    if (memoized != DBL_MAX)
-        return memoized;
-
-    // bail early if not enough room (left) in haystack for (rest of) needle
-    if (m->haystack_len - haystack_idx < m->needle_len - needle_idx) {
-        score = 0.0;
-        goto memoize;
-    }
-
+float recursive_match(
+    matchinfo_t *m,    // Sharable meta-data.
+    long haystack_idx, // Where in the path string to start.
+    long needle_idx,   // Where in the needle string to start.
+    long last_idx,     // Location of last matched character.
+    float score        // Cumulative score so far.
+) {
+    long distance, i, j;
+    float *memoized = NULL;
+    float score_for_char;
+    float seen_score = 0;
+
+    // Iterate over needle.
     for (i = needle_idx; i < m->needle_len; i++) {
-        char c = m->needle_p[i];
-        found = 0;
-
-        // similar to above, we'll stop iterating when we know we're too close
-        // to the end of the string to possibly match
-        for (j = haystack_idx;
-             j <= m->haystack_len - (m->needle_len - i);
-             j++, haystack_idx++) {
-            char d = m->haystack_p[j];
+        // Iterate over (valid range of) haystack.
+        for (j = haystack_idx; j <= m->rightmost_match_p[i]; j++) {
+            char c, d;
+
+            // Do we have a memoized result we can return?
+            memoized = &m->memo[j * m->needle_len + i];
+            if (*memoized != UNSET_SCORE) {
+                return *memoized > seen_score ? *memoized : seen_score;
+            }
+            c = m->needle_p[i];
+            d = m->haystack_p[j];
             if (d == '.') {
-                if (j == 0 || m->haystack_p[j - 1] == '/') { // this is a dot-file
-                    int dot_search = (i == 0 && c == '.'); // searching for a dot
-                    if (m->never_show_dot_files || (!dot_search && !m->always_show_dot_files)) {
-                        score = 0.0;
-                        goto memoize;
+                if (j == 0 || m->haystack_p[j - 1] == '/') { // This is a dot-file.
+                    int dot_search = c == '.'; // Searching for a dot.
+                    if (
+                        m->never_show_dot_files ||
+                        (!dot_search && !m->always_show_dot_files)
+                    ) {
+                        return *memoized = 0.0;
                     }
                 }
             } else if (d >= 'A' && d <= 'Z' && !m->case_sensitive) {
-                d += 'a' - 'A'; // add 32 to downcase
+                d += 'a' - 'A'; // Add 32 to downcase.
             }
 
             if (c == d) {
-                found = 1;
-
-                // calculate score
+                // Calculate score.
+                float sub_score = 0;
                 score_for_char = m->max_score_per_char;
                 distance = j - last_idx;
 
                 if (distance > 1) {
-                    double factor = 1.0;
+                    float factor = 1.0;
                     char last = m->haystack_p[j - 1];
-                    char curr = m->haystack_p[j]; // case matters, so get again
-                    if (last == '/')
+                    char curr = m->haystack_p[j]; // Case matters, so get again.
+                    if (last == '/') {
                         factor = 0.9;
-                    else if (last == '-' ||
-                            last == '_' ||
-                            last == ' ' ||
-                            (last >= '0' && last <= '9'))
+                    } else if (
+                        last == '-' ||
+                        last == '_' ||
+                        last == ' ' ||
+                        (last >= '0' && last <= '9')
+                    ) {
                         factor = 0.8;
-                    else if (last >= 'a' && last <= 'z' &&
-                            curr >= 'A' && curr <= 'Z')
+                    } else if (
+                        last >= 'a' && last <= 'z' &&
+                        curr >= 'A' && curr <= 'Z'
+                    ) {
                         factor = 0.8;
-                    else if (last == '.')
+                    } else if (last == '.') {
                         factor = 0.7;
-                    else
-                        // if no "special" chars behind char, factor diminishes
-                        // as distance from last matched char increases
+                    } else {
+                        // If no "special" chars behind char, factor diminishes
+                        // as distance from last matched char increases.
                         factor = (1.0 / distance) * 0.75;
+                    }
                     score_for_char *= factor;
                 }
 
-                if (++j < m->haystack_len && m->recurse) {
-                    // bump cursor one char to the right and
-                    // use recursion to try and find a better match
-                    double sub_score = recursive_match(m, j, i, last_idx, score);
-                    if (sub_score > seen_score)
+                if (j < m->rightmost_match_p[i] && m->recurse) {
+                    sub_score = recursive_match(m, j + 1, i, last_idx, score);
+                    if (sub_score > seen_score) {
                         seen_score = sub_score;
+                    }
                 }
-
+                last_idx = j;
+                haystack_idx = last_idx + 1;
                 score += score_for_char;
-                last_idx = haystack_idx++;
-                break;
+                *memoized = seen_score > score ? seen_score : score;
+                if (i == m->needle_len - 1) {
+                    // Whole string matched.
+                    return *memoized;
+                }
+                if (!m->recurse) {
+                    break;
+                }
             }
         }
-        if (!found) {
-            score = 0.0;
-            goto memoize;
-        }
     }
-
-    score = score > seen_score ? score : seen_score;
-
-memoize:
-    m->memo[needle_idx * m->needle_len + memo_idx] = score;
-    return score;
+    return *memoized = score;
 }
 
-void calculate_match(VALUE str,
-                     VALUE needle,
-                     VALUE case_sensitive,
-                     VALUE always_show_dot_files,
-                     VALUE never_show_dot_files,
-                     VALUE recurse,
-                     match_t *out)
-{
-    long i, max;
-    double score;
+float calculate_match(
+    VALUE haystack,
+    VALUE needle,
+    VALUE case_sensitive,
+    VALUE always_show_dot_files,
+    VALUE never_show_dot_files,
+    VALUE recurse,
+    long needle_bitmask,
+    long *haystack_bitmask
+) {
     matchinfo_t m;
-    m.haystack_p            = RSTRING_PTR(str);
-    m.haystack_len          = RSTRING_LEN(str);
+    long i;
+    float score             = 1.0;
+    int compute_bitmasks    = *haystack_bitmask == UNSET_BITMASK;
+    m.haystack_p            = RSTRING_PTR(haystack);
+    m.haystack_len          = RSTRING_LEN(haystack);
     m.needle_p              = RSTRING_PTR(needle);
     m.needle_len            = RSTRING_LEN(needle);
+    m.rightmost_match_p     = NULL;
     m.max_score_per_char    = (1.0 / m.haystack_len + 1.0 / m.needle_len) / 2;
     m.always_show_dot_files = always_show_dot_files == Qtrue;
     m.never_show_dot_files  = never_show_dot_files == Qtrue;
     m.case_sensitive        = (int)case_sensitive;
     m.recurse               = recurse == Qtrue;
 
-    // calculate score
-    score = 1.0;
-
-    // special case for zero-length search string
+    // Special case for zero-length search string.
     if (m.needle_len == 0) {
-
-        // filter out dot files
-        if (!m.always_show_dot_files) {
+        // Filter out dot files.
+        if (m.never_show_dot_files || !m.always_show_dot_files) {
             for (i = 0; i < m.haystack_len; i++) {
                 char c = m.haystack_p[i];
-
                 if (c == '.' && (i == 0 || m.haystack_p[i - 1] == '/')) {
-                    score = 0.0;
-                    break;
+                    return 0.0;
                 }
             }
         }
-    } else if (m.haystack_len > 0) { // normal case
+    } else {
+        long haystack_limit;
+        long memo_size;
+        long needle_idx;
+        long mask;
+        long rightmost_match_p[m.needle_len];
+
+        if (*haystack_bitmask != UNSET_BITMASK) {
+            if ((needle_bitmask & *haystack_bitmask) != needle_bitmask) {
+                return 0.0;
+            }
+        }
 
-        // prepare for memoization
-        double memo[m.haystack_len * m.needle_len];
-        for (i = 0, max = m.haystack_len * m.needle_len; i < max; i++)
-            memo[i] = DBL_MAX;
-        m.memo = memo;
+        // Pre-scan string:
+        // - Bail if it can't match at all.
+        // - Record rightmost match for each character (prune search space).
+        // - Record bitmask for haystack to speed up future searches.
+        m.rightmost_match_p = rightmost_match_p;
+        needle_idx = m.needle_len - 1;
+        mask = 0;
+        for (i = m.haystack_len - 1; i >= 0; i--) {
+            char c = m.haystack_p[i];
+            char lower = c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
+            if (!m.case_sensitive) {
+                c = lower;
+            }
+            if (compute_bitmasks) {
+                mask |= (1 << (lower - 'a'));
+            }
 
-        score = recursive_match(&m, 0, 0, 0, 0.0);
-    }
+            if (needle_idx >= 0) {
+                char d = m.needle_p[needle_idx];
+                if (c == d) {
+                    rightmost_match_p[needle_idx] = i;
+                    needle_idx--;
+                }
+            }
+        }
+        if (compute_bitmasks) {
+            *haystack_bitmask = mask;
+        }
+        if (needle_idx != -1) {
+            return 0.0;
+        }
 
-    // final book-keeping
-    out->path  = str;
-    out->score = score;
+        // Prepare for memoization.
+        haystack_limit = rightmost_match_p[m.needle_len - 1] + 1;
+        memo_size = m.needle_len * haystack_limit;
+        {
+            float memo[memo_size];
+            for (i = 0; i < memo_size; i++) {
+                memo[i] = UNSET_SCORE;
+            }
+            m.memo = memo;
+            score = recursive_match(&m, 0, 0, 0, 0.0);
+
+#ifdef DEBUG
+            fprintf(stdout, "   ");
+            for (i = 0; i < m.needle_len; i++) {
+                fprintf(stdout, "    %c   ", m.needle_p[i]);
+            }
+            fprintf(stdout, "\n");
+            for (i = 0; i < memo_size; i++) {
+                char formatted[8];
+                if (i % m.needle_len == 0) {
+                    long haystack_idx = i / m.needle_len;
+                    fprintf(stdout, "%c: ", m.haystack_p[haystack_idx]);
+                }
+                if (memo[i] == UNSET_SCORE) {
+                    snprintf(formatted, sizeof(formatted), "    -  ");
+                } else {
+                    snprintf(formatted, sizeof(formatted), " %-.4f", memo[i]);
+                }
+                fprintf(stdout, "%s", formatted);
+                if ((i + 1) % m.needle_len == 0) {
+                    fprintf(stdout, "\n");
+                } else {
+                    fprintf(stdout, " ");
+                }
+            }
+            fprintf(stdout, "Final score: %f\n\n", score);
+#endif
+        }
+    }
+    return score;
 }

data/ruby/command-t/match.h

@@ -3,16 +3,22 @@
 
 #include <ruby.h>
 
-// struct for representing an individual match
+#define UNSET_BITMASK (-1)
+
+// Struct for representing an individual match.
 typedef struct {
-    VALUE   path;
-    double  score;
+    VALUE path;
+    long bitmask;
+    float score;
 } match_t;
 
-extern void calculate_match(VALUE str,
-                            VALUE needle,
-                            VALUE case_sensitive,
-                            VALUE always_show_dot_files,
-                            VALUE never_show_dot_files,
-                            VALUE recurse,
-                            match_t *out);
+extern float calculate_match(
+    VALUE str,
+    VALUE needle,
+    VALUE case_sensitive,
+    VALUE always_show_dot_files,
+    VALUE never_show_dot_files,
+    VALUE recurse,
+    long needle_bitmask,
+    long *haystack_bitmask
+);

data/ruby/command-t/match_window.rb

@@ -15,6 +15,7 @@ module CommandT
     Highlight = Struct.new(:highlight, :bang)
 
     def initialize(options = {})
+      @encoding        = options[:encoding]
       @highlight_color = options[:highlight_color] || 'PmenuSel'
       @min_height      = options[:min_height]
       @prompt          = options[:prompt]
@@ -35,7 +36,10 @@ module CommandT
       set 'scrolloff', 0         # don't scroll near buffer edges
       set 'sidescroll', 0        # don't sidescroll in jumps
       set 'sidescrolloff', 0     # don't sidescroll automatically
-      set 'updatetime', options[:debounce_interval]
+
+      if options[:debounce_interval] > 0
+        set 'updatetime', options[:debounce_interval]
+      end
 
       # Save existing window views so we can restore them later.
       current_window = ::VIM::evaluate('winnr()')
@@ -396,6 +400,11 @@ module CommandT
     #
     def match_with_syntax_highlight(match)
       highlight_chars = @prompt.abbrev.downcase.scan(/./mu)
+      if @encoding &&
+         match.respond_to?(:force_encoding) &&
+         match.encoding != @encoding
+        match = match.force_encoding(@encoding)
+      end
       match.scan(/./mu).inject([]) do |output, char|
         if char.downcase == highlight_chars.first
           highlight_chars.shift

data/ruby/command-t/matcher.c

@@ -3,8 +3,9 @@
 
 #include <stdlib.h>  /* for qsort() */
 #include <string.h>  /* for strncmp() */
-#include "matcher.h"
 #include "match.h"
+#include "matcher.h"
+#include "heap.h"
 #include "ext.h"
 #include "ruby_compat.h"
 
@@ -13,7 +14,7 @@
 #include <pthread.h> /* for pthread_create, pthread_join etc */
 #endif
 
-// comparison function for use with qsort
+// Comparison function for use with qsort.
 int cmp_alpha(const void *a, const void *b)
 {
     match_t a_match = *(match_t *)a;
@@ -29,11 +30,11 @@ int cmp_alpha(const void *a, const void *b)
     if (a_len > b_len) {
         order = strncmp(a_p, b_p, b_len);
         if (order == 0)
-            order = 1; // shorter string (b) wins
+            order = 1; // shorter string (b) wins.
     } else if (a_len < b_len) {
         order = strncmp(a_p, b_p, a_len);
         if (order == 0)
-            order = -1; // shorter string (a) wins
+            order = -1; // shorter string (a) wins.
     } else {
         order = strncmp(a_p, b_p, a_len);
     }
@@ -41,16 +42,16 @@ int cmp_alpha(const void *a, const void *b)
     return order;
 }
 
-// comparison function for use with qsort
+// Comparison function for use with qsort.
 int cmp_score(const void *a, const void *b)
 {
     match_t a_match = *(match_t *)a;
     match_t b_match = *(match_t *)b;
 
     if (a_match.score > b_match.score)
-        return -1; // a scores higher, a should appear sooner
+        return -1; // a scores higher, a should appear sooner.
     else if (a_match.score < b_match.score)
-        return 1;  // b scores higher, a should appear later
+        return 1;  // b scores higher, a should appear later.
     else
         return cmp_alpha(a, b);
 }
@@ -62,7 +63,7 @@ VALUE CommandTMatcher_initialize(int argc, VALUE *argv, VALUE self)
     VALUE options;
     VALUE scanner;
 
-    // process arguments: 1 mandatory, 1 optional
+    // Process arguments: 1 mandatory, 1 optional.
     if (rb_scan_args(argc, argv, "11", &scanner, &options) == 1)
         options = Qnil;
     if (NIL_P(scanner))
@@ -70,7 +71,7 @@ VALUE CommandTMatcher_initialize(int argc, VALUE *argv, VALUE self)
 
     rb_iv_set(self, "@scanner", scanner);
 
-    // check optional options hash for overrides
+    // Check optional options hash for overrides.
     always_show_dot_files = CommandT_option_from_hash("always_show_dot_files", options);
     never_show_dot_files = CommandT_option_from_hash("never_show_dot_files", options);
 
@@ -84,94 +85,192 @@ typedef struct {
     long thread_count;
     long thread_index;
     long case_sensitive;
+    long limit;
     match_t *matches;
     long path_count;
-    VALUE paths;
-    VALUE abbrev;
+    VALUE haystacks;
+    VALUE needle;
     VALUE always_show_dot_files;
     VALUE never_show_dot_files;
     VALUE recurse;
+    long needle_bitmask;
 } thread_args_t;
 
 void *match_thread(void *thread_args)
 {
     long i;
+    float score;
+    heap_t *heap = NULL;
     thread_args_t *args = (thread_args_t *)thread_args;
-    for (i = args->thread_index; i < args->path_count; i += args->thread_count) {
-        VALUE path = RARRAY_PTR(args->paths)[i];
-        calculate_match(path,
-                        args->abbrev,
-                        args->case_sensitive,
-                        args->always_show_dot_files,
-                        args->never_show_dot_files,
-                        args->recurse,
-                        &args->matches[i]);
+
+    if (args->limit) {
+        // Reserve one extra slot so that we can do an insert-then-extract even
+        // when "full" (effectively allows use of min-heap to maintain a
+        // top-"limit" list of items).
+        heap = heap_new(args->limit + 1, cmp_score);
+    }
+
+    for (
+        i = args->thread_index;
+        i < args->path_count;
+        i += args->thread_count
+    ) {
+        args->matches[i].path = RARRAY_PTR(args->haystacks)[i];
+        if (args->needle_bitmask == UNSET_BITMASK) {
+            args->matches[i].bitmask = UNSET_BITMASK;
+        }
+        args->matches[i].score = calculate_match(
+            args->matches[i].path,
+            args->needle,
+            args->case_sensitive,
+            args->always_show_dot_files,
+            args->never_show_dot_files,
+            args->recurse,
+            args->needle_bitmask,
+            &args->matches[i].bitmask
+        );
+        if (heap) {
+            if (heap->count == args->limit) {
+                score = ((match_t *)HEAP_PEEK(heap))->score;
+                if (args->matches[i].score >= score) {
+                    heap_insert(heap, &args->matches[i]);
+                    (void)heap_extract(heap);
+                }
+            } else {
+                heap_insert(heap, &args->matches[i]);
+            }
+        }
     }
 
-    return NULL;
+    return heap;
+}
+
+long calculate_bitmask(VALUE string) {
+    char *str = RSTRING_PTR(string);
+    long len = RSTRING_LEN(string);
+    long i;
+    long mask = 0;
+    for (i = 0; i < len; i++) {
+        if (str[i] >= 'a' && str[i] <= 'z') {
+            mask |= (1 << (str[i] - 'a'));
+        } else if (str[i] >= 'A' && str[i] <= 'Z') {
+            mask |= (1 << (str[i] - 'A'));
+        }
+    }
+    return mask;
 }
 
 VALUE CommandTMatcher_sorted_matches_for(int argc, VALUE *argv, VALUE self)
 {
-    long i, limit, path_count, thread_count;
+    long i, j, limit, path_count, thread_count;
 #ifdef HAVE_PTHREAD_H
     long err;
     pthread_t *threads;
 #endif
+    long needle_bitmask = UNSET_BITMASK;
+    long heap_matches_count;
+    int use_heap;
+    int sort;
     match_t *matches;
+    match_t *heap_matches = NULL;
+    heap_t *heap;
     thread_args_t *thread_args;
-    VALUE abbrev;
-    VALUE case_sensitive;
     VALUE always_show_dot_files;
+    VALUE case_sensitive;
+    VALUE recurse;
+    VALUE ignore_spaces;
     VALUE limit_option;
+    VALUE needle;
     VALUE never_show_dot_files;
-    VALUE ignore_spaces;
+    VALUE new_paths_object_id;
     VALUE options;
     VALUE paths;
-    VALUE recurse;
+    VALUE paths_object_id;
     VALUE results;
     VALUE scanner;
     VALUE sort_option;
     VALUE threads_option;
+    VALUE wrapped_matches;
 
-    // process arguments: 1 mandatory, 1 optional
-    if (rb_scan_args(argc, argv, "11", &abbrev, &options) == 1)
+    // Process arguments: 1 mandatory, 1 optional.
+    if (rb_scan_args(argc, argv, "11", &needle, &options) == 1)
         options = Qnil;
-    if (NIL_P(abbrev))
-        rb_raise(rb_eArgError, "nil abbrev");
+    if (NIL_P(needle))
+        rb_raise(rb_eArgError, "nil needle");
 
-    // check optional options hash for overrides
+    // Check optional options hash for overrides.
     case_sensitive = CommandT_option_from_hash("case_sensitive", options);
     limit_option = CommandT_option_from_hash("limit", options);
     threads_option = CommandT_option_from_hash("threads", options);
     sort_option = CommandT_option_from_hash("sort", options);
     ignore_spaces = CommandT_option_from_hash("ignore_spaces", options);
+    always_show_dot_files = rb_iv_get(self, "@always_show_dot_files");
+    never_show_dot_files = rb_iv_get(self, "@never_show_dot_files");
     recurse = CommandT_option_from_hash("recurse", options);
 
-    abbrev = StringValue(abbrev);
+    limit = NIL_P(limit_option) ? 15 : NUM2LONG(limit_option);
+    sort = NIL_P(sort_option) || sort_option == Qtrue;
+    use_heap = limit && sort;
+    heap_matches_count = 0;
+
+    needle = StringValue(needle);
     if (case_sensitive != Qtrue)
-        abbrev = rb_funcall(abbrev, rb_intern("downcase"), 0);
+        needle = rb_funcall(needle, rb_intern("downcase"), 0);
 
     if (ignore_spaces == Qtrue)
-        abbrev = rb_funcall(abbrev, rb_intern("delete"), 1, rb_str_new2(" "));
+        needle = rb_funcall(needle, rb_intern("delete"), 1, rb_str_new2(" "));
 
-    // get unsorted matches
+    // Get unsorted matches.
     scanner = rb_iv_get(self, "@scanner");
     paths = rb_funcall(scanner, rb_intern("paths"), 0);
-    always_show_dot_files = rb_iv_get(self, "@always_show_dot_files");
-    never_show_dot_files = rb_iv_get(self, "@never_show_dot_files");
-
     path_count = RARRAY_LEN(paths);
-    matches = malloc(path_count * sizeof(match_t));
-    if (!matches)
-        rb_raise(rb_eNoMemError, "memory allocation failed");
+
+    // Cached C data, not visible to Ruby layer.
+    paths_object_id = rb_ivar_get(self, rb_intern("paths_object_id"));
+    new_paths_object_id = rb_funcall(paths, rb_intern("object_id"), 0);
+    rb_ivar_set(self, rb_intern("paths_object_id"), new_paths_object_id);
+    if (
+        NIL_P(paths_object_id) ||
+        NUM2LONG(new_paths_object_id) != NUM2LONG(paths_object_id)
+    ) {
+        // `paths` changed, need to replace matches array.
+        paths_object_id = new_paths_object_id;
+        matches = malloc(path_count * sizeof(match_t));
+        if (!matches) {
+            rb_raise(rb_eNoMemError, "memory allocation failed");
+        }
+        wrapped_matches = Data_Wrap_Struct(
+            rb_cObject,
+            0,
+            free,
+            matches
+        );
+        rb_ivar_set(self, rb_intern("matches"), wrapped_matches);
+    } else {
+        // Get existing array.
+        Data_Get_Struct(
+            rb_ivar_get(self, rb_intern("matches")),
+            match_t,
+            matches
+        );
+
+        // Will compare against previously computed haystack bitmasks.
+        needle_bitmask = calculate_bitmask(needle);
+    }
 
     thread_count = NIL_P(threads_option) ? 1 : NUM2LONG(threads_option);
+    if (use_heap) {
+        heap_matches = malloc(thread_count * limit * sizeof(match_t));
+        if (!heap_matches) {
+            rb_raise(rb_eNoMemError, "memory allocation failed");
+        }
+    }
 
 #ifdef HAVE_PTHREAD_H
 #define THREAD_THRESHOLD 1000 /* avoid the overhead of threading when search space is small */
-    if (path_count < THREAD_THRESHOLD)
+    if (path_count < THREAD_THRESHOLD) {
         thread_count = 1;
+    }
     threads = malloc(sizeof(pthread_t) * thread_count);
     if (!threads)
         rb_raise(rb_eNoMemError, "memory allocation failed");
@@ -185,58 +284,99 @@ VALUE CommandTMatcher_sorted_matches_for(int argc, VALUE *argv, VALUE self)
         thread_args[i].thread_index = i;
         thread_args[i].case_sensitive = case_sensitive == Qtrue;
         thread_args[i].matches = matches;
+        thread_args[i].limit = use_heap ? limit : 0;
         thread_args[i].path_count = path_count;
-        thread_args[i].paths = paths;
-        thread_args[i].abbrev = abbrev;
+        thread_args[i].haystacks = paths;
+        thread_args[i].needle = needle;
         thread_args[i].always_show_dot_files = always_show_dot_files;
         thread_args[i].never_show_dot_files = never_show_dot_files;
         thread_args[i].recurse = recurse;
+        thread_args[i].needle_bitmask = needle_bitmask;
 
 #ifdef HAVE_PTHREAD_H
         if (i == thread_count - 1) {
 #endif
-            // for the last "worker", we'll just use the main thread
-            (void)match_thread(&thread_args[i]);
+            // For the last "worker", we'll just use the main thread.
+            heap = match_thread(&thread_args[i]);
+            if (heap) {
+                for (j = 0; j < heap->count; j++) {
+                    heap_matches[heap_matches_count++] = *(match_t *)heap->entries[j];
+                }
+                heap_free(heap);
+            }
 #ifdef HAVE_PTHREAD_H
         } else {
             err = pthread_create(&threads[i], NULL, match_thread, (void *)&thread_args[i]);
-            if (err != 0)
+            if (err != 0) {
                 rb_raise(rb_eSystemCallError, "pthread_create() failure (%d)", (int)err);
+            }
         }
 #endif
     }
 
 #ifdef HAVE_PTHREAD_H
     for (i = 0; i < thread_count - 1; i++) {
-        err = pthread_join(threads[i], NULL);
-        if (err != 0)
+        err = pthread_join(threads[i], (void **)&heap);
+        if (err != 0) {
             rb_raise(rb_eSystemCallError, "pthread_join() failure (%d)", (int)err);
+        }
+        if (heap) {
+            for (j = 0; j < heap->count; j++) {
+                heap_matches[heap_matches_count++] = *(match_t *)heap->entries[j];
+            }
+            heap_free(heap);
+        }
     }
     free(threads);
 #endif
 
-    if (NIL_P(sort_option) || sort_option == Qtrue) {
-        if (RSTRING_LEN(abbrev) == 0 ||
-            (RSTRING_LEN(abbrev) == 1 && RSTRING_PTR(abbrev)[0] == '.'))
-            // alphabetic order if search string is only "" or "."
-            qsort(matches, path_count, sizeof(match_t), cmp_alpha);
-        else
-            // for all other non-empty search strings, sort by score
-            qsort(matches, path_count, sizeof(match_t), cmp_score);
+    if (sort) {
+        if (
+            RSTRING_LEN(needle) == 0 ||
+            (RSTRING_LEN(needle) == 1 && RSTRING_PTR(needle)[0] == '.')
+        ) {
+            // Alphabetic order if search string is only "" or "."
+            // TODO: make those semantics fully apply to heap case as well
+            // (they don't because the heap itself calls cmp_score, which means
+            // that the items which stay in the top [limit] may (will) be
+            // different).
+            qsort(
+                use_heap ? heap_matches : matches,
+                use_heap ? heap_matches_count : path_count,
+                sizeof(match_t),
+                cmp_alpha
+            );
+        } else {
+            qsort(
+                use_heap ? heap_matches : matches,
+                use_heap ? heap_matches_count : path_count,
+                sizeof(match_t),
+                cmp_score
+            );
+        }
     }
 
     results = rb_ary_new();
-
-    limit = NIL_P(limit_option) ? 0 : NUM2LONG(limit_option);
     if (limit == 0)
         limit = path_count;
-    for (i = 0; i < path_count && limit > 0; i++) {
-        if (matches[i].score > 0.0) {
-            rb_funcall(results, rb_intern("push"), 1, matches[i].path);
+    for (
+        i = 0;
+        i < (use_heap ? heap_matches_count : path_count) && limit > 0;
+        i++
+    ) {
+        if ((use_heap ? heap_matches : matches)[i].score > 0.0) {
+            rb_funcall(
+                results,
+                rb_intern("push"),
+                1,
+                (use_heap ? heap_matches : matches)[i].path
+            );
             limit--;
         }
     }
 
-    free(matches);
+    if (use_heap) {
+        free(heap_matches);
+    }
     return results;
 }