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