use std::collections::BTreeMap;
use std::fmt;
use crate::error::Error;
use crate::filesystem::path::SEPARATOR;
use crate::security::authorization::{ActorId, AuthorizationData};
use super::timestamp::Timestamp;
pub const ROOT_NAME: &str = "/";
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
pub struct Name(String);
impl Name {
pub fn new(name: &str) -> Result<Self, Error> {
if name.is_empty() {
return Err(Error::InvalidName(name.to_owned()));
}
if name.contains(SEPARATOR) {
return Err(Error::InvalidName(name.to_owned()));
}
if name.contains('\0') {
return Err(Error::InvalidName(name.to_owned()));
}
if name == "." || name == ".." {
return Err(Error::InvalidName(name.to_owned()));
}
Ok(Self(name.to_owned()))
}
pub fn root() -> Self {
Self(ROOT_NAME.to_owned())
}
pub fn as_str(&self) -> &str {
&self.0
}
pub fn is_root(&self) -> bool {
self.0 == ROOT_NAME
}
}
impl fmt::Display for Name {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.0.fmt(f)
}
}
#[derive(Clone, PartialEq, Debug)]
pub enum MetadataValue {
String(String),
Integer(i64),
Unsigned(u64),
Float(f64),
Boolean(bool),
}
#[derive(Clone, Debug, PartialEq)]
pub struct Metadata {
name: Name,
created: Timestamp,
modified: Timestamp,
accessed: Timestamp,
owner: Option<ActorId>,
authorization: AuthorizationData,
version: Option<String>,
declared_size: Option<u64>,
extensions: BTreeMap<String, MetadataValue>,
}
impl Metadata {
pub(crate) fn new(name: Name, now: Timestamp) -> Self {
Self {
name,
created: now,
modified: now,
accessed: now,
owner: None,
authorization: AuthorizationData::new(),
version: None,
declared_size: None,
extensions: BTreeMap::new(),
}
}
pub(crate) fn for_root() -> Self {
Self {
name: Name::root(),
created: Timestamp::ZERO,
modified: Timestamp::ZERO,
accessed: Timestamp::ZERO,
owner: None,
authorization: AuthorizationData::new(),
version: None,
declared_size: None,
extensions: BTreeMap::new(),
}
}
pub fn name(&self) -> &Name {
&self.name
}
pub fn created(&self) -> Timestamp {
self.created
}
pub fn modified(&self) -> Timestamp {
self.modified
}
pub fn accessed(&self) -> Timestamp {
self.accessed
}
pub fn owner(&self) -> Option<ActorId> {
self.owner
}
pub fn authorization(&self) -> &AuthorizationData {
&self.authorization
}
pub fn version(&self) -> Option<&str> {
self.version.as_deref()
}
pub fn declared_size(&self) -> Option<u64> {
self.declared_size
}
pub fn extension(&self, key: &str) -> Option<&MetadataValue> {
self.extensions.get(key)
}
pub fn extensions(&self) -> &BTreeMap<String, MetadataValue> {
&self.extensions
}
pub(crate) fn set_name(&mut self, name: Name) {
self.name = name;
}
pub(crate) fn set_modified(&mut self, timestamp: Timestamp) {
self.modified = timestamp;
}
pub(crate) fn set_accessed(&mut self, timestamp: Timestamp) {
self.accessed = timestamp;
}
pub(crate) fn set_owner(&mut self, owner: Option<ActorId>) {
self.owner = owner;
}
pub(crate) fn set_authorization(&mut self, authorization: AuthorizationData) {
self.authorization = authorization;
}
pub(crate) fn apply(&mut self, patch: &MetadataPatch) -> Result<(), Error> {
for key in patch.extensions.keys() {
validate_metadata_key(key)?;
}
if let Some(version) = &patch.version {
self.version = version.clone();
}
if let Some(declared_size) = &patch.declared_size {
self.declared_size = *declared_size;
}
for (key, value) in &patch.extensions {
match value {
Some(value) => {
self.extensions.insert(key.clone(), value.clone());
}
None => {
self.extensions.remove(key);
}
}
}
Ok(())
}
}
fn validate_metadata_key(key: &str) -> Result<(), Error> {
if key.is_empty() {
return Err(Error::InvalidMetadataKey(key.to_owned()));
}
Ok(())
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct MetadataPatch {
pub version: Option<Option<String>>,
pub declared_size: Option<Option<u64>>,
pub extensions: BTreeMap<String, Option<MetadataValue>>,
}
impl MetadataPatch {
pub fn is_empty(&self) -> bool {
self.version.is_none() && self.declared_size.is_none() && self.extensions.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn valid_names_are_accepted() {
for name in ["file.txt", "ls", "a b", "снег", "-"] {
assert!(Name::new(name).is_ok(), "expected {name:?} to be valid");
}
}
#[test]
fn invalid_names_are_rejected() {
for name in ["", "/", "a/b", "a\0b", ".", ".."] {
assert_eq!(
Name::new(name).err(),
Some(Error::InvalidName(name.to_owned())),
"expected {name:?} to be invalid"
);
}
}
#[test]
fn patch_applies_only_present_fields() {
let mut metadata = Metadata::new(Name::new("a").unwrap(), Timestamp::ZERO);
let patch = MetadataPatch {
version: Some(Some("1.0".to_owned())),
..MetadataPatch::default()
};
metadata.apply(&patch).unwrap();
assert_eq!(metadata.version(), Some("1.0"));
assert_eq!(metadata.declared_size(), None);
}
#[test]
fn patch_removes_extensions_with_none() {
let mut metadata = Metadata::new(Name::new("a").unwrap(), Timestamp::ZERO);
metadata
.apply(&MetadataPatch {
extensions: BTreeMap::from([(
"kind".to_owned(),
Some(MetadataValue::String("bundle".to_owned())),
)]),
..MetadataPatch::default()
})
.unwrap();
assert!(metadata.extension("kind").is_some());
metadata
.apply(&MetadataPatch {
extensions: BTreeMap::from([("kind".to_owned(), None)]),
..MetadataPatch::default()
})
.unwrap();
assert!(metadata.extension("kind").is_none());
}
}