MAX_LEN

Author: epompeii

lib/bencher_valid/src/benchmark_name.rs

@@ -13,7 +13,7 @@ use serde::{
 use crate::ValidError;
 
 // In practice, this may need to be raised all the way up to 4096.
-pub(crate) const MAX_BENCHMARK_NAME_LEN: usize = 1024;
+const MAX_BENCHMARK_NAME_LEN: usize = 1024;
 
 const BENCHER_IGNORE_SNAKE_CASE: &str = "_bencher_ignore";
 const BENCHER_IGNORE_PASCAL_CASE: &str = "BencherIgnore";
@@ -30,18 +30,18 @@ pub struct BenchmarkName(String);
 crate::typed_string!(BenchmarkName);
 
 impl BenchmarkName {
+    pub const MAX_LEN: usize = MAX_BENCHMARK_NAME_LEN;
+
     pub fn try_push(&mut self, separator: char, other: &Self) -> Result<(), ValidError> {
-        let remaining_capacity = MAX_BENCHMARK_NAME_LEN
-            .checked_sub(self.0.len())
-            .unwrap_or_default();
+        let remaining_capacity = Self::MAX_LEN.checked_sub(self.0.len()).unwrap_or_default();
         if other.0.len() < remaining_capacity {
             self.0.push(separator);
             self.0.push_str(other.as_ref());
             debug_assert!(
-                self.0.len() <= MAX_BENCHMARK_NAME_LEN,
+                self.0.len() <= Self::MAX_LEN,
                 "Benchmark name length is {} but should be <= {}",
                 self.0.len(),
-                MAX_BENCHMARK_NAME_LEN
+                Self::MAX_LEN
             );
             Ok(())
         } else {
@@ -122,7 +122,7 @@ mod test {
 
     use crate::BenchmarkName;
 
-    use super::{is_valid_benchmark_name, MAX_BENCHMARK_NAME_LEN};
+    use super::is_valid_benchmark_name;
     use pretty_assertions::assert_eq;
 
     #[test]
@@ -142,8 +142,8 @@ mod test {
         let benchmark_name_len = benchmark_name.0.len();
         assert_eq!(benchmark_name_len, 10);
 
-        let other_benchmark_name_bytes: [u8; MAX_BENCHMARK_NAME_LEN - 11] =
-            [0; MAX_BENCHMARK_NAME_LEN - 11];
+        let other_benchmark_name_bytes: [u8; BenchmarkName::MAX_LEN - 11] =
+            [0; BenchmarkName::MAX_LEN - 11];
         let other_benchmark_name: BenchmarkName = std::str::from_utf8(&other_benchmark_name_bytes)
             .unwrap()
             .parse()
@@ -153,11 +153,11 @@ mod test {
         // 10 + 1 + 1013 = 1024
         assert_eq!(
             benchmark_name_len + 1 + other_benchmark_name_len,
-            MAX_BENCHMARK_NAME_LEN
+            BenchmarkName::MAX_LEN
         );
 
         benchmark_name.try_push('.', &other_benchmark_name).unwrap();
-        assert_eq!(benchmark_name.0.len(), MAX_BENCHMARK_NAME_LEN);
+        assert_eq!(benchmark_name.0.len(), BenchmarkName::MAX_LEN);
         is_valid_benchmark_name(&benchmark_name.0);
         assert_eq!(other_benchmark_name_len, other_benchmark_name.0.len());
     }
@@ -168,8 +168,8 @@ mod test {
         let benchmark_name_len = benchmark_name.0.len();
         assert_eq!(benchmark_name_len, 10);
 
-        let other_benchmark_name_bytes: [u8; MAX_BENCHMARK_NAME_LEN - 10] =
-            [0; MAX_BENCHMARK_NAME_LEN - 10];
+        let other_benchmark_name_bytes: [u8; BenchmarkName::MAX_LEN - 10] =
+            [0; BenchmarkName::MAX_LEN - 10];
         let other_benchmark_name: BenchmarkName = std::str::from_utf8(&other_benchmark_name_bytes)
             .unwrap()
             .parse()
@@ -179,7 +179,7 @@ mod test {
         // 10 + 1 + 1014 = 1025
         assert_eq!(
             benchmark_name_len + 1 + other_benchmark_name_len,
-            MAX_BENCHMARK_NAME_LEN + 1
+            BenchmarkName::MAX_LEN + 1
         );
 
         assert!(benchmark_name.try_push('.', &other_benchmark_name).is_err());

lib/bencher_valid/src/branch_name.rs

@@ -14,7 +14,7 @@ use serde::{
 use crate::{Slug, ValidError};
 
 // https://stackoverflow.com/questions/60045157/what-is-the-maximum-length-of-a-github-branch-name
-pub(crate) const MAX_BRANCH_LEN: usize = 256;
+const MAX_BRANCH_LEN: usize = 256;
 
 #[typeshare::typeshare]
 #[derive(Debug, Display, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize)]
@@ -82,6 +82,10 @@ impl Visitor<'_> for BranchNameVisitor {
     }
 }
 
+impl BranchName {
+    pub const MAX_LEN: usize = MAX_BRANCH_LEN;
+}
+
 #[cfg_attr(feature = "wasm", wasm_bindgen)]
 pub fn is_valid_branch_name(branch_name: &str) -> bool {
     branch_name.len() <= MAX_BRANCH_LEN && name_partial(branch_name.into()).is_ok()

lib/bencher_valid/src/lib.rs

@@ -60,7 +60,7 @@ pub use secret::Secret;
 pub use units::{Units, BYTES, NANOSECONDS, SECONDS};
 pub use user_name::UserName;
 
-pub const MAX_LEN: usize = 64;
+const MAX_LEN: usize = 64;
 
 #[cfg(feature = "wasm")]
 #[wasm_bindgen(start)]

lib/bencher_valid/src/name_id.rs

@@ -126,3 +126,7 @@ impl Visitor<'_> for NameIdVisitor {
         NameId::from_str(v).map_err(|_e| E::invalid_value(Unexpected::Str(v), &self))
     }
 }
+
+impl NameId {
+    pub const MAX_LEN: usize = crate::MAX_LEN;
+}

lib/bencher_valid/src/non_empty.rs

@@ -78,6 +78,10 @@ impl Visitor<'_> for NonEmptyVisitor {
     }
 }
 
+impl NonEmpty {
+    pub const MAX_LEN: usize = crate::MAX_LEN;
+}
+
 #[cfg_attr(feature = "wasm", wasm_bindgen)]
 pub fn is_valid_non_empty(non_empty: &str) -> bool {
     crate::is_valid_non_empty(non_empty)

lib/bencher_valid/src/resource_id.rs

@@ -98,3 +98,7 @@ impl Visitor<'_> for ResourceIdVisitor {
         ResourceId::from_str(v).map_err(|_e| E::invalid_value(Unexpected::Str(v), &self))
     }
 }
+
+impl ResourceId {
+    pub const MAX_LEN: usize = crate::MAX_LEN;
+}

lib/bencher_valid/src/resource_name.rs

@@ -84,6 +84,10 @@ impl Visitor<'_> for ResourceNameVisitor {
     }
 }
 
+impl ResourceName {
+    pub const MAX_LEN: usize = crate::MAX_LEN;
+}
+
 #[cfg_attr(feature = "wasm", wasm_bindgen)]
 pub fn is_valid_resource_name(resource_name: &str) -> bool {
     is_valid_len(resource_name)

lib/bencher_valid/src/slug.rs

@@ -87,7 +87,8 @@ pub fn new_slug(slug: &str) -> String {
 }
 
 impl Slug {
-    pub const MAX: usize = MAX_LEN;
+    pub const MAX_LEN: usize = MAX_LEN;
+
     #[cfg(feature = "server")]
     const RAND_LEN: usize = 8;
 
@@ -96,8 +97,8 @@ impl Slug {
         S: AsRef<str>,
     {
         let new_slug = slug::slugify(&slug);
-        Self(if new_slug.len() > Self::MAX {
-            slug::slugify(new_slug.split_at(Slug::MAX).0)
+        Self(if new_slug.len() > Self::MAX_LEN {
+            slug::slugify(new_slug.chars().take(Self::MAX_LEN).collect::<String>())
         } else {
             new_slug
         })
@@ -136,9 +137,9 @@ impl Slug {
     #[cfg(feature = "server")]
     #[must_use]
     pub fn with_rand_suffix(self) -> Self {
-        let truncated = if self.as_ref().len() + 1 + Self::RAND_LEN > Self::MAX {
-            let mid = Self::MAX - (1 + Self::RAND_LEN);
-            slug::slugify(self.as_ref().split_at(mid).0)
+        let truncated = if self.as_ref().len() + 1 + Self::RAND_LEN > Self::MAX_LEN {
+            let mid = Self::MAX_LEN - (1 + Self::RAND_LEN);
+            slug::slugify(self.as_ref().chars().take(mid).collect::<String>())
         } else {
             self.0
         };

lib/bencher_valid/src/user_name.rs

@@ -82,6 +82,10 @@ impl Visitor<'_> for UserNameVisitor {
     }
 }
 
+impl UserName {
+    pub const MAX_LEN: usize = crate::MAX_LEN;
+}
+
 #[cfg_attr(feature = "wasm", wasm_bindgen)]
 pub fn is_valid_user_name(name: &str) -> bool {
     if !is_valid_len(name) {