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
125
126
127

use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use yaserde_derive::{YaDeserialize, YaSerialize};

use crate::{Date, PlaceReference};

/// The coverage of a resource.
#[skip_serializing_none]
#[derive(Debug, Serialize, Deserialize, YaSerialize, YaDeserialize, PartialEq, Clone, Default)]
#[yaserde(
    prefix = "gx",
    default_namespace = "gx",
    namespace = "gx: http://gedcomx.org/v1/"
)]
#[non_exhaustive]
pub struct Coverage {
    /// The spatial (i.e., geographic) coverage.
    #[yaserde(prefix = "gx")]
    pub spatial: Option<PlaceReference>,

    /// The temporal coverage.
    #[yaserde(prefix = "gx")]
    pub temporal: Option<Date>,
}

impl Coverage {
    pub fn new(spatial: Option<PlaceReference>, temporal: Option<Date>) -> Self {
        Self { spatial, temporal }
    }
}

#[cfg(test)]
mod test {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn json_deserialize() {
        let json = r#"{
            "spatial" : { "original": "Place reference"},
            "temporal" : { "original": "Original date" }
          }"#;

        let coverage: Coverage = serde_json::from_str(json).unwrap();

        assert_eq!(
            coverage,
            Coverage::new(
                Some(
                    PlaceReference::builder()
                        .original("Place reference")
                        .build()
                ),
                Some(Date::new(Some("Original date"), None))
            )
        )
    }

    #[test]
    fn xml_deserialize() {
        let xml = r#"  <Coverage>
        <spatial>
          <original>Place reference</original>
        </spatial>
        <temporal>
          <original>Original date</original>
        </temporal>
    
      </Coverage>"#;

        let coverage: Coverage = yaserde::de::from_str(xml).unwrap();

        assert_eq!(
            coverage,
            Coverage::new(
                Some(
                    PlaceReference::builder()
                        .original("Place reference")
                        .build()
                ),
                Some(Date::new(Some("Original date"), None))
            )
        )
    }

    #[test]
    fn json_serialize() {
        let coverage = Coverage::new(
            Some(
                PlaceReference::builder()
                    .original("Place reference")
                    .build(),
            ),
            Some(Date::new(Some("Original date"), None)),
        );
        let json = serde_json::to_string(&coverage).unwrap();

        assert_eq!(
            json,
            r#"{"spatial":{"original":"Place reference"},"temporal":{"original":"Original date"}}"#
        )
    }

    #[test]
    fn xml_serialize() {
        let coverage = Coverage::new(
            Some(
                PlaceReference::builder()
                    .original("Place reference")
                    .build(),
            ),
            Some(Date::new(Some("Original date"), None)),
        );

        let config = yaserde::ser::Config {
            write_document_declaration: false,
            ..yaserde::ser::Config::default()
        };

        let xml = yaserde::ser::to_string_with_config(&coverage, &config).unwrap();

        let expected_xml = r#"<Coverage xmlns="http://gedcomx.org/v1/"><spatial><original>Place reference</original></spatial><temporal><original>Original date</original></temporal></Coverage>"#;

        assert_eq!(xml, expected_xml)
    }
}