moq_lite/

path.rs

use std::fmt::{self, Display};

use crate::coding::{Decode, DecodeError, Encode};

/// A borrowed reference to a path.
///
/// This type is to Path as &str is to String. It provides a way to work with
/// path strings without requiring ownership.
#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
pub struct PathRef<'a>(&'a str);

impl<'a> PathRef<'a> {
	/// Create a new PathRef from a string slice.
	///
	/// Leading and trailing slashes are automatically trimmed.
	pub fn new(s: &'a str) -> Self {
		Self(s.trim_start_matches('/').trim_end_matches('/'))
	}

	/// Get the path as a string slice.
	pub fn as_str(&self) -> &str {
		self.0
	}

	/// Check if the path is empty.
	pub fn is_empty(&self) -> bool {
		self.0.is_empty()
	}

	/// Get the length of the path in bytes.
	pub fn len(&self) -> usize {
		self.0.len()
	}

	/// Convert to an owned Path.
	pub fn to_path(&self) -> Path {
		Path::new(self.0)
	}
}

impl<'a> From<&'a str> for PathRef<'a> {
	fn from(s: &'a str) -> Self {
		Self::new(s)
	}
}

impl<'a> From<&'a String> for PathRef<'a> {
	fn from(s: &'a String) -> Self {
		Self::new(s.as_str())
	}
}

impl<'a> From<&'a Path> for PathRef<'a> {
	fn from(p: &'a Path) -> Self {
		// Path is already trimmed, so we can use it directly
		Self(p.0.as_str())
	}
}

impl<'a, 'b> From<&'a PathRef<'b>> for PathRef<'a>
where
	'b: 'a,
{
	fn from(p: &'a PathRef<'b>) -> Self {
		Self(p.0)
	}
}

impl<'a> AsRef<str> for PathRef<'a> {
	fn as_ref(&self) -> &str {
		self.0
	}
}

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

/// A broadcast path that provides safe prefix matching operations.
///
/// This type wraps a String but provides path-aware operations that respect
/// delimiter boundaries, preventing issues like "foo" matching "foobar".
///
/// Paths are automatically trimmed of leading and trailing slashes on creation,
/// making all slashes implicit at boundaries.
///
/// # Examples
/// ```
/// use moq_lite::{Path, PathRef};
///
/// // Creation automatically trims slashes
/// let path1 = Path::new("/foo/bar/");
/// let path2 = Path::new("foo/bar");
/// assert_eq!(path1, path2);
///
/// // Methods accept both &str and &Path via PathRef
/// let base = Path::new("api/v1");
/// assert!(base.has_prefix("api"));
/// assert!(base.has_prefix(&Path::new("api/v1")));
///
/// let joined = base.join("users");
/// assert_eq!(joined.as_str(), "api/v1/users");
/// ```
#[derive(Clone, Debug, PartialEq, Eq, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize))]
pub struct Path(String);

impl Path {
	/// Create a new Path from a string.
	///
	/// Leading and trailing slashes are automatically trimmed.
	pub fn new<S: Into<String>>(s: S) -> Self {
		let s = s.into();
		Self(s.trim_start_matches('/').trim_end_matches('/').to_string())
	}

