fix doctests

crates/util/identifier/Cargo.toml

@@ -16,11 +16,10 @@ serde = { version = "1.0", optional = true }
 rimecraft-edcode = { path = "../edcode", optional = true }
 
 [features]
-default = ["vanilla", "macros"]
+default = ["vanilla"]
 serde = ["dep:serde"]
 edcode = ["dep:rimecraft-edcode"]
 vanilla = []
-macros = []
 
 [lints]
 workspace = true

crates/util/identifier/src/lib.rs

@@ -6,9 +6,6 @@ use std::{fmt::Display, str::FromStr};
 #[cfg(feature = "vanilla")]
 pub mod vanilla;
 
-#[cfg(feature = "macros")]
-pub mod macros;
-
 /// An identifier used to identify things.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[doc(alias = "ResourceLocation")]

crates/util/identifier/src/vanilla.rs

@@ -4,6 +4,8 @@ use std::{hash::Hash, str::FromStr, sync::Arc};
 
 use crate::Separate;
 
+mod macros;
+
 /// Namespace of an vanilla Minecraft `Identifier`.
 ///
 /// This is the default value of a [`Namespace`].
@@ -106,19 +108,19 @@ impl Path {
         Ok(Self(ArcCowStr::Arc(value)))
     }
 
-
     /// Creates a new [`Path`] from the given value.
     ///
     /// This function accepts a 2-dimension [`Vec`] which stands for words wrapped in locations.
     ///
     /// # Examples
     ///
     /// ```
+    /// # use rimecraft_identifier::vanilla::Path;
     /// let path = Path::new_formatted(vec![
-    /// 		vec!["tags"],
-    /// 		vec![],
-    /// 		vec!["piglin", "", "likes"],
-    /// 	]);
+    ///         vec!["tags"],
+    ///         vec![],
+    ///         vec!["piglin", "", "likes"],
+    ///     ]);
     /// let identifier = Identifier::new(MINECRAFT, path);
     ///
     /// assert_eq!("minecraft:tags/piglin_likes", identifier.to_string());
@@ -132,8 +134,8 @@ impl Path {
     where
         T: Into<Arc<str>>,
     {
-		Self::try_new_formatted(values).unwrap()
-	}
+        Self::try_new_formatted(values).unwrap()
+    }
 
     /// Creates a new [`Path`] from the given value.
     ///
@@ -142,11 +144,12 @@ impl Path {
     /// # Examples
     ///
     /// ```
+    /// # use rimecraft_identifier::vanilla::Path;
     /// let path = Path::try_new_formatted(vec![
-    /// 		vec!["tags"],
-    /// 		vec![],
-    /// 		vec!["piglin", "", "repellents"],
-    /// 	]).unwrap();
+    ///         vec!["tags"],
+    ///         vec![],
+    ///         vec!["piglin", "", "repellents"],
+    ///     ]).unwrap();
     /// let identifier = Identifier::new(MINECRAFT, path);
     /// assert_eq!("minecraft:tags/piglin_repellents", identifier.to_string());
     /// ```
@@ -174,36 +177,24 @@ impl Path {
             })
             .collect();
 
-        match values.iter().flat_map(|v| v.iter()).find_map(|r| match r {
-            Ok(_) => None,
-            Err(error) => Some(error),
-        }) {
-            Some(error) => return Err((*error).clone()),
-            None => (),
-        };
+        if let Some(err) = values
+            .iter()
+            .flat_map(|v| v.iter())
+            .find_map(|r| r.as_ref().err())
+            .cloned()
+        {
+            return Err(err);
+        }
 
         let values: Vec<Vec<Arc<str>>> = values
             .into_iter()
             .filter_map(|v| {
                 let v: Vec<Arc<str>> = v
                     .into_iter()
-                    .filter_map(|r| match r {
-                        Ok(s) => {
-                            if s.len() > 0 {
-                                Some(s)
-                            } else {
-                                None
-                            }
-                        }
-                        Err(_) => None,
-                    })
+                    .filter_map(|r| r.ok().and_then(|s| (!s.is_empty()).then_some(s)))
                     .collect();
 
-                if v.len() > 0 {
-                    Some(v)
-                } else {
-                    None
-                }
+                (!v.is_empty()).then_some(v)
             })
             .collect();
 
@@ -219,7 +210,7 @@ impl Path {
     /// Creates a new [`Path`] from the given value
     /// at compile time.
     ///
-    /// The given path shoule be all [a-z0-9/_.-] character.
+    /// The given path should be all [a-z0-9/_.-] character.
     #[inline]
     pub const fn new_unchecked(value: &'static str) -> Self {
         Self(ArcCowStr::Ref(value))
@@ -339,6 +330,7 @@ fn validate_path(value: &str) -> Result<(), Error> {
 
 /// Error type for `Namespace` and `Path`.
 #[derive(Debug, Clone)]
+#[non_exhaustive]
 pub enum Error {
     /// The given namespace is invalid.
     InvalidNamespace(String),

crates/util/identifier/src/macros.rs → crates/util/identifier/src/vanilla/macros.rs

@@ -8,13 +8,14 @@ use crate::*; // Used in docs
 /// # Examples
 ///
 /// ```
+/// # use rimecraft_identifier::{*, vanilla::*};
 /// let identifier = format_identifier!("namespace".parse().unwrap() =>
-/// 	"a", "b"; "c"; "42"
+///     "a", "b"; "c"; "42"
 /// );
 /// assert_eq!("namespace:a_b/c/42", identifier.to_string());
 ///
 /// let identifier = format_identifier!(MINECRAFT =>
-/// 	"tags"; "piglin", "repellents"
+///     "tags"; "piglin", "repellents"
 /// );
 /// assert_eq!("minecraft:tags/piglin_repellents", identifier.to_string());
 /// ```
@@ -23,21 +24,13 @@ use crate::*; // Used in docs
 macro_rules! format_identifier {
 	($namespace:expr => $($($word:expr),*);*) => {
 		{
-			let mut locations = Vec::new();
-
-			$(
-				{
-					let mut words = Vec::new();
-
-					$(
-						words.push($word);
-					)*
-
-					locations.push(words);
-				}
-			)*
-
-			Identifier::<Namespace, Path>::new($namespace, Path::new_formatted(locations))
+			$crate::Identifier::<$crate::vanilla::Namespace, $crate::vanilla::Path>::new(
+				$namespace,
+				$crate::vanilla::Path::new_formatted(
+					::std::vec![
+						$(::std::vec![$($word),*]),*
+					])
+			)
 		}
 	};
 }