use serde::Deserialize;
use serde::de::{self, IgnoredAny, MapAccess, Visitor};
use std::fmt;
#[derive(Debug, Default, Clone)]
pub struct Instance {
pub contexts: Vec<Context>,
pub units: Vec<Unit>,
pub facts: Vec<RawFact>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct Context {
#[serde(rename = "@id")]
pub id: String,
pub entity: Entity,
pub period: Period,
pub scenario: Option<Scenario>,
}
impl Context {
pub fn explicit_members(&self) -> impl Iterator<Item = &ExplicitMember> {
let segment = self.entity.segment.iter().flat_map(|s| &s.explicit_members);
let scenario = self.scenario.iter().flat_map(|s| &s.explicit_members);
segment.chain(scenario)
}
pub fn typed_members(&self) -> impl Iterator<Item = &TypedMember> {
let segment = self.entity.segment.iter().flat_map(|s| &s.typed_members);
let scenario = self.scenario.iter().flat_map(|s| &s.typed_members);
segment.chain(scenario)
}
pub fn is_consolidated(&self) -> bool {
self.explicit_members().next().is_none() && self.typed_members().next().is_none()
}
}
#[derive(Deserialize, Debug, Clone)]
pub struct Entity {
pub identifier: Identifier,
pub segment: Option<Segment>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct Identifier {
#[serde(rename = "@scheme")]
pub scheme: String,
#[serde(rename = "$text")]
pub value: String,
}
#[derive(Deserialize, Debug, Clone)]
pub struct Period {
pub instant: Option<String>,
#[serde(rename = "startDate")]
pub start_date: Option<String>,
#[serde(rename = "endDate")]
pub end_date: Option<String>,
}
#[derive(Deserialize, Debug, Clone, Default)]
pub struct Segment {
#[serde(rename = "explicitMember", default)]
pub explicit_members: Vec<ExplicitMember>,
#[serde(rename = "typedMember", default)]
pub typed_members: Vec<TypedMember>,
}
#[derive(Deserialize, Debug, Clone, Default)]
pub struct Scenario {
#[serde(rename = "explicitMember", default)]
pub explicit_members: Vec<ExplicitMember>,
#[serde(rename = "typedMember", default)]
pub typed_members: Vec<TypedMember>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct ExplicitMember {
#[serde(rename = "@dimension")]
pub dimension: String,
#[serde(rename = "$text")]
pub value: String,
}
#[derive(Debug, Clone)]
pub struct TypedMember {
pub dimension: String,
pub value: String,
}
impl<'de> Deserialize<'de> for TypedMember {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(Deserialize)]
struct Text {
#[serde(rename = "$text", default)]
text: String,
}
struct TypedMemberVisitor;
impl<'de> Visitor<'de> for TypedMemberVisitor {
type Value = TypedMember;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a typedMember element")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut dimension = None;
let mut value = String::new();
while let Some(key) = map.next_key::<String>()? {
if key == "@dimension" {
dimension = Some(map.next_value()?);
} else if key.starts_with('@') {
map.next_value::<IgnoredAny>()?;
} else if let Ok(text) = map.next_value::<Text>() {
value = text.text;
}
}
Ok(TypedMember {
dimension: dimension.ok_or_else(|| de::Error::missing_field("dimension"))?,
value,
})
}
}
deserializer.deserialize_map(TypedMemberVisitor)
}
}
#[derive(Deserialize, Debug, Clone)]
pub struct Unit {
#[serde(rename = "@id")]
pub id: String,
pub measure: Option<String>,
pub divide: Option<Divide>,
}
#[derive(Debug, Clone)]
pub struct Divide {
pub unit_numerator: UnitMeasure,
pub unit_denominator: UnitMeasure,
}
impl<'de> Deserialize<'de> for Divide {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
struct DivideVisitor;
impl<'de> Visitor<'de> for DivideVisitor {
type Value = Divide;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a divide element with a unitNumerator and a unitDenominator")
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut numerator: Option<UnitMeasure> = None;
let mut denominator: Option<UnitMeasure> = None;
while let Some(key) = map.next_key::<String>()? {
if key.eq_ignore_ascii_case("unitnumerator") {
numerator = Some(map.next_value()?);
} else if key.eq_ignore_ascii_case("unitdenominator") {
denominator = Some(map.next_value()?);
} else {
map.next_value::<IgnoredAny>()?;
}
}
Ok(Divide {
unit_numerator: numerator
.ok_or_else(|| de::Error::missing_field("unitNumerator"))?,
unit_denominator: denominator
.ok_or_else(|| de::Error::missing_field("unitDenominator"))?,
})
}
}
deserializer.deserialize_map(DivideVisitor)
}
}
#[derive(Deserialize, Debug, Clone)]
pub struct UnitMeasure {
pub measure: String,
}
#[derive(Debug, Clone, PartialEq, Default)]
pub enum XbrlValue {
String(String),
#[default]
Nil,
}
impl XbrlValue {
pub fn as_str(&self) -> Option<&str> {
match self {
XbrlValue::String(s) => Some(s),
XbrlValue::Nil => None,
}
}
pub fn is_nil(&self) -> bool {
matches!(self, XbrlValue::Nil)
}
}
#[derive(Default, Debug, Clone)]
pub struct RawFact {
pub full_name: String,
pub local_name: String,
pub context_ref: Option<String>,
pub unit_ref: Option<String>,
pub decimals: Option<String>,
pub format: Option<String>,
pub id: Option<String>,
pub value: XbrlValue,
}
#[cfg(test)]
mod tests {
use super::*;
use quick_xml::de::from_str;
#[test]
fn a_nil_value_is_the_default() {
assert_eq!(RawFact::default().value, XbrlValue::Nil);
assert!(XbrlValue::Nil.is_nil());
assert_eq!(XbrlValue::String("1".into()).as_str(), Some("1"));
}
#[test]
fn a_context_reads_explicit_and_typed_members() {
let context: Context = from_str(
r#"<xbrli:context id="c-1">
<xbrli:entity>
<xbrli:identifier scheme="http://www.sec.gov/CIK">0000320193</xbrli:identifier>
<xbrli:segment>
<xbrldi:explicitMember dimension="us-gaap:StatementClassOfStockAxis">us-gaap:CommonStockMember</xbrldi:explicitMember>
<xbrldi:typedMember dimension="us-gaap:StartDateAxis"><us-gaap:StartDateAxis.domain>2025-09-28</us-gaap:StartDateAxis.domain></xbrldi:typedMember>
</xbrli:segment>
</xbrli:entity>
<xbrli:period><xbrli:instant>2025-09-27</xbrli:instant></xbrli:period>
</xbrli:context>"#,
)
.unwrap();
assert_eq!(context.id, "c-1");
assert_eq!(context.entity.identifier.value, "0000320193");
assert_eq!(context.period.instant.as_deref(), Some("2025-09-27"));
assert!(!context.is_consolidated());
let explicit: Vec<_> = context.explicit_members().collect();
assert_eq!(explicit[0].value, "us-gaap:CommonStockMember");
let typed: Vec<_> = context.typed_members().collect();
assert_eq!(typed[0].dimension, "us-gaap:StartDateAxis");
assert_eq!(typed[0].value, "2025-09-28");
}
#[test]
fn a_context_with_only_a_typed_member_is_not_consolidated() {
let context: Context = from_str(
r#"<context id="c-2">
<entity>
<identifier scheme="http://www.sec.gov/CIK">1</identifier>
<segment><typedMember dimension="x:Axis"><x:Domain xsi:nil="true"/></typedMember></segment>
</entity>
<period><startDate>2025-01-01</startDate><endDate>2025-12-31</endDate></period>
</context>"#,
)
.unwrap();
assert!(!context.is_consolidated());
assert_eq!(context.typed_members().next().unwrap().value, "");
}
#[test]
fn a_ratio_unit_reads_in_either_spelling() {
for (numerator, denominator) in [
("unitNumerator", "unitDenominator"),
("unitnumerator", "unitdenominator"),
] {
let unit: Unit = from_str(&format!(
"<unit id=\"usdPerShare\"><divide>\
<{numerator}><measure>iso4217:USD</measure></{numerator}>\
<{denominator}><measure>xbrli:shares</measure></{denominator}>\
</divide></unit>"
))
.unwrap();
let divide = unit.divide.unwrap();
assert_eq!(divide.unit_numerator.measure, "iso4217:USD");
assert_eq!(divide.unit_denominator.measure, "xbrli:shares");
}
}
}