pubmed-client 0.1.0

An async Rust client for PubMed and PMC APIs for retrieving biomedical research articles
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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use crate::error::Result;
use crate::pmc::models::PmcFullText;

pub mod author;
pub mod metadata;
pub mod reference;
pub mod section;
pub mod xml_utils;

/// Parse PMC XML content into structured data
///
/// This function acts as a coordinator that delegates parsing tasks
/// to specialized parser modules for better maintainability and separation of concerns.
pub fn parse_pmc_xml(xml_content: &str, pmcid: &str) -> Result<PmcFullText> {
    // Delegate to specialized parsers for clean separation of concerns

    // Extract metadata using metadata module functions
    let title = metadata::extract_title(xml_content);
    let journal = metadata::extract_journal_info(xml_content);
    let pub_date = metadata::extract_pub_date(xml_content);
    let doi = metadata::extract_doi(xml_content);
    let pmid = metadata::extract_pmid(xml_content);
    let article_type = metadata::extract_article_type(xml_content);
    let keywords = metadata::extract_keywords(xml_content);
    let funding = metadata::extract_funding(xml_content);
    let conflict_of_interest = metadata::extract_conflict_of_interest(xml_content);
    let acknowledgments = metadata::extract_acknowledgments(xml_content);
    let data_availability = metadata::extract_data_availability(xml_content);
    let supplementary_materials = metadata::extract_supplementary_materials(xml_content);

    // Extract authors
    let authors = author::extract_authors(xml_content)?;

    // Extract sections using section module functions
    let sections = section::extract_sections_enhanced(xml_content);

    // Extract references using reference module functions
    let references = reference::extract_references_detailed(xml_content).unwrap_or_default();

    Ok(PmcFullText {
        pmcid: pmcid.to_string(),
        pmid,
        title,
        authors,
        journal,
        pub_date,
        doi,
        sections,
        references,
        article_type,
        keywords,
        funding,
        conflict_of_interest,
        acknowledgments,
        data_availability,
        supplementary_materials,
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_basic_structure() {
        // Test that the parse method successfully delegates to specialized parsers
        let xml_content = r#"
        <article xmlns:xlink="http://www.w3.org/1999/xlink" article-type="research-article">
            <front>
                <article-meta>
                    <article-id pub-id-type="pmc">PMC123456</article-id>
                    <article-id pub-id-type="doi">10.1234/test</article-id>
                    <title-group>
                        <article-title>Test Article Title</article-title>
                    </title-group>
                    <contrib-group>
                        <contrib>
                            <name>
                                <surname>Doe</surname>
                                <given-names>John</given-names>
                            </name>
                        </contrib>
                    </contrib-group>
                    <pub-date>
                        <year>2023</year>
                        <month>12</month>
                        <day>25</day>
                    </pub-date>
                </article-meta>
            </front>
            <body>
                <sec>
                    <title>Introduction</title>
                    <p>This is the introduction.</p>
                </sec>
            </body>
            <back>
                <ref-list>
                    <ref id="ref1">
                        <element-citation>
                            <article-title>Reference Title</article-title>
                        </element-citation>
                    </ref>
                </ref-list>
            </back>
        </article>
        "#;

        let result = parse_pmc_xml(xml_content, "PMC123456");
        assert!(result.is_ok());

        let article = result.unwrap();
        assert_eq!(article.pmcid, "PMC123456");
        assert_eq!(article.title, "Test Article Title");
        assert_eq!(article.pub_date, "2023-12-25");
        assert!(!article.authors.is_empty());
        assert!(!article.sections.is_empty());
        assert!(!article.references.is_empty());
    }

    #[test]
    fn test_parse_minimal_xml() {
        // Test parsing with minimal XML structure
        let xml_content = r#"
        <article>
            <front>
                <article-meta>
                    <title-group>
                        <article-title>Minimal Test</article-title>
                    </title-group>
                </article-meta>
            </front>
        </article>
        "#;

        let result = parse_pmc_xml(xml_content, "PMC000000");
        assert!(result.is_ok());

        let article = result.unwrap();
        assert_eq!(article.pmcid, "PMC000000");
        assert_eq!(article.title, "Minimal Test");
    }

    // Note: Most detailed tests have been moved to the individual parser modules:
    // - AuthorParser tests in author_parser.rs
    // - section module functions tests in section.rs
    // - reference module functions tests in reference.rs
    // - metadata module functions tests in metadata.rs
    // - XmlUtils tests in xml_utils.rs
}