Skip to main content

interprex_github/code_reviews/
text_records.rs

1use interprex::{ProviderTextRecord, TextRecordsProvider};
2
3use crate::GithubProvider;
4
5const CARRIER_START: &str = "<!-- ";
6const CARRIER_END: &str = "\n-->";
7
8impl TextRecordsProvider for GithubProvider {
9    fn embed_record(&self, text: &str, record: &ProviderTextRecord) -> String {
10        embed_record(text, record)
11    }
12
13    fn extract_records(&self, text: &str) -> Vec<ProviderTextRecord> {
14        extract_records(text)
15    }
16}
17
18pub(super) fn embed_record(text: &str, record: &ProviderTextRecord) -> String {
19    let payload = serde_json::to_string(record.value())
20        .expect("a provider text record contains a serde_json value");
21    // Valid JSON can contain adjacent hyphens only inside a string. JSON
22    // Unicode escapes preserve that string while keeping the HTML comment
23    // data free of the delimiter's double hyphen.
24    let payload = payload.replace("--", "\\u002d\\u002d");
25    let carrier = format!(
26        "{CARRIER_START}{}:{}\n{payload}{CARRIER_END}",
27        record.namespace(),
28        record.name()
29    );
30    if text.is_empty() {
31        carrier
32    } else {
33        format!("{text}\n\n{carrier}")
34    }
35}
36
37pub(super) fn extract_records(text: &str) -> Vec<ProviderTextRecord> {
38    text.match_indices(CARRIER_START)
39        .filter_map(|(offset, _)| parse_carrier(&text[offset..]).map(|(record, _)| record))
40        .collect()
41}
42
43pub(super) fn contains_only_records(text: &str) -> bool {
44    let mut remaining = text;
45    loop {
46        remaining = remaining.trim_start();
47        if remaining.is_empty() {
48            return true;
49        }
50        let Some((_, consumed)) = parse_carrier(remaining) else {
51            return false;
52        };
53        remaining = &remaining[consumed..];
54    }
55}
56
57fn parse_carrier(candidate: &str) -> Option<(ProviderTextRecord, usize)> {
58    let body = candidate.strip_prefix(CARRIER_START)?;
59    let (identifier, body) = body.split_once('\n')?;
60    let (namespace, name) = identifier.split_once(':')?;
61    let payload_end = body.find(CARRIER_END)?;
62    let payload = &body[..payload_end];
63    if payload.is_empty() || payload.contains(['\n', '\r']) || payload.contains("--") {
64        return None;
65    }
66    let value = serde_json::from_str(payload).ok()?;
67    let record = ProviderTextRecord::new(namespace, name, value).ok()?;
68    let consumed = candidate.len() - body.len() + payload_end + CARRIER_END.len();
69    Some((record, consumed))
70}
71
72#[cfg(test)]
73mod tests {
74    use interprex::{ProviderTextRecord, TextRecordsProvider};
75
76    use crate::{GithubConfig, from_config};
77
78    fn provider() -> crate::GithubProvider {
79        from_config(GithubConfig::default()).expect("provider")
80    }
81
82    fn record(namespace: &str, name: &str, value: serde_json::Value) -> ProviderTextRecord {
83        ProviderTextRecord::new(namespace, name, value).expect("record")
84    }
85
86    #[test]
87    fn carrier_keeps_visible_text_and_round_trips_unicode_and_delimiters() {
88        let provider = provider();
89        let record = record(
90            "comitia",
91            "loop-event",
92            serde_json::json!({
93                "version": 3,
94                "message": "Revisão 👋 keeps -- and --> as application data",
95                "offset": -2
96            }),
97        );
98
99        let body = provider.embed_record("Comitia planned round 3.", &record);
100
101        assert!(body.starts_with("Comitia planned round 3.\n\n<!-- comitia:loop-event\n"));
102        let carrier = body
103            .strip_prefix("Comitia planned round 3.\n\n")
104            .expect("visible text remains an exact prefix");
105        let payload = carrier
106            .strip_prefix("<!-- comitia:loop-event\n")
107            .and_then(|value| value.strip_suffix("\n-->"))
108            .expect("fixed carrier");
109        assert!(
110            !payload.contains("--"),
111            "HTML comment data has no double hyphen"
112        );
113        assert_eq!(provider.extract_records(&body), [record]);
114    }
115
116    #[test]
117    fn extractor_returns_several_records_in_source_order_with_trailing_text() {
118        let provider = provider();
119        let first = record(
120            "comitia",
121            "loop-event",
122            serde_json::json!({"version": 1, "round": 1}),
123        );
124        let second = record(
125            "other.app",
126            "future_record",
127            serde_json::json!({"version": 91, "content": ["opaque"]}),
128        );
129        let body = provider.embed_record("Visible", &first);
130        let body = provider.embed_record(&body, &second);
131        let body = format!("{body}\n\nTrailing text remains visible.");
132
133        assert_eq!(provider.extract_records(&body), [first, second]);
134    }
135
136    #[test]
137    fn extractor_omits_malformed_carriers_and_continues_scanning() {
138        let provider = provider();
139        let valid = record(
140            "comitia",
141            "loop-event",
142            serde_json::json!({"version": 1, "kind": "round-planned"}),
143        );
144        let valid_carrier = provider.embed_record("", &valid);
145        let body = format!(
146            "<!-- comitia:loop-event\nnot json\n-->\n\
147             <!-- bad namespace:loop-event\n{{\"version\":1}}\n-->\n\
148             <!-- comitia:loop-event\n{{\"version\":0}}\n-->\n\
149             <!-- comitia:loop-event\n{{\"version\":1,\"unsafe\":\"-->\"}}\n-->\n\
150             <!-- comitia:loop-event\n{{\"version\":1}}\n\
151             {valid_carrier}"
152        );
153
154        assert_eq!(provider.extract_records(&body), [valid]);
155    }
156
157    #[test]
158    fn generic_records_coexist_with_existing_finding_resolution_markers() {
159        let provider = provider();
160        let finding = "<!-- interprex:finding-resolution\n{\"version\":1,\"resolution_reason\":\"ADDRESSED\",\"addressing_severity\":\"minor\"}\n-->";
161        let loop_event = record(
162            "comitia",
163            "loop-event",
164            serde_json::json!({"version": 1, "kind": "round-planned"}),
165        );
166        let body = provider.embed_record(finding, &loop_event);
167
168        assert_eq!(
169            provider.extract_records(&body),
170            [
171                record(
172                    "interprex",
173                    "finding-resolution",
174                    serde_json::json!({
175                        "version": 1,
176                        "resolution_reason": "ADDRESSED",
177                        "addressing_severity": "minor"
178                    }),
179                ),
180                loop_event,
181            ]
182        );
183    }
184}