Merge remote-tracking branch 'upstream/master'

attr/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormlite-attr"
-version = "0.17.1"
+version = "0.17.3"
 edition = "2021"
 description = "See `ormlite`."
 authors = ["Kurt Wolf <[email protected]>"]

attr/src/lib.rs

@@ -7,8 +7,8 @@ mod ext;
 mod syndecode;
 
 use std::collections::HashMap;
-use std::fs;
-use std::path::Path;
+use std::{env, fs};
+use std::path::{Path, PathBuf};
 use anyhow::Context;
 use syn::{DeriveInput, Item};
 use ignore::Walk;
@@ -58,19 +58,20 @@ impl Intermediate {
                 Item::Struct(s) => {
                     let attrs = Attributes2::from(s.attrs.as_slice());
                     if attrs.has_derive("Model") {
-                        tracing::debug!(model=s.ident.to_string(), "Found");
+                        tracing::debug!(model=%s.ident.to_string(), "Found");
                         model_structs.push((s, attrs));
                     } else if attrs.has_derive("Type") {
-                        tracing::debug!(r#type=s.ident.to_string(), "Found");
+                        tracing::debug!(r#type=%s.ident.to_string(), "Found");
                         type_structs.push((s, attrs));
                     } else if attrs.has_derive("ManualType") {
-                        tracing::debug!(r#type=s.ident.to_string(), "Found");
+                        tracing::debug!(r#type=%s.ident.to_string(), "Found");
                         type_structs.push((s, attrs));
                     }
                 }
                 Item::Enum(e) => {
                     let attrs = Attributes2::from(e.attrs.as_slice());
                     if attrs.has_derive("Type") || attrs.has_derive("ManualType") {
+                        tracing::debug!(r#type=%e.ident.to_string(), "Found");
                         type_enums.push((e, attrs));
                     }
                 }
@@ -86,12 +87,16 @@ impl Intermediate {
 }
 
 pub fn schema_from_filepaths(paths: &[&Path]) -> anyhow::Result<OrmliteSchema> {
+    let cwd = env::var("PWD").unwrap_or_default();
+    let cwd = PathBuf::from(cwd);
+    let paths = paths.iter().map(|p| cwd.join(p)).collect::<Vec<_>>();
     let invalid_paths = paths.iter().filter(|p| fs::metadata(p).is_err()).collect::<Vec<_>>();
     if !invalid_paths.is_empty() {
-        for path in invalid_paths {
+        for path in &invalid_paths {
             tracing::error!(path=path.display().to_string(), "Does not exist");
         }
-        anyhow::bail!("Provided paths that did not exist.");
+        let paths = invalid_paths.iter().map(|p| p.display().to_string()).collect::<Vec<_>>().join(", ");
+        anyhow::bail!("Provided paths that did not exist: {}", paths);
     }
 
     let walk = paths.iter().flat_map(Walk::new);
@@ -111,7 +116,7 @@ pub fn schema_from_filepaths(paths: &[&Path]) -> anyhow::Result<OrmliteSchema> {
         let contents = fs::read_to_string(&entry)
             .context(format!("failed to read file: {}", entry.display()))?;
         tracing::debug!(file=entry.display().to_string(), "Checking for Model, Type, ManualType derive attrs");
-        if !contents.contains("Model") {
+        if !(contents.contains("Model") || contents.contains("Type") || contents.contains("ManualType")) {
             continue;
         }
         let ast = syn::parse_file(&contents)

attr/src/syndecode.rs

@@ -1,4 +1,4 @@
-use proc_macro2::{TokenStream};
+use proc_macro2::{TokenStream, TokenTree};
 use syn::Meta;
 
 #[derive(Debug)]
@@ -26,8 +26,6 @@ impl Attributes2 {
 }
 
 fn decode_traits_from_derive_tokens(derives: &mut Derives, tokens: &TokenStream) {
-    use proc_macro2::TokenTree;
-
     let mut iter = tokens.clone().into_iter().peekable();
 
     while let Some(tok) = iter.next() {
@@ -51,6 +49,12 @@ fn decode_traits_from_derive_tokens(derives: &mut Derives, tokens: &TokenStream)
                     }
                     _ = iter.next(); // consume the colon
                     _ = iter.next(); // consume another colon
+                    let p = iter.peek();
+                    if matches!(p, Some(TokenTree::Ident(i)) if i.to_string() == "types") {
+                        _ = iter.next(); // consume the type
+                        _ = iter.next(); // consume a colon
+                        _ = iter.next(); // consume another colon
+                    }
                     continue;
                 } else {
                     panic!("Unexpected token in derive attribute: {:?}", p);
@@ -78,6 +82,20 @@ impl From<&[syn::Attribute]> for Attributes2 {
                     } else if ident == "repr" {
                         let ident = l.tokens.clone().into_iter().next().expect("Encountered a repr attribute without an argument.");
                         repr = Some(ident.to_string());
+                    } else if ident == "cfg_attr" {
+                        let mut iter = l.tokens.clone().into_iter().skip_while(|tok| !matches!(tok, TokenTree::Punct(p) if p.as_char() == ','));
+                        iter.next(); // skip the ,
+                        while let Some(tok) = iter.next() {
+                            match tok {
+                                TokenTree::Ident(i) => {
+                                    if i.to_string() == "derive" {
+                                        let Some(TokenTree::Group(toks)) = iter.next() else { panic!("Expected a token group after derive") };
+                                        decode_traits_from_derive_tokens(&mut derives, &toks.stream());
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
                     }
                 }
                 _ => {}
@@ -130,6 +148,70 @@ pub struct QuerySet {
         assert_eq!(attr.derives.is_model, true);
         assert_eq!(attr.derives.is_type, true);
         assert_eq!(attr.derives.is_manual_type, false);
+    }
+
+    #[test]
+    fn test_cfg_attr() {
+        // the doc string is the regression test
+        let code = r#"
+#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
+#[cfg_attr(
+    target_arch = "wasm32",
+    derive(tsify::Tsify),
+    tsify(into_wasm_abi, from_wasm_abi)
+)]
+#[cfg_attr(
+    not(target_arch = "wasm32"),
+    derive(
+        sqlx::Type,
+        strum::IntoStaticStr,
+        strum::EnumString,
+    ),
+    strum(serialize_all = "snake_case")
+)]
+#[serde(rename_all = "snake_case")]
+pub enum Privacy {
+    Private,
+    Team,
+    Public,
+}
+"#;
+        let file: syn::File = syn::parse_str(code).unwrap();
+        let syn::Item::Enum(item) = file.items.first().unwrap() else { panic!() };
+        let attr = Attributes2::from(item.attrs.as_slice());
+        assert_eq!(attr.repr, None);
+        assert_eq!(attr.derives.is_model, false);
+        assert_eq!(attr.derives.is_type, true);
+        assert_eq!(attr.derives.is_manual_type, false);
+    }
 
+    #[test]
+    fn test_cfg_attr2() {
+        let code = r#"
+#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
+#[cfg_attr(
+    target_arch = "wasm32",
+    derive(tsify::Tsify),
+    tsify(into_wasm_abi, from_wasm_abi)
+)]
+#[cfg_attr(
+    not(target_arch = "wasm32"),
+    derive(ormlite::types::ManualType, strum::IntoStaticStr, strum::EnumString),
+    strum(serialize_all = "snake_case")
+)]
+#[serde(rename_all = "snake_case")]
+pub enum Privacy {
+    Private,
+    Team,
+    Public,
+}
+"#;
+        let file: syn::File = syn::parse_str(code).unwrap();
+        let syn::Item::Enum(item) = file.items.first().unwrap() else { panic!() };
+        let attr = Attributes2::from(item.attrs.as_slice());
+        assert_eq!(attr.repr, None);
+        assert_eq!(attr.derives.is_model, false);
+        assert_eq!(attr.derives.is_type, false);
+        assert_eq!(attr.derives.is_manual_type, true);
     }
 }

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormlite-cli"
-version = "0.17.1"
+version = "0.17.3"
 edition = "2021"
 description = "An ORM for people who love SQL. Use the `ormlite` crate, not this one."
 authors = ["Kurt Wolf <[email protected]>"]

cli/src/command/migrate.rs

@@ -244,9 +244,9 @@ impl Migrate {
         file_name.push_str(&self.name);
         let migration_body = migration.as_ref().map(|m| {
             m.statements.iter()
-                .map(|s| s.to_sql(Dialect::Postgres))
+                .map(|s| s.to_sql(Dialect::Postgres) + ";")
                 .collect::<Vec<_>>()
-                .join(";\n")
+                .join("\n")
         }).unwrap_or_default();
         if self.reversible {
             create_migration(&folder, file_name.clone(), MigrationType::Up, &migration_body)?;
@@ -261,9 +261,10 @@ impl Migrate {
                 println!("It auto-generated the following actions:");
                 for statement in &migration.statements {
                     match statement {
-                        Statement::CreateTable(t) => println!("Create table {} with columns: {}", &t.name, t.columns.iter().map(|c| c.name.to_string()).collect::<Vec<_>>().join(", ")),
+                        Statement::CreateTable(s) => println!("Create table {} with columns: {}", &s.name, s.columns.iter().map(|c| c.name.to_string()).collect::<Vec<_>>().join(", ")),
                         Statement::CreateIndex(s) => println!("Create index {} on {}", &s.name, &s.table),
                         Statement::AlterTable(s) => println!("Alter table {}", &s.name),
+                        Statement::Update(s) => println!("Update table {}", &s.table),
                     }
                 }
             }

core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormlite-core"
-version = "0.17.1"
+version = "0.17.3"
 edition = "2021"
 description = "An ORM for people who love SQL. Use the `ormlite` crate, not this one."
 authors = ["Kurt Wolf <[email protected]>"]

macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormlite-macro"
-version = "0.17.1"
+version = "0.17.3"
 edition = "2021"
 description = "An ORM for people who love SQL. Use the `ormlite` crate, not this one."
 authors = ["Kurt Wolf <[email protected]>"]
@@ -24,7 +24,7 @@ default-mysql = ["mysql"]
 syn = { version = "2", features = ["derive", "parsing"] }
 quote = "1"
 proc-macro2 = "1"
-ormlite-core = { path = "../core", version = "0.17.1"}
+ormlite-core = { path = "../core", version = "0.17.3"}
 ormlite-attr = { path = "../attr", version = "0.17" }
 sqlx = "0.7"
 lazy_static = "1"

ormlite/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ormlite"
-version = "0.17.1"
+version = "0.17.3"
 edition = "2021"
 authors = ["Kurt Wolf <[email protected]>"]
 description = "An ORM for people who love SQL"
@@ -49,8 +49,8 @@ default-mysql = ["mysql", "ormlite-macro/default-mysql"]
 [dependencies]
 sqlx = { version = "0.7" }
 tokio = { version = "1.24.1", features = ["full"] }
-ormlite-macro = { path = "../macro" , version = "0.17.1"}
-ormlite-core = { path = "../core" , version = "0.17.1"}
+ormlite-macro = { path = "../macro" , version = "0.17.3"}
+ormlite-core = { path = "../core" , version = "0.17.3"}
 sqlx-core = "0.7"
 sqlmo = "0.16"
 tokio-stream = "0.1.14"