rudof_cli 0.3.18

RDF and Knowledge Graphs processing tool
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

use crate::cli::parser::CommonArgsAll;
use crate::cli::wrappers::{
    DataFormatCli, DataReaderModeCli, RecursionSemanticsCli, ResultShaclValidationFormatCli, ShaclFormatCli,
    ShaclValidationModeCli, ShaclValidationSortByModeCli,
};
use clap::Args;
use rudof_lib::formats::InputSpec;

/// Arguments for the `shacl-validate` command
#[derive(Debug, Clone, Args)]
pub struct ShaclValidateArgs {
    #[clap(value_parser = clap::value_parser!(InputSpec))]
    pub data: Vec<InputSpec>,

    #[arg(
        short = 't',
        long = "data-format",
        value_name = "FORMAT",
        ignore_case = true,
        help= "RDF Data format",
        default_value_t = DataFormatCli::Turtle
    )]
    pub data_format: DataFormatCli,

    #[arg(
        long = "base-data",
        value_name = "IRI",
        help = "Base IRI (used to resolve relative IRIs in RDF data)"
    )]
    pub base_data: Option<String>,

    /// RDF Reader mode
    #[arg(
        long = "reader-mode",
        value_name = "MODE",
        ignore_case = true,
        help = "RDF Reader mode",
        default_value_t = DataReaderModeCli::Strict,
        value_enum
    )]
    pub reader_mode: DataReaderModeCli,

    #[arg(
        short = 's',
        long = "shapes",
        value_name = "INPUT",
        help = "Shapes graph: file, URI or -, if not set, it assumes the shapes come from the data"
    )]
    pub shapes: Option<InputSpec>,

    #[arg(
        short = 'f',
        long = "shapes-format",
        ignore_case = true,
        value_name = "FORMAT",
        help = "Shapes file format",
        default_value_t = ShaclFormatCli::Turtle
    )]
    pub shapes_format: ShaclFormatCli,

    #[arg(
        long = "base-shapes",
        value_name = "IRI",
        help = "Base IRI (used to resolve relative IRIs in Shapes)"
    )]
    pub base_shapes: Option<String>,

    /// Execution mode
    #[arg(
        short = 'm',
        long = "mode",
        value_name = "MODE",
        ignore_case = true,
        help = "Validation mode. `native` usually used with the in-memory store and \
                `sparql` is intended for remote SPARQL endpoints and Qlever.",
        default_value_t = ShaclValidationModeCli::Native,
        value_enum
    )]
    pub mode: ShaclValidationModeCli,

    #[arg(
        short = 'r',
        long = "result-format",
        ignore_case = true,
        value_name = "FORMAT",
        help = "Ouput result format",
        default_value_t = ResultShaclValidationFormatCli::Details
    )]
    pub result_format: ResultShaclValidationFormatCli,

    #[arg(
        long = "sort_by",
        value_name = "SORT_MODE",
        ignore_case = true,
        help = "Sort result by",
        default_value_t = ShaclValidationSortByModeCli::Severity,
        value_enum
    )]
    pub sort_by: ShaclValidationSortByModeCli,

    #[arg(
        long = "no-errors",
        help = "Don't retain violations in the validation report (default: violations are kept)"
    )]
    pub no_errors: bool,

    #[arg(
        long = "with-evidences",
        help = "Also retain evidence for why (node, shape) pairs conform (default: not kept)"
    )]
    pub with_evidences: bool,

    #[arg(
        long = "evidences-shapes-only",
        help = "With --with-evidences: keep only the per-shape summary (e.g. \"conforms to \
                :PersonShape\"), dropping the finer per-constraint-component evidence \
                (default: keep everything). No effect without --with-evidences."
    )]
    pub evidences_shapes_only: bool,

    #[arg(
        long = "recursion-semantics",
        value_name = "MODE",
        ignore_case = true,
        value_enum,
        help = "Whether to accept a shapes graph with a recursive (cyclic) shape reference, and \
                how to resolve it: `cautious` (default) accepts it and assumes a node caught in \
                the cycle does NOT conform unless proven otherwise; `brave` accepts it and \
                assumes such a node DOES conform as long as that's self-consistent; `none` \
                rejects it outright"
    )]
    pub recursion_semantics: Option<RecursionSemanticsCli>,

    #[command(flatten)]
    pub common: CommonArgsAll,
}