Support fuzzy search (lowest priority)

Author: st0012

lib/rdoc/generator/template/aliki/js/search_ranker.js

@@ -7,7 +7,7 @@
  * 3. Match types:
  *    - Namespace queries (::) and method queries (# or .) match against full_name
  *    - Regular queries match against unqualified name
- *    - Prefix matches rank higher than substring matches
+ *    - Prefix match (1000) > substring match (100) > fuzzy match (10)
  * 4. First character determines type priority:
  *    - Starts with lowercase: methods first
  *    - Starts with uppercase: classes/modules/constants first
@@ -22,6 +22,20 @@
 var MAX_RESULTS = 30;
 var MIN_QUERY_LENGTH = 1;
 
+/**
+ * Check if all characters in query appear in order in target
+ * e.g., "addalias" fuzzy matches "add_foo_alias"
+ */
+function fuzzyMatch(target, query) {
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    ti = target.indexOf(query[qi], ti);
+    if (ti === -1) return false;
+    ti++;
+  }
+  return true;
+}
+
 /**
  * Parse and normalize a search query
  * @param {string} query - The raw search query
@@ -107,18 +121,22 @@ function computeScore(entry, q) {
     // For namespace queries like "Foo::Bar" or method queries like "Array#filter",
     // match against full_name
     if (fullNameLower.startsWith(q.normalized)) {
-      matchScore = 1000; // Prefix match on full_name
+      matchScore = 1000;  // Prefix (e.g., "Arr" matches "Array")
     } else if (fullNameLower.includes(q.normalized)) {
-      matchScore = 100; // Substring match on full_name
+      matchScore = 100;   // Substring (e.g., "ray" matches "Array")
+    } else if (fuzzyMatch(fullNameLower, q.normalized)) {
+      matchScore = 10;    // Fuzzy (e.g., "addalias" matches "add_foo_alias")
     } else {
       return null;
     }
   } else {
     // For regular queries, match against unqualified name
     if (nameLower.startsWith(q.normalized)) {
-      matchScore = 1000;
+      matchScore = 1000;  // Prefix
     } else if (nameLower.includes(q.normalized)) {
-      matchScore = 100;
+      matchScore = 100;   // Substring
+    } else if (fuzzyMatch(nameLower, q.normalized)) {
+      matchScore = 10;    // Fuzzy
     } else {
       return null;
     }
@@ -206,23 +224,26 @@ function highlightMatch(text, q) {
   if (!text || !q) return text;
 
   var textLower = text.toLowerCase();
-  var queryLen = q.normalized.length;
-  var result = '';
-  var lastIndex = 0;
-  var matchIndex = textLower.indexOf(q.normalized);
-
-  while (matchIndex !== -1) {
-    // Add text before match
-    result += text.substring(lastIndex, matchIndex);
-    // Add highlighted match
-    result += '\u0001' + text.substring(matchIndex, matchIndex + queryLen) + '\u0002';
-    lastIndex = matchIndex + queryLen;
-    // Find next match
-    matchIndex = textLower.indexOf(q.normalized, lastIndex);
+  var query = q.normalized;
+
+  // Try contiguous match first (prefix or substring)
+  var matchIndex = textLower.indexOf(query);
+  if (matchIndex !== -1) {
+    return text.substring(0, matchIndex) +
+      '\u0001' + text.substring(matchIndex, matchIndex + query.length) + '\u0002' +
+      text.substring(matchIndex + query.length);
   }
 
-  // Add remaining text after last match
-  result += text.substring(lastIndex);
-
+  // Fall back to fuzzy highlight (highlight each matched character)
+  var result = '';
+  var ti = 0;
+  for (var qi = 0; qi < query.length; qi++) {
+    var charIndex = textLower.indexOf(query[qi], ti);
+    if (charIndex === -1) return text;
+    result += text.substring(ti, charIndex);
+    result += '\u0001' + text[charIndex] + '\u0002';
+    ti = charIndex + 1;
+  }
+  result += text.substring(ti);
   return result;
 }

test/rdoc/generator/aliki/search_test.rb

@@ -81,6 +81,23 @@ def test_substring_match_finds_suffix_matches
     assert_equal 'filter', results[0]['name']
   end
 
+  # Fuzzy matching support (characters in order)
+  def test_fuzzy_match_finds_non_contiguous_matches
+    results = run_search(
+      query: 'addalias',
+      data: [
+        { name: 'add_foo_alias', full_name: 'RDoc::Context#add_foo_alias', type: 'instance_method', path: 'x' },
+        { name: 'add_alias', full_name: 'RDoc::Context#add_alias', type: 'instance_method', path: 'x' },
+        { name: 'Hash', full_name: 'Hash', type: 'class', path: 'x' }
+      ]
+    )
+
+    assert_equal 2, results.length
+    # Both are fuzzy matches; shorter name wins
+    assert_equal 'add_alias', results[0]['name']
+    assert_equal 'add_foo_alias', results[1]['name']
+  end
+
   # Case-based type priority: uppercase query prioritizes classes/modules
   def test_uppercase_query_prioritizes_class_over_method
     results = run_search(