sarif_rust 0.3.0

A comprehensive Rust library for parsing, generating, and manipulating SARIF (Static Analysis Results Interchange Format) v2.1.0 files
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

//! SARIF enumeration types
//!
//! This module defines all the enumerated values used throughout the SARIF specification.

use serde::{Deserialize, Serialize};

/// Result importance level
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub enum Level {
    /// Default level - not specified
    #[default]
    None,
    /// Informational note
    Note,
    /// Warning level issue
    Warning,
    /// Error level issue
    Error,
}

/// Result kind classification
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Kind {
    /// Rule does not apply to the analysis target
    NotApplicable,
    /// Rule was evaluated and passed
    Pass,
    /// Rule was evaluated and failed
    Fail,
    /// Rule requires manual review
    Review,
    /// Result represents an open issue
    Open,
    /// Informational result
    Informational,
}

/// Baseline comparison state
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum BaselineState {
    /// New result not present in baseline
    New,
    /// Result unchanged from baseline
    Unchanged,
    /// Result updated from baseline
    Updated,
    /// Result was present in baseline but absent in current run
    Absent,
}

/// Notification importance level
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub enum NotificationLevel {
    /// Default notification level
    #[default]
    None,
    /// Informational notification
    Note,
    /// Warning notification
    Warning,
    /// Error notification
    Error,
}

/// Thread flow kind
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum ThreadFlowKind {
    /// Thread flow represents a path through code
    Path,
    /// Thread flow represents a data flow
    Data,
}

/// Suppression state
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum SuppressionKind {
    /// Result is suppressed in source code
    InSource,
    /// Result is suppressed via external configuration
    External,
}

// Column kind for location regions - ColumnKind moved to run.rs to avoid conflicts

impl std::fmt::Display for Level {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Level::None => write!(f, "none"),
            Level::Note => write!(f, "note"),
            Level::Warning => write!(f, "warning"),
            Level::Error => write!(f, "error"),
        }
    }
}

impl std::fmt::Display for Kind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Kind::NotApplicable => write!(f, "notApplicable"),
            Kind::Pass => write!(f, "pass"),
            Kind::Fail => write!(f, "fail"),
            Kind::Review => write!(f, "review"),
            Kind::Open => write!(f, "open"),
            Kind::Informational => write!(f, "informational"),
        }
    }
}

impl std::fmt::Display for BaselineState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BaselineState::New => write!(f, "new"),
            BaselineState::Unchanged => write!(f, "unchanged"),
            BaselineState::Updated => write!(f, "updated"),
            BaselineState::Absent => write!(f, "absent"),
        }
    }
}