switchback-protobuf 0.0.1-0.dev.0.ffcda32

Protobuf parser for the switchback framework.
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

//! Loaded protobuf contract view.

use std::collections::BTreeMap;

use switchback_traits::{
    CompanionFile, Contract, Entity, EntityCategory, Group, GroupId, LinkContext, Options,
    Reference, StoredEntity,
};

use crate::category::ProtobufCategory;
use crate::family::ProtobufFamily;
use crate::populate::{PopulatedContract, PopulatedEntity};

pub struct ProtobufContract {
    family: ProtobufFamily,
    version: switchback_traits::SpecVersion,
    groups: Vec<Group>,
    entities_by_group: BTreeMap<GroupId, Vec<PopulatedEntity>>,
    companions: Vec<CompanionFile>,
}

impl ProtobufContract {
    pub fn from_populated(populated: PopulatedContract) -> Self {
        Self {
            family: ProtobufFamily,
            version: populated.version,
            groups: populated.groups,
            entities_by_group: populated.entities_by_group,
            companions: populated.companions,
        }
    }

    pub fn populated_entities(&self, group: &Group) -> &[PopulatedEntity] {
        self.entities_by_group
            .get(&group.id)
            .map(|v| v.as_slice())
            .unwrap_or(&[])
    }
}

impl Contract for ProtobufContract {
    type Family = ProtobufFamily;
    type Category = ProtobufCategory;

    fn family(&self) -> &Self::Family {
        &self.family
    }

    fn version(&self) -> &switchback_traits::SpecVersion {
        &self.version
    }

    fn groups(&self) -> &[Group] {
        &self.groups
    }

    fn entities(&self, _group: &Group) -> &[Entity<Self::Category>] {
        &[]
    }

    fn link_context(&self, opts: &Options) -> LinkContext {
        let mut ctx = LinkContext::empty(opts.layout, &opts.book_root, &opts.markdown_root);
        let module_id = self
            .groups
            .first()
            .map(|g| g.id.as_str())
            .unwrap_or("default");
        for group in &self.groups {
            if group.id.as_str().is_empty() {
                continue;
            }
            for pe in self.populated_entities(group) {
                ctx.register_stored_entity(
                    module_id,
                    group.id.as_str(),
                    &group.dir,
                    &stored_entity_from_populated(pe),
                    true,
                    opts.layout,
                    &opts.markdown_root,
                );
            }
        }
        ctx
    }

    fn companions(&self) -> &[CompanionFile] {
        &self.companions
    }
}

impl ProtobufContract {
    pub fn entity_refs_for_group(
        &self,
        group: &Group,
    ) -> Vec<(&Entity<ProtobufCategory>, &[Reference])> {
        self.populated_entities(group)
            .iter()
            .map(|pe| (&pe.entity, pe.refs.as_slice()))
            .collect()
    }
}

fn stored_entity_from_populated(pe: &PopulatedEntity) -> StoredEntity {
    StoredEntity {
        name: pe.entity.id.name.clone(),
        category: pe.entity.category.as_str().to_string(),
        title: pe.entity.title.clone(),
        doc: pe.entity.doc.clone(),
        source: if pe.source_file.is_empty() {
            None
        } else {
            Some(switchback_traits::Source {
                file: pe.source_file.clone(),
                span: None,
            })
        },
        refs: pe.refs.clone(),
        intra_links: Vec::new(),
        body: pe.entity.body.clone(),
    }
}