add a macro to generate enums from pg integers

Author: pietroalbini

src/lib.rs

@@ -50,6 +50,7 @@ pub mod schema;
 pub mod tasks;
 mod test_util;
 pub mod uploaders;
+#[macro_use]
 pub mod util;
 
 pub mod controllers;

src/models/action.rs

@@ -1,23 +1,14 @@
-use chrono::NaiveDateTime;
-use diesel::prelude::*;
-use diesel::{
-    deserialize::{self, FromSql},
-    pg::Pg,
-    serialize::{self, Output, ToSql},
-    sql_types::Integer,
-};
-use std::io::Write;
-
 use crate::models::{ApiToken, User, Version};
 use crate::schema::*;
+use chrono::NaiveDateTime;
+use diesel::prelude::*;
 
-#[derive(Debug, Clone, Copy, PartialEq, FromSqlRow, AsExpression)]
-#[repr(i32)]
-#[sql_type = "Integer"]
-pub enum VersionAction {
-    Publish = 0,
-    Yank = 1,
-    Unyank = 2,
+pg_enum! {
+    pub enum VersionAction {
+        Publish = 0,
+        Yank = 1,
+        Unyank = 2,
+    }
 }
 
 impl From<VersionAction> for &'static str {
@@ -38,23 +29,6 @@ impl From<VersionAction> for String {
     }
 }
 
-impl FromSql<Integer, Pg> for VersionAction {
-    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
-        match <i32 as FromSql<Integer, Pg>>::from_sql(bytes)? {
-            0 => Ok(VersionAction::Publish),
-            1 => Ok(VersionAction::Yank),
-            2 => Ok(VersionAction::Unyank),
-            n => Err(format!("unknown version action: {}", n).into()),
-        }
-    }
-}
-
-impl ToSql<Integer, Pg> for VersionAction {
-    fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> serialize::Result {
-        ToSql::<Integer, Pg>::to_sql(&(*self as i32), out)
-    }
-}
-
 #[derive(Debug, Clone, Copy, Queryable, Identifiable, Associations)]
 #[belongs_to(Version)]
 #[belongs_to(User, foreign_key = "user_id")]

src/models/dependency.rs

@@ -1,7 +1,3 @@
-use diesel::deserialize::{self, FromSql};
-use diesel::pg::Pg;
-use diesel::sql_types::Integer;
-
 use crate::models::{Crate, Version};
 use crate::schema::*;
 
@@ -32,23 +28,10 @@ pub struct ReverseDependency {
     pub name: String,
 }
 
-#[derive(Copy, Clone, Serialize, Deserialize, Debug, FromSqlRow)]
-#[serde(rename_all = "lowercase")]
-#[repr(u32)]
-pub enum DependencyKind {
-    Normal = 0,
-    Build = 1,
-    Dev = 2,
-    // if you add a kind here, be sure to update `from_row` below.
-}
-
-impl FromSql<Integer, Pg> for DependencyKind {
-    fn from_sql(bytes: Option<&[u8]>) -> deserialize::Result<Self> {
-        match <i32 as FromSql<Integer, Pg>>::from_sql(bytes)? {
-            0 => Ok(DependencyKind::Normal),
-            1 => Ok(DependencyKind::Build),
-            2 => Ok(DependencyKind::Dev),
-            n => Err(format!("unknown kind: {}", n).into()),
-        }
+pg_enum! {
+    pub enum DependencyKind {
+        Normal = 0,
+        Build = 1,
+        Dev = 2,
     }
 }

src/util.rs

@@ -53,3 +53,38 @@ impl Maximums {
         }
     }
 }
+
+#[macro_export]
+macro_rules! pg_enum {
+    (
+        $vis:vis enum $name:ident {
+            $($item:ident = $int:expr,)*
+        }
+    ) => {
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, FromSqlRow, AsExpression)]
+        #[sql_type = "diesel::sql_types::Integer"]
+        #[serde(rename_all = "snake_case")]
+        #[repr(i32)]
+        $vis enum $name {
+            $($item = $int,)*
+        }
+
+        impl diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::pg::Pg> for $name {
+            fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
+                match <i32 as diesel::deserialize::FromSql<diesel::sql_types::Integer, diesel::pg::Pg>>::from_sql(bytes)? {
+                    $($int => Ok(Self::$item),)*
+                    n => Err(format!("unknown value: {}", n).into()),
+                }
+            }
+        }
+
+        impl diesel::serialize::ToSql<diesel::sql_types::Integer, diesel::pg::Pg> for $name {
+            fn to_sql<W: std::io::Write>(
+                &self,
+                out: &mut diesel::serialize::Output<'_, W, diesel::pg::Pg>,
+            ) -> diesel::serialize::Result {
+                diesel::serialize::ToSql::<diesel::sql_types::Integer, diesel::pg::Pg>::to_sql(&(*self as i32), out)
+            }
+        }
+    }
+}