Grcov report - templates.rs

1

use crate::server::{

2

    dataset::{Dataset, PredicateObject},

3

    DatasetSummary, DatasetVersionSummary,

4

};

5

use askama::Template;

6

use sophia::api::{prefix::PrefixMapPair, term::IriRef, MownStr};

7

use std::collections::BTreeSet;

8

9

2

#[derive(Template)]

10

2

#[template(path = "index.html")]

11

pub(crate) struct IndexTemplate<'a> {

12

    pub datasets: &'a [DatasetSummary<'a>],

13

14

15

1

#[derive(Template)]

16

1

#[template(path = "dataset.html")]

17

pub(crate) struct DatasetTemplate<'a> {

18

    pub dataset: &'a Dataset,

19

    pub versions: &'a [DatasetVersionSummary],

20

21

22

1063

#[derive(Template)]

23

1

#[template(path = "version.html")]

24

pub(crate) struct VersionTemplate<'a> {

25

    pub dataset: &'a DatasetSummary<'a>,

26

    pub version: &'a DatasetVersionSummary,

27

    pub subjects: BTreeSet<&'a IriRef<MownStr<'a>>>,

28

    pub datasets: &'a Vec<Dataset>,

29

    pub prefixes: &'a Vec<PrefixMapPair>,

30

31

32

6

#[derive(Template)]

33

1

#[template(path = "subject.html")]

34

pub(crate) struct SubjectTemplate<'a> {

35

    pub dataset: &'a DatasetSummary<'a>,

36

    pub subject: String,

37

    pub version: &'a DatasetVersionSummary,

38

    pub pos: Vec<PredicateObject<'a>>,

39

    pub datasets: &'a Vec<Dataset>,

40

    pub prefixes: &'a Vec<PrefixMapPair>,

41

42

43

mod filters {

44

    use std::{collections::BTreeSet, fmt};

45

46

    use askama::Error::Fmt;

47

    use chrono::{DateTime, Utc};

48

    use sophia::{

49

        api::{prefix::{PrefixMap, PrefixMapPair}, term::IriRef, MownStr},

50

        iri::Iri,

51

};

52

53

    use crate::{constants::LABEL_RDFS_IRI, server::{dataset::Dataset, get_dataset_version}};

54

55

124

    pub(crate) fn replace_prefix<T: std::fmt::Display>(s: T, prefixes: &Vec<PrefixMapPair>) -> ::askama::Result<String> {

56

124

        let prefix_found = prefixes.get_prefixed_pair(Iri::new_unchecked(s.to_string()));

57

58

124

        let out = if let Some(ps) = prefix_found {

59

122

            format!("{}:{}", ps.0.as_str(), ps.1)

60

        } else {

61

2

            s.to_string()

62

};

63

64

124

        Ok(out)

65

124

66

67

123

    pub(crate) fn rdfslabel<T: std::fmt::Display>(

68

123

        s: T,

69

123

        datasets: &Vec<Dataset>,

70

123

        id: &&str,

71

123

        version: &DateTime<Utc>,

72

123

    ) -> ::askama::Result<String> {

73

123

        let subject = Iri::new_unchecked(s.to_string());

74

123

        let Ok((_, dataset_version)) = get_dataset_version(&datasets, id, *version) else {

75

            return Err(Fmt(fmt::Error));

76

};

77

123

        let pos = dataset_version.pos(&subject);

78

123

79

123

        let find_target_po = pos

80

123

            .into_iter()

81

379

            .find(|po| po.predicate.as_str() == LABEL_RDFS_IRI);

82

123

        let Some(target_po) = find_target_po else {

83

7

            return Ok("".to_string());

84

};

85

116

        let Some(target_object) = target_po.object_literal else {

86

            return Ok("".to_string());

87

};

88

89

116

        Ok(target_object.to_string())

90

123

91

92

1

    pub(crate) fn categorize_subjects<'a>(

93

1

        subs: &BTreeSet<&'a IriRef<MownStr<'a>>>,

94

1

        prefixes: &Vec<PrefixMapPair>,

95

1

    ) -> ::askama::Result<(Vec<String>, Vec<usize>)> {

96

1

        let special_categories: Vec<&str> = vec!["proposal", "nlnet"];

97

1

        let mut categories: Vec<String> = prefixes

98

1

            .iter()

99

7

            .map(|(p, _)| p.to_string())

100

7

            .filter(|cat| !special_categories.contains(&cat.as_str()))

101

1

            .collect();

102

1

103

1

        let cat_assigns: Vec<usize> = subs

104

1

            .into_iter()

105

118

            .map(|s| {

106

118

                let prefix_found = prefixes.get_prefixed_pair(Iri::new_unchecked(s.to_string()));

107

108

118

                if let Some((prefix, _)) = prefix_found {

109

116

                    if let Some(idx) = special_categories

110

116

                        .iter()

111

232

                        .position(|cat| cat == &prefix.as_str())

112

113

                        return idx;

114

116

                    } else if let Some(idx) =

115

226

                        categories.iter().position(|cat| cat == &prefix.as_str())

116

117

116

                        return idx + special_categories.len();

118

119

2

120

121

2

                categories.len() + special_categories.len()

122

118

})

123

1

            .collect();

124

1

125

1

        let mut all_categories = vec!["Proposals".to_string(), "NLnet".to_string()];

126

1

        let mut others = vec!["Other".to_string()];

127

1

        all_categories.append(&mut categories);

128

1

        all_categories.append(&mut others);

129

1

130

1

        Ok((all_categories, cat_assigns))

131

1

132