xbrl-rs 0.3.0

XBRL parser and validation
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

//! Validation of XBRL instance documents against a taxonomy.

mod calculation;
mod dimension;
mod schema;
mod value;

use crate::{InstanceDocument, TaxonomySet};

/// Severity level of a validation message.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Severity {
    /// A violation of a MUST-level XBRL rule. The instance is non-conformant.
    Error,
    /// A calculation inconsistency or soft check. The instance may still be
    /// technically valid but is likely incorrect.
    Warning,
}

/// A single validation finding.
#[derive(Debug, Clone)]
pub struct ValidationMessage {
    /// Error or Warning.
    pub severity: Severity,
    /// Machine-readable rule identifier (e.g., "schema.concept_not_found").
    pub code: String,
    /// Human-readable explanation.
    pub message: String,
    /// The concept name of the fact that triggered this, if applicable.
    pub concept_name: Option<String>,
    /// The context ref of the fact that triggered this, if applicable.
    pub context_ref: Option<String>,
}

/// Collected results of validating an instance document.
#[derive(Debug, Default)]
pub struct ValidationResult {
    pub messages: Vec<ValidationMessage>,
}

impl ValidationResult {
    pub fn new() -> Self {
        Self::default()
    }

    /// All messages with Error severity.
    pub fn errors(&self) -> Vec<&ValidationMessage> {
        self.messages
            .iter()
            .filter(|m| m.severity == Severity::Error)
            .collect()
    }

    /// All messages with Warning severity.
    pub fn warnings(&self) -> Vec<&ValidationMessage> {
        self.messages
            .iter()
            .filter(|m| m.severity == Severity::Warning)
            .collect()
    }

    /// True when no errors were found (warnings are acceptable).
    pub fn is_valid(&self) -> bool {
        !self.messages.iter().any(|m| m.severity == Severity::Error)
    }

    fn add(
        &mut self,
        severity: Severity,
        code: &str,
        message: String,
        concept_name: Option<String>,
        context_ref: Option<String>,
    ) {
        self.messages.push(ValidationMessage {
            severity,
            code: code.to_string(),
            message,
            concept_name,
            context_ref,
        });
    }
}

/// Run all validation checks on schema level and linkbase level (i.e.,
/// calculation, and dimension).
pub fn validate_all(instance: &InstanceDocument, taxonomy: &TaxonomySet) -> ValidationResult {
    let mut result = ValidationResult::new();
    let prepared = value::prepare_fact_values(instance, taxonomy, &mut result);
    schema::validate_schema(instance, taxonomy, &prepared, &mut result);
    calculation::validate_calculations(instance, taxonomy, &prepared, &mut result);
    dimension::validate_dimensions(instance, taxonomy, &mut result);
    result
}