xtask-todo-lib 0.1.32

Todo workspace library and cargo devshell subcommand
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Workspace / guest-primary path mapping for builtins.

#[cfg(any(unix, feature = "beta-vm"))]
use crate::devshell::workspace::logical_path_to_guest;
use crate::devshell::workspace::WorkspaceBackendError;

use crate::devshell::workspace::read_logical_file_bytes;
use crate::devshell::workspace::WorkspaceReadError;

use super::super::super::vfs::Vfs;
#[cfg(any(unix, feature = "beta-vm"))]
use super::super::super::vm::GuestFsOps;
use super::super::super::vm::SessionHolder;
use super::super::types::BuiltinError;

pub(super) fn map_workspace_to_builtin(e: WorkspaceBackendError) -> BuiltinError {
    match e {
        WorkspaceBackendError::PathOutsideWorkspace => BuiltinError::WorkspacePathOutside,
        WorkspaceBackendError::Guest(err) => BuiltinError::GuestFsOpFailed(err.to_string()),
        _ => BuiltinError::GuestFsOpFailed(e.to_string()),
    }
}

pub(super) fn map_workspace_read_err(e: WorkspaceReadError) -> BuiltinError {
    match e {
        WorkspaceReadError::Vfs(_) => BuiltinError::CatFailed,
        WorkspaceReadError::Guest(err) => BuiltinError::GuestFsOpFailed(err.to_string()),
        WorkspaceReadError::PathOutsideWorkspace => BuiltinError::WorkspacePathOutside,
        WorkspaceReadError::Backend(err) => map_workspace_to_builtin(err),
    }
}

pub(super) fn workspace_read_file(
    vfs: &mut Vfs,
    vm_session: &mut SessionHolder,
    path: &str,
) -> Result<Vec<u8>, BuiltinError> {
    read_logical_file_bytes(vfs, vm_session, path).map_err(map_workspace_read_err)
}

pub(super) fn workspace_write_file(
    vfs: &mut Vfs,
    vm_session: &mut SessionHolder,
    path: &str,
    data: &[u8],
) -> Result<(), BuiltinError> {
    #[cfg(not(any(unix, feature = "beta-vm")))]
    let _ = vm_session;
    #[cfg(any(unix, feature = "beta-vm"))]
    if let Some((ops, mount)) = vm_session.guest_primary_fs_ops_mut() {
        let gp =
            logical_path_to_guest(&mount, vfs.cwd(), path).map_err(map_workspace_to_builtin)?;
        return GuestFsOps::write_file(ops, &gp, data)
            .map_err(|e| BuiltinError::GuestFsOpFailed(e.to_string()));
    }
    vfs.write_file(path, data)
        .map_err(|_| BuiltinError::RedirectWrite)
}

pub(super) fn workspace_list_dir(
    vfs: &Vfs,
    vm_session: &mut SessionHolder,
    path: &str,
) -> Result<Vec<String>, BuiltinError> {
    #[cfg(not(any(unix, feature = "beta-vm")))]
    let _ = vm_session;
    #[cfg(any(unix, feature = "beta-vm"))]
    if let Some((ops, mount)) = vm_session.guest_primary_fs_ops_mut() {
        let gp =
            logical_path_to_guest(&mount, vfs.cwd(), path).map_err(map_workspace_to_builtin)?;
        return GuestFsOps::list_dir(ops, &gp)
            .map_err(|e| BuiltinError::GuestFsOpFailed(e.to_string()));
    }
    vfs.list_dir(path).map_err(|_| BuiltinError::LsFailed)
}

pub(super) fn workspace_mkdir(
    vfs: &mut Vfs,
    vm_session: &mut SessionHolder,
    path: &str,
) -> Result<(), BuiltinError> {
    #[cfg(not(any(unix, feature = "beta-vm")))]
    let _ = vm_session;
    #[cfg(any(unix, feature = "beta-vm"))]
    if let Some((ops, mount)) = vm_session.guest_primary_fs_ops_mut() {
        let gp =
            logical_path_to_guest(&mount, vfs.cwd(), path).map_err(map_workspace_to_builtin)?;
        return GuestFsOps::mkdir(ops, &gp)
            .map_err(|e| BuiltinError::GuestFsOpFailed(e.to_string()));
    }
    vfs.mkdir(path).map_err(|_| BuiltinError::MkdirFailed)
}

pub(super) fn workspace_touch(
    vfs: &mut Vfs,
    vm_session: &mut SessionHolder,
    path: &str,
) -> Result<(), BuiltinError> {
    #[cfg(not(any(unix, feature = "beta-vm")))]
    let _ = vm_session;
    #[cfg(any(unix, feature = "beta-vm"))]
    if let Some((ops, mount)) = vm_session.guest_primary_fs_ops_mut() {
        let gp =
            logical_path_to_guest(&mount, vfs.cwd(), path).map_err(map_workspace_to_builtin)?;
        return GuestFsOps::write_file(ops, &gp, &[])
            .map_err(|e| BuiltinError::GuestFsOpFailed(e.to_string()));
    }
    vfs.touch(path).map_err(|_| BuiltinError::TouchFailed)
}