Minimal intermediate cleanup

TheRustifyer · TheRustifyer · commit 51c81bb33cc7 · 2023-03-24T15:12:34.000+01:00
diff --git a/canyon_macros/src/lib.rs b/canyon_macros/src/lib.rs
@@ -260,9 +260,9 @@ pub fn canyon_entity(
     let mut new_entity = CanyonRegisterEntity::default();
     let e = Box::leak(entity.struct_name.to_string().into_boxed_str());
     new_entity.entity_name = e;
-    new_entity.entity_db_table_name = table_name.unwrap_or(
-        Box::leak(helpers::default_database_table_name_from_entity_name(e).into_boxed_str())
-    );
+    new_entity.entity_db_table_name = table_name.unwrap_or(Box::leak(
+        helpers::default_database_table_name_from_entity_name(e).into_boxed_str(),
+    ));
     new_entity.user_schema_name = schema_name;
 
     // The entity fields
diff --git a/canyon_macros/src/utils/helpers.rs b/canyon_macros/src/utils/helpers.rs
@@ -21,45 +21,40 @@ pub fn table_schema_parser(macro_data: &MacroTokens<'_>) -> Result<String, Token
             let name_values_result: Result<Punctuated<MetaNameValue, Token![,]>, syn::Error> =
                 attr.parse_args_with(Punctuated::parse_terminated);
 
-            match name_values_result {
-                Ok(meta_name_values) => {
-                    for nv in meta_name_values {
-                        let ident = nv.path.get_ident();
-                        if let Some(i) = ident {
-                            let identifier = i.to_string();
-                            match &nv.lit {
-                                syn::Lit::Str(s) => {
-                                    if identifier == "table_name" {
-                                        table_name = Some(s.value())
-                                    } else if identifier == "schema" {
-                                        schema = Some(s.value())
-                                    } else {
-                                        return Err(
-                                            syn::Error::new_spanned(
-                                                Ident::new(&identifier, i.span()),
-                                                "Only string literals are valid values for the attribute arguments"
-                                            ).into_compile_error()
-                                        );
-                                    }
-                                },
-                                _ =>
+            if let Ok(meta_name_values) = name_values_result {
+                for nv in meta_name_values {
+                    let ident = nv.path.get_ident();
+                    if let Some(i) = ident {
+                        let identifier = i;
+                        match &nv.lit {
+                            syn::Lit::Str(s) => {
+                                if identifier == "table_name" {
+                                    table_name = Some(s.value())
+                                } else if identifier == "schema" {
+                                    schema = Some(s.value())
+                                } else {
                                     return Err(
                                         syn::Error::new_spanned(
-                                        Ident::new(&identifier, i.span()),
-                                        "Only string literals are valid values for the attribute arguments"
+                                            Ident::new(&identifier.to_string(), i.span()),
+                                            "Only string literals are valid values for the attribute arguments"
                                         ).into_compile_error()
-                                    ),
+                                    );
+                                }
                             }
-                        } else {
-                            return Err(syn::Error::new(
-                                Span::call_site(),
+                            _ => return Err(syn::Error::new_spanned(
+                                Ident::new(&identifier.to_string(), i.span()),
                                 "Only string literals are valid values for the attribute arguments",
                             )
-                            .into_compile_error());
+                            .into_compile_error()),
                         }
+                    } else {
+                        return Err(syn::Error::new(
+                            Span::call_site(),
+                            "Only string literals are valid values for the attribute arguments",
+                        )
+                        .into_compile_error());
                     }
                 }
-                Err(_) => return Ok(macro_data.ty.to_string()),
             }
 
             let mut final_table_name = String::new();
@@ -70,7 +65,9 @@ pub fn table_schema_parser(macro_data: &MacroTokens<'_>) -> Result<String, Token
             if let Some(t_name) = table_name {
                 final_table_name.push_str(t_name.as_str())
             } else {
-                final_table_name.push_str(macro_data.ty.to_string().as_str())
+                let defaulted =
+                    &default_database_table_name_from_entity_name(&macro_data.ty.to_string());
+                final_table_name.push_str(defaulted)
             }
 
             return Ok(final_table_name);
diff --git a/canyon_observer/src/constants.rs b/canyon_observer/src/constants.rs
@@ -1,14 +1,13 @@
 pub const NUMERIC_PK_DATATYPE: [&str; 6] = ["i16", "u16", "i32", "u32", "i64", "u64"];
 
 pub mod queries {
-    pub const INSERT_INTO_CANYON_MEMORY: &str = 
+    pub const INSERT_INTO_CANYON_MEMORY: &str =
         "INSERT INTO canyon_memory (filepath, struct_name, declared_table_name) \
         VALUES ($1, $2, $3)";
-    pub const UPDATE_CANYON_MEMORY: &str = 
+    pub const UPDATE_CANYON_MEMORY: &str =
         "UPDATE canyon_memory SET filepath = $1, struct_name = $2, \
         declared_table_name = $3 WHERE id = $4";
-    pub const DELETE_FROM_CANYON_MEMORY: &str = 
-        "DELETE FROM canyon_memory WHERE struct_name = $1";
+    pub const DELETE_FROM_CANYON_MEMORY: &str = "DELETE FROM canyon_memory WHERE struct_name = $1";
 }
 
 pub mod postgresql_queries {
@@ -180,8 +179,8 @@ pub mod sqlserver_type {
 }
 
 pub mod mocked_data {
-    use canyon_connection::lazy_static::lazy_static;
     use crate::migrations::information_schema::{ColumnMetadata, TableMetadata};
+    use canyon_connection::lazy_static::lazy_static;
 
     lazy_static! {
         pub static ref TABLE_METADATA_LEAGUE_EX: TableMetadata = TableMetadata {
diff --git a/canyon_observer/src/lib.rs b/canyon_observer/src/lib.rs
@@ -25,27 +25,4 @@ pub static CANYON_REGISTER_ENTITIES: Mutex<Vec<CanyonRegisterEntity<'static>>> =
 lazy_static! {
     pub static ref QUERIES_TO_EXECUTE: Mutex<HashMap<&'static str, Vec<String>>> =
         Mutex::new(HashMap::new());
-    pub static ref CM_QUERIES_TO_EXECUTE: Mutex<HashMap<&'static str, Vec<(&'static str, Vec<String>)>>> = // TODO Provisional until we parameterize as well the migration queries
-        Mutex::new(HashMap::new());
 }
-
-// TODO replace the unwraps for the operator ? when the appropiated crate will be added
-pub fn add_cm_query_to_execute(stmt: &'static str, datasource_name: &'static str, params: Vec<String>) {
-    if CM_QUERIES_TO_EXECUTE
-        .lock()
-        .unwrap()
-        .contains_key(datasource_name)
-    {
-        CM_QUERIES_TO_EXECUTE
-            .lock()
-            .unwrap()
-            .get_mut(datasource_name)
-            .unwrap()
-            .push((stmt, params));
-    } else {
-        CM_QUERIES_TO_EXECUTE
-            .lock()
-            .unwrap()
-            .insert(datasource_name, vec![(stmt, params)]);
-    }
-}
diff --git a/canyon_observer/src/migrations/handler.rs b/canyon_observer/src/migrations/handler.rs
@@ -58,25 +58,29 @@ impl Migrations {
             let database_tables_schema_info = Self::map_rows(schema_status);
             // println!("DB tables: {:?}", &database_tables_schema_info);
 
-
             // We filter the tables from the schema that aren't Canyon entities
             let mut user_database_tables = vec![];
             for parsed_table in database_tables_schema_info.iter() {
                 if canyon_memory
                     .memory
                     .iter()
-                    .any(|f|
-                        f.declared_table_name.eq(&parsed_table.table_name)
-                    ) || canyon_memory
-                            .renamed_entities
-                            .values()
-                            .any(|f| *f == parsed_table.table_name)
+                    .any(|f| f.declared_table_name.eq(&parsed_table.table_name))
+                    || canyon_memory
+                        .renamed_entities
+                        .values()
+                        .any(|f| *f == parsed_table.table_name)
                 {
                     user_database_tables.append(&mut vec![parsed_table]);
                 }
             }
 
-            println!("Tables to process: {:?}", user_database_tables.iter().map(|t| &t.table_name).collect::<Vec<_>>());
+            println!(
+                "Tables to process: {:?}",
+                user_database_tables
+                    .iter()
+                    .map(|t| &t.table_name)
+                    .collect::<Vec<_>>()
+            );
 
             migrations_processor
                 .process(
diff --git a/canyon_observer/src/migrations/memory.rs b/canyon_observer/src/migrations/memory.rs
@@ -1,10 +1,10 @@
+use crate::constants;
 use canyon_crud::bounds::QueryParameter;
 use canyon_crud::{bounds::RowOperations, crud::Transaction, DatabaseType, DatasourceConfig};
 use regex::Regex;
 use std::collections::HashMap;
 use std::fs;
 use walkdir::WalkDir;
-use crate::constants;
 
 use super::register_types::CanyonRegisterEntity;
 
@@ -59,7 +59,10 @@ impl CanyonMemory {
     /// Queries the database to retrieve internal data about the structures
     /// tracked by `CanyonSQL`
     #[allow(clippy::nonminimal_bool)]
-    pub async fn remember(datasource: &DatasourceConfig<'static>, canyon_entities: &Vec<CanyonRegisterEntity<'_>>) -> Self {
+    pub async fn remember(
+        datasource: &DatasourceConfig<'static>,
+        canyon_entities: &Vec<CanyonRegisterEntity<'_>>,
+    ) -> Self {
         // Creates the memory table if not exists
         Self::create_memory(datasource.name, &datasource.properties.db_type).await;
 
@@ -81,7 +84,7 @@ impl CanyonMemory {
             };
             db_rows.push(db_row);
         }
-        println!("Data in the canyon_memory table: {db_rows:?}"); 
+        println!("Data in the canyon_memory table: {db_rows:?}");
 
         // Parses the source code files looking for the #[canyon_entity] annotated classes
         let mut mem = Self {
@@ -100,23 +103,25 @@ impl CanyonMemory {
             let already_in_db = db_rows.iter().any(|el| {
                 (el.filepath == _struct.filepath && el.struct_name == _struct.struct_name)
                     || ((el.filepath != _struct.filepath && el.struct_name == _struct.struct_name)
-                        || (el.filepath == _struct.filepath && el.struct_name != _struct.struct_name))
+                        || (el.filepath == _struct.filepath
+                            && el.struct_name != _struct.struct_name))
             });
             if !already_in_db {
-                    match CanyonMemory::query(
-                        constants::queries::INSERT_INTO_CANYON_MEMORY,
-                        &[
-                            &_struct.filepath as &dyn QueryParameter,
-                            &_struct.struct_name,
-                            &_struct.declared_table_name
-                        ],
-                        datasource.name
-                    ).await {
-                        Ok(v) => println!("Query insert CM OK: {v:?}"),
-                        Err(e) => println!("Error update CM: {e:?}")
-                    }
+                match CanyonMemory::query(
+                    constants::queries::INSERT_INTO_CANYON_MEMORY,
+                    [
+                        &_struct.filepath as &dyn QueryParameter,
+                        &_struct.struct_name,
+                        &_struct.declared_table_name,
+                    ],
+                    datasource.name,
+                )
+                .await
+                {
+                    Ok(v) => println!("Query insert CM OK: {v:?}"),
+                    Err(e) => println!("Error update CM: {e:?}"),
+                }
             }
-            
 
             // When the struct or the filepath it's already on db but one of the two has been modified
             let need_to_update = db_rows.iter().find(|el| {
@@ -130,33 +135,38 @@ impl CanyonMemory {
 
                 match CanyonMemory::query(
                     constants::queries::UPDATE_CANYON_MEMORY,
-                    &[
+                    [
                         &_struct.filepath as &dyn QueryParameter,
                         &_struct.struct_name,
                         &_struct.declared_table_name,
-                        &old.id
+                        &old.id,
                     ],
-                    datasource.name
-                ).await {
+                    datasource.name,
+                )
+                .await
+                {
                     Ok(v) => println!("Query update CM OK: {v:?}"),
-                    Err(e) => println!("Error update CM: {e:?}")
+                    Err(e) => println!("Error update CM: {e:?}"),
                 }
 
                 // if the updated element is the struct name, we add it to the table_rename Hashmap
                 let rename_table = old.struct_name != _struct.struct_name;
 
                 if rename_table {
                     mem.renamed_entities.insert(
-                        _struct.struct_name.to_string(),    // The new one
-                        old.struct_name.to_string(),        // The old one
+                        _struct.struct_name.to_string(), // The new one
+                        old.struct_name.to_string(),     // The old one
                     );
                 }
             }
         }
 
         // Deletes the records when a table is dropped on the previous Canyon run
         db_rows.into_iter().for_each(|db_row| {
-            if !mem.memory.iter().any(|entity| entity.struct_name == db_row.struct_name)
+            if !mem
+                .memory
+                .iter()
+                .any(|entity| entity.struct_name == db_row.struct_name)
                 && !updates.contains(&db_row.struct_name)
             {
                 // crate::add_cm_query_to_execute(stmt, datasource.name, &[&db_row.struct_name]);
@@ -167,7 +177,10 @@ impl CanyonMemory {
 
     /// Parses the Rust source code files to find the one who contains Canyon entities
     /// ie -> annotated with `#[canyon_entity]`
-    async fn find_canyon_entity_annotated_structs(&mut self, canyon_entities: &Vec<CanyonRegisterEntity<'_>>) {
+    async fn find_canyon_entity_annotated_structs(
+        &mut self,
+        canyon_entities: &[CanyonRegisterEntity<'_>],
+    ) {
         for file in WalkDir::new("./src")
             .into_iter()
             .filter_map(|file| file.ok())
@@ -185,7 +198,9 @@ impl CanyonMemory {
                     if line.contains("#[") // separated checks for possible different paths
                         && line.contains("canyon_entity")
                         && !line.starts_with("//")
-                    { canyon_entity_macro_counter += 1; }
+                    {
+                        canyon_entity_macro_counter += 1;
+                    }
 
                     let re = Regex::new(r#"\bstruct\s+(\w+)"#).unwrap();
                     if let Some(captures) = re.captures(line) {
@@ -198,15 +213,15 @@ impl CanyonMemory {
                 match canyon_entity_macro_counter {
                     0 => (),
                     1 => {
-                        let canyon_entity = canyon_entities.iter()
+                        let canyon_entity = canyon_entities
+                            .iter()
                             .find(|ce| ce.entity_name == struct_name);
                         if let Some(c_entity) = canyon_entity {
-                            self.memory.push(
-                                CanyonMemoryAnalyzer {
-                                    filepath: file.path().display().to_string().replace('\\', "/"),
-                                    struct_name: struct_name.clone(),
-                                    declared_table_name: c_entity.entity_db_table_name.to_string()                               }
-                            )
+                            self.memory.push(CanyonMemoryAnalyzer {
+                                filepath: file.path().display().to_string().replace('\\', "/"),
+                                struct_name: struct_name.clone(),
+                                declared_table_name: c_entity.entity_db_table_name.to_string(),
+                            })
                         }
                     }
                     _ => panic!(
@@ -224,7 +239,7 @@ impl CanyonMemory {
             constants::postgresql_queries::CANYON_MEMORY_TABLE
         } else {
             constants::mssql_queries::CANYON_MEMORY_TABLE
-        }; 
+        };
 
         Self::query(query, [], datasource_name)
             .await
@@ -238,13 +253,13 @@ struct CanyonMemoryRow<'a> {
     id: i32,
     filepath: &'a str,
     struct_name: &'a str,
-    declared_table_name: &'a str
+    declared_table_name: &'a str,
 }
 
 /// Represents the data that will be serialized in the `canyon_memory` table
 #[derive(Debug)]
 pub struct CanyonMemoryAnalyzer {
     pub filepath: String,
     pub struct_name: String,
-    pub declared_table_name: String
+    pub declared_table_name: String,
 }
diff --git a/canyon_observer/src/migrations/processor.rs b/canyon_observer/src/migrations/processor.rs
diff --git a/canyon_observer/src/migrations/register_types.rs b/canyon_observer/src/migrations/register_types.rs
