Scaladoc Search Engine fixes

Author: szymon-rd

scaladoc-js/main/src/searchbar/Searchbar.scala

@@ -3,7 +3,7 @@ package dotty.tools.scaladoc
 class Searchbar {
   val pages = SearchbarGlobals.pages.toList.map(PageEntry.apply)
   val parser = QueryParser()
-  val searchEngine = SearchbarEngine(pages)
+  val searchEngine = PageSearchEngine(pages)
   val inkuireEngine = InkuireJSSearchEngine()
   val component = SearchbarComponent(searchEngine, inkuireEngine, parser)
 }

scaladoc-js/main/src/searchbar/SearchbarComponent.scala

@@ -13,7 +13,7 @@ import scala.util.chaining._
 
 import java.net.URI
 
-class SearchbarComponent(engine: SearchbarEngine, inkuireEngine: InkuireJSSearchEngine, parser: QueryParser):
+class SearchbarComponent(engine: PageSearchEngine, inkuireEngine: InkuireJSSearchEngine, parser: QueryParser):
   val initialChunkSize = 5
   val resultsChunkSize = 20
   extension (p: PageEntry)
@@ -171,9 +171,9 @@ class SearchbarComponent(engine: SearchbarEngine, inkuireEngine: InkuireJSSearch
       clearResults()
       handleRecentQueries(query)
       parser.parse(query) match {
-        case EngineMatchersQuery(matchers) =>
+        case NameAndKindQuery(matchers) =>
             handleNewFluffQuery(matchers)
-        case BySignature(signature) =>
+        case SignatureQuery(signature) =>
             val loading = createLoadingAnimation
             val kindSeparator = createKindSeparator("inkuire")
             resultsDiv.appendChild(loading)

scaladoc-js/main/src/searchbar/engine/Matchers.scala

@@ -1,29 +1,24 @@
 package dotty.tools.scaladoc
 
+case class MatchResult(score: Int, pageEntry: PageEntry, indices: Set[Int])
+
 sealed trait EngineQuery
-case class EngineMatchersQuery(matchers: List[Matchers]) extends EngineQuery
-case class BySignature(signature: String) extends EngineQuery
+case class NameAndKindQuery(name: Option[String], kind: Option[String]) extends EngineQuery:
+  
+case class SignatureQuery(signature: String) extends EngineQuery
 
 case class Match(priority: Int, matchedIndexes: Set[Int]) // matchedIndexes - indexes of chars that got matched
 
-sealed trait Matchers extends Function1[PageEntry, Match]
+sealed trait Matchers:
+  def matchEntry(p: PageEntry): Match
 
-case class ByName(query: String) extends Matchers:
-  val tokens = StringUtils.createCamelCaseTokens(query)
-  def apply(p: PageEntry): Match = {
-    val nameOption = Option(p.shortName.toLowerCase)
-    //Edge case for empty query string
-    if query == "" then Match(1, Set.empty)
-    else {
-      val (result, indexes) = p.shortName.toLowerCase.zipWithIndex.foldLeft((query.toLowerCase, Set.empty[Int])) {
-        case ((pattern, indexes), (nextChar, index)) =>
-          if !pattern.isEmpty then {
-            if pattern.head.toString.equalsIgnoreCase(nextChar.toString) then (pattern.tail, indexes + index) else (pattern, indexes)
-          } else ("", indexes)
-      }
-      if result.isEmpty then Match(p.shortName.size - query.size + 1, indexes) else Match(-1, Set.empty)
-    }
-  }
+/**
+ * Searches matches PageEntry by name. It implements the following logic:
+ *  1. When the query is empty, return successful match regardless of PageEntry.
+ *  2.
+ * @param query String to match in page names
+ */
+case class ByName(query: String) extends Matchers
 
 case class ByKind(kind: String) extends Matchers:
   def apply(p: PageEntry): Match = Match(if p.kind.equalsIgnoreCase(kind) then 1 else -1, Set.empty)

scaladoc-js/main/src/searchbar/engine/PageSearchEngine.scala

@@ -0,0 +1,78 @@
+package dotty.tools.scaladoc
+
+import math.Ordering.Implicits.seqOrdering
+import org.scalajs.dom.Node
+
+import scala.annotation.tailrec
+
+class PageSearchEngine(pages: List[PageEntry]):
+  def query(query: NameAndKindQuery): List[MatchResult] =
+    matchPages(query)
+      .filter {
+        case MatchResult(score, _, _) => score >= 0
+      }
+      .sortBy {
+        case MatchResult(score, _, _) => score
+      }
+
+  private def matchPages(query: NameAndKindQuery): List[MatchResult] = query match {
+    case NameAndKindQuery(None, None) => List.empty
+    case NameAndKindQuery(None, Some(kind)) =>
+      filterKind(pages, kind)
+        .map(MatchResult(1, _, Set.empty))
+    case NameAndKindQuery(Some(""), kind) =>
+      kind.fold(pages)(filterKind(pages, _))
+    case NameAndKindQuery(Some(nameSearch), kind) =>
+      val kindFiltered = kind.fold(pages)(filterKind(pages, _))
+      val prematchedPages = prematchPages(kindFiltered, nameSearch)
+      prematchedPages.map(matchPage(_, nameSearch))
+  }
+
+  private def matchPage(prematched: MatchResult, nameSearch: String): MatchResult =
+    val searchTokens = StringUtils.createCamelCaseTokens(nameSearch)
+    val pageTokens = page.tokens
+
+    @tailrec
+    def findHighScoreMatch(searchTokens: List[String], pageTokens: List[String], scoreAcc: Int, indicesAcc: Set[Int]): (Int, Set[Int]) =
+      val searchTokensLifted = searchTokens.lift
+      val pageTokensLifted = pageTokens.lift
+
+      // Instead znajdź wszystkie poprawne podciągi match ujących tokenów OR leave it?
+      @tailrec
+      def matchTokens(searchTokenIndex: Int, pageTokenIndex: Int, acc: Set[(Int, Int)]): Set[(Int, Int)] = (searchTokensLifted(searchTokenIndex), pageTokensLifted(pageTokenIndex)) match
+        case (None, _) || (_, None) => acc
+        case (Some(searchHead :: _), Some(pageHead :: _)) =>
+          if searchHead.head == pageHead.head then
+            matchTokens(searchTokenIndex + 1, pageTokenIndex + 1, acc + (searchTokenIndex, pageTokenIndex))
+          else
+            matchTokens(searchTokenIndex + 1, pageTokenIndex + 1, acc)
+      end matchTokens
+
+      val matchedTokens = matchTokens(0, 0, Set.empty)
+
+
+      def findHighScoreMatch(searchTokenIndex: Int, pageTokenIndex: Int, positionAcc: Set[Int], scoreAcc: Int) =
+
+
+
+  private def filterKind(pages: List[PageEntry], kind: String): List[PageEntry] =
+    pages.filter(_.kind == kind)
+
+  def prematchPages(pages: List[PageEntry], search: String): List[PageEntry]
+    pages.map(page => MatchResult(1, page, getIndicesOfSearchLetters(page.shortName, search)))
+      .filter(_.indices.nonEmpty)
+
+  private def getIndicesOfSearchLetters(pageName: String, search: String): Set[Int] =
+    @tailrec
+    def getIndicesAcc(nameIndex: Int, searchIndex: Int, acc: Set[Int]): Set[Int] =
+      if nameIndex >= pageName.length then
+        Set.empty
+      else if searchIndex >= search.length then
+        acc
+      else if pageName(nameIndex) == search(searchIndex) then
+        containsAllAcc(nameIndex + 1, searchIndex + 1, acc + nameIndex)
+      else
+        containsAllAcc(nameIndex + 1, searchIndex, acc)
+    getIndicesAcc(0, 0)
+
+  }

scaladoc-js/main/src/searchbar/engine/QueryParser.scala

@@ -29,6 +29,6 @@ class QueryParser:
   }
 
   def parse(query: String): EngineQuery = query match {
-    case signatureRegex(signature) => BySignature(signature)
-    case other => EngineMatchersQuery(parseMatchers(other))
+    case signatureRegex(signature) => SignatureQuery(signature)
+    case other => NameAndKindQuery(parseMatchers(other))
   }

scaladoc-js/main/src/searchbar/engine/SearchbarEngine.scala

@@ -28,8 +28,8 @@ class QueryParserTest:
 
   @Test
   def queryParserTests() = {
-    kinds.foreach(k => testCase(s"$k ", EngineMatchersQuery(List(ByKind(k), ByName("")))))
-    testCase("trait", EngineMatchersQuery(List(ByName("trait"))))
-    testCase("trait A", EngineMatchersQuery(List(ByKind("trait"), ByName("A"))))
-    testCase("`trait A`", EngineMatchersQuery(List(ByName("trait A"))))
+    kinds.foreach(k => testCase(s"$k ", NameAndKindQuery(List(ByKind(k), ByName("")))))
+    testCase("trait", NameAndKindQuery(List(ByName("trait"))))
+    testCase("trait A", NameAndKindQuery(List(ByKind("trait"), ByName("A"))))
+    testCase("`trait A`", NameAndKindQuery(List(ByName("trait A"))))
   }