WIP

Author: josevalim

src/hexdocs.gleam

@@ -13,6 +13,7 @@ import grille_pain/lustre/toast
 import hexdocs/data/model.{type Model, Model}
 import hexdocs/data/model/autocomplete
 import hexdocs/data/model/route
+import hexdocs/data/model/version
 import hexdocs/data/msg.{type Msg}
 import hexdocs/effects
 import hexdocs/loss.{type Loss}
@@ -168,7 +169,7 @@ fn api_returned_initial_latest_packages(
   versions: Loss(List(hexpm.Package)),
 ) -> #(Model, Effect(a)) {
   case versions {
-    Error(_) -> #(model, toast.error("Server error. Retry later."))
+    Error(_) -> model.replace_search_packages(model)
     Ok(versions) ->
       model.add_packages_versions(model, versions)
       |> model.replace_search_packages
@@ -257,14 +258,7 @@ fn user_edited_packages_filter_version(model: Model, content: String) {
 }
 
 fn user_submitted_search_input(model: Model) {
-  #(model, {
-    route.push({
-      route.Search(
-        q: model.search_input,
-        packages: model.search_packages_filters,
-      )
-    })
-  })
+  model.push_search_packages(model)
 }
 
 fn user_focused_search(model: Model) {
@@ -301,17 +295,12 @@ fn user_clicked_autocomplete_package(model: Model, package: String) {
 
 fn user_deleted_packages_filter(
   model: Model,
-  filter: #(String, String),
+  filter: version.Package,
 ) -> #(Model, Effect(msg)) {
   let search_packages_filters =
     list.filter(model.search_packages_filters, fn(f) { f != filter })
-  let model = Model(..model, search_packages_filters:)
-  #(model, {
-    route.push(route.Search(
-      q: model.search_input,
-      packages: model.search_packages_filters,
-    ))
-  })
+  Model(..model, search_packages_filters:)
+  |> model.push_search_packages
 }
 
 fn user_clicked_go_back(model: Model) -> #(Model, Effect(msg)) {
