bare_types/sys/

username.rs

//! System username type for system information.
//!
//! This module provides a type-safe abstraction for system usernames,
//! ensuring valid username strings following POSIX rules.
//!
//! # Username Format
//!
//! System usernames follow POSIX rules:
//!
//! - Must be 1-32 characters
//! - Must start with a letter or underscore
//! - Can contain alphanumeric characters, underscores, and hyphens
//!
//! # Examples
//!
//! ```rust
//! use bare_types::sys::Username;
//!
//! // Parse from string
//! let username: Username = "root".parse()?;
//!
//! // Access as string
//! assert_eq!(username.as_str(), "root");
//! # Ok::<(), bare_types::sys::UsernameError>(())
//! ```

use core::fmt;
use core::str::FromStr;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// Error type for username parsing.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum UsernameError {
    /// Empty username
    Empty,
    /// Username too long (max 32 characters)
    TooLong(usize),
    /// Invalid first character (must be letter or underscore)
    InvalidFirstCharacter,
    /// Invalid character in username
    InvalidCharacter,
}

impl fmt::Display for UsernameError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Empty => write!(f, "username cannot be empty"),
            Self::TooLong(len) => write!(f, "username too long (got {len}, max 32 characters)"),
            Self::InvalidFirstCharacter => {
                write!(f, "username must start with a letter or underscore")
            }
            Self::InvalidCharacter => write!(f, "username contains invalid character"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for UsernameError {}

/// System username.
///
/// This type provides type-safe system usernames following POSIX rules.
/// It uses the newtype pattern with `#[repr(transparent)]` for zero-cost abstraction.
#[repr(transparent)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Username(heapless::String<32>);

impl Username {
    /// Maximum length of a username (POSIX)
    pub const MAX_LEN: usize = 32;

    /// Creates a new username from a string.
    ///
    /// # Errors
    ///
    /// Returns an error `UsernameError` if the string is not a valid username.
    pub fn new(s: &str) -> Result<Self, UsernameError> {
        Self::validate(s)?;
        let mut value = heapless::String::new();
        value
            .push_str(s)
            .map_err(|_| UsernameError::TooLong(s.len()))?;
        Ok(Self(value))
    }

    /// Validates a username string.
    fn validate(s: &str) -> Result<(), UsernameError> {
        if s.is_empty() {
            return Err(UsernameError::Empty);
        }
        if s.len() > Self::MAX_LEN {
            return Err(UsernameError::TooLong(s.len()));
        }
        let mut chars = s.chars();
        if let Some(first) = chars.next() {
            if !first.is_ascii_alphabetic() && first != '_' {
                return Err(UsernameError::InvalidFirstCharacter);
            }
        }
        for ch in chars {
            if !ch.is_ascii_alphanumeric() && ch != '_' && ch != '-' {
                return Err(UsernameError::InvalidCharacter);
            }
        }
        Ok(())
    }

    /// Returns the username as a string slice.
    #[must_use]
    #[inline]
    pub fn as_str(&self) -> &str {
        &self.0
    }

    /// Returns a reference to the underlying `heapless::String`.
    #[must_use]
    #[inline]
    pub const fn as_inner(&self) -> &heapless::String<32> {
        &self.0
    }

    /// Consumes this username and returns the underlying string.
    #[must_use]
    #[inline]
    pub fn into_inner(self) -> heapless::String<32> {
        self.0
    }

    /// Returns `true` if this is a system user.
    ///
    /// System users typically start with underscore or are well-known system accounts.
    #[must_use]
    pub fn is_system_user(&self) -> bool {
        self.0.starts_with('_') || self.0 == "root" || self.0 == "daemon"
    }

    /// Returns `true` if this is a service account.
    ///
    /// Service accounts typically start with "svc-" or "service-".
    #[must_use]
    pub fn is_service_account(&self) -> bool {
        self.0.starts_with("svc-") || self.0.starts_with("service-")
    }
}

impl AsRef<str> for Username {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl TryFrom<&str> for Username {
    type Error = UsernameError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Self::new(s)
    }
}

impl FromStr for Username {
    type Err = UsernameError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::new(s)
    }
}

impl fmt::Display for Username {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_valid() {
        let username = Username::new("root").unwrap();
        assert_eq!(username.as_str(), "root");
    }

    #[test]
    fn test_new_empty() {
        assert!(matches!(Username::new(""), Err(UsernameError::Empty)));
    }

    #[test]
    fn test_new_too_long() {
        let long_name = "a".repeat(33);
        assert!(matches!(
            Username::new(&long_name),
            Err(UsernameError::TooLong(33))
        ));
    }

    #[test]
    fn test_new_invalid_first_character() {
        assert!(matches!(
            Username::new("1root"),
            Err(UsernameError::InvalidFirstCharacter)
        ));
        assert!(matches!(
            Username::new("-root"),
            Err(UsernameError::InvalidFirstCharacter)
        ));
    }

    #[test]
    fn test_new_invalid_character() {
        assert!(matches!(
            Username::new("root@"),
            Err(UsernameError::InvalidCharacter)
        ));
        assert!(matches!(
            Username::new("root.user"),
            Err(UsernameError::InvalidCharacter)
        ));
    }

    #[test]
    fn test_is_system_user() {
        let root = Username::new("root").unwrap();
        assert!(root.is_system_user());
        let daemon = Username::new("daemon").unwrap();
        assert!(daemon.is_system_user());
        let system = Username::new("_system").unwrap();
        assert!(system.is_system_user());
        let user = Username::new("user").unwrap();
        assert!(!user.is_system_user());
    }

    #[test]
    fn test_is_service_account() {
        let svc = Username::new("svc-api").unwrap();
        assert!(svc.is_service_account());
        let service = Username::new("service-api").unwrap();
        assert!(service.is_service_account());
        let user = Username::new("user").unwrap();
        assert!(!user.is_service_account());
    }

    #[test]
    fn test_from_str() {
        let username: Username = "root".parse().unwrap();
        assert_eq!(username.as_str(), "root");
    }

    #[test]
    fn test_from_str_error() {
        assert!("".parse::<Username>().is_err());
        assert!("1root".parse::<Username>().is_err());
    }

    #[test]
    fn test_display() {
        let username = Username::new("root").unwrap();
        assert_eq!(format!("{}", username), "root");
    }

    #[test]
    fn test_as_ref() {
        let username = Username::new("root").unwrap();
        let s: &str = username.as_ref();
        assert_eq!(s, "root");
    }

    #[test]
    fn test_clone() {
        let username = Username::new("root").unwrap();
        let username2 = username.clone();
        assert_eq!(username, username2);
    }

    #[test]
    fn test_equality() {
        let u1 = Username::new("root").unwrap();
        let u2 = Username::new("root").unwrap();
        let u3 = Username::new("user").unwrap();
        assert_eq!(u1, u2);
        assert_ne!(u1, u3);
    }
}