context_server

Author: epompeii

Cargo.lock

@@ -8,10 +8,12 @@ publish = false
 
 [features]
 client = ["dep:gix", "dep:uuid", "dep:windows"]
+server = ["bencher_valid/server"]
 schema = ["dep:schemars"]
 
 [dependencies]
 # Workspace
+bencher_valid = { workspace = true, optional = true }
 gix = { workspace = true, optional = true, features = ["revision"] }
 schemars = { workspace = true, optional = true }
 serde.workspace = true

lib/bencher_context/Cargo.toml

@@ -6,6 +6,8 @@ use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "client")]
 mod client;
+#[cfg(feature = "server")]
+mod server;
 
 #[cfg(feature = "client")]
 pub use client::Fingerprint;
@@ -15,39 +17,6 @@ pub use client::Fingerprint;
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
 pub struct ReportContext(pub HashMap<String, String>);
 
-#[allow(clippy::multiple_inherent_impl)]
-impl ReportContext {
-    pub fn repo_name(&self) -> Option<&str> {
-        self.0.get(ContextPath::REPO_NAME).map(String::as_str)
-    }
-
-    pub fn repo_hash(&self) -> Option<&str> {
-        self.0.get(ContextPath::REPO_HASH).map(String::as_str)
-    }
-
-    pub fn branch_ref(&self) -> Option<&str> {
-        self.0.get(ContextPath::BRANCH_REF).map(String::as_str)
-    }
-
-    pub fn branch_ref_name(&self) -> Option<&str> {
-        self.0.get(ContextPath::BRANCH_REF_NAME).map(String::as_str)
-    }
-
-    pub fn branch_hash(&self) -> Option<&str> {
-        self.0.get(ContextPath::BRANCH_HASH).map(String::as_str)
-    }
-
-    pub fn testbed_os(&self) -> Option<&str> {
-        self.0.get(ContextPath::TESTBED_OS).map(String::as_str)
-    }
-
-    pub fn testbed_fingerprint(&self) -> Option<&str> {
-        self.0
-            .get(ContextPath::TESTBED_FINGERPRINT)
-            .map(String::as_str)
-    }
-}
-
 struct ContextPath;
 
 impl ContextPath {

lib/bencher_context/src/lib.rs

@@ -0,0 +1,63 @@
+use bencher_valid::BASE_36;
+
+const BASE: u128 = 36;
+const MAX_CHUNK_SIZE: usize = 16;
+
+pub fn encode_base36(input: &str) -> String {
+    let mut result = String::new();
+    let chars = BASE_36.chars().collect::<Vec<_>>();
+
+    for chunk in input.as_bytes().chunks(MAX_CHUNK_SIZE) {
+        let mut num = chunk.iter().fold(0u128, |acc, &c| {
+            acc * (u128::from(u8::MAX) + 1) + u128::from(c)
+        });
+
+        while num > 0 {
+            let remainder = (num % BASE) as usize;
+            if let Some(c) = chars.get(remainder) {
+                result.push(*c);
+            }
+            num /= BASE;
+        }
+    }
+
+    result.chars().rev().collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_encode_base36_empty() {
+        assert_eq!(encode_base36(""), "");
+    }
+
+    #[test]
+    fn test_encode_base36_single_char() {
+        assert_eq!(encode_base36("a"), "2p");
+    }
+
+    #[test]
+    fn test_encode_base36_hello_world() {
+        assert_eq!(encode_base36("Hello, World!"), "fg3h7vqw7een6jwwnzmp");
+    }
+
+    #[test]
+    fn test_encode_base36_max_chunk_size() {
+        let max_length_string = "a".repeat(MAX_CHUNK_SIZE);
+        assert_eq!(
+            encode_base36(&max_length_string),
+            "5rjn2eqj5uddxxihjq3vmi99d"
+        );
+    }
+
+    #[test]
+    fn test_encode_base36_double() {
+        let max_length_string = "a".repeat(MAX_CHUNK_SIZE * 2);
+        assert_eq!(
+            encode_base36(&max_length_string),
+            "5rjn2eqj5uddxxihjq3vmi99d5rjn2eqj5uddxxihjq3vmi99d"
+        );
+    }
+}

lib/bencher_context/src/server/base_36.rs

@@ -0,0 +1,45 @@
+use bencher_valid::Slug;
+
+use crate::{ContextPath, ReportContext};
+
+mod base_36;
+
+#[allow(clippy::multiple_inherent_impl)]
+impl ReportContext {
+    pub fn slug(&self) -> Slug {
+        let name = self.repo_name();
+        let hash = self.repo_hash();
+
+        todo!()
+    }
+
+    pub fn repo_name(&self) -> Option<&str> {
+        self.0.get(ContextPath::REPO_NAME).map(String::as_str)
+    }
+
+    pub fn repo_hash(&self) -> Option<&str> {
+        self.0.get(ContextPath::REPO_HASH).map(String::as_str)
+    }
+
+    pub fn branch_ref(&self) -> Option<&str> {
+        self.0.get(ContextPath::BRANCH_REF).map(String::as_str)
+    }
+
+    pub fn branch_ref_name(&self) -> Option<&str> {
+        self.0.get(ContextPath::BRANCH_REF_NAME).map(String::as_str)
+    }
+
+    pub fn branch_hash(&self) -> Option<&str> {
+        self.0.get(ContextPath::BRANCH_HASH).map(String::as_str)
+    }
+
+    pub fn testbed_os(&self) -> Option<&str> {
+        self.0.get(ContextPath::TESTBED_OS).map(String::as_str)
+    }
+
+    pub fn testbed_fingerprint(&self) -> Option<&str> {
+        self.0
+            .get(ContextPath::TESTBED_FINGERPRINT)
+            .map(String::as_str)
+    }
+}

lib/bencher_context/src/server/mod.rs

@@ -9,7 +9,7 @@ publish = false
 [features]
 client = ["bencher_context/client", "bencher_valid/client"]
 table = ["dep:tabled"]
-server = ["bencher_valid/server"]
+server = ["bencher_context/server", "bencher_valid/server"]
 schema = ["dep:schemars", "bencher_context/schema", "ordered-float/schemars"]
 db = ["dep:diesel", "dep:serde_yaml", "bencher_valid/db"]
 plus = ["bencher_valid/plus"]

lib/bencher_json/Cargo.toml

@@ -28,6 +28,8 @@ mod user_name;
 
 pub use crate::git_hash::GitHash;
 pub use crate::slug::Slug;
+#[cfg(feature = "server")]
+pub use crate::slug::BASE_36;
 pub use crate::url::Url;
 pub use benchmark_name::BenchmarkName;
 pub use branch_name::BranchName;

lib/bencher_valid/src/lib.rs

@@ -12,6 +12,9 @@ use serde::{
 
 use crate::{is_valid_len, ValidError, MAX_LEN};
 
+#[cfg(feature = "server")]
+pub const BASE_36: &str = "0123456789abcdefghijklmnopqrstuvwxyz";
+
 #[typeshare::typeshare]
 #[derive(Debug, Display, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
@@ -115,7 +118,7 @@ impl Slug {
     pub fn rand_suffix() -> String {
         use rand::Rng;
 
-        const CHARSET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
+        const CHARSET: &[u8] = BASE_36.as_bytes();
         let mut rng = rand::rng();
 
         (0..Self::RAND_LEN)