ok_slug

Author: epompeii

lib/bencher_json/src/organization/mod.rs

@@ -9,7 +9,7 @@ use serde::{
     de::{self, Visitor},
 };
 
-use crate::{ProjectSlug, UserUuid};
+use crate::{ProjectSlug, UserSlug, UserUuid};
 
 pub mod claim;
 pub mod member;
@@ -23,7 +23,7 @@ crate::typed_slug::typed_slug!(OrganizationSlug, ResourceName);
 #[typeshare::typeshare]
 pub type OrganizationResourceId = ResourceId<OrganizationUuid, OrganizationSlug>;
 
-// Create a personal organization for a user.
+// Create an organization for a user.
 impl From<UserUuid> for OrganizationUuid {
     fn from(uuid: UserUuid) -> Self {
         uuid::Uuid::from(uuid).into()
@@ -37,6 +37,13 @@ impl From<ProjectSlug> for OrganizationSlug {
     }
 }
 
+/// Create an organization for a user.
+impl From<UserSlug> for OrganizationSlug {
+    fn from(slug: UserSlug) -> Self {
+        Self(slug.into())
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[cfg_attr(feature = "schema", derive(JsonSchema))]
 pub struct JsonNewOrganization {

lib/bencher_schema/src/macros/slug.rs

@@ -4,22 +4,25 @@ use crate::{context::DbConnection, model::project::ProjectId};
 
 pub type SlugExistsFn = dyn FnOnce(&mut DbConnection, Option<ProjectId>, &str) -> bool;
 
-pub fn validate_slug<S>(
+pub fn validate_slug<N, S>(
     conn: &mut DbConnection,
     project_id: Option<ProjectId>,
-    name: S,
-    slug: Option<Slug>,
+    name: N,
+    slug: Option<S>,
     exists: Box<SlugExistsFn>,
-) -> Slug
+) -> S
 where
-    S: AsRef<str> + std::fmt::Display,
+    N: AsRef<str> + std::fmt::Display,
+    S: Into<Slug> + From<Slug>,
 {
+    let slug = slug.map(Into::into);
     let new_slug = Slug::unwrap_or_new(name, slug);
     if exists(conn, project_id, new_slug.as_ref()) {
         new_slug.with_rand_suffix()
     } else {
         new_slug
     }
+    .into()
 }
 
 macro_rules! ok_slug {

lib/bencher_schema/src/model/organization/mod.rs

@@ -356,14 +356,8 @@ impl InsertOrganization {
 
     pub fn from_json(conn: &mut DbConnection, organization: JsonNewOrganization) -> Self {
         let JsonNewOrganization { name, slug } = organization;
-        let slug = ok_slug!(
-            conn,
-            &name,
-            slug.map(Into::into),
-            organization,
-            QueryOrganization
-        );
-        Self::new(name, slug.into())
+        let slug = ok_slug!(conn, &name, slug, organization, QueryOrganization);
+        Self::new(name, slug)
     }
 
     pub fn from_user(conn: &mut DbConnection, query_user: &QueryUser) -> Self {
@@ -378,7 +372,7 @@ impl InsertOrganization {
             QueryOrganization
         );
         // The user's organization should be created with the user's UUID.
-        Self::new_inner(query_user.uuid.into(), name.into(), slug.into())
+        Self::new_inner(query_user.uuid.into(), name.into(), slug)
     }
 }
 

lib/bencher_schema/src/model/project/benchmark.rs

@@ -168,20 +168,13 @@ impl InsertBenchmark {
         benchmark: JsonNewBenchmark,
     ) -> Self {
         let JsonNewBenchmark { name, slug } = benchmark;
-        let slug = ok_slug!(
-            conn,
-            project_id,
-            &name,
-            slug.map(Into::into),
-            benchmark,
-            QueryBenchmark
-        );
+        let slug = ok_slug!(conn, project_id, &name, slug, benchmark, QueryBenchmark);
         let timestamp = DateTime::now();
         Self {
             uuid: BenchmarkUuid::new(),
             project_id,
             name,
-            slug: slug.into(),
+            slug,
             created: timestamp,
             modified: timestamp,
             archived: None,

lib/bencher_schema/src/model/project/branch/mod.rs

@@ -403,20 +403,13 @@ impl InsertBranch {
         name: BranchName,
         slug: Option<BranchSlug>,
     ) -> Self {
-        let slug = ok_slug!(
-            conn,
-            project_id,
-            &name,
-            slug.map(Into::into),
-            branch,
-            QueryBranch
-        );
+        let slug = ok_slug!(conn, project_id, &name, slug, branch, QueryBranch);
         let timestamp = DateTime::now();
         Self {
             uuid: BranchUuid::new(),
             project_id,
             name,
-            slug: slug.into(),
+            slug,
             head_id: None,
             created: timestamp,
             modified: timestamp,

lib/bencher_schema/src/model/project/measure.rs

@@ -254,20 +254,13 @@ impl InsertMeasure {
 
     fn from_json(conn: &mut DbConnection, project_id: ProjectId, measure: JsonNewMeasure) -> Self {
         let JsonNewMeasure { name, slug, units } = measure;
-        let slug = ok_slug!(
-            conn,
-            project_id,
-            &name,
-            slug.map(Into::into),
-            measure,
-            QueryMeasure
-        );
+        let slug = ok_slug!(conn, project_id, &name, slug, measure, QueryMeasure);
         let timestamp = DateTime::now();
         Self {
             uuid: MeasureUuid::new(),
             project_id,
             name,
-            slug: slug.into(),
+            slug,
             units,
             created: timestamp,
             modified: timestamp,

lib/bencher_schema/src/model/project/mod.rs

@@ -591,8 +591,8 @@ impl InsertProject {
             url,
             visibility,
         } = project;
-        let slug = ok_slug!(conn, &name, slug.map(Into::into), project, QueryProject);
-        Self::new(organization.id, name, slug.into(), url, visibility)
+        let slug = ok_slug!(conn, &name, slug, project, QueryProject);
+        Self::new(organization.id, name, slug, url, visibility)
     }
 
     fn from_organization(

lib/bencher_schema/src/model/project/testbed.rs

@@ -156,20 +156,13 @@ impl InsertTestbed {
 
     fn from_json(conn: &mut DbConnection, project_id: ProjectId, testbed: JsonNewTestbed) -> Self {
         let JsonNewTestbed { name, slug } = testbed;
-        let slug = ok_slug!(
-            conn,
-            project_id,
-            &name,
-            slug.map(Into::into),
-            testbed,
-            QueryTestbed
-        );
+        let slug = ok_slug!(conn, project_id, &name, slug, testbed, QueryTestbed);
         let timestamp = DateTime::now();
         Self {
             uuid: TestbedUuid::new(),
             project_id,
             name,
-            slug: slug.into(),
+            slug,
             created: timestamp,
             modified: timestamp,
             archived: None,

lib/bencher_schema/src/model/user/mod.rs

@@ -189,12 +189,12 @@ impl InsertUser {
         slug: Option<UserSlug>,
         email: Email,
     ) -> Self {
-        let slug = ok_slug!(conn, &name, slug.map(Into::into), user, QueryUser);
+        let slug = ok_slug!(conn, &name, slug, user, QueryUser);
         let timestamp = DateTime::now();
         Self {
             uuid: UserUuid::new(),
             name,
-            slug: slug.into(),
+            slug,
             email,
             admin: false,
             locked: false,