lorenzo/start kw integration pr 9

.github/workflows/build_and_unit_test.yml

@@ -54,37 +54,3 @@ jobs:
           printf '\e[1;33m\tPLEASE, SOLVE THEM LOCALLY W/ `cargo test`\e[0m\n'
           printf '\e[1;33m\t==========================================\n\e[0m'
           exit 1
-
-  # The kw actor and the process infrastructure it uses are unix-only
-  # (#[cfg(unix)]). This job exists so a cfg leak — non-gated code
-  # referencing them — fails mechanically instead of in review.
-  check-non-unix:
-    runs-on: ubuntu-latest
-    timeout-minutes: 4
-    if: '!github.event.pull_request.draft'
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-
-      - name: Update rustup and install rustc and cargo
-        shell: bash
-        run: |
-          rustup update
-          rustup install stable
-
-      # rustls/ring needs a C toolchain for the target; windows-gnu builds
-      # with mingw on Ubuntu, unlike the MSVC target.
-      - name: Install the mingw cross toolchain
-        shell: bash
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-mingw-w64-x86-64
-
-      - name: Check non-unix compilation
-        shell: bash
-        env:
-          CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER: x86_64-w64-mingw32-gcc
-        run: |
-          rustup target add x86_64-pc-windows-gnu
-          cargo check --target x86_64-pc-windows-gnu --verbose

.github/workflows/format_and_lint.yml

@@ -58,4 +58,4 @@ jobs:
       - name: Check clippy errors
         shell: bash
         run: |
-          cargo clippy --all-features --all-targets --tests -- --allow=clippy::too-many-arguments --deny=warnings --deny=clippy::map_unwrap_or --deny=unconditional_recursion
+          cargo clippy --all-features --all-targets --tests -- --deny=warnings --deny=clippy::map_unwrap_or --deny=unconditional_recursion

.github/workflows/release.yml

@@ -110,9 +110,6 @@ jobs:
       GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json
     steps:
-      - name: enable windows longpaths
-        run: |
-          git config --global core.longpaths true
       - uses: actions/checkout@v4
         with:
           submodules: recursive

.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
         entry: cargo clippy
         args: [
           "--all-features", "--all-targets", "--tests",
-          "--", "--allow=clippy::too-many-arguments", "--deny=warnings",
+          "--", "--deny=warnings",
           "--deny=clippy::map_unwrap_or", "--deny=unconditional_recursion"
         ]
         types: [rust]

Cargo.toml

@@ -54,16 +54,21 @@ targets = ["x86_64-unknown-linux-gnu", "x86_64-unknown-linux-musl"]
 # Publish jobs to run in CI
 pr-run-mode = "plan"
 
-# Linter configurations
-[lints.rust]
-warnings = "deny"
-unconditional_recursion = "deny"
-
-[lints.clippy]
-too-many-arguments = "allow"
-map_unwrap_or = "deny"
+[lints]
+workspace = true
 
 [workspace]
 members = [
     "patch_hub_proc_macros",
 ]
+
+[workspace.lints.rust]
+warnings = "deny"
+unconditional_recursion = "deny"
+
+[workspace.lints.clippy]
+map_unwrap_or = "deny"
+unwrap_used = "deny"
+allow_attributes = "deny"
+redundant_type_annotations = "warn"
+match_wildcard_for_single_variants = "warn"

patch_hub_proc_macros/Cargo.toml

@@ -17,3 +17,6 @@ proc-macro2 = "1.0.95"
 [lib]
 proc-macro = true
 doctest = false # otherwise tests will fail
+
+[lints]
+workspace = true

patch_hub_proc_macros/src/lib.rs

@@ -1,7 +1,7 @@
 extern crate proc_macro;
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
-use syn::{parse_macro_input, Data, DeriveInput};
+use syn::{Data, DeriveInput, Fields};
 
 /// This procedural macro create default deserealization functions for each
 /// structure attribute based on std::Default impl.
@@ -36,19 +36,40 @@ use syn::{parse_macro_input, Data, DeriveInput};
 ///     "test_1": 500,
 ///     "test_2": 100
 /// });
-/// let example_struct_1: Example = serde_json::from_value(json_data_1).unwrap();
+/// let example_struct_1: Example = serde_json::from_value(json_data_1)
+///     .expect("example json deserializes");
 /// assert_eq!(example_struct_1.test_1, 500);
 /// assert_eq!(example_struct_1.test_2, 100);
 /// assert_eq!(example_struct_1.test_3, "a".to_string());
 /// ```
 #[proc_macro_attribute]
 pub fn serde_individual_default(_attr: TokenStream, input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
+    match expand_serde_individual_default(input) {
+        Ok(tokens) => tokens,
+        Err(error) => error.to_compile_error().into(),
+    }
+}
+
+fn expand_serde_individual_default(input: TokenStream) -> syn::Result<TokenStream> {
+    let input = syn::parse::<DeriveInput>(input)?;
     let struct_name = &input.ident;
     let struct_generics = &input.generics;
     let struct_fields = match &input.data {
-        Data::Struct(s) => &s.fields,
-        _ => panic!("SerdeIndividualDefault can only be used with structs"),
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => fields,
+            Fields::Unnamed(_) | Fields::Unit => {
+                return Err(syn::Error::new_spanned(
+                    struct_name,
+                    "SerdeIndividualDefault can only be used with structs that have named fields",
+                ));
+            }
+        },
+        Data::Enum(_) | Data::Union(_) => {
+            return Err(syn::Error::new_spanned(
+                struct_name,
+                "SerdeIndividualDefault can only be used with structs",
+            ));
+        }
     };
     let struct_attrs = &input.attrs;
     let struct_visibility = &input.vis;
