Schema derive macro (reborn)

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "acceptance",
+    "derive-macros",
     "ffi",
     "kernel",
     "kernel/examples/dump-table", # todo: put back to `examples/*` when inspect-table is fixed

acceptance/src/meta.rs

@@ -87,7 +87,7 @@ impl TestCaseInfo {
             properties: metadata
                 .configuration
                 .iter()
-                .map(|(k, v)| (k.clone(), v.clone().unwrap()))
+                .map(|(k, v)| (k.clone(), v.clone()))
                 .collect(),
             min_reader_version: protocol.min_reader_version as u32,
             min_writer_version: protocol.min_writer_version as u32,

derive-macros/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "derive-macros"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+license.workspace = true
+repository.workspace = true
+readme.workspace = true
+version.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+syn = { version = "2.0", features = ["extra-traits"] }
+quote = "1.0"
+
+

derive-macros/src/lib.rs

@@ -0,0 +1,85 @@
+use proc_macro2::{Ident, TokenStream};
+use quote::{quote, quote_spanned};
+use syn::spanned::Spanned;
+use syn::{parse_macro_input, Data, DataStruct, DeriveInput, Fields, PathArguments, Type};
+
+/// Derive a `deltakernel::schemas::ToDataType` implementation for the annotated struct. The actual
+/// field names in the schema (and therefore of the struct members) are all mandated by the Delta
+/// spec, and so the user of this macro is responsible for ensuring that
+/// e.g. `Metadata::schema_string` is the snake_case-ified version of `schemaString` from [Delta's
+/// Change Metadata](https://github.com/delta-io/delta/blob/master/PROTOCOL.md#change-metadata)
+/// action (this macro allows the use of standard rust snake_case, and will convert to the correct
+/// delta schema camelCase version).
+#[proc_macro_derive(Schema)]
+pub fn derive_schema(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let struct_ident = input.ident;
+
+    let schema_fields = gen_schema_fields(&input.data);
+    let output = quote! {
+        #[automatically_derived]
+        impl crate::actions::schemas::ToDataType for #struct_ident {
+            fn to_data_type() -> crate::schema::DataType {
+                use crate::actions::schemas::{ToDataType, GetStructField};
+                crate::schema::StructType::new(vec![
+                    #schema_fields
+                ]).into()
+            }
+        }
+    };
+    proc_macro::TokenStream::from(output)
+}
+
+// turn our struct name into the schema name, goes from snake_case to camelCase
+fn get_schema_name(name: &Ident) -> Ident {
+    let snake_name = name.to_string();
+    let mut next_caps = false;
+    let ret: String = snake_name
+        .chars()
+        .filter_map(|c| {
+            if c == '_' {
+                next_caps = true;
+                None
+            } else if next_caps {
+                next_caps = false;
+                // This assumes we're using ascii, should be okay
+                Some(c.to_ascii_uppercase())
+            } else {
+                Some(c)
+            }
+        })
+        .collect();
+    Ident::new(&ret, name.span())
+}
+
+fn gen_schema_fields(data: &Data) -> TokenStream {
+    let fields = match data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("this derive macro only works on structs with named fields"),
+    };
+
+    let schema_fields = fields.iter().map(|field| {
+        let name = field.ident.as_ref().unwrap(); // we know these are named fields
+        let name = get_schema_name(name);
+        match field.ty {
+            Type::Path(ref type_path) => {
+                let type_path_quoted = type_path.path.segments.iter().map(|segment| {
+                    let segment_ident = &segment.ident;
+                    match &segment.arguments {
+                        PathArguments::None => quote! { #segment_ident :: },
+                        PathArguments::AngleBracketed(angle_args) => quote! { #segment_ident::#angle_args :: },
+                        _ => panic!("Can only handle <> type path args"),
+                    }
+                });
+                quote_spanned! { field.span() => #(#type_path_quoted),* get_struct_field(stringify!(#name))}
+            }
+            _ => {
+                panic!("Can't handle type: {:?}", field.ty);
+            }
+        }
+    });
+    quote! { #(#schema_fields),* }
+}

kernel/Cargo.toml

@@ -27,6 +27,9 @@ url = "2"
 uuid = "1.3.0"
 z85 = "3.0.5"
 
+# bring in our derive macros
+derive-macros = { path = "../derive-macros" }
+
 # used for developer-visibility
 visibility = "0.1.0"
 

kernel/src/actions/deletion_vector.rs

@@ -4,12 +4,13 @@ use std::io::{Cursor, Read};
 use std::sync::Arc;
 
 use bytes::Bytes;
+use derive_macros::Schema;
 use roaring::RoaringTreemap;
 use url::Url;
 
 use crate::{DeltaResult, Error, FileSystemClient};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Schema)]
 pub struct DeletionVectorDescriptor {
     /// A single character to indicate how to access the DV. Legal options are: ['u', 'i', 'p'].
     pub storage_type: String,