artifactize-tools 0.13.1

Portable scoped tools and safe file access for artifactize.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Typed builtin results. Only the content boundary converts them to dynamic JSON.
use serde::Serialize;

use crate::scope::ArtifactId;

#[derive(Debug, Serialize)]
#[serde(untagged)]
pub(super) enum Output {
    Read(Read),
    List(List),
    Glob(Glob),
    Grep(Grep),
}

/// A listed entry always has a kind.
#[derive(Debug, Serialize)]
pub(super) struct Entry {
    #[serde(flatten)]
    pub kind: EntryKind,
    pub name: String,
    pub path: String,
}

#[derive(Debug, Serialize)]
#[serde(tag = "kind", rename_all = "lowercase")]
pub(super) enum EntryKind {
    File,
    Directory,
    Symlink,
    Other,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct Read {
    pub artifact_id: ArtifactId,
    pub resolved_artifact_id: ArtifactId,
    pub path: String,
    #[serde(flatten)]
    pub rows: ReadRows,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct ReadRows {
    pub lines: Vec<Line>,
    pub start_line: usize,
    pub end_line: Option<usize>,
    pub line_count: usize,
    #[serde(flatten)]
    pub page: ReadPage,
}

/// EOF carries the known total; a bounded page carries only its continuation.
#[derive(Debug)]
pub(super) enum ReadPage {
    Complete { total_lines: usize },
    Bounded { next_offset: usize },
}
impl Serialize for ReadPage {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::SerializeStruct;
        let mut output = serializer.serialize_struct(
            "ReadPage",
            match self {
                Self::Complete { .. } => 3,
                Self::Bounded { .. } => 2,
            },
        )?;
        match self {
            Self::Complete { total_lines } => {
                output.serialize_field("truncated", &false)?;
                output.serialize_field("nextOffset", &Option::<usize>::None)?;
                output.serialize_field("totalLines", total_lines)?;
            }
            Self::Bounded { next_offset } => {
                output.serialize_field("truncated", &true)?;
                output.serialize_field("nextOffset", next_offset)?;
            }
        }
        output.end()
    }
}

#[derive(Debug, Serialize)]
pub(super) struct Line {
    pub number: usize,
    pub text: String,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(super) struct List {
    pub artifact_id: ArtifactId,
    pub path: String,
    pub entries: Vec<Entry>,
    pub total_entries: usize,
    #[serde(flatten)]
    pub page: Page,
}

#[derive(Debug)]
pub(super) enum Page {
    Complete,
    Bounded { next_offset: usize },
}
impl Serialize for Page {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        use serde::ser::SerializeStruct;
        let next = match self {
            Self::Complete => None,
            Self::Bounded { next_offset } => Some(next_offset),
        };
        let mut output = serializer.serialize_struct("Page", 2)?;
        output.serialize_field("truncated", &next.is_some())?;
        output.serialize_field("nextOffset", &next)?;
        output.end()
    }
}

#[derive(Debug, Serialize)]
pub(super) struct Glob {
    pub path: String,
    pub files: Vec<String>,
    pub truncated: bool,
}

#[derive(Debug, Serialize)]
pub(super) struct Grep {
    pub path: String,
    pub matches: Vec<GrepMatch>,
    pub truncated: bool,
}

#[derive(Debug, Serialize)]
pub(super) struct GrepMatch {
    pub path: String,
    pub line: usize,
    pub text: String,
}