Small cleanup of macro and prepare for release

The majority of the work has been done by @patskovn in #19, I'm just cleaning up and preparing a release,
since he has used his branch to publish his own package, so I can't just merge it in unfortunately

Author: MidasLamb

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.6](https://github.com/MidasLamb/non-empty-string/compare/v0.2.5...v0.2.6) - 2025-04-09
+
+### Added
+
+- `non_empty_string!()` macro to create a `NonEmptyString` at compile time , thanks @patskovn in #19 (requires `macros` feature flag)
+
 ## [0.2.5](https://github.com/MidasLamb/non-empty-string/compare/v0.2.4...v0.2.5) - 2024-10-15
 
 ### Added

Cargo.toml

@@ -25,7 +25,7 @@ serde = { version = "1", features = ["derive"] }
 
 [features]
 default = []
-macro = []
+macros = []
 serde = ["dep:serde"]
 
 

src/lib.rs

@@ -17,7 +17,7 @@ use delegate::delegate;
 #[cfg(feature = "serde")]
 mod serde_support;
 
-#[cfg(feature = "macro")]
+#[cfg(feature = "macros")]
 mod macros;
 
 mod trait_impls;

src/macros.rs

@@ -7,9 +7,9 @@
 /// # Examples
 ///
 /// ```
-/// use non_empty_string::{non_empty, NonEmptyString};
+/// use non_empty_string::{non_empty_string, NonEmptyString};
 ///
-/// let s: NonEmptyString = non_empty!("Hello, Rust!");
+/// let s: NonEmptyString = non_empty_string!("Hello, Rust!");
 /// assert_eq!(s, NonEmptyString::new("Hello, Rust!".to_string()).unwrap());
 /// ```
 ///
@@ -18,27 +18,40 @@
 /// If an empty string is provided, this macro will cause a **compile-time error**.
 ///
 /// ```compile_fail
-/// use non_empty_string::non_empty;
+/// use non_empty_string::non_empty_string;
 ///
-/// let s = non_empty!("");
+/// let s = non_empty_string!("");
 /// ```
-macro_rules! non_empty {
+macro_rules! non_empty_string {
     ($s:expr) => {{
         // Compile-time assertion to ensure the string is non-empty
         const _: () = assert!(!$s.is_empty(), "String cannot be empty");
 
         // Create a NonEmptyString, unsafely wrapping since we've checked it's valid
-        unsafe { NonEmptyString::new_unchecked($s.to_string()) }
+        unsafe { $crate::NonEmptyString::new_unchecked($s.to_string()) }
     }};
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::NonEmptyString;
+    // We explicitely DO NOT do `use crate::NonEmptyString` or anything of the sorts to ensure the macro has proper hygiene.
+    // Otherwise tests might pass, but if a user does `non_empty_string::non_empty_string!("A")`, they might get compilation
+    // errors that `NonEmptyString` is not in scope.
+
+    const NON_EMPTY_STRING: &'static str = "non-empty-string";
+
+    #[test]
+    fn test_const_non_empty_string_macro_valid() {
+        let s = non_empty_string!(NON_EMPTY_STRING);
+        assert_eq!(
+            s,
+            crate::NonEmptyString::try_from(NON_EMPTY_STRING).unwrap()
+        );
+    }
 
     #[test]
-    fn test_non_empty_string_macro_valid() {
-        let s = non_empty!("Test String");
-        assert_eq!(s, NonEmptyString::try_from("Test String").unwrap());
+    fn test_inline_non_empty_string_macro_valid() {
+        let s = non_empty_string!("Test String");
+        assert_eq!(s, crate::NonEmptyString::try_from("Test String").unwrap());
     }
 }