diff --git a/crates/doc/src/link.rs b/crates/doc/src/link.rs index 9bb08b90e0..7ceeabb37b 100644 --- a/crates/doc/src/link.rs +++ b/crates/doc/src/link.rs @@ -1,5 +1,6 @@ -//! Which hyperlink targets may leave the document: followed by the OS, or written into an -//! exported HTML/Markdown file where a browser would run them. +//! Hyperlink targets: where a `HYPERLINK` field code points, and which targets may leave the +//! document: followed by the OS, or written into an exported HTML/Markdown file where a browser +//! would run them. /// Whether Ctrl/⌘+click may hand a document's hyperlink to the system: web and email links only, /// so a document can't launch `file:` paths, programs or custom-scheme handlers. Exact: a leading @@ -39,10 +40,121 @@ fn scheme(url: &str) -> Option { (first.is_ascii_alphabetic() && chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))).then(|| s.to_ascii_lowercase()) } +/// Where a `HYPERLINK` field code points, as a `w:hyperlink` reads: `url`, `url#bookmark` (`\l`) +/// or `#bookmark`. None for any other field, or one with no target. +pub fn hyperlink_target(instr: &str) -> Option { + // Only a `HYPERLINK` code is split up (a field's code may run to megabytes). + if !instr.trim_start().get(..9).is_some_and(|k| k.eq_ignore_ascii_case("HYPERLINK")) { + return None; + } + let args = field_args(instr); + let mut args = args.iter().peekable(); + if !args.next().is_some_and(|(k, quoted)| !quoted && k.eq_ignore_ascii_case("HYPERLINK")) { + return None; + } + let is_switch = |(a, quoted): &&(String, bool)| !quoted && a.starts_with('\\'); + let (mut url, mut anchor) = (None, None); + while let Some(arg @ (a, _)) = args.next() { + if !is_switch(&arg) { + url = url.or(Some(a.as_str())); + continue; + } + // `\l` names a bookmark, `\o` a tooltip, `\t` a frame, `\*` `\#` `\@` a format; `\m` and `\n` take none. + let takes = matches!(a.to_ascii_lowercase().as_str(), "\\l" | "\\o" | "\\t" | "\\*" | "\\#" | "\\@"); + let value = takes.then(|| args.next_if(|v| !is_switch(v))).flatten(); + if a.eq_ignore_ascii_case("\\l") + && let Some((v, _)) = value + { + anchor = Some(v.as_str()); + } + } + let url = url.map(str::trim).filter(|u| !u.is_empty()); + let anchor = anchor.map(|a| a.trim().trim_start_matches('#')).filter(|a| !a.is_empty()); + match (url, anchor) { + // `\l` replaces a fragment the address already has, as in Word. + (Some(u), Some(a)) => Some(format!("{}#{a}", u.split_once('#').map_or(u, |(base, _)| base))), + (Some(u), None) => Some(u.to_string()), + (None, Some(a)) => Some(format!("#{a}")), + (None, None) => None, + } +} + +/// A field code's words: the field's name, its switches and its arguments, each with whether +/// it was quoted. In quotes a backslash escapes the next character, as in Word. +fn field_args(instr: &str) -> Vec<(String, bool)> { + let mut out = Vec::new(); + let mut chars = instr.chars().peekable(); + while let Some(c) = chars.next() { + if c.is_whitespace() { + continue; + } + let mut word = String::new(); + if c == '"' { + while let Some(c) = chars.next() { + match c { + '"' => break, + '\\' => word.extend(chars.next()), + _ => word.push(c), + } + } + out.push((word, true)); + } else { + word.push(c); + while let Some(c) = chars.next_if(|c| !c.is_whitespace() && *c != '"') { + word.push(c); + } + out.push((word, false)); + } + } + out +} + #[cfg(test)] mod tests { use super::*; + /// Every reader's `HYPERLINK` cases: switches with and without values, quotes, escapes, spelling. + #[test] + fn hyperlink_field_codes_name_their_targets() { + for (code, want) in [ + (r#"HYPERLINK "http://example.com" \l "heading""#, Some("http://example.com#heading")), + (r#"HYPERLINK \l "heading""#, Some("#heading")), + (r#"HYPERLINK \l "_Toc1" "#, Some("#_Toc1")), + (r#"Hyperlink "http://example.com/a path""#, Some("http://example.com/a path")), + ("HYPERLINK https://example.org/b", Some("https://example.org/b")), + ("HYPERLINK\t\"http://example.com\"", Some("http://example.com")), + (r#"HYPERLINK"http://example.com""#, Some("http://example.com")), + (r#"HYPERLINK "http://example.com/path\latest""#, Some("http://example.com/pathlatest")), + (r#"HYPERLINK "C:\\Docs\\My file.docx""#, Some(r"C:\Docs\My file.docx")), + (r#"HYPERLINK "say \"hi\"""#, Some(r#"say "hi""#)), + (r#"HYPERLINK " http://example.com ""#, Some("http://example.com")), + // Switches that take a value, before or after the address, and those that take none. + (r#"HYPERLINK "http://example.com" \o "Help text""#, Some("http://example.com")), + (r#"hyperlink \o "A tip" \t "_blank" "https://example.org/""#, Some("https://example.org/")), + (r#"HYPERLINK \l "bm" \o "tip""#, Some("#bm")), + (r#"HYPERLINK \l "Sec" \m"#, Some("#Sec")), + (r#"HYPERLINK \n "http://example.com""#, Some("http://example.com")), + (r#"HYPERLINK \l "x" \* MERGEFORMAT"#, Some("#x")), + (r#"HYPERLINK "http://example.com" \l \o "tip""#, Some("http://example.com")), + (r#"HYPERLINK \l "bm" \l"#, Some("#bm")), + // A bookmark's own `#`, an address that has a fragment, and an empty address. + (r##"HYPERLINK "http://example.com" \l "#top""##, Some("http://example.com#top")), + (r#"HYPERLINK "http://example.com/#a" \l "b""#, Some("http://example.com/#b")), + (r#"HYPERLINK "" \l "x""#, Some("#x")), + // No target, or not a `HYPERLINK` field. + ("HYPERLINK", None), + (r#"HYPERLINK "" \o "tip""#, None), + (r#"HYPERLINKS "https://example.org/""#, None), + (r#"HYPERLINKX "http://example.com""#, None), + (r#"HYPERLINK\l "x""#, None), + ("PAGEREF _Toc1 \\h", None), + ("ab日本語", None), + ("", None), + ] { + assert_eq!(hyperlink_target(code).as_deref(), want, "{code:?}"); + } + } + #[test] fn only_web_and_mail_links_are_followable() { for ok in ["https://example.com/a?b#c", "http://example.com", "HTTPS://EXAMPLE.COM", "mailto:someone@example.com"] { diff --git a/crates/docbin/src/fmt.rs b/crates/docbin/src/fmt.rs index af289d318e..a5d85012c8 100644 --- a/crates/docbin/src/fmt.rs +++ b/crates/docbin/src/fmt.rs @@ -109,12 +109,13 @@ pub(crate) fn ico(i: u8) -> Option { ICO.get(i as usize).copied() } -/// The model border style a `brcType` stands for ([MS-DOC] §2.9.22 BrcType). Types the model -/// doesn't carry (the gap variants, 3-D, inset/outset) draw as single lines, as the DOCX -/// reader maps them. +/// The model border style a `brcType` stands for ([MS-DOC] §2.9.22 BrcType; 0x02, thick, is in +/// the BRC of Microsoft's Word 97-2007 specification). Types the model doesn't carry (the gap +/// variants, 3-D, inset/outset) draw as single lines, as the DOCX reader maps them. fn brc_style(t: u8) -> BorderStyle { match t { 0x00 => BorderStyle::None, + 0x02 => BorderStyle::Thick, 0x03 => BorderStyle::Double, 0x06 => BorderStyle::Dotted, 0x07 | 0x16 => BorderStyle::Dashed, @@ -125,15 +126,15 @@ fn brc_style(t: u8) -> BorderStyle { } } -/// The border width in points: `dptLineWidth` in 1/8-point steps (values below 2 count as 2; -/// 1-point steps for page borders, which never reach a paragraph property). +/// The border width in points: `dptLineWidth` in 1/8-point steps from 2 to 96, as DOCX `w:sz` +/// reads (1-point steps for page borders, which never reach a paragraph property). fn brc_width(t: u8, dpt: u8) -> f32 { - if t >= 0x40 { f32::from(dpt) } else { f32::from(dpt.max(2)) / 8.0 } + if t >= 0x40 { f32::from(dpt) } else { (f32::from(dpt.max(2)) / 8.0).min(12.0) } } /// One border from a Brc80 operand ([MS-DOC] §2.9.18). All bits set means "no border"; a /// truncated operand is ignored. -fn brc80(op: &[u8]) -> Option { +pub(crate) fn brc80(op: &[u8]) -> Option { let [dpt, ty, ico_index, tail, ..] = op else { return None }; if [*dpt, *ty, *ico_index, *tail] == [0xFF; 4] { return Some(Border::default()); diff --git a/crates/docbin/src/lib.rs b/crates/docbin/src/lib.rs index 8742c6f639..856a307c24 100644 --- a/crates/docbin/src/lib.rs +++ b/crates/docbin/src/lib.rs @@ -26,6 +26,7 @@ mod table; use std::io::{Read, Seek}; +use wordcraft_doc::link::hyperlink_target; use wordcraft_doc::para::InlineObject; use wordcraft_doc::para::NoteKind; use wordcraft_doc::para::Paragraph; @@ -722,85 +723,6 @@ fn finish_field(pb: &mut ParaBuild, f: FieldBuild, work: &Work) { pb.objects.push(InlineObject::Field { instr, result: result_text, locked: false, dirty: false, code: false, form: String::new() }); } -/// `HYPERLINK "url"` / `HYPERLINK url \l "bookmark"` → the model link target -/// (`#bookmark` for internal links); `None` when not a hyperlink. -fn hyperlink_target(instr: &str) -> Option { - let t = instr.trim(); - let rest = if t.get(..9).is_some_and(|h| h.eq_ignore_ascii_case("hyperlink")) { - t.get(9..).filter(|r| r.is_empty() || r.starts_with(char::is_whitespace))?.trim() - } else { - return None; - }; - if rest.is_empty() { - return None; - } - - let mut url: Option = None; - let mut local: Option = None; - let mut switch: Option<&str> = None; - - let mut i = 0; - let bytes = rest.as_bytes(); - while i < bytes.len() { - while i < bytes.len() && bytes[i].is_ascii_whitespace() { - i += 1; - } - if i >= bytes.len() { - break; - } - if bytes[i] == b'\\' { - let start = i; - i += 1; - while i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'*') { - i += 1; - } - switch = Some(rest.get(start..i).unwrap_or("")); - continue; - } - let arg = if bytes[i] == b'"' { - i += 1; - let start = i; - while i < bytes.len() && bytes[i] != b'"' { - i += 1; - } - let val = rest.get(start..i).unwrap_or(""); - if i < bytes.len() && bytes[i] == b'"' { - i += 1; - } - val.to_string() - } else { - let start = i; - while i < bytes.len() && !bytes[i].is_ascii_whitespace() { - i += 1; - } - rest.get(start..i).unwrap_or("").to_string() - }; - let clean_arg = arg.replace("%22", "\""); - match switch.take() { - Some("\\l") => local = Some(clean_arg), - Some(_) => {} - None => { - if url.is_none() { - url = Some(clean_arg); - } - } - } - } - - match (url, local) { - (Some(u), Some(l)) if !u.is_empty() && !l.is_empty() => { - let frag = l.trim_start_matches('#'); - if u.contains('#') { Some(u) } else { Some(format!("{u}#{frag}")) } - } - (Some(u), _) if !u.is_empty() => Some(u), - (None, Some(l)) if !l.is_empty() => { - let frag = l.trim_start_matches('#'); - Some(format!("#{frag}")) - } - _ => None, - } -} - /// `sprmCPicLocation` from a CHPX grpprl: the fc of the picture in the Data stream. fn pic_location(chpx: &[u8]) -> Option { for prl in sprm::iter(chpx) { diff --git a/crates/docbin/src/table.rs b/crates/docbin/src/table.rs index 8604140a20..3b0daf6395 100644 --- a/crates/docbin/src/table.rs +++ b/crates/docbin/src/table.rs @@ -5,7 +5,7 @@ use std::sync::Arc; use wordcraft_doc::Rgb; use wordcraft_doc::para::Paragraph; -use wordcraft_doc::props::{Align, Border, BorderStyle, Borders, CellProps, HeightRule, RowProps, TableProps, VAlign, VMerge}; +use wordcraft_doc::props::{Align, Borders, CellProps, HeightRule, RowProps, TableProps, VAlign, VMerge}; use wordcraft_doc::table::{Cell, Row, Table}; use wordcraft_doc::{Block, Blocks, para_block}; @@ -458,32 +458,12 @@ fn def_table_edges(operand: &[u8]) -> Vec { } /// Table borders from `sprmTTableBorders80`: cb (0x18) then six Brc80s in the order top, -/// left, bottom, right, inside-horizontal, inside-vertical. +/// left, bottom, right, inside-horizontal, inside-vertical, read as paragraph borders are. fn table_borders(operand: &[u8]) -> Option { - let b = |i: usize| operand.get(1 + i * 4..1 + i * 4 + 4).and_then(brc80); + let b = |i: usize| operand.get(1 + i * 4..1 + i * 4 + 4).and_then(fmt::brc80); Some(Borders { top: b(0), left: b(1), bottom: b(2), right: b(3), between: b(4), inside_v: b(5) }) } -/// One Brc80: width in 1/8 pt, type, palette colour, space/flags byte. -fn brc80(b: &[u8]) -> Option { - let [w, ty, ico, flags] = b else { return None }; - let style = match ty { - 0x00 => BorderStyle::None, - 0x02 | 0x15 => BorderStyle::Thick, - 0x03 => BorderStyle::Double, - 0x04 | 0x05 => BorderStyle::Dotted, - 0x06 | 0x07 => BorderStyle::Dashed, - 0x08 | 0x09 => BorderStyle::DotDash, - 0x0A | 0x18 => BorderStyle::Wave, - 0x11 => BorderStyle::Triple, - _ => BorderStyle::Single, - }; - if *ty == 0 && *w == 0 { - return None; - } - Some(Border { style, width: (*w as f32 / 8.0).clamp(0.25, 12.0), color: fmt::ico(*ico), space: (flags & 0x1F) as f32 }) -} - /// Background colour from a 10-byte `Shd`: cvFore, cvBack (COLORREFs), ipat. Solid patterns /// show the foreground; clear (0) and the other patterns show the background (Word writes a /// plain cell fill as clear with cvBack); nil (0xFFFF) and automatic colours are no fill. diff --git a/crates/docbin/src/tests.rs b/crates/docbin/src/tests.rs index 6354316069..b251cadbb5 100644 --- a/crates/docbin/src/tests.rs +++ b/crates/docbin/src/tests.rs @@ -1209,6 +1209,53 @@ fn table_merges_borders_shading() { assert_eq!(top.width, 0.5); } +/// Table borders read the BrcType byte as paragraph borders do; a nil Brc80 is no border. +#[test] +fn table_borders_read_border_types_as_paragraphs_do() { + use wordcraft_doc::props::BorderStyle as S; + let text = "a\u{7}\u{7}tail\r"; + let in_tbl = grpprl(&[(0x2416, &[0x01]), (0x6649, &[1, 0, 0, 0])]); + let row_end = { + let mut v = [grpprl(&[(0x2416, &[0x01]), (0x2417, &[0x01]), (0x6649, &[1, 0, 0, 0])]), t_def_edges(&[0, 2880])].concat(); + v.extend_from_slice(&0xD605u16.to_le_bytes()); + v.push(0x18); + // Dotted, triple, double wave, nil, 3-D emboss 255/8 pt wide, all zero. + for brc in [[8, 0x06, 1, 0], [8, 0x0A, 1, 0], [8, 0x15, 1, 0], [0xFF; 4], [0xFF, 0x18, 1, 0], [0, 0, 0, 0]] { + v.extend_from_slice(&brc); + } + v + }; + let spec = StructSpec { + text, + header_stories: vec![], + sections: vec![(text.chars().count() as u32, Vec::new())], + chpx_runs: vec![(0, Vec::new())], + papx_entries: vec![(0, 0, in_tbl), (2, 0, row_end), (3, 0, grpprl(&[(0x6424, &[0xFF, 0x01, 1, 0])]))], + plf_lst: Vec::new(), + plf_lfo: Vec::new(), + note_stories: vec![], + endnote_stories: vec![], + extra_pairs: Vec::new(), + data_stream: Vec::new(), + }; + let doc = read(&struct_doc(&spec)).expect("opens"); + let tbl = doc.body.iter().find_map(|b| b.as_table()).expect("table"); + let b = tbl.props.borders.expect("table borders"); + let seen = [b.top, b.left, b.bottom, b.right, b.between, b.inside_v].map(|s| s.map(|s| (s.style, s.is_visible(), s.width))); + let want = [ + (S::Dotted, true, 1.0), + (S::Triple, true, 1.0), + (S::Wave, true, 1.0), + (S::None, false, 0.0), + (S::Single, true, 12.0), + (S::None, false, 0.25), + ]; + assert_eq!(seen, want.map(Some)); + // A paragraph border is at most 12 points too, as a table border and a DOCX `w:sz` are. + let tail = doc.body.iter().filter_map(|b| b.as_para()).find(|p| p.text == "tail").expect("tail paragraph"); + assert_eq!(tail.props.borders.and_then(|b| b.top).map(|t| t.width), Some(12.0)); +} + // --------------------------------------------------------------------------------------------- // D3: lists (PlfLst + PlfLfo) and the combined document. @@ -1469,6 +1516,16 @@ fn hyperlink_target_needs_the_whole_field_name() { assert_eq!(super::hyperlink_target(r#"HYPERLINK "http://example.com""#), Some("http://example.com".into())); } +/// A bare `\m` or `\n` keeps the address after it; escapes, an empty address and `%22` read as in DOCX. +#[test] +fn hyperlink_target_keeps_the_address_after_a_bare_switch() { + assert_eq!(super::hyperlink_target(r#"HYPERLINK \m "http://example.com""#), Some("http://example.com".into())); + assert_eq!(super::hyperlink_target(r#"HYPERLINK \n "http://example.com""#), Some("http://example.com".into())); + assert_eq!(super::hyperlink_target(r#"HYPERLINK "C:\\Docs\\f.doc""#), Some(r"C:\Docs\f.doc".into())); + assert_eq!(super::hyperlink_target(r#"HYPERLINK "" \l "bm""#), Some("#bm".into())); + assert_eq!(super::hyperlink_target(r#"HYPERLINK "http://example.com/a%22b""#), Some("http://example.com/a%22b".into())); +} + #[test] fn bookmarks_become_objects() { let text = "Hello world\r"; @@ -2482,17 +2539,21 @@ fn symbol_runs_read_the_character_and_font_from_sprm_c_symbol() { } /// Paragraph borders around a block are read from both storage forms: the Word 97 Brc80 -/// (palette colour) and the Word 2000+ BrcOperand (cb + Brc with a full colour). +/// (palette colour) and the Word 2000+ BrcOperand (cb + Brc with a full colour). A thick +/// border (type 0x02) stays thick in both, as tables read it too. #[test] fn paragraph_borders_read_from_both_forms() { + use wordcraft_doc::props::BorderStyle as S; let b80 = [8u8, 0x01, 0x06, 0x01]; // 1 pt single line, palette red (6), 1 pt from the text + let thick80 = [8u8, 0x02, 0x06, 0x01]; let brc = [8u8, 0xFF, 0x00, 0x00, 0x00, 8, 0x01, 0x02, 0x00]; // cb 8, red COLORREF, 1 pt single, space 2 + let thick = [8u8, 0xFF, 0x00, 0x00, 0x00, 8, 0x02, 0x02, 0x00]; let text = "boxed\r\r"; let spec = StructSpec { text, papx_entries: vec![ - (0, 0, grpprl(&[(0x6424, &b80), (0x6425, &b80), (0x6426, &b80), (0x6427, &b80), (0x6428, &b80)])), - (6, 0, grpprl(&[(0xC64E, &brc)])), + (0, 0, grpprl(&[(0x6424, &b80), (0x6425, &thick80), (0x6426, &b80), (0x6427, &b80), (0x6428, &b80)])), + (6, 0, grpprl(&[(0xC64E, &brc), (0xC64F, &thick)])), ], ..structured_spec(text, text.chars().count() as u32) }; @@ -2500,13 +2561,16 @@ fn paragraph_borders_read_from_both_forms() { let p0 = doc.body.first().and_then(|b| b.as_para()).expect("first paragraph"); let b = p0.props.borders.expect("borders"); let top = b.top.expect("top border"); - assert_eq!((top.style, top.width, top.space), (wordcraft_doc::props::BorderStyle::Single, 1.0, 1.0)); + assert_eq!((top.style, top.width, top.space), (S::Single, 1.0, 1.0)); assert_eq!(top.color, Some(wordcraft_doc::Rgb(0xFF, 0, 0))); - assert!(b.left.is_some() && b.bottom.is_some() && b.right.is_some() && b.between.is_some()); + assert_eq!(b.left.map(|l| (l.style, l.width)), Some((S::Thick, 1.0)), "Brc80 thick"); + assert!(b.bottom.is_some() && b.right.is_some() && b.between.is_some()); let p1 = doc.body.get(1).and_then(|b| b.as_para()).expect("second paragraph"); - let top = p1.props.borders.expect("borders").top.expect("top border"); - assert_eq!((top.style, top.width, top.space), (wordcraft_doc::props::BorderStyle::Single, 1.0, 2.0)); + let b = p1.props.borders.expect("borders"); + let top = b.top.expect("top border"); + assert_eq!((top.style, top.width, top.space), (S::Single, 1.0, 2.0)); assert_eq!(top.color, Some(wordcraft_doc::Rgb(0xFF, 0, 0))); + assert_eq!(b.left.map(|l| (l.style, l.width)), Some((S::Thick, 1.0)), "BrcOperand thick"); } /// #3642: a small compound file whose DIFAT names one FAT sector thousands of times made `cfb` diff --git a/crates/docx/src/read/story/fields.rs b/crates/docx/src/read/story/fields.rs index 1847d3e8ad..68b29f200e 100644 --- a/crates/docx/src/read/story/fields.rs +++ b/crates/docx/src/read/story/fields.rs @@ -1,4 +1,5 @@ use super::{CharProps, FieldState, InlineObject, Item, MAX_FIELD_DEPTH, PB, Phase, Reader, StoryCtx}; +use wordcraft_doc::link::hyperlink_target; /// Enclosed characters (`eq \o\ac(○,字)`), with their style from the code's font sizes: Word /// enlarges the symbol (bigger than the text, which keeps the field's size) or shrinks the text @@ -24,69 +25,6 @@ fn is_range_instr(instr: &str) -> bool { crate::read::is_toc(instr) || instr.trim_start().get(..5).is_some_and(|k| k.eq_ignore_ascii_case("ADDIN")) } -/// Where a `HYPERLINK` field goes, as a `w:hyperlink` reads: `url`, `url#bookmark` (`\l`) or -/// `#bookmark`. None for any other field, or one with no target. -fn hyperlink_target(instr: &str) -> Option { - // Only a `HYPERLINK` code is split up (a field's code may run to megabytes). - if !instr.split_whitespace().next().is_some_and(|k| k.eq_ignore_ascii_case("HYPERLINK")) { - return None; - } - let args = field_args(instr); - let mut args = args.iter(); - if !args.next().is_some_and(|(k, quoted)| !quoted && k.eq_ignore_ascii_case("HYPERLINK")) { - return None; - } - let (mut url, mut anchor) = (None, None); - while let Some((a, quoted)) = args.next() { - if *quoted || !a.starts_with('\\') { - url = url.or(Some(a.as_str())); - continue; - } - // `\l` names a bookmark, `\o` a tooltip and `\t` a target frame; `\m` and `\n` take none. - let value = matches!(a.to_ascii_lowercase().as_str(), "\\l" | "\\o" | "\\t").then(|| args.next()).flatten(); - if a.eq_ignore_ascii_case("\\l") { - anchor = value.map(|(v, _)| v.as_str()); - } - } - let (url, anchor) = (url.map(str::trim).filter(|u| !u.is_empty()), anchor.map(str::trim).filter(|a| !a.is_empty())); - match (url, anchor) { - (Some(u), Some(a)) => Some(format!("{u}#{a}")), - (Some(u), None) => Some(u.to_string()), - (None, Some(a)) => Some(format!("#{a}")), - (None, None) => None, - } -} - -/// A field code's words: the field's name, its switches and its arguments, each with whether -/// it was quoted. In quotes, `\"` is a quote and `\\` a backslash. -fn field_args(instr: &str) -> Vec<(String, bool)> { - let mut out = Vec::new(); - let mut chars = instr.chars().peekable(); - while let Some(c) = chars.next() { - if c.is_whitespace() { - continue; - } - let mut word = String::new(); - if c == '"' { - while let Some(c) = chars.next() { - match c { - '"' => break, - '\\' if matches!(chars.peek(), Some('"' | '\\')) => word.extend(chars.next()), - _ => word.push(c), - } - } - out.push((word, true)); - } else { - word.push(c); - while let Some(c) = chars.next_if(|c| !c.is_whitespace() && *c != '"') { - word.push(c); - } - out.push((word, false)); - } - } - out -} - impl Reader<'_> { // ---- fields ---- diff --git a/crates/formats/src/rtf/export.rs b/crates/formats/src/rtf/export.rs index 0b98c81eb7..e9610a5f37 100644 --- a/crates/formats/src/rtf/export.rs +++ b/crates/formats/src/rtf/export.rs @@ -235,7 +235,9 @@ impl Writer { // leaks the reader's NTLM credentials. match f.link.as_deref().filter(|l| wordcraft_doc::link::is_safe_href(l)) { Some(l) => { - out.push_str(&format!("{{\\field{{\\*\\fldinst{{HYPERLINK \"{}\"}}}}{{\\fldrslt{{{}}}}}}}", esc(&l.replace('"', "%22")), body)); + // In a field's quotes `\\` is one backslash; a quote is stored as `%22`. + let target = l.replace('\\', "\\\\").replace('"', "%22"); + out.push_str(&format!("{{\\field{{\\*\\fldinst{{HYPERLINK \"{}\"}}}}{{\\fldrslt{{{}}}}}}}", esc(&target), body)); } None => out.push_str(&body), } diff --git a/crates/formats/src/rtf/tests.rs b/crates/formats/src/rtf/tests.rs index 733bfaad8f..acff0a4e10 100644 --- a/crates/formats/src/rtf/tests.rs +++ b/crates/formats/src/rtf/tests.rs @@ -1558,8 +1558,42 @@ fn hyperlink_field_targets() { assert_eq!(hyperlink(r#"HYPERLINK "http://example.com" \l "heading""#), Some("http://example.com#heading".into())); assert_eq!(hyperlink(r#"HYPERLINK \l "heading""#), Some("#heading".into())); assert_eq!(hyperlink(r#"Hyperlink "http://example.com""#), Some("http://example.com".into())); - assert_eq!(hyperlink(r#"HYPERLINK "http://example.com/path\latest""#), Some("http://example.com/path\\latest".into())); + assert_eq!(hyperlink(r#"HYPERLINK "http://example.com/path\latest""#), Some("http://example.com/pathlatest".into())); assert_eq!(hyperlink(r#"HYPERLINK "http://example.com" \o "Help text""#), Some("http://example.com".into())); + // A tooltip or frame before the address, a longer field name, escapes and the writer's `%22`. + assert_eq!(hyperlink(r#"HYPERLINK \o "tip" \t "_blank" "http://example.com""#), Some("http://example.com".into())); + assert_eq!(hyperlink(r#"HYPERLINKX "http://example.com""#), None); + assert_eq!(hyperlink(r#"HYPERLINK "C:\\Docs\\f.rtf""#), Some(r"C:\Docs\f.rtf".into())); + assert_eq!(hyperlink(r#"HYPERLINK "http://example.com/a%22b""#), Some(r#"http://example.com/a"b"#.into())); +} + +/// A link with a quote in it survives export and import: the writer stores it as `%22`. +#[test] +fn a_quote_in_a_link_round_trips() { + let rtf = br#"{\rtf1\ansi{\field{\*\fldinst{HYPERLINK "http://a.b/x%22y"}}{\fldrslt{link}}}\par}"#; + let link = |d: &Document| d.body.iter().find_map(|b| b.as_para()?.runs.iter().find_map(|r| r.props.link.clone())); + let d = import(rtf).unwrap(); + assert_eq!(link(&d).as_deref(), Some(r#"http://a.b/x"y"#)); + let exported = export(&d); + assert!(exported.contains("x%22y"), "{exported}"); + assert_eq!(link(&import(exported.as_bytes()).unwrap()).as_deref(), Some(r#"http://a.b/x"y"#)); +} + +/// Backslashes in a link survive export and import, a trailing one and two in a row too. +#[test] +fn backslashes_in_a_link_round_trip() { + let link = |d: &Document| d.body.iter().find_map(|b| b.as_para()?.runs.iter().find_map(|r| r.props.link.clone())); + for target in [r"docs\", r"a\\b", r"..\up\f.doc"] { + let mut d = import(br#"{\rtf1\ansi{\field{\*\fldinst{HYPERLINK "x"}}{\fldrslt{link}}}\par}"#).unwrap(); + for b in d.body.iter_mut() { + if let wordcraft_doc::Block::Para(p) = std::sync::Arc::make_mut(b) { + p.runs.iter_mut().filter(|r| r.props.link.is_some()).for_each(|r| r.props.link = Some(target.into())); + } + } + assert_eq!(link(&d).as_deref(), Some(target)); + let exported = export(&d); + assert_eq!(link(&import(exported.as_bytes()).unwrap()).as_deref(), Some(target), "{exported}"); + } } #[test] diff --git a/crates/formats/src/rtf/word.rs b/crates/formats/src/rtf/word.rs index 94815e196e..1b0d0c8d68 100644 --- a/crates/formats/src/rtf/word.rs +++ b/crates/formats/src/rtf/word.rs @@ -507,76 +507,7 @@ impl Reader { } } -/// The target of a `HYPERLINK "url"` (or `HYPERLINK "url" \l "bookmark"`, `HYPERLINK \l "bookmark"`) field instruction. +/// The target of a `HYPERLINK` field instruction; `%22` is a quote, as the writer stores one. pub(super) fn hyperlink(instr: &str) -> Option { - let t = instr.trim(); - let rest = if t.get(..9).is_some_and(|h| h.eq_ignore_ascii_case("hyperlink")) { - t[9..].trim() - } else { - return None; - }; - if rest.is_empty() { - return None; - } - - let mut url: Option = None; - let mut local: Option = None; - let mut switch: Option<&str> = None; - - let mut i = 0; - let bytes = rest.as_bytes(); - while i < bytes.len() { - while i < bytes.len() && bytes[i].is_ascii_whitespace() { - i += 1; - } - if i >= bytes.len() { - break; - } - if bytes[i] == b'\\' { - let start = i; - i += 1; - while i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'*') { - i += 1; - } - switch = Some(&rest[start..i]); - continue; - } - let arg = if bytes[i] == b'"' { - i += 1; - let start = i; - while i < bytes.len() && bytes[i] != b'"' { - i += 1; - } - let val = &rest[start..i]; - if i < bytes.len() && bytes[i] == b'"' { - i += 1; - } - val.to_string() - } else { - let start = i; - while i < bytes.len() && !bytes[i].is_ascii_whitespace() { - i += 1; - } - rest[start..i].to_string() - }; - let clean_arg = arg.replace("%22", "\""); - if switch.take() == Some("\\l") { - local = Some(clean_arg); - } else if url.is_none() { - url = Some(clean_arg); - } - } - - match (url, local) { - (Some(u), Some(l)) if !u.is_empty() && !l.is_empty() => { - let frag = l.trim_start_matches('#'); - if u.contains('#') { Some(u) } else { Some(format!("{u}#{frag}")) } - } - (Some(u), _) if !u.is_empty() => Some(u), - (None, Some(l)) if !l.is_empty() => { - let frag = l.trim_start_matches('#'); - Some(format!("#{frag}")) - } - _ => None, - } + wordcraft_doc::link::hyperlink_target(instr).map(|t| t.replace("%22", "\"")) }