Merge pull request #590 from joshuachp/push-nsytqoommonn

feat(derive): add rename attribute to the derive macros

Author: harlem88

Cargo.lock

@@ -182,6 +182,7 @@ cfg-if = "1.0.0"
 chrono = "0.4.34"
 clap = "4.5.32"
 color-eyre = "0.6.3"
+darling = "0.23.0"
 eyre = "0.6.12"
 flate2 = "1.0.0"
 futures = "0.3.0"

Cargo.toml

@@ -1,7 +1,20 @@
 # This file is part of Astarte.
 #
-# Copyright 2023 SECO Mind Srl
+# Copyright 2023, 2026 SECO Mind Srl
 #
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
 # SPDX-License-Identifier: CC0-1.0
 
 [package]
@@ -24,6 +37,7 @@ description = "Derive macros implementation used by Astarte Device SDK"
 proc-macro = true
 
 [dependencies]
+darling.workspace = true
 proc-macro2.workspace = true
 quote.workspace = true
 syn = { workspace = true, features = ["full"] }

astarte-device-sdk-derive/Cargo.toml

@@ -1,6 +1,6 @@
 // This file is part of Astarte.
 //
-// Copyright 2023 - 2025 SECO Mind Srl
+// Copyright 2023-2026 SECO Mind Srl
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -16,68 +16,49 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{
-    borrow::Cow,
-    fmt::{self, Debug, Display},
-};
+use std::fmt::Debug;
+
+use darling::FromMeta;
 
 /// The different possible ways to change case of fields in a struct.
-#[derive(Debug, Copy, Clone, PartialEq, Default)]
+#[derive(Debug, Copy, Clone, PartialEq, FromMeta)]
 pub enum RenameRule {
-    /// Do not rename.
-    #[default]
-    None,
     /// Rename to "lowercase" style.
-    LowerCase,
+    #[darling(rename = "lowercase")]
+    Lower,
     /// Rename to "UPPERCASE" style.
-    UpperCase,
+    #[darling(rename = "UPPERCASE")]
+    Upper,
     /// Rename to "PascalCase" style.
-    PascalCase,
+    #[darling(rename = "PascalCase")]
+    Pascal,
     /// Rename to "camelCase" style.
-    CamelCase,
+    #[darling(rename = "camelCase")]
+    Camel,
     /// Rename to "snake_case" style.
-    SnakeCase,
+    #[darling(rename = "snake_case")]
+    Snake,
     /// Rename to "SCREAMING_SNAKE_CASE" style.
-    ScreamingSnakeCase,
+    #[darling(rename = "SCREAMING_SNAKE_CASE")]
+    ScreamingSnake,
     /// Rename to "kebab-case" style.
-    KebabCase,
+    #[darling(rename = "kebab-case")]
+    Kebab,
     /// Rename to "SCREAMING-KEBAB-CASE" style.
-    ScreamingKebabCase,
+    #[darling(rename = "SCREAMING-KEBAB-CASE")]
+    ScreamingKebab,
 }
 
-static RENAME_RULES: &[(&str, RenameRule)] = &[
-    ("lowercase", RenameRule::LowerCase),
-    ("UPPERCASE", RenameRule::UpperCase),
-    ("PascalCase", RenameRule::PascalCase),
-    ("camelCase", RenameRule::CamelCase),
-    ("snake_case", RenameRule::SnakeCase),
-    ("SCREAMING_SNAKE_CASE", RenameRule::ScreamingSnakeCase),
-    ("kebab-case", RenameRule::KebabCase),
-    ("SCREAMING-KEBAB-CASE", RenameRule::ScreamingKebabCase),
-];
-
 impl RenameRule {
-    /// Obrain a rename rule from a str
-    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError<'_>> {
-        for (name, rule) in RENAME_RULES {
-            if rename_all_str == *name {
-                return Ok(*rule);
-            }
-        }
-        Err(ParseError {
-            unknown: rename_all_str,
-        })
-    }
-
     /// Apply a renaming rule to a struct field, returning the version expected in the source.
