nostralink 0.2.4

Linked data library for nostr
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

use language::Language;
use serde::de::Deserializer;
use serde::ser::{Serialize, SerializeStruct, Serializer};
use serde::Deserialize;
use serde_json::{json, Value};

/// Newtype for [`Language`]
#[derive(Debug, Clone)]
pub struct LanguageJLD(pub Language);

/// JSON-LD serialization for [`Language`]
impl Serialize for LanguageJLD {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Language", 5)?;
        state.serialize_field("@id", &lang_iri(self.0))?;
        state.serialize_field("@type", &"Language")?;
        state.serialize_field("@context", &"https://schema.org")?;
        state.serialize_field("name", &self.0.as_str())?;
        state.serialize_field("alternateName", &self.0.as_tag())?;
        state.end()
    }
}

/// Deserialization isn't used
impl<'de> Deserialize<'de> for LanguageJLD {
    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Ok(LanguageJLD(Language::EnGb))
    }
}

/// Returns a URN for that language with the NSS set to "nostr-lang"
/// e.g. <urn:nostr-lang:en-GB>
pub fn lang_iri(lang: Language) -> String {
    format!("urn:nostr-lang:{}", lang.as_tag()).to_string()
}

/// Returns a schema.org Language object for the passed language
pub fn lang_jsonld(lang: Language) -> Value {
    json!({
        "@id": lang_iri(lang),
        "@type": "Language",
        "name": lang.as_str().to_owned(),
        "alternateName": lang.as_tag().to_owned(),
    })
}