use crate::date::PartialDate;
use crate::id::Identifier;
use serde::{Deserialize, Deserializer, Serialize};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Metadata {
#[serde(deserialize_with = "bag")]
pub id: Vec<Identifier>,
#[serde(deserialize_with = "blank_is_none")]
pub title: Option<String>,
#[serde(deserialize_with = "entities")]
pub author: Vec<Entity>,
#[serde(default, deserialize_with = "entities")]
pub editor: Vec<Entity>,
#[serde(rename = "pub_date", deserialize_with = "blank_date_is_none")]
pub published: Option<PartialDate>,
#[serde(default, deserialize_with = "entity")]
pub venue: Option<Entity>,
#[serde(default, deserialize_with = "blank_is_none")]
pub volume: Option<String>,
#[serde(default, deserialize_with = "blank_is_none")]
pub issue: Option<String>,
#[serde(default, deserialize_with = "blank_is_none")]
pub page: Option<String>,
#[serde(rename = "type", default, deserialize_with = "blank_is_none")]
pub type_: Option<String>,
#[serde(default, deserialize_with = "entity")]
pub publisher: Option<Entity>,
}
impl Metadata {
pub fn doi(&self) -> Option<&str> {
self.id.iter().find_map(Identifier::as_doi)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Entity {
pub name: String,
pub ids: Vec<Identifier>,
}
impl Entity {
pub fn family(&self) -> Option<&str> {
self.name.split_once(',').map(|(family, _)| family.trim())
}
pub fn given(&self) -> Option<&str> {
self.name
.split_once(',')
.map(|(_, given)| given.trim())
.filter(|given| !given.is_empty())
}
fn parse(raw: &str) -> Result<Option<Self>, crate::Error> {
let raw = raw.trim();
if raw.is_empty() {
return Ok(None);
}
let (name, ids) = match raw.strip_suffix(']').and_then(|rest| rest.rsplit_once('[')) {
Some((name, ids)) => (name.trim(), Identifier::parse_bag(ids)?),
None => (raw, Vec::new()),
};
Ok(Some(Entity {
name: name.to_string(),
ids,
}))
}
}
fn bag<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<Identifier>, D::Error> {
let raw = String::deserialize(deserializer)?;
Identifier::parse_bag(&raw).map_err(serde::de::Error::custom)
}
fn blank_is_none<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
let raw = String::deserialize(deserializer)?;
let raw = raw.trim();
Ok((!raw.is_empty()).then(|| raw.to_string()))
}
fn blank_date_is_none<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Option<PartialDate>, D::Error> {
let raw = String::deserialize(deserializer)?;
let raw = raw.trim();
if raw.is_empty() {
return Ok(None);
}
raw.parse().map(Some).map_err(serde::de::Error::custom)
}
fn entities<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<Entity>, D::Error> {
let raw = String::deserialize(deserializer)?;
raw.split(';')
.map(Entity::parse)
.collect::<Result<Vec<_>, _>>()
.map(|entities| entities.into_iter().flatten().collect())
.map_err(serde::de::Error::custom)
}
fn entity<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<Entity>, D::Error> {
let raw = String::deserialize(deserializer)?;
Entity::parse(&raw).map_err(serde::de::Error::custom)
}
#[cfg(test)]
mod tests {
use super::*;
const WIRE: &str = r#"{
"id": "doi:10.1016/j.marpol.2021.104855 openalex:W3214241825 omid:br/06220256775",
"title": "Sustainable Regional Industry Development Through Co-Evolution",
"author": "Lindfors, Emil Tomson [omid:ra/06220760311]; Jakobsen, Stig-Erik [omid:ra/06220760312]",
"pub_date": "2022-01",
"issue": "",
"volume": "135",
"venue": "Marine Policy [issn:0308-597X issn:1872-9460 omid:br/062607308]",
"type": "journal article",
"page": "104855",
"publisher": "Elsevier Bv [crossref:78 omid:ra/0610116009]",
"editor": ""
}"#;
#[test]
fn a_record_unpacks_the_strings_meta_packs_structure_into() {
let meta: Metadata = serde_json::from_str(WIRE).unwrap();
assert_eq!(meta.doi(), Some("10.1016/j.marpol.2021.104855"));
assert_eq!(meta.id.len(), 3);
assert_eq!(meta.published.unwrap().to_string(), "2022-01");
assert_eq!(meta.volume.as_deref(), Some("135"));
assert_eq!(meta.type_.as_deref(), Some("journal article"));
}
#[test]
fn the_authors_split_into_one_entity_each() {
let meta: Metadata = serde_json::from_str(WIRE).unwrap();
assert_eq!(meta.author.len(), 2);
assert_eq!(meta.author[0].family(), Some("Lindfors"));
assert_eq!(meta.author[0].given(), Some("Emil Tomson"));
assert_eq!(meta.author[0].ids, vec![Identifier::omid("ra/06220760311")]);
assert_eq!(meta.author[1].family(), Some("Jakobsen"));
}
#[test]
fn a_venue_and_a_publisher_keep_their_identifiers() {
let meta: Metadata = serde_json::from_str(WIRE).unwrap();
let venue = meta.venue.unwrap();
assert_eq!(venue.name, "Marine Policy");
assert!(venue.ids.contains(&Identifier::issn("0308-597X")));
assert_eq!(venue.family(), None);
let publisher = meta.publisher.unwrap();
assert_eq!(publisher.name, "Elsevier Bv");
assert_eq!(publisher.ids.len(), 2);
}
#[test]
fn an_empty_field_is_absent_rather_than_empty() {
let meta: Metadata = serde_json::from_str(WIRE).unwrap();
assert_eq!(meta.issue, None);
assert!(meta.editor.is_empty());
}
#[test]
fn an_entity_without_identifiers_is_still_an_entity() {
let wire = WIRE.replace(
r#""publisher": "Elsevier Bv [crossref:78 omid:ra/0610116009]""#,
r#""publisher": "Some Press""#,
);
let meta: Metadata = serde_json::from_str(&wire).unwrap();
let publisher = meta.publisher.unwrap();
assert_eq!(publisher.name, "Some Press");
assert!(publisher.ids.is_empty());
}
}