bibparser 0.4.0

A parser for .bib files
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

use bibparser::Parser;
use std::error;

use clap;
use clap::Parser as CLIParser;

#[cfg(not(feature = "serde_json"))]
#[derive(clap::Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Settings {
    /// Filepath to file to parse
    #[clap(short, long)]
    input: String,

    /// Return only entries with this ID
    #[clap(short, long)]
    query_id: Option<String>,
}

#[cfg(feature = "serde_json")]
#[derive(clap::Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Settings {
    /// Filepath to file to parse
    #[clap(short, long)]
    input: String,

    /// Return only entries with this ID
    #[clap(short, long)]
    query_id: Option<String>,

    #[clap(long)]
    json: bool,
}

fn print_human_readable(s: &Settings) -> Result<(), Box<dyn error::Error>> {
    let mut p = Parser::from_file(&s.input)?;
    for result in p.iter() {
        let entry = result?;
        if let Some(query) = &s.query_id {
            if query != &entry.id {
                continue;
            }
        }
        println!("type = {}", entry.kind);
        println!("id = {}", entry.id);
        for (name, _) in entry.fields.iter() {
            println!("\t{}\t= {}", name, entry.unicode_data(name).unwrap());
        }
    }

    Ok(())
}

#[cfg(feature = "serde_json")]
fn print_json(s: &Settings) -> Result<(), Box<dyn error::Error>> {
    use serde::{Deserialize, Serialize};
    use serde_json::Result;
    use std::collections::HashMap;

    #[derive(Serialize, Deserialize)]
    struct Entry {
        kind: String,
        id: String,
        fields: HashMap<String, String>,
    }

    #[derive(Serialize, Deserialize)]
    struct Entries {
        data: Vec<Entry>,
    }

    let mut json_entries = Entries { data: Vec::new() };
    for result in Parser::from_file(&s.input)?.iter() {
        let entry = result?;
        if let Some(query) = &s.query_id {
            if query != &entry.id {
                continue;
            }
        }

        json_entries.data.push(Entry {
            kind: entry.kind,
            id: entry.id,
            fields: entry.fields.clone(),
        });
    }

    println!("{}", serde_json::to_string(&json_entries)?);

    Ok(())
}

fn main() -> Result<(), Box<dyn error::Error>> {
    let settings = Settings::parse();

    #[cfg(feature = "serde_json")]
    {
        print_json(&settings)?;
    }
    #[cfg(not(feature = "serde_json"))]
    {
        print_human_readable(&settings)?;
    }

    Ok(())
}