Group contents

Author: josevalim

src/hexdocs/components/iframe.gleam

@@ -55,7 +55,7 @@ fn init(_) {
 }
 
 fn update(model: Model, msg: Msg) -> #(Model, Effect(msg)) {
-  case echo msg {
+  case msg {
     UserChangedTitle(title) -> #(Model(..model, title:), effect.none())
     IFrameStateChanged(state) -> #(Model(..model, state:), effect.none())
     UserChangedTo(to) -> #(

src/hexdocs/services/hexdocs.gleam

@@ -22,9 +22,14 @@ pub type Document {
     ref: String,
     title: String,
     type_: String,
+    headers: List(Header),
   )
 }
 
+pub type Header {
+  Header(ref: String, title: String)
+}
+
 pub fn packages() {
   let endpoint = endpoints.packages()
   let assert Ok(request) = request.from_uri(endpoint)
@@ -58,13 +63,91 @@ pub fn typesense_decoder() {
         use ref <- decode.field("ref", decode.string)
         use title <- decode.field("title", decode.string)
         use type_ <- decode.field("type", decode.string)
-        Document(doc:, id:, package:, proglang:, ref:, title:, type_:)
+        Document(
+          doc:,
+          id:,
+          package:,
+          proglang:,
+          ref:,
+          title:,
+          type_:,
+          headers: [],
+        )
         |> decode.success
       })
       decode.success(document)
     })
   })
-  decode.success(#(found, hits))
+  let grouped_results = group_headers(hits)
+  let removed_count = list.length(hits) - list.length(grouped_results)
+  let max_results = list.take(grouped_results, config.per_page())
+  decode.success(#(found - removed_count, max_results))
+}
+
+fn group_headers(documents: List(Document)) -> List(Document) {
+  // Convert to indexed tuples
+  let indexed_docs = list.index_map(documents, fn(doc, index) { #(index, doc) })
+
+  // First pass: separate parents and children with their indexes
+  let #(parents, children) =
+    list.partition(indexed_docs, fn(indexed_doc) {
+      let #(_index, doc) = indexed_doc
+      !list.any(indexed_docs, fn(other_indexed) {
+        let #(_other_index, other) = other_indexed
+        string.starts_with(doc.ref, other.ref <> "-")
+        && doc.package == other.package
+        && doc.id != other.id
+      })
+    })
+
+  // Second pass: attach children to parents and compute min index
+  let grouped_with_index =
+    list.map(parents, fn(parent_indexed) {
+      let #(parent_index, parent) = parent_indexed
+
+      let matching_headers =
+        list.filter_map(children, fn(child_indexed) {
+          let #(_child_index, child) = child_indexed
+          case
+            string.starts_with(child.ref, parent.ref <> "-")
+            && child.package == parent.package
+          {
+            True -> {
+              let cleaned_title =
+                string.replace(child.title, " - " <> parent.title, "")
+              Ok(#(child_indexed, Header(ref: child.ref, title: cleaned_title)))
+            }
+            False -> Error(Nil)
+          }
+        })
+
+      let child_indexes =
+        list.map(matching_headers, fn(header_data) {
+          let #(#(child_index, _child), _header) = header_data
+          child_index
+        })
+
+      let min_index = list.fold(child_indexes, parent_index, int.min)
+      let headers =
+        list.map(matching_headers, fn(header_data) {
+          let #(_child_indexed, header) = header_data
+          header
+        })
+
+      #(min_index, Document(..parent, headers: headers))
+    })
+
+  // Sort by index and return documents
+  grouped_with_index
+  |> list.sort(fn(a, b) {
+    let #(index_a, _doc_a) = a
+    let #(index_b, _doc_b) = b
+    int.compare(index_a, index_b)
+  })
+  |> list.map(fn(indexed_doc) {
+    let #(_index, doc) = indexed_doc
+    doc
+  })
 }
 
 fn new_search_query_params(
@@ -77,7 +160,8 @@ fn new_search_query_params(
   |> list.key_set("query_by", "title,doc,type")
   |> list.key_set("query_by_weights", "3,1,1")
   |> list.key_set("page", int.to_string(page))
-  |> list.key_set("per_page", int.to_string(config.per_page()))
+  // We multiply per 2 because we group results
+  |> list.key_set("per_page", int.to_string(config.per_page() * 2))
   |> list.key_set("highlight_fields", "none")
   |> add_filter_by_packages_param(packages)
   |> uri.query_to_string

src/hexdocs/view/search.gleam

@@ -495,6 +495,45 @@ fn result_card(model: Model, document: hexdocs.Document) {
       [class("text-slate-800 dark:text-slate-300 leading-normal mt-2")],
       hexdocs.snippet(document.doc, model.search_input),
     ),
+    case list.is_empty(document.headers) {
+      True -> element.none()
+      False ->
+        html.div([class("mt-4 space-y-3")], [
+          html.h4(
+            [class("text-slate-600 dark:text-slate-400 text-sm font-medium")],
+            [html.text("Related sections:")],
+          ),
+          html.ul([class("space-y-1")], {
+            list.map(document.headers, fn(header: hexdocs.Header) {
+              let header_display_url =
+                "/"
+                <> string.replace(document.package, "-", "/")
+                <> "/"
+                <> header.ref
+              let header_link_url = config.hexdocs_url() <> header_display_url
+
+              html.li(
+                [
+                  class(
+                    "list-disc list-inside text-slate-400 dark:text-slate-500",
+                  ),
+                ],
+                [
+                  html.a(
+                    [
+                      attribute.href(header_link_url),
+                      class(
+                        "text-blue-600 dark:text-blue-400 text-sm hover:underline",
+                      ),
+                    ],
+                    [html.text(header.title)],
+                  ),
+                ],
+              )
+            })
+          }),
+        ])
+    },
     html.div([class("mt-4 flex flex-wrap gap-3")], [
       html.button(
         [