refactor(code): move "default_impl" code to "Struct::render"

And add test for it

Author: hasezoey

src/code.rs

@@ -228,7 +228,7 @@ impl<'a> Struct<'a> {
                     derives_vec.push(derives::PARTIALEQ);
                 }
 
-                /*if !self.config.options.default_impl*/ {
+                if !self.config.options.default_impl {
                     derives_vec.push(derives::DEFAULT);
                 }
             }
@@ -299,7 +299,7 @@ impl<'a> Struct<'a> {
             .collect::<Vec<String>>()
             .join(" ");
 
-        let fields = self.fields();
+        let mut fields = self.fields();
 
         if fields.is_empty() {
             self.has_fields = Some(false);
@@ -332,18 +332,18 @@ impl<'a> Struct<'a> {
         };
 
         let mut lines = Vec::with_capacity(fields.len());
-        for mut f in fields.into_iter() {
+        for f in fields.iter_mut() {
             let field_name = &f.name;
 
             if f.base_type == "String" {
                 f.base_type = match self.ty {
-                    StructType::Read => f.base_type,
+                    StructType::Read => f.base_type.clone(),
                     StructType::Update => self.opts.get_update_str_type().as_str().to_string(),
                     StructType::Create => self.opts.get_create_str_type().as_str().to_string(),
                 }
             } else if f.base_type == "Vec<u8>" {
                 f.base_type = match self.ty {
-                    StructType::Read => f.base_type,
+                    StructType::Read => f.base_type.clone(),
                     StructType::Update => self.opts.get_update_bytes_type().as_str().to_string(),
                     StructType::Create => self.opts.get_create_bytes_type().as_str().to_string(),
                 }
@@ -382,7 +382,7 @@ impl<'a> Struct<'a> {
             ),
         };
 
-        let struct_code = formatdoc!(
+        let mut struct_code = formatdoc!(
             r#"
             {doccomment}
             {tsync_attr}{derive_attr}
@@ -409,6 +409,14 @@ impl<'a> Struct<'a> {
             lines = lines.join("\n"),
         );
 
+        if self.config.options.default_impl {
+            struct_code.push('\n');
+            struct_code.push_str(&build_default_impl_fn(
+                &ty.format(&table.struct_name),
+                &fields,
+            ));
+        }
+
         self.has_fields = Some(true);
         self.rendered_code = Some(struct_code);
     }
@@ -784,51 +792,40 @@ fn default_for_type(typ: &str) -> &'static str {
     }
 }
 
-struct NameTypNullable<'a> {
-    name: String,
-    typ: &'a str,
-    nullable: bool,
-}
-
 /// Generate default (insides of the `impl Default for StructName { fn default() -> Self {} }`)
-fn build_default_impl_fn<'a>(
-    struct_name: &str,
-    column_name_type_nullable: impl Iterator<Item = NameTypNullable<'a>>,
-) -> String {
-    let fields_to_defaults = column_name_type_nullable
+fn build_default_impl_fn<'a>(struct_name: &str, fields: &[StructField]) -> String {
+    let fields: Vec<String> = fields
+        .iter()
         .map(|name_typ_nullable| {
             format!(
-                "        {name}: {typ_default}",
+                "{name}: {typ_default},",
                 name = name_typ_nullable.name,
-                typ_default = if name_typ_nullable.nullable {
+                typ_default = if name_typ_nullable.is_optional {
                     "None"
                 } else {
-                    default_for_type(name_typ_nullable.typ)
+                    default_for_type(&name_typ_nullable.base_type)
                 }
             )
         })
-        .collect::<Vec<String>>()
-        .join(",\n");
+        .collect();
     formatdoc!(
-        r#"impl Default for {struct_name} {{
-  fn default() -> Self {{
-    Self {{
-{fields_to_defaults}
-    }}
-  }}
-}}"#
+        r#"
+        impl Default for {struct_name} {{
+            fn default() -> Self {{
+                Self {{
+                    {fields}
+                }}
+            }}
+        }}
+        "#,
+        fields = fields.join("\n            ")
     )
 }
 
 /// Generate a full file for a given diesel table
 pub fn generate_for_table(table: &ParsedTableMacro, config: &GenerationConfig) -> String {
     // early to ensure the table options are set for the current table
-    let struct_name = &table.struct_name;
     let table_options = config.table(&table.name.to_string());
-    let generated_columns = table_options.get_autogenerated_columns();
-    let not_generated = |col: &&ParsedColumnMacro| -> bool {
-        !generated_columns.contains(&col.column_name.as_str())
-    };
 
     let mut ret_buffer = format!("{FILE_SIGNATURE}\n\n");
 
@@ -844,51 +841,13 @@ pub fn generate_for_table(table: &ParsedTableMacro, config: &GenerationConfig) -
     if create_struct.has_code() {
         ret_buffer.push('\n');
         ret_buffer.push_str(create_struct.code());
-        if config.options.default_impl {
-            ret_buffer.push('\n');
-            ret_buffer.push_str(
-                build_default_impl_fn(
-                    &StructType::format(&StructType::Create, &struct_name),
-                    create_struct
-                        .table
-                        .columns
-                        .iter()
-                        .filter(not_generated)
-                        .map(|col| NameTypNullable {
-                            name: col.column_name.to_string(),
-                            typ: col.ty.as_str(),
-                            nullable: col.is_nullable,
-                        }),
-                )
-                .as_str(),
-            );
-        }
     }
 
     let update_struct = Struct::new(StructType::Update, table, config);
 
     if update_struct.has_code() {
         ret_buffer.push('\n');
         ret_buffer.push_str(update_struct.code());
-        /*if config.options.default_impl {
-            ret_buffer.push('\n');
-            ret_buffer.push_str(
-                build_default_impl_fn(
-                    &StructType::format(&StructType::Update, &struct_name),
-                    update_struct
-                        .table
-                        .columns
-                        .iter()
-                        .filter(not_generated)
-                        .map(|col| NameTypNullable {
-                            name: col.column_name.to_string(),
-                            typ: col.ty.as_str(),
-                            nullable: col.is_nullable,
-                        }),
-                )
-                .as_str(),
-            );
-        }*/
     }
 
     // third, push functions - if enabled
@@ -897,20 +856,5 @@ pub fn generate_for_table(table: &ParsedTableMacro, config: &GenerationConfig) -
         ret_buffer.push_str(build_table_fns(table, config, create_struct, update_struct).as_str());
     }
 
