cargo-aprz-lib 0.14.0

Internal library for cargo-aprz
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

use super::{CrateId, define_rows, define_table};
use chrono::{DateTime, Utc};
use url::Url;

/// Log target for crates table
const LOG_TARGET: &str = "    crates";

define_rows! {
    CrateRow<'a> {
        pub id: CrateId,
        pub name: &'a str,
        pub created_at: DateTime<Utc>,
        pub updated_at: DateTime<Utc>,
        repository: &'a str,
        #[cfg(all_fields)]
        pub description: &'a str,
        #[cfg(all_fields)]
        documentation: &'a str,
        #[cfg(all_fields)]
        homepage: &'a str,
        #[cfg(all_fields)]
        pub readme: &'a str,
        #[cfg(all_fields)]
        pub max_features: Option<u64>,
        #[cfg(all_fields)]
        pub max_upload_size: Option<u64>,
        #[cfg(all_fields)]
        pub trustpub_only: bool,
    }
}

impl CrateRow<'_> {
    /// # Panics
    ///
    /// Panics if the repository URL in the database is malformed
    #[must_use]
    pub fn repository(&self) -> Option<Url> {
        if self.repository.is_empty() {
            None
        } else {
            Some(Url::parse(self.repository).expect("invalid URL in repository field"))
        }
    }

    #[cfg(all_fields)]
    #[must_use]
    pub fn homepage(&self) -> Option<Url> {
        if self.homepage.is_empty() {
            None
        } else {
            Some(Url::parse(self.homepage).expect("invalid URL in homepage field"))
        }
    }

    #[cfg(all_fields)]
    #[must_use]
    pub fn documentation(&self) -> Option<Url> {
        if self.documentation.is_empty() {
            None
        } else {
            Some(Url::parse(self.documentation).expect("invalid URL in documentation field"))
        }
    }
}

define_table! {
    crates {
        fn write_row(csv_row: &CsvCrateRow<'a>, writer: &mut RowWriter<impl Write>) -> Result<()> {
            writer.write_str(csv_row.name);
            writer.write_str_as_u64(csv_row.id)?;
            writer.write_str_as_datetime(csv_row.created_at)?;

            if let Err(e) = writer.write_str_as_url(csv_row.repository) {
                log::debug!(target: LOG_TARGET,
                    "invalid repository URL in crates table for crate '{}': {}",
                    csv_row.name,
                    e
                );
                writer.write_str("");
            }

            writer.write_str_as_datetime(csv_row.updated_at)?;

            #[cfg(all_fields)]
            {
                writer.write_str(csv_row.description);

                if let Err(e) = writer.write_str_as_url(csv_row.documentation) {
                    log::debug!(target: LOG_TARGET,
                        "invalid documentation URL in crates table for crate '{}': {}",
                        csv_row.name,
                        e
                    );
                    writer.write_str("");
                }

                if let Err(e) = writer.write_str_as_url(csv_row.homepage) {
                    log::debug!(target: LOG_TARGET,
                        "invalid homepage URL in crates table for crate '{}': {}",
                        csv_row.name,
                        e
                    );
                    writer.write_str("");
                }

                writer.write_str(csv_row.readme);
                writer.write_optional_str_as_u64(csv_row.max_features)?;
                writer.write_optional_str_as_u64(csv_row.max_upload_size)?;
                writer.write_str_as_bool(csv_row.trustpub_only)?;
            }

            Ok(())
        }

        fn read_row<'a>(reader: &mut RowReader<'a>) -> CrateRow<'a> {
            CrateRow {
                name: reader.read_str(),
                id: CrateId(reader.read_u64()),
                created_at: reader.read_datetime(),
                repository: reader.read_str(),
                updated_at: reader.read_datetime(),

                #[cfg(all_fields)]
                description: reader.read_str(),
                #[cfg(all_fields)]
                documentation: reader.read_str(),
                #[cfg(all_fields)]
                homepage: reader.read_str(),
                #[cfg(all_fields)]
                readme: reader.read_str(),
                #[cfg(all_fields)]
                max_features: reader.read_optional_u64(),
                #[cfg(all_fields)]
                max_upload_size: reader.read_optional_u64(),
                #[cfg(all_fields)]
                trustpub_only: reader.read_bool(),
            }
        }
    }
}