@@ -327,21 +316,19 @@ fn user_submitted_packages_filter(model: Model) {
   |> result.try(list.find(_, fn(r) { r.version == version }))
   |> result.map(fn(_) {
     let search_packages_filters =
-      [#(package, version)]
+      [version.Package(name: package, version: version, resolved: True)]
       |> list.append(model.search_packages_filters, _)
       |> list.unique
-    let model =
-      Model(
-        ..model,
-        search_packages_filters:,
-        search_packages_filter_input: "",
-        search_packages_filter_input_displayed: "",
-        search_packages_filter_version_input: "",
-        search_packages_filter_version_input_displayed: "",
-      )
-    route.Search(q: model.search_input, packages: model.search_packages_filters)
-    |> route.push
-    |> pair.new(model, _)
+
+    Model(
+      ..model,
+      search_packages_filters:,
+      search_packages_filter_input: "",
+      search_packages_filter_input_displayed: "",
+      search_packages_filter_version_input: "",
+      search_packages_filter_version_input_displayed: "",
+    )
+    |> model.push_search_packages
   })
   |> result.lazy_unwrap(fn() { #(model, effect.none()) })
 }

src/hexdocs/data/model.gleam

@@ -71,7 +71,7 @@ pub type Model {
     search_packages_filter_version_input: String,
     search_packages_filter_version_input_displayed: String,
     /// Store the current set packages filters.
-    search_packages_filters: List(#(String, String)),
+    search_packages_filters: List(version.Package),
   )
 }
 
@@ -226,47 +226,60 @@ pub fn update_route(model: Model, route: uri.Uri) {
   case route {
     route.Home | route.NotFound -> #(model, effect.none())
     route.Search(q:, packages:) -> {
-      case string.is_empty(q) {
-        True -> #(set_search_results(model, #(-1, [])), effect.none())
-        False -> {
-          let latest = list.filter(packages, fn(p) { p.1 == "latest" })
-          Model(..model, search_input: q, search_packages_filters: packages)
-          |> pair.new({
-            case latest {
-              [] -> effects.typesense_search(q, packages)
-              latest -> {
-                latest
-                |> list.map(pair.first)
-                |> effects.initial_latest_packages
-              }
+      let packages = {
+        use #(package, version) <- list.map(packages)
+        use <- bool.guard(
+          when: version != "latest",
+          return: version.Package(package, version, resolved: True),
+        )
+        case dict.get(model.packages_versions, package) {
+          Error(_) -> version.Package(package, version, resolved: False)
+          Ok(versions) -> {
+            case versions.releases {
+              [] -> version.Package(package, version, resolved: False)
+              [release, ..] ->
+                version.Package(package, release.version, resolved: True)
             }
-          })
+          }
         }
       }
+
+      let latest = list.filter(packages, fn(p) { p.version == "latest" })
+
+      let model =
+        Model(..model, search_input: q, search_packages_filters: packages)
+
+      case latest {
+        [] ->
+          case string.is_empty(q) {
+            True ->
+              pair.new(set_search_results(model, #(-1, [])), effect.none())
+            False -> pair.new(model, effects.typesense_search(q, packages))
+          }
+
+        latest ->
+          pair.new(
+            model,
+            latest
+              |> list.map(fn(p) { p.name })
+              |> effects.initial_latest_packages,
+          )
+      }
     }
   }
 }
 
 pub fn replace_search_packages(model: Model) {
-  let model =
-    Model(..model, search_packages_filters: {
-      use #(package, version) <- list.map(model.search_packages_filters)
-      use <- bool.guard(when: version != "latest", return: #(package, version))
-      case dict.get(model.packages_versions, package) {
-        Error(_) -> #(package, version)
-        Ok(versions) -> {
-          case versions.releases {
-            [] -> #(package, version)
-            [release, ..] -> #(package, release.version)
-          }
-        }
-      }
-    })
-  route.Search(q: model.search_input, packages: model.search_packages_filters)
+  model
+  |> model_to_search
   |> route.replace
   |> pair.new(model, _)
 }
 
+pub fn push_search_packages(model: Model) {
+  #(model, route.push(model_to_search(model)))
+}
+
 pub fn select_autocomplete_option(model: Model, package: String) {
   case model.autocomplete, model.route {
     None, _ -> model
@@ -326,9 +339,9 @@ pub fn compute_filters_input(model: Model) -> #(Model, Effect(Msg)) {
   let search_input = keep_search_input_non_packages_text(model)
   case list.is_empty(packages_to_fetch) {
     True -> {
-      #(Model(..model, search_packages_filters: filters, search_input:), {
-        route.push(route.Search(q: search_input, packages: filters))
-      })
+      let model =
+        Model(..model, search_packages_filters: filters, search_input:)
+      push_search_packages(model)
     }
     False -> #(model, {
       use dispatch <- effect.from()
@@ -350,6 +363,15 @@ pub fn compute_filters_input(model: Model) -> #(Model, Effect(Msg)) {
   }
 }
 
+fn model_to_search(model: Model) {
+  route.Search(
+    q: model.search_input,
+    packages: list.map(model.search_packages_filters, fn(p) {
+      pair.new(p.name, p.version)
+    }),
+  )
+}
+
 /// Typical home search input will be something like `foo #phoenix #ecto:1.0.0`.
 /// `extract_packages_filters_or_fetches` will extract the `#ecto:1.0.0` part
 /// as a filter, and will return a side-effect to fetch `phoenix`, in order to
@@ -358,14 +380,21 @@ pub fn compute_filters_input(model: Model) -> #(Model, Effect(Msg)) {
 /// correct model and will reroute to the search page.
 fn extract_packages_filters_or_fetches(model: Model) {
   let segments = string.split(model.home_input_displayed, on: " ")
-  let search_packages_filters = list.filter_map(segments, version.match_package)
+  let search_packages_filters =
+    list.filter_map(segments, version.input_match_package)
   list.fold(search_packages_filters, #([], []), fn(acc, val) {
     let #(filters, packages_to_fetch) = acc
     let #(package, version) = val
     let is_existing_package = list.contains(model.packages, package)
     use <- bool.guard(when: !is_existing_package, return: acc)
     case version {
-      Some(version) -> #([#(package, version), ..filters], packages_to_fetch)
+      Some(version) -> #(
+        [
+          version.Package(name: package, version: version, resolved: True),
+          ..filters
+        ],
+        packages_to_fetch,
+      )
       None -> {
         case dict.get(model.packages_versions, package) {
           Error(_) -> #(filters, [package, ..packages_to_fetch])
@@ -374,8 +403,14 @@ fn extract_packages_filters_or_fetches(model: Model) {
               // That case is impossible, returning the neutral element.
               Error(_) -> #(filters, packages_to_fetch)
               Ok(release) -> {
-                let version = release.version
-                #([#(package, version), ..filters], packages_to_fetch)
+                let ver = release.version
+                #(
+                  [
+                    version.Package(name: package, version: ver, resolved: True),
+                    ..filters
+                  ],
+                  packages_to_fetch,
+                )
               }
             }
           }
@@ -391,7 +426,7 @@ fn extract_packages_filters_or_fetches(model: Model) {
 fn keep_search_input_non_packages_text(model: Model) -> String {
   let segments = string.split(model.home_input_displayed, on: " ")
   segments
-  |> list.filter(fn(s) { version.match_package(s) |> result.is_error })
+  |> list.filter(fn(s) { version.input_match_package(s) |> result.is_error })
   |> string.join(with: " ")
 }
 

src/hexdocs/data/model/route.gleam

@@ -4,7 +4,6 @@ import gleam/option.{None, Some}
 import gleam/result
 import gleam/string
 import gleam/uri.{type Uri}
-import hexdocs/data/model/version
 import modem
 
 pub type Route {
@@ -57,7 +56,7 @@ fn create_query(
   packages: List(#(String, String)),
 ) -> List(#(String, String)) {
   use <- bool.guard(when: list.is_empty(packages), return: query)
-  let packages = list.map(packages, version.to_string)
+  let packages = list.map(packages, fn(p) { p.0 <> ":" <> p.1 })
   let packages = string.join(packages, with: ",")
   list.append(query, [#("packages", packages)])
 }
@@ -75,10 +74,9 @@ fn search_from_uri(location: Uri) {
             |> result.unwrap("")
             |> string.split(on: ",")
             |> list.filter_map(fn(package) {
-              case version.match_package(package) {
-                Ok(#(package, Some(version))) -> Ok(#(package, version))
-                Ok(_) -> Error(Nil)
-                Error(Nil) -> Error(Nil)
+              case string.split(package, ":") {
+                [name, version] -> Ok(#(name, version))
+                _ -> Error(Nil)
               }
             })
           })

src/hexdocs/data/model/version.gleam

@@ -1,9 +1,16 @@
 import gleam/option.{type Option, None, Some}
 import gleam/regexp
 
-const version_regexp = "^#([a-zA-Z_0-9]+)(:((([0-9]+|\\.){1,5})|latest))?"
+const input_regexp = "^#(\\w+)(:([0-9]+\\.[\\w+.-]+))?"
 
-pub fn match_package(word: String) -> Result(#(String, Option(String)), Nil) {
+/// Represents a package filter with its name, version, and resolution status.
+pub type Package {
+  Package(name: String, version: String, resolved: Bool)
+}
+
+pub fn input_match_package(
+  word: String,
+) -> Result(#(String, Option(String)), Nil) {
   let regexp = version_search()
   case regexp.scan(regexp, word) {
     [regexp.Match(content: _, submatches:)] -> {
@@ -17,14 +24,13 @@ pub fn match_package(word: String) -> Result(#(String, Option(String)), Nil) {
   }
 }
 
-pub fn to_string(package: #(String, String)) {
-  let #(package, version) = package
-  let package = "#" <> package
-  package <> ":" <> version
+pub fn to_string(package: Package) {
+  let package_name = "#" <> package.name
+  package_name <> ":" <> package.version
 }
 
 fn version_search() {
   let options = regexp.Options(case_insensitive: False, multi_line: False)
-  let assert Ok(regexp) = regexp.compile(version_regexp, with: options)
+  let assert Ok(regexp) = regexp.compile(input_regexp, with: options)
   regexp
 }

src/hexdocs/data/msg.gleam

@@ -1,6 +1,7 @@
 import gleam/dynamic.{type Dynamic}
 import gleam/hexpm
 import gleam/uri
+import hexdocs/data/model/version
 import hexdocs/loss.{type Loss}
 
 pub type Msg {
@@ -32,7 +33,7 @@ pub type Msg {
   UserSubmittedAutocomplete
 
   // Search page messages.
-  UserDeletedPackagesFilter(#(String, String))
+  UserDeletedPackagesFilter(version.Package)
   UserEditedPackagesFilterInput(String)
   UserEditedPackagesFilterVersion(String)
   UserEditedSearchInput(search_input: String)

src/hexdocs/effects.gleam

@@ -4,6 +4,7 @@ import gleam/http/response.{type Response}
 import gleam/javascript/promise
 import gleam/list
 import gleam/result
+import hexdocs/data/model/version
 import hexdocs/data/msg
 import hexdocs/loss.{type Loss}
 import hexdocs/services/hex
@@ -54,7 +55,7 @@ pub fn subscribe_blurred_search() {
   |> dispatch
 }
 
-pub fn typesense_search(query: String, packages: List(#(String, String))) {
+pub fn typesense_search(query: String, packages: List(version.Package)) {
   use dispatch <- effect.from()
   use _ <- function.tap(Nil)
   use response <- promise.map(hexdocs.typesense_search(query, packages, 1))