	/// Check if this path has the given prefix, respecting path boundaries.
	///
	/// Unlike String::starts_with, this ensures that "foo" does not match "foobar".
	/// The prefix must either:
	/// - Be exactly equal to this path
	/// - Be followed by a '/' delimiter in the original path
	/// - Be empty (matches everything)
	///
	/// # Examples
	/// ```
	/// use moq_lite::Path;
	///
	/// let path = Path::new("foo/bar");
	/// assert!(path.has_prefix("foo"));
	/// assert!(path.has_prefix(&Path::new("foo")));
	/// assert!(path.has_prefix("foo/"));
	/// assert!(!path.has_prefix("fo"));
	///
	/// let path = Path::new("foobar");
	/// assert!(!path.has_prefix("foo"));
	/// ```
	pub fn has_prefix<'a>(&self, prefix: impl Into<PathRef<'a>>) -> bool {
		let prefix = prefix.into();
		if prefix.is_empty() {
			return true;
		}

		if !self.0.starts_with(prefix.as_str()) {
			return false;
		}

		// Check if the prefix is the exact match
		if self.0.len() == prefix.len() {
			return true;
		}

		// Otherwise, ensure the character after the prefix is a delimiter
		self.0.chars().nth(prefix.len()) == Some('/')
	}

	/// Strip the given prefix from this path, returning the suffix.
	///
	/// Returns None if the prefix doesn't match according to has_prefix rules.
	///
	/// # Examples
	/// ```
	/// use moq_lite::Path;
	///
	/// let path = Path::new("foo/bar/baz");
	/// let suffix = path.strip_prefix("foo").unwrap();
	/// assert_eq!(suffix.as_str(), "bar/baz");
	///
	/// let suffix = path.strip_prefix(&Path::new("foo/")).unwrap();
	/// assert_eq!(suffix.as_str(), "bar/baz");
	/// ```
	pub fn strip_prefix<'a>(&'a self, prefix: impl Into<PathRef<'a>>) -> Option<PathRef<'a>> {
		let prefix = prefix.into();
		if !self.has_prefix(prefix) {
			return None;
		}

		let suffix = &self.0[prefix.len()..];
		// Trim leading slash since paths should not start with /
		let suffix = suffix.trim_start_matches('/');
		Some(PathRef(suffix))
	}

	/// Get the path as a string slice.
	pub fn as_str(&self) -> &str {
		&self.0
	}

	/// Check if the path is empty.
	pub fn is_empty(&self) -> bool {
		self.0.is_empty()
	}

	/// Get the length of the path in bytes.
	pub fn len(&self) -> usize {
		self.0.len()
	}

	/// Join this path with another path component.
	///
	/// # Examples
	/// ```
	/// use moq_lite::Path;
	///
	/// let base = Path::new("foo");
	/// let joined = base.join("bar");
	/// assert_eq!(joined.as_str(), "foo/bar");
	///
	/// let joined = base.join(&Path::new("bar"));
	/// assert_eq!(joined.as_str(), "foo/bar");
	/// ```
	pub fn join<'a>(&self, other: impl Into<PathRef<'a>>) -> Path {
		let other = other.into();
		if self.0.is_empty() {
			other.to_path()
		} else if other.is_empty() {
			self.clone()
		} else {
			// Since paths are trimmed, we always need to add a slash
			Path::new(format!("{}/{}", self.0, other.as_str()))
		}
	}
}

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

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

impl From<String> for Path {
	fn from(s: String) -> Self {
		Self::new(s)
	}
}

impl From<&str> for Path {
	fn from(s: &str) -> Self {
		Self::new(s)
	}
}

impl From<&String> for Path {
	fn from(s: &String) -> Self {
		Self::new(s)
	}
}

impl From<&Path> for Path {
	fn from(p: &Path) -> Self {
		p.clone()
	}
}

impl From<PathRef<'_>> for Path {
	fn from(p: PathRef<'_>) -> Self {
		Path::new(p.0)
	}
}

impl Decode for Path {
	fn decode<R: bytes::Buf>(r: &mut R) -> Result<Self, DecodeError> {
		let path = String::decode(r)?;
		Ok(Self::new(path))
	}
}

impl Encode for Path {
	fn encode<W: bytes::BufMut>(&self, w: &mut W) {
		self.0.encode(w)
	}
}

