docsearch 0.3.5

Resolve crate items to rustdoc URLs.
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

use std::collections::HashMap;

use serde::Deserialize;
use serde_tuple::Deserialize_tuple;

use super::{ItemType, RawCrateData, RawIndexData};
use crate::error::{Error, Result};

#[derive(Deserialize)]
struct RawIndex {
    #[serde(flatten)]
    crates: HashMap<String, RawCrate>,
}

#[derive(Deserialize)]
pub(super) struct RawCrate {
    doc: String,
    i: Vec<Entry>,
    p: Vec<(ItemType, String)>,
}

impl From<RawCrate> for RawCrateData {
    fn from(mut raw: RawCrate) -> Self {
        RawCrateData {
            doc: raw.doc,
            t: raw.i.iter().map(|entry| entry.t).collect(),
            n: raw
                .i
                .iter_mut()
                .map(|entry| entry.n.take().unwrap_or_default())
                .collect(),
            q: raw
                .i
                .iter_mut()
                .enumerate()
                .filter_map(|(i, entry)| {
                    let q = entry.q.take().unwrap_or_default();
                    (!q.is_empty()).then_some((i, q))
                })
                .collect(),
            d: raw
                .i
                .iter_mut()
                .map(|entry| entry.d.take().unwrap_or_default())
                .collect(),
            i: raw
                .i
                .iter_mut()
                .map(|entry| entry.i.unwrap_or_default())
                .collect(),
            p: raw.p,
        }
    }
}

#[derive(Deserialize_tuple)]
struct Entry {
    t: ItemType,
    n: Option<String>,
    q: Option<String>,
    d: Option<String>,
    i: Option<usize>,
    #[allow(dead_code)]
    f: Option<Vec<serde_json::Value>>,
}

pub(super) fn load_raw(index: &str) -> Result<RawIndexData> {
    let json = {
        let mut json = index
            .lines()
            .filter_map(|l| {
                if l.starts_with('"') {
                    l.strip_suffix('\\')
                } else {
                    None
                }
            })
            .fold(String::from("{"), |mut json, l| {
                json.push_str(l);
                json
            });
        json.push('}');

        // Inverse operation of:
        // <https://github.com/rust-lang/rust/blob/eba3228b2a9875d268ff3990903d04e19f6cdb0c/src/librustdoc/html/render/cache.rs#L175-L190>.
        json.replace("\\\\\"", "\\\"")
            .replace(r"\'", "'")
            .replace(r"\\", r"\")
    };

    let raw = serde_json::from_str::<RawIndex>(&json).map_err(Error::from)?;

    Ok(RawIndexData {
        crates: raw
            .crates
            .into_iter()
            .map(|(name, raw)| (name, raw.into()))
            .collect(),
    })
}