-    if config.options.default_impl {
-        ret_buffer.push('\n');
-        ret_buffer.push_str(
-            build_default_impl_fn(
-                &struct_name,
-                table.columns.iter().map(|col| NameTypNullable {
-                    name: col.name.to_string().to_owned(),
-                    typ: col.ty.as_str(),
-                    nullable: col.is_nullable,
-                }),
-            )
-            .as_str(),
-        );
-    }
-
     ret_buffer
 }

test/default_impl/Cargo.toml

@@ -0,0 +1,18 @@
+[lib]
+path = "lib.rs"
+
+[package]
+name = "default_impl"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+diesel = { version = "*", default-features = false, features = [
+    "sqlite",
+    "r2d2",
+    "chrono",
+    "returning_clauses_for_sqlite_3_35",
+] }
+r2d2.workspace = true
+chrono.workspace = true
+serde.workspace = true

test/default_impl/lib.rs

@@ -0,0 +1,6 @@
+pub mod models;
+pub mod schema;
+
+pub mod diesel {
+    pub use diesel::*;
+}

test/default_impl/models/mod.rs

@@ -0,0 +1 @@
+pub mod todos;

test/default_impl/models/todos/generated.rs

@@ -0,0 +1,151 @@
+/* @generated and managed by dsync */
+
+#[allow(unused)]
+use crate::diesel::*;
+use crate::schema::*;
+
+pub type ConnectionType = diesel::r2d2::PooledConnection<diesel::r2d2::ConnectionManager<diesel::sqlite::SqliteConnection>>;
+
+/// Struct representing a row in table `todos`
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, diesel::Queryable, diesel::Selectable, diesel::QueryableByName, PartialEq, diesel::Identifiable)]
+#[diesel(table_name=todos, primary_key(id))]
+pub struct Todos {
+    /// Field representing column `id`
+    pub id: i32,
+    /// Field representing column `text`
+    pub text: String,
+    /// Field representing column `completed`
+    pub completed: bool,
+    /// Field representing column `type`
+    pub type_: String,
+    /// Field representing column `smallint`
+    pub smallint: i16,
+    /// Field representing column `bigint`
+    pub bigint: i64,
+    /// Field representing column `created_at`
+    pub created_at: chrono::NaiveDateTime,
+    /// Field representing column `updated_at`
+    pub updated_at: chrono::NaiveDateTime,
+}
+
+impl Default for Todos {
+    fn default() -> Self {
+        Self {
+            id: 0,
+            text: String::new(),
+            completed: false,
+            type_: String::new(),
+            smallint: 0,
+            bigint: 0,
+            created_at: Default::default(),
+            updated_at: Default::default(),
+        }
+    }
+}
+
+/// Create Struct for a row in table `todos` for [`Todos`]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, diesel::Insertable)]
+#[diesel(table_name=todos)]
+pub struct CreateTodos {
+    /// Field representing column `text`
+    pub text: String,
+    /// Field representing column `completed`
+    pub completed: bool,
+    /// Field representing column `type`
+    pub type_: String,
+    /// Field representing column `smallint`
+    pub smallint: i16,
+    /// Field representing column `bigint`
+    pub bigint: i64,
+}
+
+impl Default for CreateTodos {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            completed: false,
+            type_: String::new(),
+            smallint: 0,
+            bigint: 0,
+        }
+    }
+}
+
+/// Update Struct for a row in table `todos` for [`Todos`]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, diesel::AsChangeset, PartialEq)]
+#[diesel(table_name=todos)]
+pub struct UpdateTodos {
+    /// Field representing column `text`
+    pub text: Option<String>,
+    /// Field representing column `completed`
+    pub completed: Option<bool>,
+    /// Field representing column `type`
+    pub type_: Option<String>,
+    /// Field representing column `smallint`
+    pub smallint: Option<i16>,
+    /// Field representing column `bigint`
+    pub bigint: Option<i64>,
+    /// Field representing column `created_at`
+    pub created_at: Option<chrono::NaiveDateTime>,
+    /// Field representing column `updated_at`
+    pub updated_at: Option<chrono::NaiveDateTime>,
+}
+
+impl Default for UpdateTodos {
+    fn default() -> Self {
+        Self {
+            text: String::new(),
+            completed: false,
+            type_: String::new(),
+            smallint: 0,
+            bigint: 0,
+            created_at: Default::default(),
+            updated_at: Default::default(),
+        }
+    }
+}
+
+/// Result of a `.paginate` function
+#[derive(Debug, serde::Serialize)]
+pub struct PaginationResult<T> {
+    /// Resulting items that are from the current page
+    pub items: Vec<T>,
+    /// The count of total items there are
+    pub total_items: i64,
+    /// Current page, 0-based index
+    pub page: i64,
+    /// Size of a page
+    pub page_size: i64,
+    /// Number of total possible pages, given the `page_size` and `total_items`
+    pub num_pages: i64,
+}
+
+impl Todos {
+    /// Insert a new row into `todos` with a given [`CreateTodos`]
+    pub fn create(db: &mut ConnectionType, item: &CreateTodos) -> diesel::QueryResult<Self> {
+        use crate::schema::todos::dsl::*;
+
+        diesel::insert_into(todos).values(item).get_result::<Self>(db)
+    }
+
+    /// Get a row from `todos`, identified by the primary key
+    pub fn read(db: &mut ConnectionType, param_id: i32) -> diesel::QueryResult<Self> {
+        use crate::schema::todos::dsl::*;
+
+        todos.filter(id.eq(param_id)).first::<Self>(db)
+    }
+
+    /// Update a row in `todos`, identified by the primary key with [`UpdateTodos`]
+    pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> diesel::QueryResult<Self> {
+        use crate::schema::todos::dsl::*;
+
+        diesel::update(todos.filter(id.eq(param_id))).set(item).get_result(db)
+    }
+
+    /// Delete a row in `todos`, identified by the primary key
+    pub fn delete(db: &mut ConnectionType, param_id: i32) -> diesel::QueryResult<usize> {
+        use crate::schema::todos::dsl::*;
+
+        diesel::delete(todos.filter(id.eq(param_id))).execute(db)
+    }
+}

test/default_impl/models/todos/mod.rs

@@ -0,0 +1,2 @@
+pub use generated::*;
+pub mod generated;