treease-cli 1.2.0

Command-line interface for querying, transforming, and previewing structured documents with Treease
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

use std::io;

use treease_core::core::CoreError;

#[derive(Debug, Clone)]
pub(crate) struct ParsedArgs {
    pub(crate) command: CommandKind,
    pub(crate) expression: String,
    pub(crate) files: Vec<String>,
    pub(crate) help: bool,
    pub(crate) null_input: bool,
    pub(crate) exit_status: bool,
    pub(crate) input_format: Option<String>,
    pub(crate) output_format: Option<String>,
    pub(crate) pretty_print: Option<bool>,
    pub(crate) indent: Option<i32>,
    pub(crate) unwrap_scalar: bool,
    pub(crate) no_doc: bool,
    pub(crate) inplace: bool,
    pub(crate) metadata_format: Option<String>,
    pub(crate) metadata_target: Option<String>,
    pub(crate) metadata_category: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum CommandKind {
    Run,
    Web,
    Help,
    OperatorsList,
    OperatorsGet,
    OperatorsSearch,
    FormatsList,
    FormatsGet,
}

impl Default for ParsedArgs {
    fn default() -> Self {
        Self {
            command: CommandKind::Run,
            expression: ".".to_string(),
            files: Vec::new(),
            help: false,
            null_input: false,
            exit_status: false,
            input_format: None,
            output_format: None,
            pretty_print: None,
            indent: None,
            unwrap_scalar: false,
            no_doc: false,
            inplace: false,
            metadata_format: None,
            metadata_target: None,
            metadata_category: None,
        }
    }
}

#[derive(Debug)]
pub(crate) enum CliError {
    #[allow(dead_code)]
    MissingValue(&'static str),
    InvalidIndent(String),
    UnsupportedFormat(String),
    UnsupportedOperator(String),
    InvalidFlagCombination,
    MultipleInputFiles,
    MultipleInputFilesForInplace,
    UnsupportedWebFlag(&'static str),
    InvalidWebInputCount,
    WebAssetDownload(String),
    WebAssetManifest(String),
    WebAssetCache(String),
    #[allow(dead_code)]
    WebServer(String),
    #[allow(dead_code)]
    WebForbidden,
    UnknownCommand(String),
    UnknownFlag(String),
    Eval(String),
    Io(io::Error),
    Core(CoreError),
}

impl From<io::Error> for CliError {
    fn from(value: io::Error) -> Self {
        Self::Io(value)
    }
}

impl From<CoreError> for CliError {
    fn from(value: CoreError) -> Self {
        Self::Core(value)
    }
}

#[derive(Debug, Clone)]
pub(crate) struct InputPayload {
    pub(crate) name: String,
    pub(crate) bytes: Vec<u8>,
}

impl InputPayload {
    pub(crate) fn display_name(&self) -> &str {
        &self.name
    }
}

#[derive(Debug, Clone)]
pub(crate) struct StreamingInput {
    pub(crate) name: String,
    pub(crate) input_format: String,
    pub(crate) source: StreamingInputSource,
}

#[derive(Debug, Clone)]
pub(crate) enum StreamingInputSource {
    Stdin(Vec<u8>),
    FilePath(String),
}

impl StreamingInput {
    pub(crate) fn display_name(&self) -> &str {
        &self.name
    }
}