address review comments

Author: m4tx

src/error.rs

@@ -119,10 +119,10 @@ pub enum PropertyError {
     },
 }
 
-#[cfg(feature = "write")]
 /// An error that can occur when building or modifying a device tree model.
 #[derive(Debug, Clone, PartialEq, Eq, Error)]
 #[non_exhaustive]
+#[cfg(feature = "write")]
 pub enum ModelError {
     /// The node name is invalid.
     #[error("Invalid node name: '{0}'")]

src/lib.rs

@@ -88,7 +88,7 @@ pub mod memreserve;
 #[cfg(feature = "write")]
 pub mod model;
 pub mod standard;
-pub(crate) mod validate;
+mod validate;
 
 use core::ffi::CStr;
 use core::fmt::{self, Display, Formatter};

src/model/node.rs

@@ -13,6 +13,7 @@ use indexmap::IndexMap;
 use twox_hash::xxhash64;
 
 use super::property::DeviceTreeProperty;
+use crate::error::ModelError;
 use crate::{Node, Property};
 
 /// A mutable, in-memory representation of a device tree node.
@@ -107,8 +108,7 @@ impl DeviceTreeNode {
     ///
     /// # Errors
     ///
-    /// Returns a [`ModelError`](crate::error::ModelError) if the node name is
-    /// invalid.
+    /// Returns a [`ModelError::InvalidNodeName`] if the node name is invalid.
     ///
     /// # Examples
     ///
@@ -119,10 +119,10 @@ impl DeviceTreeNode {
     /// let node = DeviceTreeNode::new("my-node").unwrap();
     /// assert_eq!((&node).name(), "my-node");
     /// ```
-    pub fn new(name: impl Into<String>) -> Result<Self, crate::error::ModelError> {
+    pub fn new(name: impl Into<String>) -> Result<Self, ModelError> {
         let name = name.into();
         if !crate::validate::is_valid_node_name(&name) {
-            return Err(crate::error::ModelError::InvalidNodeName(name));
+            return Err(ModelError::InvalidNodeName(name));
         }
         Ok(Self::new_unchecked(name))
     }
@@ -140,11 +140,8 @@ impl DeviceTreeNode {
     ///
     /// # Errors
     ///
-    /// Returns a [`ModelError`](crate::error::ModelError) if the node name is
-    /// invalid.
-    pub fn builder(
-        name: impl Into<String>,
-    ) -> Result<DeviceTreeNodeBuilder, crate::error::ModelError> {
+    /// Returns a [`ModelError::InvalidNodeName`] if the node name is invalid.
+    pub fn builder(name: impl Into<String>) -> Result<DeviceTreeNodeBuilder, ModelError> {
         DeviceTreeNodeBuilder::new(name)
     }
 
@@ -325,7 +322,7 @@ pub struct DeviceTreeNodeBuilder {
 }
 
 impl DeviceTreeNodeBuilder {
-    fn new(name: impl Into<String>) -> Result<Self, crate::error::ModelError> {
+    fn new(name: impl Into<String>) -> Result<Self, ModelError> {
         Ok(Self {
             node: DeviceTreeNode::new(name)?,
         })

src/model/property.rs

@@ -11,6 +11,7 @@ use alloc::vec::Vec;
 use core::str;
 
 use crate::Property;
+use crate::error::ModelError;
 
 /// A mutable, in-memory representation of a device tree property.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -34,8 +35,8 @@ impl DeviceTreeProperty {
     ///
     /// # Errors
     ///
-    /// Returns a [`ModelError`](crate::error::ModelError) if the property name
-    /// is invalid.
+    /// Returns a [`ModelError::InvalidPropertyName`] if the property name is
+    /// invalid.
     ///
     /// # Examples
     ///
@@ -47,13 +48,10 @@ impl DeviceTreeProperty {
     /// assert_eq!((&prop).name(), "my-prop");
     /// assert_eq!((&prop).value(), &[1, 2, 3, 4]);
     /// ```
-    pub fn new(
-        name: impl Into<String>,
-        value: impl Into<Vec<u8>>,
-    ) -> Result<Self, crate::error::ModelError> {
+    pub fn new(name: impl Into<String>, value: impl Into<Vec<u8>>) -> Result<Self, ModelError> {
         let name = name.into();
         if !crate::validate::is_valid_property_name(&name) {
-            return Err(crate::error::ModelError::InvalidPropertyName(name));
+            return Err(ModelError::InvalidPropertyName(name));
         }
         Ok(Self {
             name,

src/validate.rs

@@ -8,12 +8,12 @@
 
 //! Validation functions for Device Tree node and property names.
 
-fn is_valid_node_char(c: char) -> bool {
-    c.is_ascii_alphanumeric() || c == ',' || c == '.' || c == '_' || c == '+' || c == '-'
+const fn is_valid_node_char(c: char) -> bool {
+    c.is_ascii_alphanumeric() || matches!(c, ',' | '.' | '_' | '+' | '-')
 }
 
-fn is_valid_property_char(c: char) -> bool {
-    is_valid_node_char(c) || c == '?' || c == '#'
+const fn is_valid_property_char(c: char) -> bool {
+    is_valid_node_char(c) || matches!(c, '?' | '#')
 }
 
 /// Validates a node name according to the Devicetree Specification.