-    pub fn apply_to_field<'a>(&self, field: &'a str) -> Cow<'a, str> {
-        match *self {
-            RenameRule::None => Cow::Borrowed(field),
-            RenameRule::LowerCase | RenameRule::SnakeCase => field.to_ascii_lowercase().into(),
-            RenameRule::UpperCase => field.to_ascii_uppercase().into(),
-            RenameRule::PascalCase => {
+    pub fn apply_to_field(&self, field: &str) -> String {
+        match self {
+            RenameRule::Lower | RenameRule::Snake => field.to_ascii_lowercase(),
+            RenameRule::Upper => field.to_ascii_uppercase(),
+            RenameRule::Pascal => {
                 let mut pascal = String::new();
                 let mut capitalize = true;
+
                 for ch in field.chars() {
                     if ch == '_' {
                         capitalize = true;
@@ -88,39 +69,20 @@ impl RenameRule {
                         pascal.push(ch);
                     }
                 }
-                Cow::Owned(pascal)
-            }
-            RenameRule::CamelCase => {
-                let pascal = RenameRule::PascalCase.apply_to_field(field);
-                Cow::Owned(pascal[..1].to_ascii_lowercase() + &pascal[1..])
-            }
-            RenameRule::ScreamingSnakeCase => field.to_ascii_uppercase().into(),
-            RenameRule::KebabCase => field.replace('_', "-").into(),
-            RenameRule::ScreamingKebabCase => RenameRule::ScreamingSnakeCase
-                .apply_to_field(field)
-                .replace('_', "-")
-                .into(),
-        }
-    }
-}
 
-#[derive(Debug)]
-pub struct ParseError<'a> {
-    unknown: &'a str,
-}
+                pascal
+            }
+            RenameRule::Camel => {
+                let pascal = RenameRule::Pascal.apply_to_field(field);
 
-impl Display for ParseError<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("unknown rename rule `rename_all = ")?;
-        Debug::fmt(self.unknown, f)?;
-        f.write_str("`, expected one of ")?;
-        for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
-            if i > 0 {
-                f.write_str(", ")?;
+                pascal[..1].to_ascii_lowercase() + &pascal[1..]
             }
-            Debug::fmt(name, f)?;
+            RenameRule::ScreamingSnake => field.to_ascii_uppercase(),
+            RenameRule::Kebab => field.replace('_', "-"),
+            RenameRule::ScreamingKebab => RenameRule::ScreamingSnake
+                .apply_to_field(field)
+                .replace('_', "-"),
         }
-        Ok(())
     }
 }
 
@@ -146,18 +108,17 @@ mod test {
             ("a", "A", "A", "a", "A", "a", "A"),
             ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
         ] {
-            assert_eq!(RenameRule::None.apply_to_field(original), original);
-            assert_eq!(RenameRule::UpperCase.apply_to_field(original), upper);
-            assert_eq!(RenameRule::PascalCase.apply_to_field(original), pascal);
-            assert_eq!(RenameRule::CamelCase.apply_to_field(original), camel);
-            assert_eq!(RenameRule::SnakeCase.apply_to_field(original), original);
+            assert_eq!(RenameRule::Upper.apply_to_field(original), upper);
+            assert_eq!(RenameRule::Pascal.apply_to_field(original), pascal);
+            assert_eq!(RenameRule::Camel.apply_to_field(original), camel);
+            assert_eq!(RenameRule::Snake.apply_to_field(original), original);
             assert_eq!(
-                RenameRule::ScreamingSnakeCase.apply_to_field(original),
+                RenameRule::ScreamingSnake.apply_to_field(original),
                 screaming
             );
-            assert_eq!(RenameRule::KebabCase.apply_to_field(original), kebab);
+            assert_eq!(RenameRule::Kebab.apply_to_field(original), kebab);
             assert_eq!(
-                RenameRule::ScreamingKebabCase.apply_to_field(original),
+                RenameRule::ScreamingKebab.apply_to_field(original),
                 screaming_kebab
             );
         }