#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Path {
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: serde::Deserializer<'de>,
	{
		let s = String::deserialize(deserializer)?;
		Ok(Path::new(s))
	}
}

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

	#[test]
	fn test_has_prefix() {
		let path = Path::new("foo/bar/baz");

		// Valid prefixes - test with both &str and &Path
		assert!(path.has_prefix(""));
		assert!(path.has_prefix("foo"));
		assert!(path.has_prefix(&Path::new("foo")));
		assert!(path.has_prefix("foo/"));
		assert!(path.has_prefix("foo/bar"));
		assert!(path.has_prefix(&Path::new("foo/bar/")));
		assert!(path.has_prefix("foo/bar/baz"));

		// Invalid prefixes - should not match partial components
		assert!(!path.has_prefix("f"));
		assert!(!path.has_prefix(&Path::new("fo")));
		assert!(!path.has_prefix("foo/b"));
		assert!(!path.has_prefix("foo/ba"));
		assert!(!path.has_prefix(&Path::new("foo/bar/ba")));

		// Edge case: "foobar" should not match "foo"
		let path = Path::new("foobar");
		assert!(!path.has_prefix("foo"));
		assert!(path.has_prefix(&Path::new("foobar")));
	}

	#[test]
	fn test_strip_prefix() {
		let path = Path::new("foo/bar/baz");

		// Test with both &str and &Path
		assert_eq!(path.strip_prefix("").unwrap().as_str(), "foo/bar/baz");
		assert_eq!(path.strip_prefix("foo").unwrap().as_str(), "bar/baz");
		assert_eq!(path.strip_prefix(&Path::new("foo/")).unwrap().as_str(), "bar/baz");
		assert_eq!(path.strip_prefix("foo/bar").unwrap().as_str(), "baz");
		assert_eq!(path.strip_prefix(&Path::new("foo/bar/")).unwrap().as_str(), "baz");
		assert_eq!(path.strip_prefix("foo/bar/baz").unwrap().as_str(), "");

		// Should fail for invalid prefixes
		assert!(path.strip_prefix("fo").is_none());
		assert!(path.strip_prefix(&Path::new("bar")).is_none());
	}

	#[test]
	fn test_join() {
		// Test with both &str and &Path
		assert_eq!(Path::new("foo").join("bar").as_str(), "foo/bar");
		assert_eq!(Path::new("foo/").join(&Path::new("bar")).as_str(), "foo/bar");
		assert_eq!(Path::new("").join("bar").as_str(), "bar");
		assert_eq!(Path::new("foo/bar").join(&Path::new("baz")).as_str(), "foo/bar/baz");
	}

	#[test]
	fn test_empty() {
		let empty = Path::new("");
		assert!(empty.is_empty());
		assert_eq!(empty.len(), 0);

		let non_empty = Path::new("foo");
		assert!(!non_empty.is_empty());
		assert_eq!(non_empty.len(), 3);
	}

	#[test]
	fn test_from_conversions() {
		let path1 = Path::from("foo/bar");
		let path2 = Path::from(String::from("foo/bar"));
		let s = String::from("foo/bar");
		let path3 = Path::from(&s);

		assert_eq!(path1.as_str(), "foo/bar");
		assert_eq!(path2.as_str(), "foo/bar");
		assert_eq!(path3.as_str(), "foo/bar");
	}

	#[test]
	fn test_path_prefix_join() {
		let prefix = Path::new("foo");
		let suffix = Path::new("bar/baz");
		let path = prefix.join(&suffix);
		assert_eq!(path.as_str(), "foo/bar/baz");

		let prefix = Path::new("foo/");
		let suffix = Path::new("bar/baz");
		let path = prefix.join(&suffix);
		assert_eq!(path.as_str(), "foo/bar/baz");

		let prefix = Path::new("foo");
		let suffix = Path::new("/bar/baz");
		let path = prefix.join(&suffix);
		assert_eq!(path.as_str(), "foo/bar/baz");

		let prefix = Path::new("");
		let suffix = Path::new("bar/baz");
		let path = prefix.join(&suffix);
		assert_eq!(path.as_str(), "bar/baz");
	}

	#[test]
	fn test_path_prefix_conversions() {
		let prefix1 = Path::from("foo/bar");
		let prefix2 = Path::from(String::from("foo/bar"));
		let s = String::from("foo/bar");
		let prefix3 = Path::from(&s);

		assert_eq!(prefix1.as_str(), "foo/bar");
		assert_eq!(prefix2.as_str(), "foo/bar");
		assert_eq!(prefix3.as_str(), "foo/bar");
	}

	#[test]
	fn test_path_suffix_conversions() {
		let suffix1 = Path::from("foo/bar");
		let suffix2 = Path::from(String::from("foo/bar"));
		let s = String::from("foo/bar");
		let suffix3 = Path::from(&s);

		assert_eq!(suffix1.as_str(), "foo/bar");
		assert_eq!(suffix2.as_str(), "foo/bar");
		assert_eq!(suffix3.as_str(), "foo/bar");
	}

	#[test]
	fn test_path_types_basic_operations() {
		let prefix = Path::new("foo/bar");
		assert_eq!(prefix.as_str(), "foo/bar");
		assert!(!prefix.is_empty());
		assert_eq!(prefix.len(), 7);

		let suffix = Path::new("baz/qux");
		assert_eq!(suffix.as_str(), "baz/qux");
		assert!(!suffix.is_empty());
		assert_eq!(suffix.len(), 7);

		let empty_prefix = Path::new("");
		assert!(empty_prefix.is_empty());
		assert_eq!(empty_prefix.len(), 0);

		let empty_suffix = Path::new("");
		assert!(empty_suffix.is_empty());
		assert_eq!(empty_suffix.len(), 0);
	}

	#[test]
	fn test_prefix_has_prefix() {
		// Test empty prefix (should match everything)
		let prefix = Path::new("foo/bar");
		assert!(prefix.has_prefix(&Path::new("")));

		// Test exact matches
		let prefix = Path::new("foo/bar");
		assert!(prefix.has_prefix(&Path::new("foo/bar")));

		// Test valid prefixes
		assert!(prefix.has_prefix(&Path::new("foo")));
		assert!(prefix.has_prefix(&Path::new("foo/")));

		// Test invalid prefixes - partial matches should fail
		assert!(!prefix.has_prefix(&Path::new("f")));
		assert!(!prefix.has_prefix(&Path::new("fo")));
		assert!(!prefix.has_prefix(&Path::new("foo/b")));
		assert!(!prefix.has_prefix(&Path::new("foo/ba")));

		// Test edge cases
		let prefix = Path::new("foobar");
		assert!(!prefix.has_prefix(&Path::new("foo")));
		assert!(prefix.has_prefix(&Path::new("foobar")));

		// Test trailing slash handling
		let prefix = Path::new("foo/bar/");
		assert!(prefix.has_prefix(&Path::new("foo")));
		assert!(prefix.has_prefix(&Path::new("foo/")));
		assert!(prefix.has_prefix(&Path::new("foo/bar")));
		assert!(prefix.has_prefix(&Path::new("foo/bar/")));

		// Test single component
		let prefix = Path::new("foo");
		assert!(prefix.has_prefix(&Path::new("")));
		assert!(prefix.has_prefix(&Path::new("foo")));
		assert!(prefix.has_prefix(&Path::new("foo/"))); // "foo/" becomes "foo" after trimming
		assert!(!prefix.has_prefix(&Path::new("f")));

		// Test empty prefix
		let prefix = Path::new("");
		assert!(prefix.has_prefix(&Path::new("")));
		assert!(!prefix.has_prefix(&Path::new("foo")));
	}

	#[test]
	fn test_prefix_join() {
		// Basic joining
		let prefix = Path::new("foo");
		let suffix = Path::new("bar");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar");

		// Trailing slash on prefix
		let prefix = Path::new("foo/");
		let suffix = Path::new("bar");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar");

		// Leading slash on suffix
		let prefix = Path::new("foo");
		let suffix = Path::new("/bar");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar");

		// Trailing slash on suffix
		let prefix = Path::new("foo");
		let suffix = Path::new("bar/");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar"); // trailing slash is trimmed

		// Both have slashes
		let prefix = Path::new("foo/");
		let suffix = Path::new("/bar");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar");

		// Empty suffix
		let prefix = Path::new("foo");
		let suffix = Path::new("");
		assert_eq!(prefix.join(&suffix).as_str(), "foo");

		// Empty prefix
		let prefix = Path::new("");
		let suffix = Path::new("bar");
		assert_eq!(prefix.join(&suffix).as_str(), "bar");

		// Both empty
		let prefix = Path::new("");
		let suffix = Path::new("");
		assert_eq!(prefix.join(&suffix).as_str(), "");

		// Complex paths
		let prefix = Path::new("foo/bar");
		let suffix = Path::new("baz/qux");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar/baz/qux");

		// Complex paths with slashes
		let prefix = Path::new("foo/bar/");
		let suffix = Path::new("/baz/qux/");
		assert_eq!(prefix.join(&suffix).as_str(), "foo/bar/baz/qux"); // all slashes are trimmed
	}

	#[test]
	fn test_path_ref() {
		// Test PathRef creation and trimming
		let ref1 = PathRef::new("/foo/bar/");
		assert_eq!(ref1.as_str(), "foo/bar");

		let ref2 = PathRef::from("///foo///");
		assert_eq!(ref2.as_str(), "foo");

		// Test conversions
		let path = Path::new("foo/bar");
		let path_ref = PathRef::from(&path);
		assert_eq!(path_ref.as_str(), "foo/bar");

		// Test that Path methods work with PathRef
		let path2 = Path::new("foo/bar/baz");
		assert!(path2.has_prefix(path_ref));
		assert_eq!(path2.strip_prefix(path_ref).unwrap().as_str(), "baz");

		// Test empty PathRef
		let empty = PathRef::new("");
		assert!(empty.is_empty());
		assert_eq!(empty.len(), 0);
	}

	#[test]
	fn test_prefix_strip_prefix() {
		// Test basic stripping
		let prefix = Path::new("foo/bar/baz");
		assert_eq!(prefix.strip_prefix(&Path::new("")).unwrap().as_str(), "foo/bar/baz");
		assert_eq!(prefix.strip_prefix(&Path::new("foo")).unwrap().as_str(), "bar/baz");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/")).unwrap().as_str(), "bar/baz");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/bar")).unwrap().as_str(), "baz");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/bar/")).unwrap().as_str(), "baz");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/bar/baz")).unwrap().as_str(), "");

		// Test invalid prefixes
		assert!(prefix.strip_prefix(&Path::new("fo")).is_none());
		assert!(prefix.strip_prefix(&Path::new("bar")).is_none());
		assert!(prefix.strip_prefix(&Path::new("foo/ba")).is_none());

		// Test edge cases
		let prefix = Path::new("foobar");
		assert!(prefix.strip_prefix(&Path::new("foo")).is_none());
		assert_eq!(prefix.strip_prefix(&Path::new("foobar")).unwrap().as_str(), "");

		// Test empty prefix
		let prefix = Path::new("");
		assert_eq!(prefix.strip_prefix(&Path::new("")).unwrap().as_str(), "");
		assert!(prefix.strip_prefix(&Path::new("foo")).is_none());

		// Test single component
		let prefix = Path::new("foo");
		assert_eq!(prefix.strip_prefix(&Path::new("foo")).unwrap().as_str(), "");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/")).unwrap().as_str(), ""); // "foo/" becomes "foo" after trimming

		// Test trailing slash handling
		let prefix = Path::new("foo/bar/");
		assert_eq!(prefix.strip_prefix(&Path::new("foo")).unwrap().as_str(), "bar");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/")).unwrap().as_str(), "bar");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/bar")).unwrap().as_str(), "");
		assert_eq!(prefix.strip_prefix(&Path::new("foo/bar/")).unwrap().as_str(), "");
	}
}