Optimize and fix some bugs in indexing (#98)

* Improve curseforge and local indexing

This should make curseforge indexing more efficient, and reuses
some of the normal local indexing for the queued indexing of
recently created mods.

* Unify impls for single and multiple routes for mods and versions

This uses the same backend for the single and multiple query
routes so that they no longer return inconsistent information.

* Cache valid curseforge mod ids to reduce request load

This caches the ids of minecraft mods and reuses them on indexing
to reduce the amount of unused addons that are returned.

src/search/indexing/mod.rs

@@ -18,7 +18,7 @@ pub enum IndexingError {
     #[error("Error while connecting to the MeiliSearch database")]
     IndexDBError(#[from] meilisearch_sdk::errors::Error),
     #[error("Error while importing mods from CurseForge")]
-    CurseforgeImportError(reqwest::Error),
+    CurseforgeImportError(#[from] reqwest::Error),
     #[error("Error while serializing or deserializing JSON: {0}")]
     SerDeError(#[from] serde_json::Error),
     #[error("Error while parsing a timestamp: {0}")]
@@ -63,6 +63,8 @@ pub async fn index_mods(
 ) -> Result<(), IndexingError> {
     let mut docs_to_add: Vec<UploadSearchMod> = vec![];
 
+    let cache_path = std::path::PathBuf::from(std::env::var_os("INDEX_CACHE_PATH").unwrap());
+
     if settings.index_local {
         docs_to_add.append(&mut index_local(pool.clone()).await?);
     }
@@ -72,7 +74,7 @@ pub async fn index_mods(
             .map(|i| i.parse().unwrap())
             .unwrap_or(450_000);
 
-        docs_to_add.append(&mut index_curseforge(1, end_index).await?);
+        docs_to_add.append(&mut index_curseforge(1, end_index, &cache_path).await?);
     }
 
     // Write Indices
@@ -284,3 +286,60 @@ fn default_settings() -> Settings {
 }
 
 //endregion
+
+// This shouldn't be relied on for proper sorting, but it makes an
+// attempt at getting proper sorting for mojang's versions.
+// This isn't currenly used, but I wrote it and it works, so I'm
+// keeping this mess in case someone needs it in the future.
+#[allow(dead_code)]
+pub fn sort_mods(a: &str, b: &str) -> std::cmp::Ordering {
+    use std::cmp::Ordering;
+
+    let cmp = a.contains('.').cmp(&b.contains('.'));
+    if cmp != Ordering::Equal {
+        return cmp;
+    }
+    let mut a = a.split(&['.', '-'] as &[char]);
+    let mut b = b.split(&['.', '-'] as &[char]);
+    let a = (a.next(), a.next(), a.next(), a.next());
+    let b = (b.next(), b.next(), b.next(), b.next());
+    if a.0 == b.0 {
+        let cmp =
+            a.1.map(|s| s.chars().all(|c| c.is_ascii_digit()))
+                .cmp(&b.1.map(|s| s.chars().all(|c| c.is_ascii_digit())));
+        if cmp != Ordering::Equal {
+            return cmp;
+        }
+        if a.1 == b.1 {
+            let cmp =
+                a.2.map(|s| s.chars().all(|c| c.is_ascii_digit()))
+                    .unwrap_or(true)
+                    .cmp(
+                        &b.2.map(|s| s.chars().all(|c| c.is_ascii_digit()))
+                            .unwrap_or(true),
+                    );
+            if cmp != Ordering::Equal {
+                return cmp;
+            }
+            if a.2 == b.2 {
+                match (a.3.is_some(), b.3.is_some()) {
+                    (false, false) => Ordering::Equal,
+                    (false, true) => Ordering::Greater,
+                    (true, false) => Ordering::Less,
+                    (true, true) => a.3.cmp(&b.3),
+                }
+            } else {
+                a.2.cmp(&b.2)
+            }
+        } else {
+            a.1.cmp(&b.1)
+        }
+    } else {
+        match (a.0 == Some("1"), b.0 == Some("1")) {
+            (false, false) => a.0.cmp(&b.0),
+            (true, false) => Ordering::Greater,
+            (false, true) => Ordering::Less,
+            (true, true) => Ordering::Equal, // unreachable
+        }
+    }
+}