Struct Evidence 

pub struct Evidence {
    pub rule: Option<String>,
    pub location: Option<String>,
    pub found: String,
    pub expected: Option<Expected>,
}

A single violation found during a check.

rule identifies what was violated, found shows what triggered it. expected optionally carries what the check expected instead, when the rule name alone isn’t enough to act on.

use scute_core::{Evidence, Expected};

let e = Evidence::with_expected(
    "unknown-type",
    "banana",
    Expected::List(vec!["feat".into(), "fix".into()]),
);
assert_eq!(e.rule.as_deref(), Some("unknown-type"));
assert_eq!(e.found, "banana");
assert!(e.expected.is_some());

Fields

rule: Option<String>

location: Option<String>

found: String

expected: Option<Expected>

Implementations

impl Evidence

pub fn new(rule: &str, found: &str) -> Self

pub fn with_expected(rule: &str, found: &str, expected: Expected) -> Self

Trait Implementations

impl Debug for Evidence

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Evidence

fn eq(&self, other: &Evidence) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Evidence

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Evidence