@@ -69,36 +90,37 @@ pub fn serde_individual_default(_attr: TokenStream, input: TokenStream) -> Token
     };
 
     // build struct attributes with #[serde(default = "")] and build the default function itself
-    let (all_field_attrs, default_deserialize_function_definitions) = struct_fields.iter().fold(
-        (vec![], vec![]),
-        |(mut all_field_attrs, mut default_deserialize_function_definitions), field| {
-            let field_name = &field.ident;
-            let field_type = &field.ty;
-            let field_vis = &field.vis;
-            let field_attrs = &field.attrs;
-            let field_name_str = field_name.as_ref().unwrap().to_string();
-
-            // default function name will be named default_{struct_name}_{field_name}
-            let default_deserialize_function_name =
-                format_ident!("default_{}_{}", struct_name_str, field_name_str);
+    let mut all_field_attrs = Vec::new();
+    let mut default_deserialize_function_definitions = Vec::new();
+    for field in &struct_fields.named {
+        let field_name = field.ident.as_ref().ok_or_else(|| {
+            syn::Error::new_spanned(
+                field,
+                "SerdeIndividualDefault requires every field to be named",
+            )
+        })?;
+        let field_type = &field.ty;
+        let field_vis = &field.vis;
+        let field_attrs = &field.attrs;
+        let field_name_str = field_name.to_string();
 
-            let default_deserialize_function_name_str =
-                default_deserialize_function_name.to_string();
+        // default function name will be named default_{struct_name}_{field_name}
+        let default_deserialize_function_name =
+            format_ident!("default_{}_{}", struct_name_str, field_name_str);
 
-            all_field_attrs.push(quote! {
-                #(#field_attrs)*
-                #[serde(default = #default_deserialize_function_name_str)]
-                #field_vis #field_name: #field_type,
-            });
-            default_deserialize_function_definitions.push(quote! {
-                fn #default_deserialize_function_name() -> #field_type {
-                    #default_config_struct_name.#field_name.clone()
-                }
-            });
+        let default_deserialize_function_name_str = default_deserialize_function_name.to_string();
 
-            (all_field_attrs, default_deserialize_function_definitions)
-        },
-    );
+        all_field_attrs.push(quote! {
+            #(#field_attrs)*
+            #[serde(default = #default_deserialize_function_name_str)]
+            #field_vis #field_name: #field_type,
+        });
+        default_deserialize_function_definitions.push(quote! {
+            fn #default_deserialize_function_name() -> #field_type {
+                #default_config_struct_name.#field_name.clone()
+            }
+        });
+    }
 
     // build final struct.
     //We have to explicitly derive Deserialize here so the serde attribute works
@@ -113,5 +135,5 @@ pub fn serde_individual_default(_attr: TokenStream, input: TokenStream) -> Token
 
         #(#default_deserialize_function_definitions)*
     };
-    TokenStream::from(expanded_token_stream)
+    Ok(TokenStream::from(expanded_token_stream))
 }

patch_hub_proc_macros/tests/serde_individual_default.rs

@@ -62,7 +62,8 @@ fn should_have_default_serialization() {
         "test_2": 100
     });
 
-    let example_struct_1: Example = serde_json::from_value(json_data_1).unwrap();
+    let example_struct_1: Example =
+        serde_json::from_value(json_data_1).expect("example with a missing field deserializes");
 
     // Assert that`test_1` and `test_2` are set to the custom value
     assert_eq!(example_struct_1.test_1, 500);
@@ -79,7 +80,8 @@ fn should_have_default_serialization() {
         "test_3": "test".to_string()
     });
 
-    let example_struct_2: Example = serde_json::from_value(json_data_2).unwrap();
+    let example_struct_2: Example = serde_json::from_value(json_data_2)
+        .expect("example with another missing field deserializes");
 
     // Assert that`test_1` and `test_3` are set to the custom value
     assert_eq!(example_struct_2.test_1, 999);
@@ -98,7 +100,8 @@ fn should_preserve_other_attributes() {
         "test_3": "b".to_string()
     });
 
-    let example_struct: Example = serde_json::from_value(json_data).unwrap();
+    let example_struct: Example =
+        serde_json::from_value(json_data).expect("fully populated example deserializes");
 
     // Assert that`test_2` and `test_3` have getters
     assert_eq!(example_struct.test_1, 500);
@@ -113,7 +116,7 @@ fn test_struct_without_serialize() {
     });
 
     let example_without_serialize: ExampleWithoutSerialize =
-        serde_json::from_value(json_data).unwrap();
+        serde_json::from_value(json_data).expect("struct without Serialize deserializes");
 
     assert_eq!(example_without_serialize.test_1, 765);
     assert_eq!(example_without_serialize.test_2, 123);
@@ -125,7 +128,8 @@ fn test_public_struct() {
         "test_1": 345,
     });
 
-    let example_public: ExamplePublic = serde_json::from_value(json_data).unwrap();
+    let example_public: ExamplePublic =
+        serde_json::from_value(json_data).expect("public struct deserializes");
 
     assert_eq!(example_public.test_1, 345);
     assert_eq!(example_public.test_2, 403);