readmer 0.0.3

Compose README.md files from Jinja2 or Liquid templates.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// This is free and unencumbered software released into the public domain.

use crate::{AncestorPath, FromPathError, Utf8PathBuf};
use alloc::vec::Vec;
use camino::{FromPathBufError, Utf8Components};
use core::str::FromStr;

/// A relative path within the workspace.
pub type WorkspacePath = RootedPath;

/// A rooted path is a path relative to a particular root directory.
///
/// Note that what's meant by the root directory here is *not* the file system
/// root directory, but rather just a root directory of your choice.
#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RootedPath {
    /// The path from the current directory to the root directory.
    pub up: Option<AncestorPath>,

    /// The path from the root directory to the current directory.
    pub down: Utf8PathBuf,
}

impl FromStr for RootedPath {
    type Err = std::io::Error;

    fn from_str(input: &str) -> core::result::Result<Self, Self::Err> {
        use alloc::format;
        use std::io::{Error, ErrorKind};
        let up = AncestorPath::from_str(input).map_err(FromPathError::into_io_error)?;
        let cwd = Utf8PathBuf::try_from(std::env::current_dir()?)
            .map_err(FromPathBufError::into_io_error)?;
        let mut parts = cwd.components().rev().take(up.depth()).collect::<Vec<_>>();
        parts.reverse();
        if parts.len() != up.depth() {
            return Err(Error::new(
                ErrorKind::Other,
                format!("path depth mismatch: {} != {}", parts.len(), up.depth()),
            ));
        }
        let down = Utf8PathBuf::from_iter(parts);
        Ok(Self { up: Some(up), down })
    }
}