Adjust scoring system

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 match (1000) > substring match (100) > fuzzy match (10)
+ *    - Prefix (10000) > substring (5000) > fuzzy (1000)
  * 4. First character determines type priority:
  *    - Starts with lowercase: methods first
  *    - Starts with uppercase: classes/modules/constants first
@@ -22,6 +22,25 @@
 var MAX_RESULTS = 30;
 var MIN_QUERY_LENGTH = 1;
 
+/*
+ * Scoring constants - organized in tiers where each tier dominates lower tiers.
+ * This ensures match type always beats type priority, etc.
+ *
+ * Tier 0: Exact matches (immediate return)
+ * Tier 1: Match type (prefix > substring > fuzzy)
+ * Tier 2: Exact name bonus
+ * Tier 3: Type priority (method vs class based on query case)
+ * Tier 4: Minor bonuses (top-level, class method, name length)
+ */
+var SCORE_EXACT_FULL_NAME = 1000000;  // Tier 0: Query exactly matches full_name
+var SCORE_MATCH_PREFIX    = 10000;    // Tier 1: Query is prefix of name
+var SCORE_MATCH_SUBSTRING = 5000;     // Tier 1: Query is substring of name
+var SCORE_MATCH_FUZZY     = 1000;     // Tier 1: Query chars appear in order
+var SCORE_EXACT_NAME      = 500;      // Tier 2: Name exactly equals query
+var SCORE_TYPE_PRIORITY   = 100;      // Tier 3: Preferred type (method/class)
+var SCORE_TOP_LEVEL       = 50;       // Tier 4: Top-level over namespaced
+var SCORE_CLASS_METHOD    = 10;       // Tier 4: Class method over instance method
+
 /**
  * Check if all characters in query appear in order in target
  * e.g., "addalias" fuzzy matches "add_foo_alias"
@@ -112,61 +131,32 @@ function computeScore(entry, q) {
 
   // Exact full_name match (e.g., "Array#filter" matches Array#filter)
   if (q.matchesFullName && fullNameLower === q.normalized) {
-    return 1000000;
+    return SCORE_EXACT_FULL_NAME;
   }
 
   var matchScore = 0;
-
-  if (q.matchesFullName) {
-    // For namespace queries like "Foo::Bar" or method queries like "Array#filter",
-    // match against full_name
-    if (fullNameLower.startsWith(q.normalized)) {
-      matchScore = 1000;  // Prefix (e.g., "Arr" matches "Array")
-    } else if (fullNameLower.includes(q.normalized)) {
-      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;
-    }
+  var target = q.matchesFullName ? fullNameLower : nameLower;
+
+  if (target.startsWith(q.normalized)) {
+    matchScore = SCORE_MATCH_PREFIX;     // Prefix (e.g., "Arr" matches "Array")
+  } else if (target.includes(q.normalized)) {
+    matchScore = SCORE_MATCH_SUBSTRING;  // Substring (e.g., "ray" matches "Array")
+  } else if (fuzzyMatch(target, q.normalized)) {
+    matchScore = SCORE_MATCH_FUZZY;      // Fuzzy (e.g., "addalias" matches "add_foo_alias")
   } else {
-    // For regular queries, match against unqualified name
-    if (nameLower.startsWith(q.normalized)) {
-      matchScore = 1000;  // Prefix
-    } else if (nameLower.includes(q.normalized)) {
-      matchScore = 100;   // Substring
-    } else if (fuzzyMatch(nameLower, q.normalized)) {
-      matchScore = 10;    // Fuzzy
-    } else {
-      return null;
-    }
+    return null;
   }
 
   var score = matchScore;
   var isMethod = (type === 'instance_method' || type === 'class_method');
 
-  if (q.prioritizeMethod) {
-    if (isMethod) score += 10000;
-  } else {
-    if (!isMethod) score += 10000;
-  }
-
-  // Class method > instance method
-  if (type === 'class_method') {
-    score += 500;
-  }
-
-  // Top-level (Hash) > namespaced (Foo::Hash)
-  if (name === fullName) {
-    score += 5000;
-  }
-
-  // Exact name match (e.g., "Hash" matches Hash over Hashable)
-  if (nameLower === q.normalized) {
-    score += 50000;
+  if (q.prioritizeMethod ? isMethod : !isMethod) {
+    score += SCORE_TYPE_PRIORITY;
   }
 
-  // Shorter name is better (subtract name length)
+  if (type === 'class_method') score += SCORE_CLASS_METHOD;
+  if (name === fullName) score += SCORE_TOP_LEVEL;  // Top-level (Hash) > namespaced (Foo::Hash)
+  if (nameLower === q.normalized) score += SCORE_EXACT_NAME;  // Exact name match
   score -= name.length;
 
   return score;