perf: optimize fuzzy matching with String#index and lookup table

- Use String#index for character search instead of manual iteration
- Pre-compute sqrt values in SQRT_TABLE for proximity bonus
- Add TryEntry Data wrapper to avoid Hash#merge per result
- Reduces search time by ~50% for 2000 directories

Benchmarks (2000 directories):
- load_all_tries: ~27ms (filesystem I/O)
- get_tries (empty): ~22ms
- get_tries (query): ~110ms (was ~228ms)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: tobi

lib/fuzzy.rb

@@ -79,52 +79,48 @@ def each(&block)
 
     private
 
+    # Pre-computed sqrt values for proximity bonus (gap 0-15)
+    SQRT_TABLE = (0..16).map { |n| 2.0 / Math.sqrt(n + 1) }.freeze
+
     def calculate_match(entry)
       positions = []
       score = entry.base_score
 
       # Empty query = match all with base score only
-      if @query.empty?
-        return [score, positions]
-      end
+      return [score, positions] if @query.empty?
 
-      text_lower = entry.text_lower
-      text_len = text_lower.length
-      query_len = @query_chars.length
+      text = entry.text_lower
+      query_chars = @query_chars
+      query_len = query_chars.length
 
       last_pos = -1
-      query_idx = 0
+      pos = 0
 
-      i = 0
-      while i < text_len
-        break if query_idx >= query_len
+      query_chars.each do |qc|
+        # Find next occurrence of query char starting from pos
+        found = text.index(qc, pos)
+        return nil unless found  # No match
 
-        if text_lower[i] == @query_chars[query_idx]
-          positions << i
-
-          # Base match point
-          score += 1.0
+        positions << found
 
-          # Word boundary bonus (start of string or after non-alphanumeric)
-          is_boundary = (i == 0) || text_lower[i - 1].match?(/[^a-z0-9]/)
-          score += 1.0 if is_boundary
+        # Base match point
+        score += 1.0
 
-          # Proximity bonus (consecutive chars score higher)
-          if last_pos >= 0
-            gap = i - last_pos - 1
-            score += 2.0 / Math.sqrt(gap + 1)
-          end
+        # Word boundary bonus (start of string or after non-alphanumeric)
+        if found == 0 || text[found - 1].match?(/[^a-z0-9]/)
+          score += 1.0
+        end
 
-          last_pos = i
-          query_idx += 1
+        # Proximity bonus (consecutive chars score higher)
+        if last_pos >= 0
+          gap = found - last_pos - 1
+          score += gap < 16 ? SQRT_TABLE[gap] : (2.0 / Math.sqrt(gap + 1))
         end
 
-        i += 1
+        last_pos = found
+        pos = found + 1
       end
 
-      # Not all query chars matched = no match
-      return nil if query_idx < query_len
-
       # Density bonus: prefer shorter spans
       score *= (query_len.to_f / (last_pos + 1)) if last_pos >= 0
 

try.rb

@@ -125,13 +125,32 @@ def load_all_tries
     end
   end
 
+  # Result wrapper to avoid Hash#merge allocation per entry
+  TryEntry = Data.define(:data, :score, :highlight_positions) do
+    def [](key)
+      case key
+      when :score then score
+      when :highlight_positions then highlight_positions
+      else data[key]
+      end
+    end
+
+    def method_missing(name, *)
+      data[name]
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      data.key?(name) || super
+    end
+  end
+
   def get_tries
     load_all_tries
     @fuzzy ||= Fuzzy.new(@all_tries)
 
     results = []
     @fuzzy.match(@input_buffer).each do |entry, positions, score|
-      results << entry.merge(score: score, highlight_positions: positions)
+      results << TryEntry.new(entry, score, positions)
     end
     results
   end