knave 0.14.14

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use std::path::{Component, Path, PathBuf};

use super::program_file::ProgramFile;

pub enum RepositoryAddress<'u> {
    Remote(&'u str),
    Local(PathBuf),
}

#[derive(Clone)]
pub struct CheckoutBounds {
    root: PathBuf,
}

impl<'u> RepositoryAddress<'u> {
    const SCHEME_SEPARATOR: &'static str = "://";
    const FILE_SCHEME: &'static str = "file";
    const HOST_SEPARATOR: char = ':';
    const PATH_SEPARATOR: char = '/';

    pub fn of(url: &'u str) -> Self {
        if let Some((scheme, rest)) = url.split_once(Self::SCHEME_SEPARATOR) {
            return match scheme {
                Self::FILE_SCHEME => Self::Local(PathBuf::from(rest)),
                _ => Self::Remote(url),
            };
        }
        if Self::is_host_and_path(url) {
            return Self::Remote(url);
        }
        Self::Local(PathBuf::from(url))
    }

    fn is_host_and_path(url: &str) -> bool {
        let Some(host_end) = url.find(Self::HOST_SEPARATOR) else {
            return false;
        };
        !url[..host_end].contains(Self::PATH_SEPARATOR)
    }
}

impl CheckoutBounds {
    pub fn of(checkout: &Path) -> Self {
        Self {
            root: Self::resolved(checkout),
        }
    }

    pub fn root(&self) -> &Path {
        &self.root
    }

    pub fn contains(&self, path: &Path) -> bool {
        Self::resolved(path).starts_with(&self.root)
    }

    fn resolved(path: &Path) -> PathBuf {
        path.ancestors()
            .find_map(|ancestor| {
                let canonical = ProgramFile::canonical(ancestor)?;
                let rest = path.strip_prefix(ancestor).ok()?;
                Some(Self::without_parent_steps(&canonical.join(rest)))
            })
            .unwrap_or_else(|| Self::without_parent_steps(path))
    }

    fn without_parent_steps(path: &Path) -> PathBuf {
        let mut resolved = PathBuf::new();
        for component in path.components() {
            match component {
                Component::ParentDir => {
                    resolved.pop();
                }
                Component::CurDir => {}
                other => resolved.push(other),
            }
        }
        resolved
    }
}