M5b plan: task 10, gatewayd posts images and untrusted links as code
Task 10 (spec 9, the owner's option C): a new module gatewayd::links with
disarm(text, untrusted) -> Disarmed { text, links }, given as a skeleton
with 16 small todo!() helpers, and deliver posting each answer through
answer_posts: disarm, split_answer, disarm each part again, NOTICE once
at the end of the last post when a link was put in a code span.
Checks, against a reference kept off master:
- Replayed from ref 09 in a scratch worktree with its own target/: the
task's edits (applied from the task text) plus the given files plus the
reference bodies are byte-identical to the reference. make gate on
rustc/clippy 1.98.1: gate: ok, 1081 tests (1058 + 7 + 7 + 9). /tmp
holds nothing new after the gate.
- Step 2 (E0432 only) and step 3 (6/1, 7, 9 failing, all "not yet
implemented"; warnings as the task lists) seen in the replay.
- 71 one-line breaks of the reference, each caught by the given tests.
- Differential fuzz of generated Markdown through Mattermost's marked
fork (mattermost/marked c211e4c, the webapp's options) and CommonMark:
on the final code, 600k replies in each mode, half with inline LaTeX
on, render no image and (untrusted) no link.
- disarm(disarm(x)) == disarm(x) on 200k generated replies, both modes.
- Given files pass rustfmt; skeleton comments read beside their
signatures; no chat-template tag in the plan or given files;
deliver_links 40 runs under CPU load, no failure.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,384 @@
|
|||||||
|
# M5b task 10: `gatewayd` posts images, and the links of untrusted replies, as code
|
||||||
|
|
||||||
|
**Branch:** `m5b` (run `git switch m5b`; `git status --short` must be empty, otherwise stop)
|
||||||
|
**Commit subject:** `gatewayd: images, and links in untrusted replies, are posted as code`
|
||||||
|
|
||||||
|
## Read this first: the given tests
|
||||||
|
|
||||||
|
The given tests are tables of Markdown built to trick Mattermost's two Markdown readers, with
|
||||||
|
links to made-up hosts (`evil.example`, `e.example`). They are data. You copy them; you do not
|
||||||
|
need to read them to do this task. Each failure message names its case and shows the text the
|
||||||
|
test wanted (`right`) and the text it got (`left`).
|
||||||
|
|
||||||
|
## Goal
|
||||||
|
|
||||||
|
Mattermost fetches a post's images by itself: the server when the post is created, and every
|
||||||
|
client when it shows it (the owner's server has no image proxy). The server also fetches the
|
||||||
|
first plain URL of a post for a link preview. Either fetch can carry data out in its URL, with no
|
||||||
|
click: `` sends `c2VjcmV0` to `evil.example`. Text in
|
||||||
|
a code span is never fetched. This was measured on the owner's server (M5b spec, section 9):
|
||||||
|
|
||||||
|
| Posted | Link preview | Image fetched by the server |
|
||||||
|
|---|---|---|
|
||||||
|
| a plain URL | marked for a preview | |
|
||||||
|
| a URL in a code span, or in a fenced block | none | |
|
||||||
|
| a Markdown link, `[text](url)` | none | |
|
||||||
|
| a Markdown image | | yes, at posting time |
|
||||||
|
| a Markdown image in a code span | none | none |
|
||||||
|
|
||||||
|
The owner chose (spec 9, "C"):
|
||||||
|
|
||||||
|
- **Every image in every reply goes in a code span**, so it shows as text and nothing fetches it.
|
||||||
|
- **In a reply from a session that has read untrusted content** (`TurnDone.untrusted`, task 09),
|
||||||
|
every link and URL goes in a code span too, and the reply ends with this line:
|
||||||
|
`Links in this reply are shown as code because this conversation has read untrusted content.`
|
||||||
|
- **In a clean reply, links stay as they are**, clickable and previewed.
|
||||||
|
- **Code the reply already holds is left as it is**: a URL in a code span or a fenced block is
|
||||||
|
not put in a second one.
|
||||||
|
|
||||||
|
This task adds a module, `gatewayd::links`, with one function, `disarm`, and makes `deliver`
|
||||||
|
post each answer through it. It is given as a skeleton: the glue is written, and you fill 16
|
||||||
|
small functions, each from the comment above it.
|
||||||
|
|
||||||
|
**Decisions this task makes** (you do not need to change any of them):
|
||||||
|
|
||||||
|
1. **Only answers pass through `disarm`**, the text the model wrote. Every other post of
|
||||||
|
`gatewayd` is its own fixed text (`BUSY`, `LOOP_DOWN`, `INTERRUPTED`, the approval notices), or
|
||||||
|
shows the model's text in code already (an approval's arguments are in a fenced block made by
|
||||||
|
`approvals::text::fence`, its tool and grant in spans made by `approvals::text::code`), or is
|
||||||
|
`loopd`'s own error text (`error_text`).
|
||||||
|
2. **The notice only when a link or URL was put in a code span.** An image alone does not bring
|
||||||
|
it: images go in code spans in every reply, and the notice speaks of links. Nor does a reply
|
||||||
|
whose links were all in code already. So `disarm` says, in `Disarmed.links`, whether it put a
|
||||||
|
link in a code span, and a reply without one reads as the model wrote it.
|
||||||
|
3. **Disarm, split, disarm each part again.** `split_answer` cuts a long answer into posts of at
|
||||||
|
most `MAX_POST` characters. Disarming first means the parts are cut from the text as it will be
|
||||||
|
posted. But each post is rendered on its own: a cut inside a fenced block leaves the rest of
|
||||||
|
the block as prose in the next post, where an image would be live. So each part is disarmed
|
||||||
|
again. The second pass changes nothing else: the given tests check that `disarm` of its own
|
||||||
|
output is that output. The notice goes once, after an empty line, at the end of the last post.
|
||||||
|
|
||||||
|
### Two readers, and why the rules are many
|
||||||
|
|
||||||
|
Two programs read a post's Markdown. The server (Go) follows CommonMark; it finds the images it
|
||||||
|
fetches and the URL it previews. The clients (web and desktop) render the post with a fork of
|
||||||
|
the JavaScript library marked (`mattermost/marked`, commit `c211e4c`), whose rules differ from
|
||||||
|
CommonMark in places: an unclosed fence is code only at times; `\r` ends a line; emphasis
|
||||||
|
(`**`), an HTML tag, inline LaTeX (`$…$`), a link, an autolink or a URL can take a backtick that
|
||||||
|
CommonMark would read as the start of a code span. A code span `disarm` trusts must be code to
|
||||||
|
both. So `disarm` leaves text alone only where both readers see code, and treats everything else
|
||||||
|
as prose: an image in it goes in a code span, even if one reader would have shown it as code
|
||||||
|
already. The worst that does is show a few backticks; it never leaves an image live.
|
||||||
|
|
||||||
|
Each rule is one small function, and each has cases in the given tests:
|
||||||
|
|
||||||
|
| Rule | Function | Tests |
|
||||||
|
|---|---|---|
|
||||||
|
| A fenced block is code only if both read it so: opened by 3 or more backticks or `~` after at most 3 spaces, with no backtick, `~` or `\|` after them; closed by a later line; no line between indented less than the opener; not continuing a list item or quote; no line before it starting with an HTML tag | `opener`, `closes`, `fence_end`, `nested_start`, `html_start` (and `disarm`, given) | `links_marked`: fences |
|
||||||
|
| A line ends at `\n`, `\r`, `\r\n` or U+2424; an empty line ends a paragraph, a line of spaces does not | `lines` and `Out::prose` (given) | `links_marked`: lines |
|
||||||
|
| A code span is code only if both read it so: its closing run on the same line, no `\|` inside, no backtick run whose length is a hazard, nothing that could close an emphasis, tag or LaTeX opened before it | `span_len`, `Seen::plain` | `links_marked`: spans, steals |
|
||||||
|
| A backslash escapes the next character if marked would | `escape_len` | `links`: images |
|
||||||
|
| Images: ``, with a size or title, `![alt][ref]`, `![alt][]`, `![ref]`, and a `![` with no `]` | `construct_len`, `bracket_end`, `paren_end` | `links`: images |
|
||||||
|
| Links (untrusted): `[text](url)`, `[text][ref]`, autolinks `<…>`, definitions `[ref]: url`, URLs with a scheme, `www.`, or a domain and a `/` | `construct_len`, `autolink_len`, `definition`, `url_len` (and `url_start`, given) | `links`: links |
|
||||||
|
| A new code span splits at line ends, `\|`, backticks, and closers seen before it; its runs are longer than any in the reply; it never touches a backtick, a backslash or a URL | `Out::wrap`, `Out::code` | `links`: ticks, images |
|
||||||
|
|
||||||
|
## Every place the answer is posted
|
||||||
|
|
||||||
|
| Place | What happens there |
|
||||||
|
|---|---|
|
||||||
|
| `crates/gatewayd/src/deliver.rs`, `one_turn` | reads `TurnDone.untrusted` into `Outcome::Answer` (edit D3) |
|
||||||
|
| `crates/gatewayd/src/deliver.rs`, `deliver` | posts `answer_posts` instead of `split_answer` (edit D5) |
|
||||||
|
| `crates/gatewayd/src/serve/handle.rs`, `start` | calls `deliver`; no change |
|
||||||
|
| `Outcome::Answer` anywhere else | nowhere: no other file names it |
|
||||||
|
|
||||||
|
## Files
|
||||||
|
|
||||||
|
- Copy, from `docs/plans/M5b/files/` (the same path under it):
|
||||||
|
- the skeletons `crates/gatewayd/src/links/mod.rs` (you fill 7 functions) and
|
||||||
|
`crates/gatewayd/src/links/inline.rs` (you fill 9)
|
||||||
|
- tests: `crates/gatewayd/tests/links.rs`, `crates/gatewayd/tests/links_marked.rs`,
|
||||||
|
`crates/gatewayd/tests/deliver_links.rs`
|
||||||
|
- Modify: `crates/gatewayd/src/lib.rs` (edit L1), `crates/gatewayd/src/deliver.rs` (edits D1 to
|
||||||
|
D5), `docs/implementer-log.md`.
|
||||||
|
- Do not touch: any other source file, any `Cargo.toml`, the tests in
|
||||||
|
`crates/gatewayd/tests/support/`, and in the skeletons anything but the 16 `todo!()` bodies.
|
||||||
|
|
||||||
|
## Facts you need
|
||||||
|
|
||||||
|
- **Offsets are bytes.** Every offset and length in the module is in bytes of UTF-8, and every
|
||||||
|
slice is taken with `str::get` (`text.get(a..b)`), which gives `None` instead of panicking.
|
||||||
|
Never write `text[a..b]`. The characters the rules look for (backticks, brackets, `<`, `|`,
|
||||||
|
`\`, `$`, spaces) are all one byte, so the offset right after one of them is always a
|
||||||
|
character boundary; for any other character use `c.len_utf8()`.
|
||||||
|
- **The skeleton's given code**, which you call and must not change:
|
||||||
|
|
||||||
|
| Name | What it is |
|
||||||
|
|---|---|
|
||||||
|
| `BREAKS` | `[char; 3]`: `'\n'`, `'\r'`, `'\u{2424}'`; `text.contains(BREAKS)`, `BREAKS.contains(&c)` |
|
||||||
|
| `content(line)` | `fn content(line: &str) -> &str`: the line without its line end |
|
||||||
|
| `runs(text)` | `fn runs(text: &str) -> Vec<(usize, usize)>`: each backtick run as (byte offset, length) |
|
||||||
|
| `Out` | `text: String` (what is written so far), `ticks: usize`, `links: bool` |
|
||||||
|
| `Seen` | `hazards: Vec<usize>` (run lengths), `closers: Vec<char>` |
|
||||||
|
| `closing(text, run)` | `fn closing(text: &str, run: usize) -> Option<usize>`: offset of the first run of exactly `run` backticks |
|
||||||
|
| `window(text)` | `fn window(text: &str) -> &str`: at most the first `WINDOW` (2048) characters |
|
||||||
|
| `reference_end(text)` | `fn reference_end(text: &str) -> Option<usize>`: `text` starts with `[`; offset of the `]` closing it, or `None` |
|
||||||
|
| `ESCAPABLE`, `TRAILING` | `&str` of the characters marked escapes; `[char; 11]` a URL loses at its end |
|
||||||
|
|
||||||
|
- **The functions you fill, in the order to fill them**, with who calls them:
|
||||||
|
|
||||||
|
| Function | Signature | Called by |
|
||||||
|
|---|---|---|
|
||||||
|
| `html_start` | `fn html_start(line: &str) -> bool` | `disarm` |
|
||||||
|
| `nested_start` | `fn nested_start(line: &str) -> bool` | `disarm` |
|
||||||
|
| `opener` | `fn opener(line: &str) -> Option<(usize, &str)>` | `fence_end` |
|
||||||
|
| `closes` | `fn closes(line: &str, run: &str) -> bool` | `fence_end` |
|
||||||
|
| `fence_end` | `fn fence_end(lines: &[&str], at: usize) -> Option<usize>` | `disarm` |
|
||||||
|
| `Out::code` | `fn code(&mut self, piece: &str)` | `Out::wrap` |
|
||||||
|
| `Out::wrap` | `fn wrap(&mut self, construct: &str, after: &str, closers: &[char])` | `Out::image` |
|
||||||
|
| `Seen::plain` | `fn plain(&mut self, c: char)` | `Out::paragraph`, `Out::construct` |
|
||||||
|
| `escape_len` | `fn escape_len(rest: &str) -> Option<usize>` | `Out::token` |
|
||||||
|
| `paren_end` | `fn paren_end(text: &str) -> Option<usize>` | `construct_len` |
|
||||||
|
| `bracket_end` | `fn bracket_end(text: &str, code: bool) -> Option<usize>` | `construct_len` |
|
||||||
|
| `construct_len` | `fn construct_len(text: &str, bare: bool) -> Option<usize>` | `Out::token`, `Out::bracket` |
|
||||||
|
| `span_len` | `fn span_len(rest: &str, seen: &Seen) -> Option<usize>` | `Out::backticks` |
|
||||||
|
| `autolink_len` | `fn autolink_len(rest: &str) -> Option<usize>` | `Out::autolink` |
|
||||||
|
| `definition` | `fn definition(rest: &str) -> bool` | `Out::token` |
|
||||||
|
| `url_len` | `fn url_len(rest: &str, whole: bool) -> usize` | `Out::url` |
|
||||||
|
|
||||||
|
- **The calls the bodies need**, all in the standard library or given:
|
||||||
|
|
||||||
|
| Call | Signature, and what it gives |
|
||||||
|
|---|---|
|
||||||
|
| `str::get` | `text.get(a..)`, `text.get(..b)`, `text.get(a..b)` → `Option<&str>`; `None` off a character boundary or past the end |
|
||||||
|
| `str::chars`, `char_indices` | `text.chars().next()` → `Option<char>`; `text.char_indices()` yields `(byte offset, char)` |
|
||||||
|
| `Iterator::take_while`, `count` | `rest.chars().take_while(\|&c\| c == '`').count()`: the length of the run `rest` starts with |
|
||||||
|
| `Iterator::enumerate`, `skip`, `any`, `all` | `lines.iter().enumerate().skip(at + 1)`; `pairs.any(\|p\| …)`; `chars.all(\|c\| …)` |
|
||||||
|
| `matches!` | `matches!(first, Some('>' \| '-' \| '*' \| '+' \| '0'..='9'))`: whether `first` fits the pattern |
|
||||||
|
| `str::trim_start`, `trim`, `trim_start_matches`, `trim_end_matches` | `text.trim_start_matches(' ')`, `.trim_start_matches([' ', '\u{a0}'])`, `.trim_start_matches(\|c: char\| c.is_whitespace() \|\| ">-*+.)".contains(c))`, `.trim_end_matches(TRAILING)` |
|
||||||
|
| `str::strip_prefix` | `rest.strip_prefix(run)`, `.strip_prefix('[')` → `Option<&str>`, the text after it |
|
||||||
|
| `str::find`, `contains`, `starts_with`, `ends_with` | `rest.find('>')`, `rest.find(BREAKS)` → `Option<usize>`; `text.contains(['`', '~', '\|'])`, `content.contains(seen.closers.as_slice())`; `self.text.ends_with(\|c: char\| !c.is_whitespace())` |
|
||||||
|
| `str::chars().count()` | the number of characters (not bytes) |
|
||||||
|
| `str::eq_ignore_ascii_case` | `w.eq_ignore_ascii_case("www")` |
|
||||||
|
| `str::repeat`, `String::push`, `push_str` | `"`".repeat(self.ticks)`; `self.text.push('\\')`; `self.text.push_str(piece)` |
|
||||||
|
| `char` tests | `c.is_whitespace()`, `c.is_ascii_alphabetic()`, `c.is_ascii_digit()`, `c.len_utf8()` |
|
||||||
|
| `Option` | `.filter(\|c\| …)`, `.and_then(f)`, `.or_else(\|\| …)`, `.is_some_and(f)`, `.is_none_or(f)`, `.unwrap_or(x)`, `.unwrap_or_default()`; `bool::then_some(x)` → `Some(x)` if true |
|
||||||
|
| `usize::saturating_sub` | `depth.saturating_sub(1)`: never below 0 |
|
||||||
|
| `Vec::contains`, `push` | `self.closers.contains(&c)`, `seen.hazards.contains(&run)` |
|
||||||
|
|
||||||
|
- **The skeleton compiles as given**, with warnings for the unfilled functions: unused variables;
|
||||||
|
functions, a method and constants never used (`closing`, `reference_end`, `Out::code`,
|
||||||
|
`ESCAPABLE`, `TRAILING` and the like); and the field `ticks` never read. They go as you fill the
|
||||||
|
bodies.
|
||||||
|
- Until every body is filled, any call to `disarm` panics with `not yet implemented`. From step 3
|
||||||
|
to step 5, run only the three new test files: the other `gatewayd` tests now post answers
|
||||||
|
through `disarm` too.
|
||||||
|
|
||||||
|
## The edits, exactly
|
||||||
|
|
||||||
|
Nothing else in these files changes. Each quoted "before" block occurs exactly once in its file.
|
||||||
|
|
||||||
|
### `crates/gatewayd/src/lib.rs`
|
||||||
|
|
||||||
|
**L1.** The line
|
||||||
|
|
||||||
|
```rust
|
||||||
|
pub mod http;
|
||||||
|
```
|
||||||
|
|
||||||
|
becomes
|
||||||
|
|
||||||
|
```rust
|
||||||
|
pub mod http;
|
||||||
|
pub mod links;
|
||||||
|
```
|
||||||
|
|
||||||
|
### `crates/gatewayd/src/deliver.rs`
|
||||||
|
|
||||||
|
**D1.** The lines
|
||||||
|
|
||||||
|
```rust
|
||||||
|
use crate::mm::MmError;
|
||||||
|
use crate::mm::rest::Client;
|
||||||
|
```
|
||||||
|
|
||||||
|
become
|
||||||
|
|
||||||
|
```rust
|
||||||
|
use crate::links::{NOTICE, disarm};
|
||||||
|
use crate::mm::MmError;
|
||||||
|
use crate::mm::rest::Client;
|
||||||
|
```
|
||||||
|
|
||||||
|
**D2.** The line
|
||||||
|
|
||||||
|
```rust
|
||||||
|
Answer(String),
|
||||||
|
```
|
||||||
|
|
||||||
|
becomes
|
||||||
|
|
||||||
|
```rust
|
||||||
|
/// The reply, and whether its session has read untrusted content.
|
||||||
|
Answer {
|
||||||
|
content: String,
|
||||||
|
untrusted: bool,
|
||||||
|
},
|
||||||
|
```
|
||||||
|
|
||||||
|
**D3.** In `one_turn`, the lines
|
||||||
|
|
||||||
|
```rust
|
||||||
|
// 3. `read_frame` until the end: (id 1, not final, TurnEvent) -> on_event; (1, final, TurnDone)
|
||||||
|
// -> Answer with its content; (1, final, Error) -> Refused; a read error -> LoopDown("the
|
||||||
|
// turn ended early: <e>"); anything else -> LoopDown("an unexpected frame").
|
||||||
|
```
|
||||||
|
|
||||||
|
become
|
||||||
|
|
||||||
|
```rust
|
||||||
|
// 3. `read_frame` until the end: (id 1, not final, TurnEvent) -> on_event; (1, final, TurnDone)
|
||||||
|
// -> Answer with its content and untrusted; (1, final, Error) -> Refused; a read error ->
|
||||||
|
// LoopDown("the turn ended early: <e>"); anything else -> LoopDown("an unexpected frame").
|
||||||
|
```
|
||||||
|
|
||||||
|
and further down in `one_turn`, the line
|
||||||
|
|
||||||
|
```rust
|
||||||
|
(true, Message::TurnDone(d)) => return Outcome::Answer(d.content.clone()),
|
||||||
|
```
|
||||||
|
|
||||||
|
becomes
|
||||||
|
|
||||||
|
```rust
|
||||||
|
(true, Message::TurnDone(d)) => {
|
||||||
|
return Outcome::Answer {
|
||||||
|
content: d.content.clone(),
|
||||||
|
untrusted: d.untrusted,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
**D4.** The lines
|
||||||
|
|
||||||
|
```rust
|
||||||
|
/// Send one turn and read it to its end; `on_event` sees every event.
|
||||||
|
```
|
||||||
|
|
||||||
|
become
|
||||||
|
|
||||||
|
```rust
|
||||||
|
/// The posts of a reply: disarmed (M5b spec, section 9), then cut by `split_answer`. Each part is
|
||||||
|
/// disarmed again: a cut inside a fenced block leaves the rest of it as prose in the next post.
|
||||||
|
/// The last post ends with `NOTICE` if either pass put a link in a code span.
|
||||||
|
pub fn answer_posts(content: &str, untrusted: bool) -> Vec<String> {
|
||||||
|
let whole = disarm(content, untrusted);
|
||||||
|
let mut links = whole.links;
|
||||||
|
let mut posts = Vec::new();
|
||||||
|
for part in split_answer(&whole.text) {
|
||||||
|
let again = disarm(&part, untrusted);
|
||||||
|
links = links || again.links;
|
||||||
|
posts.push(again.text);
|
||||||
|
}
|
||||||
|
if links && let Some(last) = posts.last_mut() {
|
||||||
|
last.push_str("\n\n");
|
||||||
|
last.push_str(NOTICE);
|
||||||
|
}
|
||||||
|
posts
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Send one turn and read it to its end; `on_event` sees every event.
|
||||||
|
```
|
||||||
|
|
||||||
|
**D5.** In `deliver`, the line
|
||||||
|
|
||||||
|
```rust
|
||||||
|
// Answer -> every part of `split_answer`, in order; Refused -> `error_text`;
|
||||||
|
```
|
||||||
|
|
||||||
|
becomes
|
||||||
|
|
||||||
|
```rust
|
||||||
|
// Answer -> every post of `answer_posts`, in order; Refused -> `error_text`;
|
||||||
|
```
|
||||||
|
|
||||||
|
and the lines
|
||||||
|
|
||||||
|
```rust
|
||||||
|
Outcome::Answer(content) => {
|
||||||
|
for part in split_answer(&content) {
|
||||||
|
```
|
||||||
|
|
||||||
|
become
|
||||||
|
|
||||||
|
```rust
|
||||||
|
Outcome::Answer { content, untrusted } => {
|
||||||
|
for part in answer_posts(&content, untrusted) {
|
||||||
|
```
|
||||||
|
|
||||||
|
## Steps
|
||||||
|
|
||||||
|
- [ ] **1. Copy the given tests.** From the repository root, three commands:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
cp docs/plans/M5b/files/crates/gatewayd/tests/links.rs crates/gatewayd/tests/
|
||||||
|
cp docs/plans/M5b/files/crates/gatewayd/tests/links_marked.rs crates/gatewayd/tests/
|
||||||
|
cp docs/plans/M5b/files/crates/gatewayd/tests/deliver_links.rs crates/gatewayd/tests/
|
||||||
|
```
|
||||||
|
|
||||||
|
- [ ] **2. See them fail.** `cargo test -p gatewayd --test links --test links_marked --test
|
||||||
|
deliver_links --no-fail-fast`: none compiles. Every error is `E0432`, an unresolved import:
|
||||||
|
`gatewayd::links` in all three, and `answer_posts` in `deliver_links` as well.
|
||||||
|
- [ ] **3. The module and the edits.** Copy the two skeletons, then make edits L1 and D1 to D5:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
mkdir -p crates/gatewayd/src/links
|
||||||
|
cp docs/plans/M5b/files/crates/gatewayd/src/links/mod.rs crates/gatewayd/src/links/
|
||||||
|
cp docs/plans/M5b/files/crates/gatewayd/src/links/inline.rs crates/gatewayd/src/links/
|
||||||
|
```
|
||||||
|
|
||||||
|
`cargo check -p gatewayd`: no error, only the warnings "Facts you need" describes. The command
|
||||||
|
of step 2 now compiles; `links` has 6 failing tests and 1 passing (`the_notice_is_one_line`),
|
||||||
|
`links_marked` 7 failing, `deliver_links` 9 failing, and every failure is
|
||||||
|
`not yet implemented`.
|
||||||
|
- [ ] **4. Fill the seven functions of `mod.rs`, one at a time, in this order**, each from its
|
||||||
|
comment, and run `cargo check -p gatewayd` after each: `html_start`, `nested_start`, `opener`,
|
||||||
|
`closes`, `fence_end`, `Out::code`, `Out::wrap`.
|
||||||
|
- [ ] **5. Fill the nine functions of `inline.rs`, one at a time, in this order**, each from its
|
||||||
|
comment, and run `cargo check -p gatewayd` after each: `Seen::plain`, `escape_len`,
|
||||||
|
`paren_end`, `bracket_end`, `construct_len`, `span_len`, `autolink_len`, `definition`,
|
||||||
|
`url_len`. Change nothing else in either file.
|
||||||
|
- [ ] **6. See them pass.** The command of step 2: `links` 7 passed, `links_marked` 7 passed,
|
||||||
|
`deliver_links` 9 passed. Then `cargo test -p gatewayd`: every suite passes.
|
||||||
|
- [ ] **7. Run the gate.** `cargo fmt --all`, then `make gate`, with a shell timeout of 600000 ms.
|
||||||
|
Expected last line: `gate: ok`, with 1081 tests: 1058 before this task, plus 7 in `links.rs`, 7
|
||||||
|
in `links_marked.rs` and 9 in `deliver_links.rs`.
|
||||||
|
- [ ] **8. Log and commit.** `git status --short` lists `crates/gatewayd/src/lib.rs` and
|
||||||
|
`crates/gatewayd/src/deliver.rs` as modified, and `crates/gatewayd/src/links/` and the three
|
||||||
|
test files as new, besides your log. Stage with
|
||||||
|
`git add crates/gatewayd docs/implementer-log.md Cargo.lock`, then commit as `AGENTS.md` says.
|
||||||
|
`Cargo.lock` does not change in this task; the `git add` is harmless.
|
||||||
|
|
||||||
|
## Done when
|
||||||
|
|
||||||
|
- `make gate` prints `gate: ok` with 1081 tests.
|
||||||
|
- `git diff HEAD~1 --stat` lists only `crates/gatewayd/src/lib.rs`,
|
||||||
|
`crates/gatewayd/src/deliver.rs`, the two files under `crates/gatewayd/src/links/`, the three
|
||||||
|
new test files and `docs/implementer-log.md`.
|
||||||
|
|
||||||
|
## Stop and report if
|
||||||
|
|
||||||
|
- A "before" block of L1 or D1 to D5 is not in its file exactly as shown, or is there more than
|
||||||
|
once.
|
||||||
|
- Step 2 or 3 shows a different result: other errors, other failing tests, or other counts.
|
||||||
|
- `cargo check -p gatewayd` reports an error after a body you filled, and the comment does not
|
||||||
|
tell you how to fix it. Quote the error and the comment, and stop.
|
||||||
|
- A comment in a skeleton does not fit the code under it, or two comments contradict each other.
|
||||||
|
Quote them and stop.
|
||||||
|
- After step 6 a test fails although each function follows its comment. Do not change a test, a
|
||||||
|
table or the given code of the skeletons: stop, and give the failing tests' names and their
|
||||||
|
messages.
|
||||||
|
- The fix seems to need a change anywhere else: in `bxcore`, another file of `gatewayd`, or a
|
||||||
|
`Cargo.toml`. It does not; stop and say why you think so.
|
||||||
|
- A test outside `gatewayd` fails in the gate: check once whether it fails without your change,
|
||||||
|
then stop and report both results.
|
||||||
|
- The gate passes with a count other than 1081.
|
||||||
@@ -0,0 +1,337 @@
|
|||||||
|
//! One paragraph of prose: code spans, escapes, images, links and URLs, left to right.
|
||||||
|
|
||||||
|
use super::{BREAKS, Out, runs};
|
||||||
|
|
||||||
|
/// What marked lets a backslash escape. Other characters after a backslash are plain text.
|
||||||
|
const ESCAPABLE: &str = "\\`*{}[]()#+-.!_>|~";
|
||||||
|
|
||||||
|
/// What a URL loses at its end: marked leaves these out of a link when they end it.
|
||||||
|
const TRAILING: [char; 11] = ['.', ',', ':', ';', '!', '?', '*', '_', '~', '\'', '"'];
|
||||||
|
|
||||||
|
/// How many characters a search for the end of a construct looks at, so that a reply full of
|
||||||
|
/// brackets costs time in proportion to its length. An image longer than this still has its `![`
|
||||||
|
/// put in a code span; a link longer than this keeps only its URL in one.
|
||||||
|
const WINDOW: usize = 2048;
|
||||||
|
|
||||||
|
/// What a paragraph has shown so far that changes how its later code spans may pair.
|
||||||
|
#[derive(Default)]
|
||||||
|
struct Seen {
|
||||||
|
/// Backtick run lengths that may pair differently in the two parsers from here on.
|
||||||
|
hazards: Vec<usize>,
|
||||||
|
/// What would close what a plain character opened: marked lets emphasis (`*`, `_`, `~`), a
|
||||||
|
/// tag (`<`) and inline LaTeX (`$`) take a backtick before a code span starts.
|
||||||
|
closers: Vec<char>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Seen {
|
||||||
|
/// Add to `hazards`, once each, every length from 1 to that of each backtick run in `text`:
|
||||||
|
/// marked may read part of a run as part of a URL, and the rest as a run of its own.
|
||||||
|
fn runs(&mut self, text: &str) {
|
||||||
|
for (_, len) in runs(text) {
|
||||||
|
for part in 1..=len {
|
||||||
|
if !self.hazards.contains(&part) {
|
||||||
|
self.hazards.push(part);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A plain character: `*`, `_`, `~` and `$` are their own closers, and `<` is closed by `>`;
|
||||||
|
/// push the closer onto `closers` if it is not there yet. Any other character: nothing.
|
||||||
|
fn plain(&mut self, c: char) {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Out {
|
||||||
|
/// Write `para` with its images, and when `untrusted` its links and URLs, in code spans.
|
||||||
|
pub(super) fn paragraph(&mut self, para: &str, untrusted: bool) {
|
||||||
|
let mut seen = Seen::default();
|
||||||
|
let mut prev = None;
|
||||||
|
let mut at = 0;
|
||||||
|
while let Some(rest) = para.get(at..).filter(|rest| !rest.is_empty()) {
|
||||||
|
let line_start = at == 0 || para.get(..at).is_some_and(|done| done.ends_with(BREAKS));
|
||||||
|
match self.token(rest, prev, line_start, untrusted, &mut seen) {
|
||||||
|
Some(used) if used > 0 => {
|
||||||
|
at += used;
|
||||||
|
prev = None;
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
let c = rest.chars().next().unwrap_or_default();
|
||||||
|
self.text.push(c);
|
||||||
|
seen.plain(c);
|
||||||
|
at += c.len_utf8();
|
||||||
|
prev = Some(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write the token `rest` starts with and give its length in bytes, or `None` when `rest`
|
||||||
|
/// starts with a plain character, which the caller writes. `prev` is the plain character
|
||||||
|
/// before, `None` after a token or at the start.
|
||||||
|
fn token(
|
||||||
|
&mut self,
|
||||||
|
rest: &str,
|
||||||
|
prev: Option<char>,
|
||||||
|
line_start: bool,
|
||||||
|
untrusted: bool,
|
||||||
|
seen: &mut Seen,
|
||||||
|
) -> Option<usize> {
|
||||||
|
if untrusted && line_start && definition(rest) {
|
||||||
|
let end = rest.find(BREAKS).unwrap_or(rest.len());
|
||||||
|
return Some(self.link(rest, end, seen));
|
||||||
|
}
|
||||||
|
match rest.chars().next()? {
|
||||||
|
'\\' => escape_len(rest).map(|len| self.copy(rest, len)),
|
||||||
|
'`' => Some(self.backticks(rest, seen)),
|
||||||
|
'!' if rest.starts_with("![") => {
|
||||||
|
// No `]` in reach: the `` or `[text][…]`: see `construct`. Any other `[` is
|
||||||
|
/// written escaped if `](` follows within `WINDOW`: marked may still read a link from it, with
|
||||||
|
/// a label that takes in new code spans.
|
||||||
|
fn bracket(&mut self, rest: &str, untrusted: bool, seen: &mut Seen) -> Option<usize> {
|
||||||
|
let Some(len) = construct_len(rest, false) else {
|
||||||
|
if !window(rest).contains("](") {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
self.text.push_str("\\[");
|
||||||
|
return Some(1);
|
||||||
|
};
|
||||||
|
self.construct(rest, len, untrusted, seen)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A `<` that starts an autolink: see `construct`.
|
||||||
|
fn autolink(&mut self, rest: &str, untrusted: bool, seen: &mut Seen) -> Option<usize> {
|
||||||
|
let len = autolink_len(rest)?;
|
||||||
|
self.construct(rest, len, untrusted, seen)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A URL: see `construct`. In a clean reply it is the most marked may read as the URL
|
||||||
|
/// (`url_len` with `whole`), backticks included, since marked reads them as part of it.
|
||||||
|
fn url(&mut self, rest: &str, untrusted: bool, seen: &mut Seen) -> Option<usize> {
|
||||||
|
let len = url_len(rest, !untrusted);
|
||||||
|
self.construct(rest, len, untrusted, seen)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The first `len` bytes of `rest`, a link, go in code spans when `untrusted`, and also in a
|
||||||
|
/// clean reply when they hold `![` (CommonMark may read the image where marked reads a link).
|
||||||
|
/// Otherwise they are written as they are. Marked may end the link sooner than this, so its
|
||||||
|
/// backtick runs become hazards, and each of its characters counts as `Seen::plain`.
|
||||||
|
fn construct(
|
||||||
|
&mut self,
|
||||||
|
rest: &str,
|
||||||
|
len: usize,
|
||||||
|
untrusted: bool,
|
||||||
|
seen: &mut Seen,
|
||||||
|
) -> Option<usize> {
|
||||||
|
let construct = rest.get(..len)?;
|
||||||
|
if untrusted {
|
||||||
|
return Some(self.link(rest, len, seen));
|
||||||
|
}
|
||||||
|
if construct.contains("![") {
|
||||||
|
return Some(self.image(rest, len, seen));
|
||||||
|
}
|
||||||
|
seen.runs(construct);
|
||||||
|
construct.chars().for_each(|c| seen.plain(c));
|
||||||
|
Some(self.copy(rest, len))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn copy(&mut self, rest: &str, len: usize) -> usize {
|
||||||
|
self.text.push_str(rest.get(..len).unwrap_or_default());
|
||||||
|
len
|
||||||
|
}
|
||||||
|
|
||||||
|
fn image(&mut self, rest: &str, len: usize, seen: &Seen) -> usize {
|
||||||
|
self.wrap(
|
||||||
|
rest.get(..len).unwrap_or_default(),
|
||||||
|
rest.get(len..).unwrap_or_default(),
|
||||||
|
&seen.closers,
|
||||||
|
);
|
||||||
|
len
|
||||||
|
}
|
||||||
|
|
||||||
|
fn link(&mut self, rest: &str, len: usize, seen: &Seen) -> usize {
|
||||||
|
self.links = true;
|
||||||
|
self.image(rest, len, seen)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `rest` starts with a backslash: `Some(2)` if the next character is one of `ESCAPABLE`, else
|
||||||
|
/// `None` (the backslash is plain).
|
||||||
|
fn escape_len(rest: &str) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `rest` starts with a run of `run` backticks. The span's length, `run + close + run`, if both
|
||||||
|
/// parsers read it as code: `run` is not in `seen.hazards`; `closing(after, run)` gives `close`
|
||||||
|
/// in the text `after` the run; and the content between holds no line end (`BREAKS`), no `|`,
|
||||||
|
/// none of `seen.closers`, and no run (`runs`) whose length is in `seen.hazards`.
|
||||||
|
fn span_len(rest: &str, seen: &Seen) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The byte offset in `text` of the first run of exactly `run` backticks, if there is one.
|
||||||
|
fn closing(text: &str, run: usize) -> Option<usize> {
|
||||||
|
let mut start = 0;
|
||||||
|
let mut len = 0;
|
||||||
|
for (i, c) in text.char_indices() {
|
||||||
|
if c == '`' {
|
||||||
|
if len == 0 {
|
||||||
|
start = i;
|
||||||
|
}
|
||||||
|
len += 1;
|
||||||
|
} else if len > 0 {
|
||||||
|
if len == run {
|
||||||
|
return Some(start);
|
||||||
|
}
|
||||||
|
len = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
(len == run).then_some(start)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// At most the first `WINDOW` characters of `text`.
|
||||||
|
fn window(text: &str) -> &str {
|
||||||
|
match text.char_indices().nth(WINDOW) {
|
||||||
|
Some((end, _)) => text.get(..end).unwrap_or(text),
|
||||||
|
None => text,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` starts with `[`; only `window(text)` is looked at. The label ends at
|
||||||
|
/// `bracket_end(text, true)`, or if that is `None`, `bracket_end(text, false)`. Right after it: a
|
||||||
|
/// `(` closed by `paren_end` gives the length through that `)`; or else, after white space
|
||||||
|
/// (`trim_start`), a `[` closed by `reference_end` gives it through that `]`; or else, only when
|
||||||
|
/// `bare` (an image may be `![alt]`), through the label's `]`. `None` if nothing fits.
|
||||||
|
fn construct_len(text: &str, bare: bool) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` starts with `[`: the byte offset of the `]` that closes it. Walk it counting `[` up and
|
||||||
|
/// `]` down (to 0: found), skipping the character after each backslash. When `code`, a backtick
|
||||||
|
/// run jumps past the next run of the same length (`closing`), as a CommonMark code span; a run
|
||||||
|
/// with none is skipped as plain. `None` if no `]` closes it.
|
||||||
|
fn bracket_end(text: &str, code: bool) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` starts with `(`: the byte offset of the `)` that closes it, counting `(` up and `)` down
|
||||||
|
/// (to 0: found). A backslash escapes nothing here, as in marked's link destinations. `None` if
|
||||||
|
/// no `)` closes it.
|
||||||
|
fn paren_end(text: &str) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` starts with `[`: the byte index of the next `]`, skipping the character after each
|
||||||
|
/// backslash, if no `[` comes first (a reference label does not nest). `None` otherwise, and when
|
||||||
|
/// `text` does not start with `[`.
|
||||||
|
fn reference_end(text: &str) -> Option<usize> {
|
||||||
|
let mut chars = text.strip_prefix('[')?.char_indices();
|
||||||
|
while let Some((i, c)) = chars.next() {
|
||||||
|
match c {
|
||||||
|
'\\' => {
|
||||||
|
chars.next();
|
||||||
|
}
|
||||||
|
'[' => return None,
|
||||||
|
']' => return Some(i + 1),
|
||||||
|
_ => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `rest` starts with `<`: the length of the autolink it starts, `<` through the first `>` in
|
||||||
|
/// `window(rest)`, if the text between is not empty, holds no space, tab or no-break space (a line
|
||||||
|
/// end is allowed, as in marked), and holds `:` or `@` or starts with `www` in any case.
|
||||||
|
fn autolink_len(rest: &str) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether the line `rest` starts (up to the first of `BREAKS`) is a link reference definition:
|
||||||
|
/// after white space (`trim_start`), `[`, then a label of at least one character with no `]` in
|
||||||
|
/// it, then `]:`.
|
||||||
|
fn definition(rest: &str) -> bool {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether a URL starts at `rest`, after the plain character `prev`: a `scheme` or `www` where
|
||||||
|
/// `prev` is not an ASCII letter or digit, or a `scheme_less` domain where `prev` is not a
|
||||||
|
/// letter, digit, `.` or `-`. `prev` is `None` at the start and after a token.
|
||||||
|
fn url_start(rest: &str, prev: Option<char>) -> bool {
|
||||||
|
let word = prev.is_none_or(|p| !p.is_ascii_alphanumeric());
|
||||||
|
let run = prev.is_none_or(|p| !(p.is_alphanumeric() || p == '.' || p == '-'));
|
||||||
|
(word && (scheme(rest) || www(rest))) || (run && scheme_less(rest))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether `rest` starts with a scheme: an ASCII letter, then ASCII letters, digits, `+`, `.`
|
||||||
|
/// or `-`, then `:` and a `/`, `%`, or letter or digit of any script.
|
||||||
|
fn scheme(rest: &str) -> bool {
|
||||||
|
rest.starts_with(|c: char| c.is_ascii_alphabetic())
|
||||||
|
&& rest
|
||||||
|
.trim_start_matches(|c: char| c.is_ascii_alphanumeric() || matches!(c, '+' | '.' | '-'))
|
||||||
|
.strip_prefix(':')
|
||||||
|
.and_then(|after| after.chars().next())
|
||||||
|
.is_some_and(|c| c == '/' || c == '%' || c.is_alphanumeric())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether `rest` starts with `www` in any case, then ASCII digits (none or more), then `.` and a
|
||||||
|
/// character that is not white space.
|
||||||
|
fn www(rest: &str) -> bool {
|
||||||
|
rest.get(..3).is_some_and(|w| w.eq_ignore_ascii_case("www"))
|
||||||
|
&& rest
|
||||||
|
.get(3..)
|
||||||
|
.unwrap_or_default()
|
||||||
|
.trim_start_matches(|c: char| c.is_ascii_digit())
|
||||||
|
.strip_prefix('.')
|
||||||
|
.and_then(|after| after.chars().next())
|
||||||
|
.is_some_and(|c| !c.is_whitespace())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether `rest` starts with a domain and a `/` (marked links `example.com/x` bare): a run of
|
||||||
|
/// letters, digits, `.` and `-`, whose part after its last `.` is 2 to 4 letters with something
|
||||||
|
/// before it, then `/`.
|
||||||
|
fn scheme_less(rest: &str) -> bool {
|
||||||
|
let end = rest
|
||||||
|
.find(|c: char| !(c.is_alphanumeric() || c == '.' || c == '-'))
|
||||||
|
.unwrap_or(rest.len());
|
||||||
|
let (Some(host), Some(after)) = (rest.get(..end), rest.get(end..)) else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
let Some((name, tld)) = host.rsplit_once('.') else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
after.starts_with('/')
|
||||||
|
&& !name.is_empty()
|
||||||
|
&& (2..=4).contains(&tld.chars().count())
|
||||||
|
&& tld.chars().all(char::is_alphabetic)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The length of the URL `rest` starts with: up to white space, a `)` that closes no `(` of the
|
||||||
|
/// URL (count them), or a `<` before white space, `(`, `)`, `<`, `>` or the end (marked leaves it
|
||||||
|
/// out: it may start an autolink); unless `whole`, up to any `<`, `>`, `|` or backtick too. Then
|
||||||
|
/// less the characters of `TRAILING` at its end. `whole` is the most marked may read as the URL.
|
||||||
|
fn url_len(rest: &str, whole: bool) -> usize {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
@@ -0,0 +1,194 @@
|
|||||||
|
//! Images and links in a reply (M5b spec, section 9). Mattermost fetches a post's images when it
|
||||||
|
//! is posted (the server) and when it is shown (each client: the owner's server has no image
|
||||||
|
//! proxy), and the server previews the first plain URL. Either fetch can carry data out in its
|
||||||
|
//! URL, with no click. A code span stops both. So `disarm` puts every image in a code span,
|
||||||
|
//! always, and in a reply from a session that has read untrusted content, every link and URL too.
|
||||||
|
//!
|
||||||
|
//! Two parsers read a post: the server's, which follows CommonMark, and the clients' fork of
|
||||||
|
//! marked (`mattermost/marked`), which has rules of its own. Text is left as it is only where both
|
||||||
|
//! read it as code. Where they may differ, it is read as prose, and an image or URL in it goes in
|
||||||
|
//! a code span: the reply may show a few backticks, but nothing in it is fetched. The rules are
|
||||||
|
//! in the functions below, each with the case it covers.
|
||||||
|
//!
|
||||||
|
//! Not covered, both in marked alone and both only a link, which needs a click: a link label may
|
||||||
|
//! pair backtick runs of different lengths across new code spans, and an autolink may run across
|
||||||
|
//! the lines of a quote or list item.
|
||||||
|
|
||||||
|
mod inline;
|
||||||
|
|
||||||
|
/// The line that ends a reply whose links were put in code spans.
|
||||||
|
pub const NOTICE: &str =
|
||||||
|
"Links in this reply are shown as code because this conversation has read untrusted content.";
|
||||||
|
|
||||||
|
/// The characters that end a line: marked reads `\r` and U+2424 as line feeds, and `\r\n` is one.
|
||||||
|
const BREAKS: [char; 3] = ['\n', '\r', '\u{2424}'];
|
||||||
|
|
||||||
|
/// A reply after `disarm`: its text, and whether a link or URL was put in a code span.
|
||||||
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||||
|
pub struct Disarmed {
|
||||||
|
pub text: String,
|
||||||
|
pub links: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The text being written, and the length of the backtick runs its new code spans use: longer
|
||||||
|
/// than any run in the reply, so a new span pairs with nothing the reply already holds.
|
||||||
|
struct Out {
|
||||||
|
text: String,
|
||||||
|
ticks: usize,
|
||||||
|
links: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` with every image in a code span, and when `untrusted`, every link and URL as well.
|
||||||
|
/// Code the reply already holds is left as it is, and so is everything else.
|
||||||
|
pub fn disarm(text: &str, untrusted: bool) -> Disarmed {
|
||||||
|
let longest = runs(text).into_iter().map(|(_, len)| len).max();
|
||||||
|
let mut out = Out {
|
||||||
|
text: String::with_capacity(text.len()),
|
||||||
|
ticks: longest.unwrap_or(0) + 1,
|
||||||
|
links: false,
|
||||||
|
};
|
||||||
|
let lines = lines(text);
|
||||||
|
// `html`: a line so far may start an HTML block, which can swallow a fence (marked).
|
||||||
|
// `nested`: the lines since the last empty one hold a list item or a quote, which a fence
|
||||||
|
// may continue; marked may then end the item inside the fence (at an empty line, a rule, a
|
||||||
|
// definition or the next item), and CommonMark may end it at the fence.
|
||||||
|
let (mut html, mut nested) = (false, false);
|
||||||
|
let (mut prose, mut at) = (0, 0);
|
||||||
|
while let Some(line) = lines.get(at) {
|
||||||
|
let closer = if html || nested {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
fence_end(&lines, at)
|
||||||
|
};
|
||||||
|
if let Some(end) = closer {
|
||||||
|
out.prose(lines.get(prose..at).unwrap_or_default(), untrusted);
|
||||||
|
for line in lines.get(at..=end).unwrap_or_default() {
|
||||||
|
out.text.push_str(line);
|
||||||
|
}
|
||||||
|
(at, prose, nested) = (end + 1, end + 1, false);
|
||||||
|
} else {
|
||||||
|
html = html || html_start(line);
|
||||||
|
nested = !content(line).is_empty() && (nested || nested_start(line));
|
||||||
|
at += 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out.prose(lines.get(prose..).unwrap_or_default(), untrusted);
|
||||||
|
Disarmed {
|
||||||
|
text: out.text,
|
||||||
|
links: out.links,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Out {
|
||||||
|
/// Lines outside fenced blocks, one paragraph at a time: an empty line ends one. A line of
|
||||||
|
/// spaces does not, since marked reads it as part of the paragraph.
|
||||||
|
fn prose(&mut self, lines: &[&str], untrusted: bool) {
|
||||||
|
let mut paragraph = String::new();
|
||||||
|
for line in lines {
|
||||||
|
if content(line).is_empty() {
|
||||||
|
self.paragraph(¶graph, untrusted);
|
||||||
|
paragraph.clear();
|
||||||
|
self.text.push_str(line);
|
||||||
|
} else {
|
||||||
|
paragraph.push_str(line);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
self.paragraph(¶graph, untrusted);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write `construct` as code spans (`code`), one per piece between split characters, each
|
||||||
|
/// split character written after its piece: a line end (`BREAKS`) or `|` (a table cell ends
|
||||||
|
/// there, even in a code span) as it is; a backtick or one of `closers` after a backslash,
|
||||||
|
/// except `$` (marked does not escape it), so that nothing before can pair with it. Last, a
|
||||||
|
/// space if `after` starts with a backtick: runs that touch would merge.
|
||||||
|
fn wrap(&mut self, construct: &str, after: &str, closers: &[char]) {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// One piece as a code span: `self.ticks` backticks, the piece, as many again. An empty piece,
|
||||||
|
/// or one of only white space (`trim().is_empty()`), is written as it is. Before the span, a
|
||||||
|
/// space, unless the text so far is empty or ends with white space: marked reads backticks as
|
||||||
|
/// part of a URL they touch, a backtick would merge with the run, a backslash escape it.
|
||||||
|
fn code(&mut self, piece: &str) {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// `text` cut after each line end (`\r\n`, `\n`, `\r` or U+2424), each line keeping its end;
|
||||||
|
/// the last line may have none. An empty `text` gives no lines.
|
||||||
|
fn lines(text: &str) -> Vec<&str> {
|
||||||
|
let mut lines = Vec::new();
|
||||||
|
let mut start = 0;
|
||||||
|
let mut chars = text.char_indices().peekable();
|
||||||
|
while let Some((i, c)) = chars.next() {
|
||||||
|
let end = match c {
|
||||||
|
'\r' if chars.next_if(|&(_, next)| next == '\n').is_some() => i + 2,
|
||||||
|
'\n' | '\r' | '\u{2424}' => i + c.len_utf8(),
|
||||||
|
_ => continue,
|
||||||
|
};
|
||||||
|
lines.push(text.get(start..end).unwrap_or_default());
|
||||||
|
start = end;
|
||||||
|
}
|
||||||
|
if start < text.len() {
|
||||||
|
lines.push(text.get(start..).unwrap_or_default());
|
||||||
|
}
|
||||||
|
lines
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A line without its line end.
|
||||||
|
fn content(line: &str) -> &str {
|
||||||
|
line.trim_end_matches(BREAKS)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Each run of backticks in `text` (a run is as long as it goes), as (byte offset, length).
|
||||||
|
fn runs(text: &str) -> Vec<(usize, usize)> {
|
||||||
|
let mut found: Vec<(usize, usize)> = Vec::new();
|
||||||
|
let mut last_end = None;
|
||||||
|
for (i, c) in text.char_indices() {
|
||||||
|
if c != '`' {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
match found.last_mut() {
|
||||||
|
Some(run) if last_end == Some(i) => run.1 += 1,
|
||||||
|
_ => found.push((i, 1)),
|
||||||
|
}
|
||||||
|
last_end = Some(i + 1);
|
||||||
|
}
|
||||||
|
found
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether the line may start an HTML block: after white space, ASCII digits and the characters
|
||||||
|
/// `>-*+.)` of list and quote markers at its start (`trim_start_matches`), it starts with `<` and
|
||||||
|
/// an ASCII letter or `/`.
|
||||||
|
fn html_start(line: &str) -> bool {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether the line starts like a list item or a quote: the first character of
|
||||||
|
/// `content(line).trim_start()` is `>`, `-`, `*`, `+` or an ASCII digit.
|
||||||
|
fn nested_start(line: &str) -> bool {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The index of the line that closes the fenced block `lines[at]` opens: `opener` gives
|
||||||
|
/// `(indent, run)`, else `None`. Then for each later line `i`, in order: if `closes(line, run)`,
|
||||||
|
/// `Some(i)`; else if its `content` is not empty and starts with fewer than `indent` spaces,
|
||||||
|
/// `None` (it leaves a list item in CommonMark, and the block with it). No closer: `None`, since
|
||||||
|
/// marked reads an unclosed fence as code only at times.
|
||||||
|
fn fence_end(lines: &[&str], at: usize) -> Option<usize> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// If the line opens a fenced block, its indent and run. In its `content`: up to 3 spaces (the
|
||||||
|
/// indent), then the run, 3 or more of one character, a backtick or `~`; the rest of the line (the
|
||||||
|
/// info) holds no backtick, `~` or `|` (a `|` can make it a table row in marked). Else `None`.
|
||||||
|
fn opener(line: &str) -> Option<(usize, &str)> {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Whether the line closes a block opened with `run`, as marked decides: its `content` starts
|
||||||
|
/// with at most 3 characters that are spaces or no-break spaces (U+00A0), then `run`; after that
|
||||||
|
/// come only backticks and `~`, then only spaces, tabs or no-break spaces.
|
||||||
|
fn closes(line: &str, run: &str) -> bool {
|
||||||
|
todo!()
|
||||||
|
}
|
||||||
@@ -0,0 +1,196 @@
|
|||||||
|
//! A reply's images and links as `deliver` posts them, against a fake `loopd` whose `TurnDone`
|
||||||
|
//! says whether the session has read untrusted content; and `answer_posts` on replies long enough
|
||||||
|
//! to be split (M5b spec, section 9). Do not edit.
|
||||||
|
|
||||||
|
#[path = "support/fake_loop.rs"]
|
||||||
|
mod fake_loop;
|
||||||
|
#[path = "support/tmp.rs"]
|
||||||
|
mod tmp;
|
||||||
|
|
||||||
|
use std::sync::Mutex;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use bxcore::{Envelope, Message, PROTOCOL_VERSION, SessionId, TurnDone, Usage};
|
||||||
|
use fake_loop::{Reply, done, serve_loop};
|
||||||
|
use gatewayd::deliver::{EMPTY_ANSWER, MAX_POST, Notice, Poster, answer_posts, deliver};
|
||||||
|
use gatewayd::links::NOTICE;
|
||||||
|
use gatewayd::mm::MmError;
|
||||||
|
use gatewayd::sessions::{Batch, Thread};
|
||||||
|
use tmp::TempDir;
|
||||||
|
|
||||||
|
const DM: &str = "d0000000000000000000000000";
|
||||||
|
const ROOT: &str = "r0000000000000000000000000";
|
||||||
|
|
||||||
|
#[derive(Default)]
|
||||||
|
struct Record {
|
||||||
|
posts: Mutex<Vec<String>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Poster for Record {
|
||||||
|
fn post(&self, channel: &str, root: &str, text: &str) -> Result<(), MmError> {
|
||||||
|
assert_eq!((channel, root), (DM, ROOT), "every post in the thread");
|
||||||
|
self.posts.lock().unwrap().push(text.to_string());
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The frame that ends a turn of a session that has read untrusted content.
|
||||||
|
fn done_untrusted(content: &str) -> Reply {
|
||||||
|
let msg = Message::TurnDone(TurnDone {
|
||||||
|
content: content.to_string(),
|
||||||
|
usage: Usage {
|
||||||
|
cache_n: 0,
|
||||||
|
prompt_n: 1,
|
||||||
|
predicted_n: 1,
|
||||||
|
reasoning_tokens: 0,
|
||||||
|
thinking_capped: false,
|
||||||
|
},
|
||||||
|
untrusted: true,
|
||||||
|
});
|
||||||
|
Reply::Frame(Envelope {
|
||||||
|
v: PROTOCOL_VERSION,
|
||||||
|
id: 1,
|
||||||
|
r#final: true,
|
||||||
|
msg,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// One turn against a fake `loopd` that ends it with `reply`; the posts, in order.
|
||||||
|
fn posts(tag: &str, reply: fn(&str) -> Reply, content: &'static str) -> Vec<String> {
|
||||||
|
let dir = TempDir::new(tag);
|
||||||
|
let socket = dir.path().join("loop.sock");
|
||||||
|
let turns = serve_loop(&socket, move |_, _| vec![reply(content)]);
|
||||||
|
let batch = Batch {
|
||||||
|
session: SessionId::new(&format!("mm-{ROOT}")).unwrap(),
|
||||||
|
thread: Thread {
|
||||||
|
channel: DM.to_string(),
|
||||||
|
root: ROOT.to_string(),
|
||||||
|
},
|
||||||
|
resume: false,
|
||||||
|
text: "hi".to_string(),
|
||||||
|
};
|
||||||
|
let never = |_: u64| false;
|
||||||
|
let notice = Notice {
|
||||||
|
posted: &never,
|
||||||
|
wait: Duration::ZERO,
|
||||||
|
};
|
||||||
|
let record = Record::default();
|
||||||
|
let log = Mutex::new(Vec::new());
|
||||||
|
deliver(
|
||||||
|
&record,
|
||||||
|
&socket,
|
||||||
|
&batch,
|
||||||
|
&|line| log.lock().unwrap().push(line.to_string()),
|
||||||
|
¬ice,
|
||||||
|
);
|
||||||
|
turns.recv_timeout(Duration::from_secs(5)).unwrap();
|
||||||
|
assert!(log.lock().unwrap().is_empty(), "{:?}", log.lock().unwrap());
|
||||||
|
record.posts.into_inner().unwrap()
|
||||||
|
}
|
||||||
|
|
||||||
|
const LINKED: &str = "See [the docs](https://docs.example/p) and https://b.example/x.";
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_untrusted_reply_posts_its_links_as_code_and_ends_with_the_notice() {
|
||||||
|
assert_eq!(
|
||||||
|
posts("links-untrusted", done_untrusted, LINKED),
|
||||||
|
[format!(
|
||||||
|
"See `[the docs](https://docs.example/p)` and `https://b.example/x`.\n\n{NOTICE}"
|
||||||
|
)]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_clean_reply_keeps_its_links() {
|
||||||
|
assert_eq!(posts("links-clean", done, LINKED), [LINKED]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_image_that_carries_data_is_posted_as_text_in_a_clean_reply() {
|
||||||
|
assert_eq!(
|
||||||
|
posts(
|
||||||
|
"links-image",
|
||||||
|
done,
|
||||||
|
"Summary done. "
|
||||||
|
),
|
||||||
|
["Summary done. ``"]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_untrusted_reply_with_only_an_image_has_no_notice() {
|
||||||
|
assert_eq!(
|
||||||
|
posts(
|
||||||
|
"links-only-image",
|
||||||
|
done_untrusted,
|
||||||
|
""
|
||||||
|
),
|
||||||
|
["``"]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn code_in_an_untrusted_reply_is_left_and_needs_no_notice() {
|
||||||
|
let text = "Run `curl https://example.com/x`:\n```\nhttps://example.com/y\n```";
|
||||||
|
assert_eq!(posts("links-code", done_untrusted, text), [text]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_long_untrusted_reply_has_one_notice_at_its_end() {
|
||||||
|
let content = format!(
|
||||||
|
"https://a.example/1\n{}\nhttps://b.example/2",
|
||||||
|
"x".repeat(MAX_POST - 10)
|
||||||
|
);
|
||||||
|
let posts = answer_posts(&content, true);
|
||||||
|
assert_eq!(
|
||||||
|
posts,
|
||||||
|
[
|
||||||
|
"`https://a.example/1`".to_string(),
|
||||||
|
"x".repeat(MAX_POST - 10),
|
||||||
|
format!("`https://b.example/2`\n\n{NOTICE}"),
|
||||||
|
]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_part_that_starts_inside_a_fence_is_disarmed_again() {
|
||||||
|
let content = format!(
|
||||||
|
"```\n{}\n{}\n\n```",
|
||||||
|
"y".repeat(10_000),
|
||||||
|
"z".repeat(10_000)
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
answer_posts(&content, false),
|
||||||
|
[
|
||||||
|
format!("```\n{}", "y".repeat(10_000)),
|
||||||
|
format!(
|
||||||
|
"{}\n````````\n```",
|
||||||
|
"z".repeat(10_000)
|
||||||
|
),
|
||||||
|
]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_link_found_only_after_the_split_still_brings_the_notice() {
|
||||||
|
let content = format!(
|
||||||
|
"```\n{}\n{}\nhttps://e.example/a\n```",
|
||||||
|
"y".repeat(10_000),
|
||||||
|
"z".repeat(10_000)
|
||||||
|
);
|
||||||
|
assert_eq!(
|
||||||
|
answer_posts(&content, true),
|
||||||
|
[
|
||||||
|
format!("```\n{}", "y".repeat(10_000)),
|
||||||
|
format!(
|
||||||
|
"{}\n````https://e.example/a````\n```\n\n{NOTICE}",
|
||||||
|
"z".repeat(10_000)
|
||||||
|
),
|
||||||
|
]
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_empty_answer_is_posted_as_before() {
|
||||||
|
assert_eq!(answer_posts(" \n", true), [EMPTY_ANSWER]);
|
||||||
|
}
|
||||||
@@ -0,0 +1,431 @@
|
|||||||
|
//! `links::disarm` on each form of image and link, clean and untrusted, and on code that must be
|
||||||
|
//! left as it is (M5b spec, section 9; the plan's review focus 4). Do not edit.
|
||||||
|
|
||||||
|
use gatewayd::links::{NOTICE, disarm};
|
||||||
|
|
||||||
|
/// (case, input, clean reply, untrusted reply, whether the untrusted reply had a link disarmed).
|
||||||
|
type Case = (&'static str, &'static str, &'static str, &'static str, bool);
|
||||||
|
|
||||||
|
const IMAGES: &[Case] = &[
|
||||||
|
(
|
||||||
|
"inline image",
|
||||||
|
"An image  here.",
|
||||||
|
"An image `` here.",
|
||||||
|
"An image `` here.",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image with a size",
|
||||||
|
"",
|
||||||
|
"``",
|
||||||
|
"``",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image with a width and a title",
|
||||||
|
"![alt](https://e.example/x.png =50 \"Hover\")",
|
||||||
|
"`![alt](https://e.example/x.png =50 \"Hover\")`",
|
||||||
|
"`![alt](https://e.example/x.png =50 \"Hover\")`",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"reference image and its definition",
|
||||||
|
"![alt][logo]\n\n[logo]: https://e.example/l.png",
|
||||||
|
"`![alt][logo]`\n\n[logo]: https://e.example/l.png",
|
||||||
|
"`![alt][logo]`\n\n`[logo]: https://e.example/l.png`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"collapsed and shortcut reference images",
|
||||||
|
"![logo][] and ![logo]",
|
||||||
|
"`![logo][]` and `![logo]`",
|
||||||
|
"`![logo][]` and `![logo]`",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"reference image with a space before its label",
|
||||||
|
"![alt] [logo] end",
|
||||||
|
"`![alt] [logo]` end",
|
||||||
|
"`![alt] [logo]` end",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"data in an image URL (T37)",
|
||||||
|
"Done. ",
|
||||||
|
"Done. ``",
|
||||||
|
"Done. ``",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image glued to text, non-ASCII too",
|
||||||
|
"AB 字字",
|
||||||
|
"A ``B 字 ``字",
|
||||||
|
"A ``B 字 ``字",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image alt over two lines",
|
||||||
|
"",
|
||||||
|
"``",
|
||||||
|
"``",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image alt with a pipe",
|
||||||
|
"",
|
||||||
|
"``",
|
||||||
|
"``",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image inside a link",
|
||||||
|
"[](https://b.example)",
|
||||||
|
"`[](https://b.example)`",
|
||||||
|
"`[](https://b.example)`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"image inside brackets that are no link",
|
||||||
|
"[]",
|
||||||
|
"\\[ ``]",
|
||||||
|
"\\[ ``]",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"no bracket closes the alt",
|
||||||
|
"",
|
||||||
|
"\\",
|
||||||
|
"\\! `[x](https://e.example/a)`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"escaped backslash, then an image",
|
||||||
|
"\\\\",
|
||||||
|
"\\\\ ``",
|
||||||
|
"\\\\ ``",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const LINKS: &[Case] = &[
|
||||||
|
(
|
||||||
|
"plain URL, its full stop left out",
|
||||||
|
"See https://example.com/a.",
|
||||||
|
"See https://example.com/a.",
|
||||||
|
"See `https://example.com/a`.",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"autolink",
|
||||||
|
"<https://example.com/a>",
|
||||||
|
"<https://example.com/a>",
|
||||||
|
"`<https://example.com/a>`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"email autolink",
|
||||||
|
"Write to <owner@example.com>.",
|
||||||
|
"Write to <owner@example.com>.",
|
||||||
|
"Write to `<owner@example.com>`.",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"Markdown link with a title",
|
||||||
|
"[the docs](https://docs.example/p \"Title\")",
|
||||||
|
"[the docs](https://docs.example/p \"Title\")",
|
||||||
|
"`[the docs](https://docs.example/p \"Title\")`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"reference link and its definition",
|
||||||
|
"[docs][d]\n\n[d]: https://docs.example/p",
|
||||||
|
"[docs][d]\n\n[d]: https://docs.example/p",
|
||||||
|
"`[docs][d]`\n\n`[d]: https://docs.example/p`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"relative link",
|
||||||
|
"[home](/channels/town)",
|
||||||
|
"[home](/channels/town)",
|
||||||
|
"`[home](/channels/town)`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"www without a scheme",
|
||||||
|
"at www.example.com today",
|
||||||
|
"at www.example.com today",
|
||||||
|
"at `www.example.com` today",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"domain and path without a scheme",
|
||||||
|
"example.org/path and example.org",
|
||||||
|
"example.org/path and example.org",
|
||||||
|
"`example.org/path` and example.org",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"schemes without slashes",
|
||||||
|
"mailto:owner@example.com or tel:5551234",
|
||||||
|
"mailto:owner@example.com or tel:5551234",
|
||||||
|
"`mailto:owner@example.com` or `tel:5551234`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"prose with colons",
|
||||||
|
"Note: a ratio of 3:2 and key:value",
|
||||||
|
"Note: a ratio of 3:2 and key:value",
|
||||||
|
"Note: a ratio of 3:2 and `key:value`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"URL with parentheses, inside parentheses",
|
||||||
|
"(see https://en.example/wiki/Rust_(language))",
|
||||||
|
"(see https://en.example/wiki/Rust_(language))",
|
||||||
|
"(see `https://en.example/wiki/Rust_(language)`)",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"URL up to a backtick",
|
||||||
|
"https://x.example/a`b",
|
||||||
|
"https://x.example/a`b",
|
||||||
|
"``https://x.example/a`` `b",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"non-ASCII URL and text",
|
||||||
|
"Привет, мир: https://пример.рф/путь и всё.",
|
||||||
|
"Привет, мир: https://пример.рф/путь и всё.",
|
||||||
|
"Привет, мир: `https://пример.рф/путь` и всё.",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"two links on a line",
|
||||||
|
"[a](https://a.example) or https://b.example/x?y=1",
|
||||||
|
"[a](https://a.example) or https://b.example/x?y=1",
|
||||||
|
"`[a](https://a.example)` or `https://b.example/x?y=1`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"angle brackets around a space are no autolink",
|
||||||
|
"<a b:c>",
|
||||||
|
"<a b:c>",
|
||||||
|
"<a `b:c`>",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a scheme inside a word is no URL",
|
||||||
|
"1http://x.example/p",
|
||||||
|
"1http://x.example/p",
|
||||||
|
"1http://x.example/p",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a last part of five letters is no domain",
|
||||||
|
"x.abcde/p and x.abcd/p",
|
||||||
|
"x.abcde/p and x.abcd/p",
|
||||||
|
"x.abcde/p and `x.abcd/p`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"www with digits",
|
||||||
|
"www2.example.com",
|
||||||
|
"www2.example.com",
|
||||||
|
"`www2.example.com`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"brackets and angle brackets that are no link",
|
||||||
|
"[not a link] and <foo> and a < b",
|
||||||
|
"[not a link] and <foo> and a < b",
|
||||||
|
"[not a link] and <foo> and a < b",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"definition padded with spaces, ending in a backtick",
|
||||||
|
" [x]: https://e.example/`",
|
||||||
|
" [x]: https://e.example/`",
|
||||||
|
"`` [x]: https://e.example/``\\`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a definition needs a label",
|
||||||
|
"[]: https://e.example/x",
|
||||||
|
"[]: https://e.example/x",
|
||||||
|
"[]: `https://e.example/x`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a definition only at the start of a line",
|
||||||
|
"text [x]: https://e.example",
|
||||||
|
"text [x]: https://e.example",
|
||||||
|
"text [x]: `https://e.example`",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const CODE: &[Case] = &[
|
||||||
|
(
|
||||||
|
"code spans",
|
||||||
|
"Run `curl https://example.com/x` and `` now.",
|
||||||
|
"Run `curl https://example.com/x` and `` now.",
|
||||||
|
"Run `curl https://example.com/x` and `` now.",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"fenced block",
|
||||||
|
"Before:\n```sh\ncurl https://example.com/x\n\n```\nAfter.",
|
||||||
|
"Before:\n```sh\ncurl https://example.com/x\n\n```\nAfter.",
|
||||||
|
"Before:\n```sh\ncurl https://example.com/x\n\n```\nAfter.",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"tilde fence, and a longer fence holding a shorter one",
|
||||||
|
"~~~\n\n~~~\n````\n```\nhttps://b.example\n````",
|
||||||
|
"~~~\n\n~~~\n````\n```\nhttps://b.example\n````",
|
||||||
|
"~~~\n\n~~~\n````\n```\nhttps://b.example\n````",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"span with a backtick inside",
|
||||||
|
"``a ` https://x.example`` and ````",
|
||||||
|
"``a ` https://x.example`` and ````",
|
||||||
|
"``a ` https://x.example`` and ````",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"link text in code",
|
||||||
|
"[`code`](https://d.example)",
|
||||||
|
"[`code`](https://d.example)",
|
||||||
|
"``[``\\` ``code``\\` ``](https://d.example)``",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"code in code, and a link beside it",
|
||||||
|
"`https://a.example` https://b.example",
|
||||||
|
"`https://a.example` https://b.example",
|
||||||
|
"`https://a.example` ``https://b.example``",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const TICKS: &[Case] = &[
|
||||||
|
(
|
||||||
|
"runs longer than any in the reply",
|
||||||
|
"``x`` then https://y.example and ",
|
||||||
|
"``x`` then https://y.example and ``````",
|
||||||
|
"``x`` then ```https://y.example``` and ``````",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence counts",
|
||||||
|
"```\ncode\n```\nhttps://y.example",
|
||||||
|
"```\ncode\n```\nhttps://y.example",
|
||||||
|
"```\ncode\n```\n````https://y.example````",
|
||||||
|
true,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"backticks inside the image go between spans, escaped",
|
||||||
|
"",
|
||||||
|
"````",
|
||||||
|
"````",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a backtick right after the image",
|
||||||
|
"x `y`",
|
||||||
|
"x ```` `y`",
|
||||||
|
"x ```` `y`",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a lone backtick right before the image",
|
||||||
|
"`",
|
||||||
|
"` ````",
|
||||||
|
"` ````",
|
||||||
|
false,
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
fn check(table: &[Case]) {
|
||||||
|
for &(case, input, clean, untrusted, links) in table {
|
||||||
|
let got = disarm(input, false);
|
||||||
|
assert_eq!(got.text, clean, "{case}: clean");
|
||||||
|
assert!(!got.links, "{case}: a clean reply never has links disarmed");
|
||||||
|
let got = disarm(input, true);
|
||||||
|
assert_eq!(got.text, untrusted, "{case}: untrusted");
|
||||||
|
assert_eq!(got.links, links, "{case}: links");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn images_are_code_in_every_reply() {
|
||||||
|
check(IMAGES);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn links_are_code_only_when_untrusted() {
|
||||||
|
check(LINKS);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn code_is_left_as_it_is() {
|
||||||
|
check(CODE);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn new_spans_use_a_longer_run_and_never_touch_a_backtick() {
|
||||||
|
check(TICKS);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn disarming_twice_changes_nothing() {
|
||||||
|
for table in [IMAGES, LINKS, CODE, TICKS] {
|
||||||
|
for &(case, input, ..) in table {
|
||||||
|
for untrusted in [false, true] {
|
||||||
|
let once = disarm(input, untrusted).text;
|
||||||
|
let twice = disarm(&once, untrusted);
|
||||||
|
assert_eq!(twice.text, once, "{case}: untrusted {untrusted}");
|
||||||
|
assert!(
|
||||||
|
!twice.links,
|
||||||
|
"{case}: untrusted {untrusted}: nothing left to disarm"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn text_without_images_or_links_is_unchanged() {
|
||||||
|
for text in [
|
||||||
|
"",
|
||||||
|
"Plain words.",
|
||||||
|
"Ünïcödé, 日本語, emoji 🦀, and a tab\there.",
|
||||||
|
"Lines\n\nwith\r\nbreaks\rof\u{2424}every kind\n",
|
||||||
|
"A list:\n- one\n- two\n\n> a quote\n\n# A heading",
|
||||||
|
"Emphasis: *a*, **b**, _c_, ~~d~~ and a table:\n| a | b |\n|---|---|\n| 1 | 2 |",
|
||||||
|
"Paths: crates/gatewayd/src/links.rs, ../x.txt, C:\\temp and std::io",
|
||||||
|
] {
|
||||||
|
for untrusted in [false, true] {
|
||||||
|
let got = disarm(text, untrusted);
|
||||||
|
assert_eq!(got.text, text, "untrusted {untrusted}");
|
||||||
|
assert!(!got.links);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn the_notice_is_one_line() {
|
||||||
|
assert_eq!(
|
||||||
|
NOTICE,
|
||||||
|
"Links in this reply are shown as code because this conversation has read untrusted content."
|
||||||
|
);
|
||||||
|
assert!(!NOTICE.contains('\n'));
|
||||||
|
}
|
||||||
@@ -0,0 +1,363 @@
|
|||||||
|
//! `links::disarm` where the server's CommonMark parser and the clients' marked may read a reply
|
||||||
|
//! differently: such text is read as prose, so an image in it still goes in a code span (M5b
|
||||||
|
//! spec, section 9). Each case names the rule it pins. Do not edit.
|
||||||
|
|
||||||
|
use gatewayd::links::disarm;
|
||||||
|
|
||||||
|
/// (case, input, clean reply). The untrusted reply is checked by the tests in `links.rs`.
|
||||||
|
type Case = (&'static str, &'static str, &'static str);
|
||||||
|
|
||||||
|
const FENCES: &[Case] = &[
|
||||||
|
(
|
||||||
|
"an unclosed fence is prose",
|
||||||
|
"```\n",
|
||||||
|
"```\n````````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a closer may end with tildes, and what follows is prose",
|
||||||
|
"```\n\n```~\n",
|
||||||
|
"```\n\n```~\n````````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a longer closer closes, a shorter one does not",
|
||||||
|
"```\n\n````\n````\n```\n\n````",
|
||||||
|
"```\n\n````\n````\n```\n\n````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an opener indented four spaces is prose",
|
||||||
|
" ```\n \n ```",
|
||||||
|
" ```\n ````````\n ```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"two backticks are no fence",
|
||||||
|
"``\n\n``",
|
||||||
|
"``\n``````\n``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a closer indented four spaces does not close",
|
||||||
|
"```\n\n ```\n\n```",
|
||||||
|
"```\n\n ```\n\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an opener indented three spaces is a fence",
|
||||||
|
" ```\n \n```",
|
||||||
|
" ```\n \n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an opener with a pipe after it is prose",
|
||||||
|
"```|x\n\n```",
|
||||||
|
"```|x\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an opener with a backtick after it is prose",
|
||||||
|
"``` a`b\n\n```",
|
||||||
|
"``` a`b\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence continuing a list item is prose",
|
||||||
|
"- item\n```\n\n```",
|
||||||
|
"- item\n```\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence continuing a quote is prose",
|
||||||
|
"> quote\n```\n\n```",
|
||||||
|
"> quote\n```\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence continuing a numbered item is prose",
|
||||||
|
"1. item\n```\n\n```",
|
||||||
|
"1. item\n```\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence after an empty line below a list is a fence, even with an empty line inside",
|
||||||
|
"- item\n\n```\n\n\nx\n```",
|
||||||
|
"- item\n\n```\n\n\nx\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a line indented less than the opener ends it",
|
||||||
|
"- item\n\n ```\n\n ```",
|
||||||
|
"- item\n\n ```\n````````\n ```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an empty line inside an indented fence does not end it",
|
||||||
|
"- item\n\n ```\n one\n\n \n ```",
|
||||||
|
"- item\n\n ```\n one\n\n \n ```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a fence after an HTML tag is prose",
|
||||||
|
"<div>\n\n```\n\n```\n\n</div>",
|
||||||
|
"<div>\n\n```\n````````\n```\n\n</div>",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a tag after a list marker counts",
|
||||||
|
"- <div>\n\n```\n\n```",
|
||||||
|
"- <div>\n\n```\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a tag inside a line does not",
|
||||||
|
"Use `Vec<String>`:\n```\n\n```",
|
||||||
|
"Use `Vec<String>`:\n```\n\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a closing tag counts",
|
||||||
|
"</p>\n```\n\n```",
|
||||||
|
"</p>\n```\n````````\n```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a tag after the fence does not matter",
|
||||||
|
"```\n\n```\n<div>",
|
||||||
|
"```\n\n```\n<div>",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a tag inside a fence does not count",
|
||||||
|
"```\n<div>\n```\n```\n\n```",
|
||||||
|
"```\n<div>\n```\n```\n\n```",
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const LINES: &[Case] = &[
|
||||||
|
(
|
||||||
|
"a carriage return ends a line",
|
||||||
|
"```\r\r```\rtext\r",
|
||||||
|
"```\r\r```\rtext\r````````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"U+2424 ends a line",
|
||||||
|
"```\u{2424}\u{2424}```",
|
||||||
|
"```\u{2424}\u{2424}```",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"CRLF is one line end, not an empty line",
|
||||||
|
"`a\r\n``",
|
||||||
|
"`a\r\n` ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a line of spaces inside an alt is written as it is",
|
||||||
|
"",
|
||||||
|
"``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an alt split by CRLF keeps it",
|
||||||
|
"",
|
||||||
|
"``",
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const SPANS: &[Case] = &[
|
||||||
|
(
|
||||||
|
"a span on one line is code",
|
||||||
|
"a\n``",
|
||||||
|
"a\n``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"after a lone backtick, a span of its length is prose",
|
||||||
|
"`a\n``",
|
||||||
|
"`a\n` ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a span of another length is still code",
|
||||||
|
"`a\n````",
|
||||||
|
"`a\n````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a span holding a run of that length is prose",
|
||||||
|
"`lone\n``a `  ``",
|
||||||
|
"`lone\n``a ` `````` ``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an empty line starts afresh",
|
||||||
|
"`a\n\n``",
|
||||||
|
"`a\n\n``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a line of spaces does not",
|
||||||
|
"`a\n \n``",
|
||||||
|
"`a\n \n` ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a span that does not close on its line is prose",
|
||||||
|
"`a\nb` ",
|
||||||
|
"`a\nb` ````",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a span holding a pipe is prose (a table cell ends there)",
|
||||||
|
"| `x |  | y` |",
|
||||||
|
"| `x | ```` | y` |",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"an escaped backtick opens nothing",
|
||||||
|
"\\``",
|
||||||
|
"\\` ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a backtick in a URL opens nothing (marked reads it as the URL's)",
|
||||||
|
"https://x.example/a`b  `",
|
||||||
|
"https://x.example/a`b ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a backtick in a link destination opens nothing",
|
||||||
|
"[a](x `)  `",
|
||||||
|
"[a](x `) ```` `",
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
const BRACKETS: &[Case] = &[
|
||||||
|
(
|
||||||
|
"a label holding a bracket in code",
|
||||||
|
"![a `]` b](https://e.example/a)",
|
||||||
|
"``![a ``\\` ``]``\\` `` b](https://e.example/a)``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a label holding a lone backtick",
|
||||||
|
" `",
|
||||||
|
"`````` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"nested brackets and escapes in the label",
|
||||||
|
"![a [b] \\] c](https://e.example/a)",
|
||||||
|
"`![a [b] \\] c](https://e.example/a)`",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"nested parentheses in the destination; a backslash does not escape one",
|
||||||
|
"\\)c) d",
|
||||||
|
"`\\)`c) d",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"no parenthesis closes the destination",
|
||||||
|
"![a](https://e.example/a b",
|
||||||
|
"`![a]`(https://e.example/a b",
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
/// What marked lets take a backtick before a code span starts: emphasis, a tag, a URL, a link.
|
||||||
|
const STEALS: &[Case] = &[
|
||||||
|
(
|
||||||
|
"emphasis before a span that holds its closer makes it prose",
|
||||||
|
"** `**  `",
|
||||||
|
"** `** ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a tag before a span that holds a `>` makes it prose",
|
||||||
|
"<b x='`'>  `",
|
||||||
|
"<b x='`'> ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a `[` that starts no link is escaped when a `](` follows",
|
||||||
|
"[x [y](https://l.example) and [z]",
|
||||||
|
"\\[x [y](https://l.example) and [z]",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"the characters of a clean link count as seen",
|
||||||
|
"[a*b](https://l.example) `*`",
|
||||||
|
"[a*b](https://l.example) `* ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"inline LaTeX before a span that holds a `$` makes it prose",
|
||||||
|
"$a `$  `",
|
||||||
|
"$a `$ ```` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a new span splits at a `$` seen before it, which marked does not escape",
|
||||||
|
"$x ",
|
||||||
|
"$x ``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"but not at a `$` seen only after it",
|
||||||
|
" $x",
|
||||||
|
"`` $x",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a new span splits at a closer seen before it",
|
||||||
|
"*a* ",
|
||||||
|
"*a* ``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"but not at one seen only after it",
|
||||||
|
" *a*",
|
||||||
|
"`` *a*",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"marked may read part of a run into a clean URL",
|
||||||
|
"www.x.example/p```)``",
|
||||||
|
"www.x.example/p```)` ```````` `",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a clean URL ends at a `<` before a line end, which may start an autolink",
|
||||||
|
"e.org/p<\ne.org/p<https://a.example>",
|
||||||
|
"e.org/p<\ne.org/p<https://a.example> ``",
|
||||||
|
),
|
||||||
|
(
|
||||||
|
"a clean URL holding an image goes in code whole",
|
||||||
|
"https://x.example/ end",
|
||||||
|
"`https://x.example/` end",
|
||||||
|
),
|
||||||
|
];
|
||||||
|
|
||||||
|
fn check(table: &[Case]) {
|
||||||
|
for &(case, input, clean) in table {
|
||||||
|
let once = disarm(input, false);
|
||||||
|
assert_eq!(once.text, clean, "{case}");
|
||||||
|
assert_eq!(disarm(clean, false).text, clean, "{case}: twice");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn fences_both_parsers_read_as_code() {
|
||||||
|
check(FENCES);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn lines_end_where_marked_ends_them() {
|
||||||
|
check(LINES);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn spans_both_parsers_read_as_code() {
|
||||||
|
check(SPANS);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn labels_and_destinations_end_where_either_parser_ends_them() {
|
||||||
|
check(BRACKETS);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn what_marked_lets_take_a_backtick_leaves_no_image() {
|
||||||
|
check(STEALS);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn a_construct_is_looked_for_in_its_first_2048_characters() {
|
||||||
|
// From its `[` to its `)`: 2048 characters, found whole.
|
||||||
|
let image = |alt: usize| format!("", "a".repeat(alt));
|
||||||
|
assert_eq!(
|
||||||
|
disarm(&image(2025), false).text,
|
||||||
|
format!("`{}`", image(2025))
|
||||||
|
);
|
||||||
|
// One more, and the `)` is out of reach: the image is read as `![alt]`.
|
||||||
|
let alt = "a".repeat(2026);
|
||||||
|
let got = disarm(&image(2026), false).text;
|
||||||
|
assert_eq!(got, format!("`![{alt}]`(https://e.example/x)"));
|
||||||
|
// With the `]` out of reach too, only the `"));
|
||||||
|
let got = disarm(&image(2047), true).text;
|
||||||
|
assert_eq!(got, format!("`"));
|
||||||
|
// A link out of reach keeps only its URL in code.
|
||||||
|
let got = disarm(&format!("[{alt}](https://l.example/x)"), true);
|
||||||
|
assert_eq!(got.text, format!("[{alt}]( `https://l.example/x`)"));
|
||||||
|
assert!(got.links);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn an_untrusted_reply_follows_the_same_rules() {
|
||||||
|
let text = "- item\n```\nhttps://e.example/a\n```\n\n```\nhttps://e.example/b\n```";
|
||||||
|
let got = disarm(text, true);
|
||||||
|
assert_eq!(
|
||||||
|
got.text,
|
||||||
|
"- item\n```\n````https://e.example/a````\n```\n\n```\nhttps://e.example/b\n```"
|
||||||
|
);
|
||||||
|
assert!(got.links);
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user