Skip to main content

provenant/models/
output.rs

1use super::{FileInfo, Package, TopLevelDependency};
2use serde::{Deserialize, Serialize};
3
4pub const OUTPUT_FORMAT_VERSION: &str = "4.0.0";
5
6#[derive(Serialize, Deserialize, Debug)]
7/// Top-level ScanCode-compatible JSON payload.
8pub struct Output {
9    #[serde(skip_serializing_if = "Option::is_none")]
10    pub summary: Option<Summary>,
11    pub headers: Vec<Header>,
12    pub packages: Vec<Package>,
13    pub dependencies: Vec<TopLevelDependency>,
14    pub files: Vec<FileInfo>,
15    pub license_references: Vec<LicenseReference>,
16    pub license_rule_references: Vec<LicenseRuleReference>,
17}
18
19#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
20pub struct Summary {
21    #[serde(skip_serializing_if = "Option::is_none")]
22    pub declared_license_expression: Option<String>,
23    #[serde(skip_serializing_if = "Option::is_none")]
24    pub license_clarity_score: Option<LicenseClarityScore>,
25    #[serde(skip_serializing_if = "Option::is_none")]
26    pub declared_holder: Option<String>,
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub primary_language: Option<String>,
29    #[serde(default, skip_serializing_if = "Vec::is_empty")]
30    pub other_languages: Vec<TallyEntry>,
31}
32
33#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
34pub struct LicenseClarityScore {
35    pub score: usize,
36    pub declared_license: bool,
37    pub identification_precision: bool,
38    pub has_license_text: bool,
39    pub declared_copyrights: bool,
40    pub conflicting_license_categories: bool,
41    pub ambiguous_compound_licensing: bool,
42}
43
44#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
45pub struct TallyEntry {
46    #[serde(skip_serializing_if = "Option::is_none")]
47    pub value: Option<String>,
48    pub count: usize,
49}
50
51#[derive(Serialize, Deserialize, Debug)]
52/// Scan execution metadata stored in `output.headers`.
53pub struct Header {
54    pub start_timestamp: String,
55    pub end_timestamp: String,
56    pub duration: f64,
57    pub extra_data: ExtraData,
58    pub errors: Vec<String>,
59    pub output_format_version: String,
60}
61
62#[derive(Serialize, Deserialize, Debug)]
63/// Additional counters and environment details for a scan run.
64pub struct ExtraData {
65    pub files_count: usize,
66    pub directories_count: usize,
67    pub excluded_count: usize,
68    pub system_environment: SystemEnvironment,
69}
70
71#[derive(Serialize, Deserialize, Debug)]
72/// Host environment information captured during scan execution.
73pub struct SystemEnvironment {
74    pub operating_system: Option<String>,
75    pub cpu_architecture: String,
76    pub platform: String,
77    pub rust_version: String,
78}
79
80#[derive(Serialize, Deserialize, Debug)]
81/// Reference entry for a detected license.
82pub struct LicenseReference {
83    pub name: String,
84    pub short_name: String,
85    pub spdx_license_key: String,
86    pub text: String,
87}
88
89#[derive(Serialize, Deserialize, Debug)]
90/// Reference metadata for a license detection rule.
91pub struct LicenseRuleReference {
92    pub identifier: String,
93    pub license_expression: String,
94    pub is_license_text: bool,
95    pub is_license_notice: bool,
96    pub is_license_reference: bool,
97    pub is_license_tag: bool,
98    pub is_license_clue: bool,
99    pub is_license_intro: bool,
100}