| // Copyright 2023 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| //! A FileRelativePathBuf is a path which is stored in a file as being relative |
| //! to the file it's stored in. |
| //! |
| //! When a file contains paths to other files, those paths either need to be |
| //! absolute, or need to relative to some base. Consider the following tree of |
| //! directories and files: |
| //! |
| //! ``` |
| //! <root>/ |
| //! +-- resources/ |
| //! +-- foo/ |
| //! | +-- file_1.json |
| //! +-- bar/ |
| //! | +-- file_2.json |
| //! | +-- file_3.json |
| //! +-- manifest.json |
| //! ``` |
| //! |
| //! The file `manifest.json` contains the paths to each of the json files. |
| //! |
| //! If those paths are relative to itself (ie, file-relative), then they would |
| //! be: |
| //! |
| //! - foo/file_1.json |
| //! - bar/file_2.json |
| //! - bar/file_3.json |
| //! |
| //! However, for a program running in the root folder, the path to the |
| //! `manifest.json` file is `resources/manifest.json`, and the paths to the json |
| //! files it lists, when "resolved" against the path to the `manifest.json` file |
| //! are: |
| //! |
| //! - resources/foo/file_1.json |
| //! - resources/bar/file_2.json |
| //! - resources/bar/file_3.json |
| //! |
| //! This crate is meant to simplify the parsing and use of these files by |
| //! performing most of the path resolution and relativization. |
| //! |
| //! This crate offers two pieces that work in concert, an enum for the paths in |
| //! the file (to track their file-relative or resolved state), and a trait which |
| //! can be easily implemented by structs that contain these paths to handle the |
| //! conversion of the structure from one form to another. |
| //! |
| |
| use anyhow::{anyhow, Result}; |
| use camino::{Utf8Path, Utf8PathBuf}; |
| use pathdiff::diff_utf8_paths; |
| use schemars::JsonSchema; |
| use serde::{Deserialize, Serialize}; |
| |
| /// A Utf8PathBuf which can be either file-relative, or has been resolved with |
| /// the path to the containing file. |
| /// |
| /// The 'serde::Deserialize' implementation results in these path being in the |
| /// file-relative state. |
| /// |
| /// The FileRelativePathBuf has 'From' implementations that create it in the |
| /// "resolved" state when converting from path formats that are used by an |
| /// application (str, String, Utf8Path, Utf8PathBuf, etc.) |
| /// |
| /// ``` |
| /// use assembly_file_relative_path::FileRelativePathBuf; |
| /// |
| /// let path: FileRelativePathBuf = "some/path/to/file_1.json".into(); |
| /// assert_eq!( |
| /// path, |
| /// FileRelativePathBuf::Resolved("some/path/to/file_1.json".into()) |
| /// ); |
| /// |
| /// let relative = path.make_relative_to_dir("some/path")?; |
| /// assert_eq!( |
| /// relative, |
| /// FileRelativePathBuf::FileRelative("to/file_1.json".into()) |
| /// ); |
| /// ``` |
| /// |
| #[derive(Debug, Deserialize, Serialize, Clone, PartialEq, JsonSchema)] |
| #[serde(from = "FileRelativePathBufSerializationHelper")] |
| #[serde(into = "FileRelativePathBufSerializationHelper")] |
| pub enum FileRelativePathBuf { |
| /// The path is file-relative. |
| /// |
| /// For structs that are stored in files that contain to other paths, which |
| /// are relative to the containing file, this is the serialized form of this |
| /// type. |
| /// |
| /// When first deserialized file a file (or otherwise using |
| /// 'serde::Deserialize`, this is the state that the FileRelativePathBuf |
| /// will be in. |
| /// |
| /// From this state, it can can be resolved against the path to the |
| /// containing file to make it usable by the application. |
| #[schemars(schema_with = "path_schema")] |
| FileRelative(Utf8PathBuf), |
| |
| /// The path has been 'resolved'. This is the state it's in when created directly |
| /// using From/Into. This state can be made relative from a path to a file |
| /// that will contain this path as a file-relative path. |
| #[schemars(schema_with = "path_schema")] |
| Resolved(Utf8PathBuf), |
| } |
| |
| fn path_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema { |
| let mut schema: schemars::schema::SchemaObject = <String>::json_schema(gen).into(); |
| schema.format = Some("Utf8PathBuf".to_owned()); |
| schema.into() |
| } |
| |
| impl FileRelativePathBuf { |
| /// Convert the file-relative path into a resolved path that combines the |
| /// 'path_to_dir' and the file-relative path together. |
| /// |
| /// NOTE: This version takes a path to a _directory_, while the |
| /// `resolve_path_from_file()` fn takes a path to a _file_. |
| /// |
| /// ``` |
| /// let path = FileRelativePathBuf::FileRelative("foo/file_1.json".into()); |
| /// let resolved_path = path.resolve_from_dir("resources".into()); |
| /// |
| /// assert_eq!( |
| /// resolved_path, |
| /// Some(FileRelativePathBuf::Resolved("resources/foo/file_1.json")) |
| /// ); |
| ///``` |
| pub fn resolve_from_dir(self, path_to_dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| match self { |
| FileRelativePathBuf::FileRelative(file_relative) => { |
| Ok(Self::Resolved(path_to_dir.as_ref().join(file_relative))) |
| } |
| passthrough @ FileRelativePathBuf::Resolved(..) => Ok(passthrough), |
| } |
| } |
| |
| /// Take a resolved path, and make it relative to a file. |
| /// |
| /// ``` |
| /// let resolved_path = FileRelativePathBuf::Resolved("resources/bar/file_2.json".into()); |
| /// let file_relative = resolved_path.make_relative_to_file("resources/manifest.json".into()); |
| /// |
| /// assert_eq!( |
| /// file_relative, |
| /// Some(FileRelativePathBuf::FileRelative("bar/file_2.json")) |
| /// ); |
| /// ``` |
| pub fn make_relative_to_file(self, path_to_file: impl AsRef<Utf8Path>) -> Result<Self> { |
| match self { |
| resolved @ Self::Resolved(..) => { |
| let dir = get_file_parent_dir(path_to_file.as_ref())?; |
| resolved.make_relative_to_dir(dir) |
| } |
| passthrough @ Self::FileRelative(..) => Ok(passthrough), |
| } |
| } |
| |
| /// Take a resolved path, and make it relative to a directory. |
| /// |
| /// ``` |
| /// let resolved_path = FileRelativePathBuf::Resolved("resources/bar/file_2.json".into()); |
| /// let file_relative = resolved_path.make_relative_to_dir("resources"); |
| /// |
| /// assert_eq!( |
| /// file_relative, |
| /// Some(FileRelativePathBuf::FileRelative("bar/file_2.json")) |
| /// ); |
| /// ``` |
| pub fn make_relative_to_dir(self, dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| match self { |
| Self::Resolved(resolved) => { |
| let file_relative = diff_utf8_paths(&resolved, &dir).ok_or_else(|| { |
| anyhow!( |
| "Unable to make a path to '{}' that's relative to '{}'.", |
| resolved, |
| dir.as_ref() |
| ) |
| })?; |
| Ok(Self::FileRelative(file_relative)) |
| } |
| passthrough @ Self::FileRelative { .. } => Ok(passthrough), |
| } |
| } |
| |
| /// Use this FileRelativePathBuf as a simple Utf8PathBuf |
| pub fn as_utf8_pathbuf(&self) -> &Utf8PathBuf { |
| match self { |
| FileRelativePathBuf::FileRelative(path_in_file) => path_in_file, |
| FileRelativePathBuf::Resolved(resolved_path) => resolved_path, |
| } |
| } |
| |
| /// Convert this FileRelativePathBuf to a simple Utf8PathBuf |
| pub fn to_utf8_pathbuf(self) -> Utf8PathBuf { |
| match self { |
| FileRelativePathBuf::FileRelative(path_in_file) => path_in_file, |
| FileRelativePathBuf::Resolved(resolved_path) => resolved_path, |
| } |
| } |
| } |
| |
| /// This trait can be implemented by structs to allow them to easily resolve or |
| /// make file-relative all of their FileRelativePathBuf fields. |
| /// |
| /// The implementation of this trait is straightforward, and can be moved to a |
| /// derive macro in the future. |
| /// |
| /// ``` |
| /// struct Foo { |
| /// some_relative_path: FileRelativePathBuf, |
| /// some_flag: bool, |
| /// child: Bar, // also impl's SupportsFileRelativePaths |
| /// } |
| /// |
| /// struct Bar { |
| /// some_other_path: FileRelativePathBuf |
| /// } |
| /// |
| /// impl SupportsFileRelativePaths for Foo { |
| /// |
| /// fn resolve_paths_from_dir(self, path_to_dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| /// let path_to_file = path_to_file.as_ref(); |
| /// Ok( Self { |
| /// some_relative_path: self.some_relative_path.resolve_path_from_dir(&path_to_dir)?, |
| /// child: self.child.resolve_paths_from_dir(&path_to_dir)?, |
| /// ..self |
| /// }) |
| /// } |
| /// } |
| /// |
| /// let foo = Foo{ ... } |
| /// let resolved = foo.resolve_paths_from_file("path/to/file.txt")?; |
| /// |
| /// ``` |
| pub trait SupportsFileRelativePaths { |
| /// After deserializing a file containing file-relative paths, this function |
| /// is used to convert all the FileRelativePathBufs into their resolved form. |
| /// |
| /// This is used after deserializing the struct from a file, with the path |
| /// to that file. |
| /// |
| /// ``` |
| /// struct Foo { |
| /// some_path: FileRelativePathBuf, |
| /// } |
| /// // trait impl omitted for brevity. |
| /// |
| /// let foo = Foo { |
| /// some_path: FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// }; |
| /// let foo_resolved = foo.resolve_paths_from_file("path/to/containing_file.json")?; |
| /// |
| /// assert_eq( |
| /// foo_resolved.some_path, |
| /// FileRelativePathBuf::Resolved("path/to/some/file.json".into()) |
| /// ); |
| /// ``` |
| fn resolve_paths_from_file(self, path_to_containing_file: impl AsRef<Utf8Path>) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| let dir = get_file_parent_dir(path_to_containing_file.as_ref())?; |
| self.resolve_paths_from_dir(&dir) |
| } |
| |
| /// Convert all the FileRelativePathBufs in this struct (recursively) into |
| /// the Resolved state, using the path to the directory of the file that |
| /// contains file-relative paths. |
| /// |
| /// This is the function that needs to be implemented by structs. |
| /// |
| /// ``` |
| /// struct Foo { |
| /// some_path: FileRelativePathBuf, |
| /// } |
| /// // trait impl omitted for brevity. |
| /// |
| /// let foo = Foo { |
| /// some_path: FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// }; |
| /// let foo_resolved = foo.resolve_paths_from_dir("path/to".into())?; |
| /// |
| /// assert_eq( |
| /// foo_resolved.some_path, |
| /// FileRelativePathBuf::Resolved("path/to/some/file.json".into()) |
| /// ); |
| /// ``` |
| fn resolve_paths_from_dir(self, dir_path: impl AsRef<Utf8Path>) -> Result<Self> |
| where |
| Self: Sized; |
| |
| /// Convert all the FileRelativePathBufs in this struct (recursively) into |
| /// the FileRelative state, using the path to the file that will contain the |
| /// file-relative paths. |
| /// |
| /// This is used before serializing the struct to a file, with the path to |
| /// that file. |
| /// |
| /// ``` |
| /// struct Foo { |
| /// some_path: FileRelativePathBuf, |
| /// } |
| /// // trait impl omitted for brevity. |
| /// |
| /// let foo = Foo { |
| /// some_path: FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// }; |
| /// let foo_relative = foo.make_paths_relative_to_file("path/to/containing_file.json".into())?; |
| /// |
| /// assert_eq( |
| /// foo_relative.some_path, |
| /// FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// ); |
| /// ``` |
| fn make_paths_relative_to_file( |
| self, |
| path_to_containing_file: impl AsRef<Utf8Path>, |
| ) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| let dir = get_file_parent_dir(path_to_containing_file.as_ref())?; |
| self.make_paths_relative_to_dir(&dir) |
| } |
| |
| /// Convert all the FileRelativePathBufs in this struct (recursively) into |
| /// the FileRelative state, using the path to the directory of the file that |
| /// will contain the file-relative paths. |
| /// |
| /// This is the function that needs to be implemented by structs. |
| /// |
| /// ``` |
| /// struct Foo { |
| /// some_path: FileRelativePathBuf, |
| /// } |
| /// // trait impl omitted for brevity. |
| /// |
| /// let foo = Foo { |
| /// some_path: FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// }; |
| /// let foo_relative = foo.make_paths_relative_to_file("path/to".into())?; |
| /// |
| /// assert_eq( |
| /// foo_relative.some_path, |
| /// FileRelativePathBuf::FileRelative("some/file.json".into()) |
| /// ); |
| /// ``` |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> |
| where |
| Self: Sized; |
| } |
| |
| /// A helper function to get the parent of a Utf8Path, or return an error |
| /// that the given path doesn't have a parent. |
| fn get_file_parent_dir(file_path: impl AsRef<Utf8Path>) -> Result<Utf8PathBuf> { |
| file_path.as_ref().parent().map(Into::into).ok_or_else(|| { |
| anyhow!("The given file path does not have a parent: {}", file_path.as_ref()) |
| }) |
| } |
| |
| // Implement SupportsFileRelativePaths for FileRelativePathBuf so there is |
| // has an implementation that satisfies Option<T: SupportsFileRelativePaths> for |
| // Option<FileRelativePathBuf> |
| impl SupportsFileRelativePaths for FileRelativePathBuf { |
| fn resolve_paths_from_dir(self, dir_path: impl AsRef<Utf8Path>) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| self.resolve_from_dir(dir_path) |
| } |
| |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| self.make_relative_to_dir(path_to_containing_dir) |
| } |
| } |
| |
| // |
| // Serialization / Deserialization implementations for FileRelativePathBuf |
| // |
| |
| /// This struct is used by serde to perform the Serialization and Deserialization |
| /// of the FileRelativePathBuf. |
| #[derive(Debug, Clone, Deserialize, Serialize)] |
| struct FileRelativePathBufSerializationHelper(Utf8PathBuf); |
| |
| impl From<FileRelativePathBufSerializationHelper> for FileRelativePathBuf { |
| fn from(value: FileRelativePathBufSerializationHelper) -> Self { |
| FileRelativePathBuf::FileRelative(value.0) |
| } |
| } |
| |
| impl Into<FileRelativePathBufSerializationHelper> for FileRelativePathBuf { |
| fn into(self) -> FileRelativePathBufSerializationHelper { |
| FileRelativePathBufSerializationHelper(self.into()) |
| } |
| } |
| |
| // |
| // Conversion implementations for FileRelativePathBuf |
| // |
| |
| // The FileRelativePathBuf can be converted into a standard Utf8PathBuf in either |
| // form. |
| impl From<FileRelativePathBuf> for Utf8PathBuf { |
| fn from(value: FileRelativePathBuf) -> Self { |
| value.to_utf8_pathbuf() |
| } |
| } |
| |
| impl AsRef<Utf8Path> for FileRelativePathBuf { |
| fn as_ref(&self) -> &Utf8Path { |
| self.as_utf8_pathbuf() |
| } |
| } |
| |
| impl AsRef<std::path::Path> for FileRelativePathBuf { |
| fn as_ref(&self) -> &std::path::Path { |
| self.as_utf8_pathbuf().as_std_path() |
| } |
| } |
| |
| // Creating a FileRelativePathBuf from a Utf8PathBuf or a string of some kind |
| // will always create it in the resolved state (since this is likely the format |
| // that those paths will be in). |
| impl From<Utf8PathBuf> for FileRelativePathBuf { |
| fn from(value: Utf8PathBuf) -> Self { |
| Self::Resolved(value) |
| } |
| } |
| |
| impl From<String> for FileRelativePathBuf { |
| fn from(string: String) -> FileRelativePathBuf { |
| FileRelativePathBuf::Resolved(string.into()) |
| } |
| } |
| |
| impl std::str::FromStr for FileRelativePathBuf { |
| type Err = std::convert::Infallible; |
| |
| fn from_str(s: &str) -> Result<Self, Self::Err> { |
| Ok(FileRelativePathBuf::Resolved(s.into())) |
| } |
| } |
| |
| impl<T: ?Sized + AsRef<str>> From<&T> for FileRelativePathBuf { |
| fn from(s: &T) -> FileRelativePathBuf { |
| FileRelativePathBuf::from(s.as_ref().to_owned()) |
| } |
| } |
| |
| impl std::fmt::Display for FileRelativePathBuf { |
| fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| AsRef::<Utf8Path>::as_ref(self).fmt(f) |
| } |
| } |
| |
| // |
| // Trait implementations for various containers of FileRelativePathBuf |
| // |
| |
| impl<T: SupportsFileRelativePaths> SupportsFileRelativePaths for Vec<T> { |
| fn resolve_paths_from_dir(self, dir_path: impl AsRef<Utf8Path>) -> Result<Self> { |
| self.into_iter().map(|p| p.resolve_paths_from_dir(&dir_path)).collect() |
| } |
| |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> { |
| self.into_iter().map(|p| p.make_paths_relative_to_dir(&path_to_containing_dir)).collect() |
| } |
| } |
| |
| impl<T: SupportsFileRelativePaths> SupportsFileRelativePaths for Option<T> { |
| fn resolve_paths_from_dir(self, dir_path: impl AsRef<Utf8Path>) -> Result<Self> { |
| self.map(|s| s.resolve_paths_from_dir(dir_path)).transpose() |
| } |
| |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> { |
| self.map(|s| s.make_paths_relative_to_dir(path_to_containing_dir)).transpose() |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| use std::str::FromStr; |
| |
| #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)] |
| struct SimpleStruct { |
| flag: bool, |
| path: FileRelativePathBuf, |
| } |
| |
| impl SupportsFileRelativePaths for SimpleStruct { |
| fn resolve_paths_from_dir(self, path_to_dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| Ok(Self { path: self.path.resolve_from_dir(path_to_dir)?, ..self }) |
| } |
| |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> { |
| Ok(Self { path: self.path.make_relative_to_dir(path_to_containing_dir)?, ..self }) |
| } |
| } |
| |
| #[test] |
| fn test_standard_usage_simple_struct() { |
| let json = serde_json::json!({ |
| "flag": true, |
| "path": "foo/file_1.json" |
| }); |
| |
| // The parsed file uses "file-relative" paths |
| let parsed: SimpleStruct = serde_json::from_value(json).unwrap(); |
| assert_eq!( |
| &parsed, |
| &SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()) |
| } |
| ); |
| |
| // After resolving, they will be "resolved" paths |
| let resolved = parsed.resolve_paths_from_file("resources/manifest.json").unwrap(); |
| assert_eq!( |
| resolved, |
| SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::Resolved("resources/foo/file_1.json".into()) |
| } |
| ); |
| |
| // When created from paths/strings, they will start as "resolved" |
| let created = SimpleStruct { flag: false, path: "resources/foo/file_1.json".into() }; |
| assert_eq!( |
| &created, |
| &SimpleStruct { |
| flag: false, |
| path: FileRelativePathBuf::Resolved("resources/foo/file_1.json".into()) |
| } |
| ); |
| |
| // And then can be made relative |
| let relative = created.make_paths_relative_to_file("resources/manifest.json").unwrap(); |
| assert_eq!( |
| relative, |
| SimpleStruct { |
| flag: false, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()) |
| } |
| ); |
| |
| // The re-serialized value should be the same as it originally was. |
| let serialized = serde_json::to_value(relative).unwrap(); |
| assert_eq!( |
| serialized, |
| serde_json::json!({ |
| "flag": false, |
| "path": "foo/file_1.json" |
| }) |
| ) |
| } |
| |
| #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)] |
| struct ParentStruct { |
| name: String, |
| some_path: FileRelativePathBuf, |
| child: SimpleStruct, |
| } |
| |
| impl SupportsFileRelativePaths for ParentStruct { |
| fn resolve_paths_from_dir(self, path_to_dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| Ok(Self { |
| // Convert the path in this struct |
| some_path: self.some_path.resolve_from_dir(&path_to_dir)?, |
| |
| // Convert the fields that implement this trait |
| child: self.child.resolve_paths_from_dir(&path_to_dir)?, |
| |
| // and forward the rest of the fields |
| ..self |
| }) |
| } |
| |
| fn make_paths_relative_to_dir(self, path_to_dir: impl AsRef<Utf8Path>) -> Result<Self> { |
| Ok(Self { |
| // Convert the path in this struct |
| some_path: self.some_path.make_relative_to_dir(&path_to_dir)?, |
| |
| // Convert the fields that implement this trait |
| child: self.child.make_paths_relative_to_dir(&path_to_dir)?, |
| |
| // and forward the rest of the fields |
| ..self |
| }) |
| } |
| } |
| |
| #[test] |
| fn test_standard_usage_nested_struct() { |
| let json = serde_json::json!({ |
| "name": "A name", |
| "some_path": "bar/file_2.json", |
| "child": { |
| "flag": true, |
| "path": "foo/file_1.json" |
| } |
| }); |
| |
| // The parsed file uses "file-relative" paths |
| let parsed: ParentStruct = serde_json::from_value(json).unwrap(); |
| assert_eq!( |
| &parsed, |
| &ParentStruct { |
| name: "A name".into(), |
| some_path: FileRelativePathBuf::FileRelative("bar/file_2.json".into()), |
| child: SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()) |
| } |
| } |
| ); |
| |
| // And then can be resolved: |
| let resolved = parsed.resolve_paths_from_file("resources/manifest.json").unwrap(); |
| assert_eq!( |
| resolved, |
| ParentStruct { |
| name: "A name".into(), |
| some_path: FileRelativePathBuf::Resolved("resources/bar/file_2.json".into()), |
| child: SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::Resolved("resources/foo/file_1.json".into()) |
| } |
| } |
| ); |
| |
| // Create a new one (say after copying): |
| let created = ParentStruct { |
| name: "A name".into(), |
| some_path: "some/new/location/bar/file_2.json".into(), |
| child: SimpleStruct { flag: true, path: "some/new/location/foo/file_1.json".into() }, |
| }; |
| assert_eq!( |
| created.some_path, |
| FileRelativePathBuf::Resolved("some/new/location/bar/file_2.json".into()) |
| ); |
| assert_eq!( |
| created.child.path, |
| FileRelativePathBuf::Resolved("some/new/location/foo/file_1.json".into()) |
| ); |
| |
| // And make relative again: |
| let relative = |
| created.make_paths_relative_to_file("some/new/location/outputs.json").unwrap(); |
| assert_eq!( |
| relative, |
| ParentStruct { |
| name: "A name".into(), |
| some_path: FileRelativePathBuf::FileRelative("bar/file_2.json".into()), |
| child: SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()) |
| } |
| } |
| ); |
| |
| // And then serialize: |
| let serialzed = serde_json::to_value(relative).unwrap(); |
| assert_eq!( |
| serialzed, |
| serde_json::json!({ |
| "name": "A name", |
| "some_path": "bar/file_2.json", |
| "child": { |
| "flag": true, |
| "path": "foo/file_1.json" |
| } |
| }) |
| ); |
| } |
| |
| #[derive(Deserialize)] |
| struct StructWithVec { |
| paths: Vec<FileRelativePathBuf>, |
| } |
| |
| impl SupportsFileRelativePaths for StructWithVec { |
| fn resolve_paths_from_dir(self, dir_path: impl AsRef<Utf8Path>) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| Ok(Self { paths: self.paths.resolve_paths_from_dir(dir_path)? }) |
| } |
| |
| fn make_paths_relative_to_dir( |
| self, |
| path_to_containing_dir: impl AsRef<Utf8Path>, |
| ) -> Result<Self> |
| where |
| Self: Sized, |
| { |
| Ok(Self { paths: self.paths.make_paths_relative_to_dir(path_to_containing_dir)? }) |
| } |
| } |
| |
| #[test] |
| fn test_trait_impl_vec_resolve() { |
| let json = serde_json::json!({ |
| "paths": [ |
| "file_1", |
| "file_2", |
| "file_3" |
| ] |
| }); |
| |
| let parsed: StructWithVec = serde_json::from_value(json).unwrap(); |
| assert_eq!( |
| &parsed.paths, |
| &vec![ |
| FileRelativePathBuf::FileRelative("file_1".into()), |
| FileRelativePathBuf::FileRelative("file_2".into()), |
| FileRelativePathBuf::FileRelative("file_3".into()), |
| ] |
| ); |
| |
| let resolved = parsed.resolve_paths_from_file("some/manifest").unwrap(); |
| assert_eq!( |
| &resolved.paths, |
| &vec![ |
| FileRelativePathBuf::Resolved("some/file_1".into()), |
| FileRelativePathBuf::Resolved("some/file_2".into()), |
| FileRelativePathBuf::Resolved("some/file_3".into()), |
| ] |
| ); |
| } |
| |
| #[test] |
| fn test_trait_impl_vec_make_relative() { |
| let created = StructWithVec { |
| paths: vec!["some/file_1".into(), "some/file_2".into(), "some/file_3".into()], |
| }; |
| |
| let relative = created.make_paths_relative_to_file("some/other_manifest").unwrap(); |
| assert_eq!( |
| &relative.paths, |
| &vec![ |
| FileRelativePathBuf::FileRelative("file_1".into()), |
| FileRelativePathBuf::FileRelative("file_2".into()), |
| FileRelativePathBuf::FileRelative("file_3".into()), |
| ] |
| ); |
| } |
| |
| #[test] |
| fn test_trait_impl_option_resolve() { |
| let option = Some(SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("a/file.json".into()), |
| }); |
| let resolved = option.resolve_paths_from_file("some/manifest.list").unwrap(); |
| assert_eq!( |
| resolved, |
| Some(SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::Resolved("some/a/file.json".into()) |
| }) |
| ); |
| } |
| |
| #[test] |
| fn test_trait_impl_option_make_relative() { |
| let option = Some(SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::Resolved("some/a/file.json".into()), |
| }); |
| let resolved = option.make_paths_relative_to_file("some/manifest.list").unwrap(); |
| assert_eq!( |
| resolved, |
| Some(SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("a/file.json".into()) |
| }) |
| ); |
| } |
| |
| #[test] |
| fn test_trait_resolve_usage() { |
| let parsed = SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()), |
| }; |
| let resolved = parsed.resolve_paths_from_file("resources/manifest.json").unwrap(); |
| assert_eq!( |
| resolved, |
| SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::Resolved("resources/foo/file_1.json".into()) |
| } |
| ); |
| } |
| |
| #[test] |
| fn test_trait_make_relative_usage() { |
| let original = SimpleStruct { flag: true, path: "resources/foo/file_1.json".into() }; |
| let relative = original.make_paths_relative_to_file("resources/manifest.json").unwrap(); |
| assert_eq!( |
| relative, |
| SimpleStruct { |
| flag: true, |
| path: FileRelativePathBuf::FileRelative("foo/file_1.json".into()) |
| } |
| ) |
| } |
| |
| #[test] |
| fn test_field_from_str() { |
| // Validate that when creating from a string, it's always a 'resolved' path. |
| let created = FileRelativePathBuf::from_str("resources/foo/file_2.json").unwrap(); |
| assert_eq!(created, FileRelativePathBuf::Resolved("resources/foo/file_2.json".into())); |
| } |
| |
| #[test] |
| fn test_field_from_string() { |
| let created = FileRelativePathBuf::from(&String::from("resources/foo/file_2.json")); |
| assert_eq!(created, FileRelativePathBuf::Resolved("resources/foo/file_2.json".into())) |
| } |
| |
| #[test] |
| fn test_field_resolve_from_dir() { |
| let parsed = FileRelativePathBuf::FileRelative("foo/file_2.json".into()); |
| let resolved = parsed.resolve_from_dir("resources").unwrap(); |
| assert_eq!(resolved, FileRelativePathBuf::Resolved("resources/foo/file_2.json".into())); |
| } |
| |
| #[test] |
| fn test_field_make_relative_to_file() { |
| let original = FileRelativePathBuf::from("foo/bar/baz.json"); |
| let relative = original.make_relative_to_file("foo/file.json").unwrap(); |
| assert_eq!(relative, FileRelativePathBuf::FileRelative("bar/baz.json".into())) |
| } |
| |
| #[test] |
| fn test_field_make_relative_to_dir() { |
| let original = FileRelativePathBuf::from("foo/bar/baz.json"); |
| let relative = original.make_relative_to_dir("foo").unwrap(); |
| assert_eq!(relative, FileRelativePathBuf::FileRelative("bar/baz.json".into())) |
| } |
| |
| #[test] |
| fn test_display() { |
| let original = FileRelativePathBuf::from("foo/bar/baz.json"); |
| assert_eq!(format!("{}", original), "foo/bar/baz.json"); |
| |
| let relative = original.make_relative_to_dir("foo").unwrap(); |
| assert_eq!(format!("{}", relative), "bar/baz.json"); |
| } |
| } |
