Grcov report - mod.rs

1

//! XML/HTML parsing module for the Azul toolkit.

2

//!

3

//! Provides two parsing paths:

4

//! - `parse_xml_string`: builds an `XmlNode` tree (used by `domxml_from_str`)

5

//! - `parse_xml_to_fast_dom_with_css`: builds an arena-based `FastDom` directly

6

//!   from XML tokens (used by `parse_xml_to_styled_dom`)

7

//!

8

//! Both paths handle HTML5-lite features: void elements, auto-closing tags,

9

//! XML entity decoding, `<style>` CSS extraction, and BOM/DOCTYPE stripping.

10

//!

11

//! Data types (`XmlNode`, `XmlError`, etc.) live in `azul_core::xml`; this

12

//! module provides the parsing implementations.

13

14

#![allow(unused_variables)]

15

16

use alloc::{boxed::Box, collections::BTreeMap, string::String, vec::Vec};

17

use core::fmt;

18

#[cfg(feature = "std")]

19

use std::path::Path;

20

21

#[cfg(feature = "svg")]

22

pub mod svg;

23

24

/// Decodes XML/HTML entities in a string.

25

/// Handles standard XML entities: &lt; &gt; &amp; &apos; &quot;

26

/// and numeric character references: &#60; &#x3C;

27

/// Returns `Cow::Borrowed` when no entities are found (zero-alloc fast path).

28

72088

fn decode_xml_entities(s: &str) -> std::borrow::Cow<'_, str> {

29

    // Fast path: if no ampersand, no entities to decode

30

72088

    if !s.contains('&') {

31

72016

        return std::borrow::Cow::Borrowed(s);

32

72

33

72

    decode_xml_entities_slow(s)

34

72088

35

36

85

fn decode_xml_entities_slow(s: &str) -> std::borrow::Cow<'_, str> {

37

85

    let mut result = String::with_capacity(s.len());

38

85

    let mut chars = s.chars().peekable();

39

40

1060354

    while let Some(c) = chars.next() {

41

1060269

        if c == '&' {

42

            // Collect the entity reference

43

50179

            let mut entity = String::new();

44

50179

            let mut found_semicolon = false;

45

46

150501

            while let Some(&next) = chars.peek() {

47

150486

                if next == ';' {

48

50074

                    chars.next();

49

50074

                    found_semicolon = true;

50

50074

                    break;

51

100412

52

100412

                if !next.is_alphanumeric() && next != '#' {

53

86

                    break;

54

100326

55

100326

                entity.push(chars.next().unwrap());

56

100326

                if entity.len() > 10 {

57

                    // Entity too long, not a valid entity

58

4

                    break;

59

100322

60

61

62

50179

            if found_semicolon {

63

                // Try to decode the entity

64

50074

                match entity.as_str() {

65

50074

                    "lt" => result.push('<'),

66

65

                    "gt" => result.push('>'),

67

59

                    "amp" => result.push('&'),

68

43

                    "apos" => result.push('\''),

69

38

                    "quot" => result.push('"'),

70

33

                    "nbsp" => result.push('\u{00A0}'),

71

32

                    s if s.starts_with('#') => {

72

                        // Numeric character reference

73

22

                        let num_str = &s[1..];

74

22

                        let code_point = if num_str.starts_with('x') || num_str.starts_with('X') {

75

                            // Hexadecimal

76

13

                            u32::from_str_radix(&num_str[1..], 16).ok()

77

                        } else {

78

                            // Decimal

79

9

                            num_str.parse::<u32>().ok()

80

};

81

22

                        if let Some(cp) = code_point {

82

19

                            if let Some(ch) = char::from_u32(cp) {

83

13

                                result.push(ch);

84

13

                            } else {

85

6

                                // Invalid code point, keep original

86

6

                                result.push('&');

87

6

                                result.push_str(&entity);

88

6

                                result.push(';');

89

6

90

3

                        } else {

91

3

                            // Parse failed, keep original

92

3

                            result.push('&');

93

3

                            result.push_str(&entity);

94

3

                            result.push(';');

95

3

96

97

10

                    _ => {

98

10

                        // Unknown entity, keep original

99

10

                        result.push('&');

100

10

                        result.push_str(&entity);

101

10

                        result.push(';');

102

10

103

104

105

            } else {

105

                // No semicolon found, not a valid entity reference

106

105

                result.push('&');

107

105

                result.push_str(&entity);

108

105

109

1010090

        } else {

110

1010090

            result.push(c);

111

1010090

112

113

114

85

    std::borrow::Cow::Owned(result)

115

85

116

117

pub use azul_core::xml::*;

118

use azul_core::{dom::Dom, impl_from, styled_dom::StyledDom, window::StringPairVec};

119

#[cfg(feature = "parser")]

120

use azul_css::parser2::CssParseError;

121

use azul_css::{css::Css, AzString, OptionString, U8Vec};

122

use xmlparser::Tokenizer;

123

124

#[cfg(feature = "xml")]

125

2073

#[must_use] pub fn domxml_from_str(xml: &str, component_map: &ComponentMap) -> DomXml {

126

2073

    let error_css = Css::empty();

127

128

2073

    let parsed = match parse_xml_string(xml) {

129

2058

        Ok(parsed) => parsed,

130

15

        Err(e) => {

131

15

            return DomXml {

132

15

                parsed_dom: {

133

15

                    let mut dom = Dom::create_body()

134

15

                        .with_children(vec![Dom::create_p_with_text(format!("{e}"))].into());

135

15

                    StyledDom::create(&mut dom, error_css)

136

15

},

137

15

};

138

139

};

140

141

2058

    let parsed_dom = match str_to_dom(parsed.as_ref(), component_map, None) {

142

2050

        Ok(o) => o,

143

8

        Err(e) => {

144

8

            return DomXml {

145

8

                parsed_dom: {

146

8

                    let mut dom = Dom::create_body()

147

8

                        .with_children(vec![Dom::create_p_with_text(format!("{e}"))].into());

148

8

                    StyledDom::create(&mut dom, error_css)

149

8

},

150

8

};

151

152

};

153

154

2050

    DomXml { parsed_dom }

155

2073

156

157

/// Create a Dom (with CSS attached but not applied) from an already-parsed Xml structure.

158

///

159

/// Returns an unstyled `Dom` suitable for use in layout callbacks (which return `Dom`,

160

/// not `StyledDom`). The CSS from `<style>` tags is attached to the `Dom.css` field

161

/// and will be applied during the cascade pass.

162

// FFI-exported (api.json fn_body azul_layout::xml::dom_from_parsed_xml(xml)): owned Xml by value.

163

#[allow(clippy::needless_pass_by_value)]

164

51

#[must_use] pub fn dom_from_parsed_xml(xml: Xml) -> Dom {

165

51

    let component_map = ComponentMap::with_builtin();

166

51

    match str_to_dom_unstyled(xml.root.as_ref(), &component_map) {

167

47

        Ok(dom) => dom,

168

4

        Err(e) => Dom::create_body().with_children(vec![Dom::create_p_with_text(format!("{e}"))].into()),

169

170

51

171

172

/// Fastest path: parse XML string directly into `FastDom` without intermediate `XmlNode` tree.

173

///

174

/// Feeds XML tokenizer events directly into `CompactDomBuilder`, skipping both the

175

/// `XmlNode` tree construction AND the Dom tree construction.

176

/// Parse XML string directly into a `FastDom` (arena-based DOM) in a single pass.

177

///

178

/// Also extracts `<style>` tag content as CSS. Returns both the `FastDom` and

179

/// collected CSS stylesheets. No intermediate `XmlNode` tree is built.

180

///

181

/// This is the fastest XML→DOM path: XML tokens feed directly into

182

/// `CompactDomBuilder`, and `<style>` text is collected inline.

183

/// # Errors

184

///

185

/// Returns an `XmlError` if the XML cannot be parsed.

186

129

pub fn parse_xml_to_fast_dom(xml: &str) -> Result<azul_core::dom::FastDom, XmlError> {

187

129

    let (fast_dom, _css) = parse_xml_to_fast_dom_with_css(xml)?;

188

107

    Ok(fast_dom)

189

129

190

191

/// Parse XML directly into `FastDom` + extracted CSS, ready for `StyledDom`.

192

#[allow(clippy::cast_precision_loss)] // bounded layout/render numeric cast

193

/// # Errors

194

///

195

/// Returns an `XmlError` if the XML cannot be parsed.

196

209

pub fn parse_xml_to_styled_dom(xml: &str) -> Result<StyledDom, XmlError> {

197

    // Optional per-phase RSS/timing breakdown.

198

    // Gated on AZ_PROFILE=memory — prints

199

    //   [XML] tokenize+fast_dom       : +XX MiB in YY ms

200

    //   [XML] css attach              : +XX MiB in YY ms

201

    //   [XML] create_from_fast_dom    : +XX MiB in YY ms

202

    // to locate which sub-phase of the parse-cascade dominates the

203

    // RSS jump seen between `page start` and `xml parsed`.

204

    static MEM_ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();

205

209

    let mem_on = *MEM_ENABLED.get_or_init(azul_core::profile::memory_enabled);

206

207

209

    let rss0 = if mem_on { peak_rss_bytes() } else { 0 };

208

209

    let (mut fast_dom, css) = parse_xml_to_fast_dom_with_css(xml)?;

209

187

    if mem_on {

210

        let rss1 = peak_rss_bytes();

211

        eprintln!(

212

            "[XML] tokenize+fast_dom       : +{:.2} MiB",

213

            (rss1.saturating_sub(rss0)) as f64 / 1024.0 / 1024.0,

214

);

215

187

216

217

187

    let rss1 = if mem_on { peak_rss_bytes() } else { 0 };

218

    // Attach CSS to the FastDom

219

187

    if !css.is_empty() {

220

        // Rules AND keyframes: merging by rules alone silently dropped every

221

        // `@keyframes` block a `<style>` element declared, so

222

        // `-azul-animation-out: shrinkOut 1s` fell back to the default slide

223

        // at runtime while the unit parser tests stayed green.

224

172

        let mut combined_rules = Vec::new();

225

172

        let mut combined_keyframes = Vec::new();

226

344

        for c in css {

227

172

            combined_rules.extend(c.rules.into_library_owned_vec());

228

172

            combined_keyframes.extend(c.keyframes.into_library_owned_vec());

229

172

230

172

        let mut combined_css = Css::new(combined_rules);

231

172

        combined_css.keyframes = combined_keyframes.into();

232

172

        fast_dom.css = vec![azul_core::dom::CssWithNodeId {

233

172

            node_id: 0, // global scope

234

172

            css: combined_css,

235

172

        }].into();

236

15

237

187

    if mem_on {

238

        let rss2 = peak_rss_bytes();

239

        eprintln!(

240

            "[XML] css attach              : +{:.2} MiB",

241

            (rss2.saturating_sub(rss1)) as f64 / 1024.0 / 1024.0,

242

);

243

187

244

245

    // Hint the allocator to return pages freed by the CSS parser.

246

    // The tokenizer+parser created many small allocations (selectors,

247

    // declarations, strings) that are now packed into FastDom. Purging

248

    // here returns those pages before the cascade allocates more.

249

187

    crate::probe::hint_purge_allocator();

250

251

187

    let rss2 = if mem_on { peak_rss_bytes() } else { 0 };

252

187

    let styled = StyledDom::create_from_fast_dom(fast_dom);

253

254

    // Major purge point: the cascade just freed ~3 MiB of intermediate

255

    // allocations (build-phase Vecs, CSS selector matching state, pruned

256

    // properties). Tell the allocator to return those pages NOW before

257

    // the layout pass allocates more on top of them.

258

187

    crate::probe::hint_purge_allocator();

259

260

187

    if mem_on {

261

        let rss3 = peak_rss_bytes();

262

        eprintln!(

263

            "[XML] create_from_fast_dom    : +{:.2} MiB",

264

            (rss3.saturating_sub(rss2)) as f64 / 1024.0 / 1024.0,

265

);

266

187

267

268

187

    Ok(styled)

269

209

270

271

/// Resident-set bytes for RSS checkpoints — mirrors servo-shot's

272

/// `peak_rss_bytes()`. Uses `getrusage(RUSAGE_SELF)` via the

273

/// `probe` feature's `libc` dep; returns 0 without it so the

274

/// caller just doesn't emit meaningful deltas.

275

#[cfg(all(unix, feature = "probe"))]

276

fn peak_rss_bytes() -> u64 {

277

    let mut usage: libc::rusage = unsafe { std::mem::zeroed() };

278

    if unsafe { libc::getrusage(libc::RUSAGE_SELF, &raw mut usage) } != 0 {

279

        return 0;

280

281

    let ru = usage.ru_maxrss as u64;

282

    // macOS reports bytes, Linux reports KiB.

283

    #[cfg(target_os = "macos")]

284

    { ru }

285

    #[cfg(not(target_os = "macos"))]

286

    { ru.saturating_mul(1024) }

287

288

289

#[cfg(not(all(unix, feature = "probe")))]

290

2

const fn peak_rss_bytes() -> u64 {

291

2

292

2

293

294

/// Internal: parse XML into `FastDom` + collected CSS stylesheets.

295

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

296

#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

297

339

fn parse_xml_to_fast_dom_with_css(xml: &str) -> Result<(azul_core::dom::FastDom, Vec<Css>), XmlError> {

298

    use xmlparser::{ElementEnd::{Open, Empty, Close}, Token::{ElementStart, Attribute, ElementEnd, Text}, Tokenizer};

299

    use azul_core::dom::{NodeData, NodeType, IdOrClass, TabIndex};

300

    use azul_core::xml::CompactDomBuilder;

301

302

    const ESTIMATED_BYTES_PER_NODE: usize = 20;

303

304

    const VOID_ELEMENTS: &[&str] = &[

305

        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta",

306

        "param", "source", "track", "wbr",

307

];

308

309

    // Lowercase `src` into `dst`, reusing `dst`'s existing capacity.

310

    // Zero-alloc when dst's capacity is already ≥ src.len() AND no uppercase

311

    // conversion is needed (the happy path for HTML5 where tags are lowercase).

312

11600

    fn lowercase_into(dst: &mut String, src: &str) {

313

11600

        dst.clear();

314

35712

        if src.bytes().all(|b| !b.is_ascii_uppercase()) {

315

11597

            dst.push_str(src);

316

11597

        } else {

317

3

            dst.reserve(src.len());

318

11

            for b in src.bytes() {

319

11

                dst.push(b.to_ascii_lowercase() as char);

320

11

321

322

11600

323

324

    // Strip BOM

325

339

    let xml = xml.strip_prefix('\u{FEFF}').unwrap_or(xml);

326

339

    let mut xml = xml.trim();

327

328

    // Skip <?xml ... ?>

329

339

    if xml.starts_with("<?") {

330

5

        if let Some(pos) = xml.find("?>") {

331

1

            xml = &xml[(pos + 2)..];

332

4

333

334

335

    // Skip <!DOCTYPE ...>

336

339

    let mut xml = xml.trim();

337

339

    if xml.len() > 9 && xml.is_char_boundary(9) && xml[..9].to_ascii_lowercase().starts_with("<!doctype") {

338

3

        if let Some(pos) = xml.find('>') {

339

3

            xml = &xml[(pos + 1)..];

340

3

341

336

    } else if xml.starts_with("<!--") {

342

5

        if let Some(end) = xml.find("-->") {

343

1

            xml = &xml[(end + 3)..];

344

1

            xml = xml.trim();

345

4

346

331

347

348

339

    let tokenizer = Tokenizer::from_fragment(xml, 0..xml.len());

349

350

339

    let estimated_nodes = xml.len() / ESTIMATED_BYTES_PER_NODE;

351

339

    let mut builder = CompactDomBuilder::with_capacity(estimated_nodes);

352

339

    let mut collected_css: Vec<Css> = Vec::new();

353

339

    let mut inside_style_tag = false;

354

339

    let mut style_text = String::new();

355

    // Track <head> depth: skip DOM nodes inside <head> (still collect <style> CSS).

356

    // This ensures the FastDom contains only <html><body>... as the layout engine expects.

357

339

    let mut head_depth: usize = 0;

358

359

    // Temporary storage for current element's attributes

360

339

    let mut current_tag: String = String::new();

361

339

    let mut current_attrs: Vec<(String, String)> = Vec::new();

362

339

    let mut pending_open = false;

363

364

    // Pre-compute the CSS key map once (used for style= attribute parsing)

365

339

    let css_key_map = azul_css::props::property::get_css_key_map();

366

367

    // One bump arena for every AzString produced during this parse —

368

    // id/class tokens, text nodes, etc. Replaces ~1k small heap allocs

369

    // with a handful of 64 KiB chunks. Each AzString carries its own

370

    // Arc reference to the arena, so the arena survives until the last

371

    // string is dropped (typically when the StyledDom is dropped).

372

339

    let mut str_arena = azul_css::corety::StringArena::new();

373

374

    // Finalize the pending open element: create NodeData from tag + attrs, push to builder

375

    // tag is already lowercase

376

339

    let finalize_open = |

377

        builder: &mut CompactDomBuilder,

378

        str_arena: &mut azul_css::corety::StringArena,

379

        tag: &str,

380

        attrs: &[(String, String)],

381

        css_key_map: &azul_css::props::property::CssKeyMap,

382

11239

| {

383

11239

        let node_type = tag_to_node_type(tag);

384

11239

        let mut nd = NodeData::create_node(node_type);

385

386

        // Apply attributes — build AttributeTypeVec directly (avoids the

387

        // clone + retain dance in set_ids_and_classes for fresh NodeData).

388

11239

        let mut attr_vec: Vec<azul_core::dom::AttributeType> = Vec::new();

389

12244

        for (key, value) in attrs {

390

1005

            match key.as_str() {

391

1005

                "id" => {

392

598

                    for id in value.split_whitespace() {

393

598

                        attr_vec.push(azul_core::dom::AttributeType::Id(str_arena.intern(id)));

394

598

395

396

408

                "class" => {

397

298

                    for class in value.split_whitespace() {

398

298

                        attr_vec.push(azul_core::dom::AttributeType::Class(str_arena.intern(class)));

399

298

400

401

112

                "focusable" => {

402

5

                    if let Some(f) = parse_bool(value.as_str()) {

403

2

                        nd.set_tab_index(if f { TabIndex::Auto } else { TabIndex::NoKeyboardFocus });

404

3

405

406

107

                "tabindex" => {

407

84

                    if let Ok(ti) = value.parse::<isize>() {

408

7

                        match ti {

409

66

                            0 => nd.set_tab_index(TabIndex::Auto),

410

7

                            i if i > 0 => nd.set_tab_index(TabIndex::OverrideInParent(i as u32)),

411

2

                            _ => nd.set_tab_index(TabIndex::NoKeyboardFocus),

412

413

11

414

415

23

                "style" => {

416

14

                    let mut css_attrs = Vec::new();

417

2026

                    for s in value.split(';') {

418

2026

                        let mut s = s.split(':');

419

2026

                        let Some(key) = s.next() else { continue };

420

2026

                        let Some(val) = s.next() else { continue };

421

                        // Called for its side effect (writes parsed props into

422

                        // `css_attrs`); the returned value is intentionally discarded.

423

2013

                        drop(azul_css::parser2::parse_css_declaration(

424

2013

                            key.trim(), val.trim(),

425

2013

                            azul_css::parser2::ErrorLocationRange::default(),

426

2013

                            css_key_map, &mut Vec::new(), &mut css_attrs,

427

));

428

429

14

                    let props = css_attrs.into_iter().filter_map(|s| {

430

                        use azul_css::css::CssDeclaration;

431

                        use azul_css::dynamic_selector::CssPropertyWithConditions;

432

2

                        match s {

433

2

                            CssDeclaration::Static(s) => Some(CssPropertyWithConditions::simple(s)),

434

                            CssDeclaration::Dynamic(_) => None,

435

436

14

                    }).collect::<Vec<_>>();

437

14

                    if !props.is_empty() {

438

2

                        nd.set_css_props(props.into());

439

12

440

441

9

                "contenteditable" => {

442

9

                    if parse_bool(value.as_str()).unwrap_or(false) {

443

5

                        nd.set_contenteditable(true);

444

8

445

446

                _ => {}

447

448

449

11239

        if !attr_vec.is_empty() {

450

618

            nd.set_attributes(attr_vec.into());

451

10889

452

453

11239

        builder.open_node(nd);

454

11239

};

455

456

339

    let mut last_was_void = false;

457

339

    let mut tag_stack: Vec<String> = Vec::new(); // for matching close tags

458

459

38274

    for token in tokenizer {

460

37979

        let token = token.map_err(|e| XmlError::ParserError(translate_xmlparser_error(e)))?;

461

23179

        match token {

462

11600

            ElementStart { local, .. } => {

463

                // Flush any pending open element

464

11600

                if pending_open {

465

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

466

                    if current_tag == "head" { head_depth += 1; }

467

                    if head_depth == 0 {

468

                        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

469

                        if is_void { builder.close_node(); }

470

471

                    if !is_void {

472

                        tag_stack.push(core::mem::take(&mut current_tag));

473

474

11600

475

476

                // Reuse the current_tag buffer — avoids ~1023 fresh String

477

                // allocations per parse (one per ElementStart).

478

11600

                lowercase_into(&mut current_tag, local.as_str());

479

11600

                current_attrs.clear();

480

11600

                pending_open = true;

481

11600

                last_was_void = VOID_ELEMENTS.contains(&current_tag.as_str());

482

483

1014

            Attribute { local, value, .. } => {

484

1014

                // decode_xml_entities returns Cow::Borrowed when no entities

485

1014

                // are present (the common case), so `.into_owned()` is the

486

1014

                // only fresh allocation here. The key is copied via

487

1014

                // `to_string()` because we can't hold a borrow across token

488

1014

                // iterations. TODO: when we switch current_attrs to

489

1014

                // Vec<(&str, Cow<str>)> this becomes zero-alloc for the key.

490

1014

                current_attrs.push((local.to_string(), decode_xml_entities(value.as_str()).into_owned()));

491

1014

492

            ElementEnd { end: Open, .. } => {

493

11584

                if pending_open {

494

11584

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

495

11584

                    if current_tag == "style" {

496

174

                        inside_style_tag = true;

497

174

                        style_text.clear();

498

11410

499

11584

                    if current_tag == "head" { head_depth += 1; }

500

11584

                    if head_depth == 0 {

501

11227

                        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

502

11227

                        if is_void { builder.close_node(); }

503

357

504

11584

                    if !is_void {

505

11584

                        // Use take() instead of clone() — after pending_open=false,

506

11584

                        // current_tag is not read again until the next ElementStart

507

11584

                        // reassigns it via lowercase_into.

508

11584

                        tag_stack.push(core::mem::take(&mut current_tag));

509

11584

510

11584

                    pending_open = false;

511

512

513

            ElementEnd { end: Empty, .. } => {

514

                // Self-closing element: open + immediately close

515

12

                if pending_open {

516

12

                    if current_tag == "head" { head_depth += 1; }

517

12

                    if head_depth == 0 {

518

12

                        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

519

12

                        builder.close_node();

520

12

521

12

                    if current_tag == "head" && head_depth > 0 { head_depth -= 1; }

522

12

                    pending_open = false;

523

524

525

11583

            ElementEnd { end: Close(_, close_value), .. } => {

526

11583

                if pending_open {

527

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

528

                    if current_tag == "head" { head_depth += 1; }

529

                    if head_depth == 0 {

530

                        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

531

                        if is_void { builder.close_node(); }

532

533

                    if !is_void {

534

                        tag_stack.push(core::mem::take(&mut current_tag));

535

536

                    pending_open = false;

537

11583

538

539

11583

                let close_lower = close_value.as_str().to_ascii_lowercase();

540

11583

                let close_str = close_lower.as_str();

541

11583

                if VOID_ELEMENTS.contains(&close_str) {

542

                    continue;

543

11583

544

545

                // If closing a <style> tag, parse collected CSS

546

11583

                if close_str == "style" && inside_style_tag {

547

174

                    if !style_text.is_empty() {

548

174

                        let parsed_css = Css::from_string(core::mem::take(&mut style_text).into());

549

174

                        collected_css.push(parsed_css);

550

174

551

174

                    inside_style_tag = false;

552

11409

553

554

                // Pop until we find matching tag

555

11591

                while let Some(top) = tag_stack.last() {

556

11565

                    let is_match = top == close_str;

557

11565

                    let was_head = top == "head";

558

                    // Pop this tag (unconditionally auto-close mismatched tags)

559

11565

                    let popped = tag_stack.pop().unwrap();

560

11565

                    if popped == "head" && head_depth > 0 { head_depth -= 1; }

561

11565

                    if head_depth == 0 && !was_head {

562

11216

                        builder.close_node();

563

11216

564

11565

                    if is_match { break; }

565

566

567

2142

            Text { text } => {

568

2142

                if pending_open {

569

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

570

                    if current_tag == "style" {

571

                        inside_style_tag = true;

572

                        style_text.clear();

573

574

                    if current_tag == "head" { head_depth += 1; }

575

                    if head_depth == 0 {

576

                        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

577

                        if is_void { builder.close_node(); }

578

579

                    if !is_void {

580

                        tag_stack.push(current_tag.clone());

581

582

                    pending_open = false;

583

2142

584

585

2142

                let text_str = text.as_str();

586

2142

                if !text_str.is_empty() {

587

2142

                    if inside_style_tag {

588

174

                        style_text.push_str(text_str);

589

1968

                    } else if head_depth == 0 {

590

                        // Skip whitespace-only text at <html> level (between </head> and <body>)

591

                        // but keep whitespace inside <body> (it's significant for inline layout)

592

2765

                        let inside_body = tag_stack.iter().any(|t| t == "body");

593

1643

                        if inside_body || !text_str.trim().is_empty() {

594

1148

                            let decoded = decode_xml_entities(text_str);

595

1148

                            builder.add_leaf(NodeData::create_text_do_not_use_without_block_level_wrapper(str_arena.intern(&decoded)));

596

1157

597

325

598

599

600

            _ => {}

601

602

603

604

    // Close any remaining open elements

605

295

    if pending_open {

606

        finalize_open(&mut builder, &mut str_arena, &current_tag, &current_attrs, &css_key_map);

607

295

608

306

    while tag_stack.pop().is_some() {

609

11

        builder.close_node();

610

11

611

612

    // Drop the arena handle explicitly. AzStrings already embedded in

613

    // the FastDom keep the backing bytes alive via their cloned Arc refs.

614

295

    drop(str_arena);

615

616

295

    Ok((builder.finish(), collected_css))

617

339

618

619

/// Loads, parses and builds a DOM from an XML file

620

///

621

/// **Warning**: The file is reloaded from disk on every function call - do not

622

/// use this in release builds! This function deliberately never fails: In an error case,

623

/// the error gets rendered as a `NodeType::Label`.

624

#[cfg(all(feature = "std", feature = "xml"))]

625

4

pub fn domxml_from_file<I: AsRef<Path>>(

626

4

    file_path: I,

627

4

    component_map: &ComponentMap,

628

4

) -> DomXml {

629

    use std::fs;

630

631

4

    let error_css = Css::empty();

632

633

4

    let xml = match fs::read_to_string(file_path.as_ref()) {

634

        Ok(xml) => xml,

635

4

        Err(e) => {

636

4

            return DomXml {

637

4

                parsed_dom: {

638

4

                    let mut dom = Dom::create_body()

639

4

                        .with_children(

640

4

                            vec![Dom::create_p_with_text(format!(

641

4

                                "Error reading: \"{}\": {}",

642

4

                                file_path.as_ref().to_string_lossy(),

643

4

644

4

))]

645

4

                            .into(),

646

4

);

647

4

                    StyledDom::create(&mut dom, error_css)

648

4

},

649

4

};

650

651

};

652

653

    domxml_from_str(&xml, component_map)

654

4

655

656

/// Parses the XML string into an XML tree, returns

657

/// the root `<app></app>` node, with the children attached to it.

658

///

659

/// Since the XML allows multiple root nodes, this function returns

660

/// a `Vec<XmlNode>` - which are the "root" nodes, containing all their

661

/// children recursively.

662

#[cfg(feature = "xml")]

663

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

664

/// # Errors

665

///

666

/// Returns an `XmlError` if the XML cannot be parsed.

667

2490

pub fn parse_xml_string(xml: &str) -> Result<Vec<XmlNodeChild>, XmlError> {

668

    use xmlparser::{ElementEnd::{Empty, Close}, Token::{ElementStart, ElementEnd, Attribute, Text}, Tokenizer};

669

670

    use self::XmlParseError::*;

671

672

    // HTML5-lite parser: List of void elements that should auto-close

673

    // See: https://developer.mozilla.org/en-US/docs/Glossary/Void_element

674

    const VOID_ELEMENTS: &[&str] = &[

675

        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param",

676

        "source", "track", "wbr",

677

];

678

679

    // HTML5-lite parser: Elements that auto-close when certain other elements are encountered

680

    // Format: (element_name, closes_when_encountering)

681

    const AUTO_CLOSE_RULES: &[(&str, &[&str])] = &[

682

        // List items close when encountering another list item or when parent closes

683

        ("li", &["li"]),

684

        // Table cells/rows have complex closing rules

685

        ("td", &["td", "th", "tr"]),

686

        ("th", &["td", "th", "tr"]),

687

        ("tr", &["tr"]),

688

        // Paragraphs close on block-level elements

689

690

            "p",

691

&[

692

                "address",

693

                "article",

694

                "aside",

695

                "blockquote",

696

                "div",

697

                "dl",

698

                "fieldset",

699

                "footer",

700

                "form",

701

                "h1",

702

                "h2",

703

                "h3",

704

                "h4",

705

                "h5",

706

                "h6",

707

                "header",

708

                "hr",

709

                "main",

710

                "nav",

711

                "ol",

712

                "p",

713

                "pre",

714

                "section",

715

                "table",

716

                "ul",

717

],

718

),

719

        // Option closes on another option or optgroup

720

        ("option", &["option", "optgroup"]),

721

        ("optgroup", &["optgroup"]),

722

        // DD/DT close on each other

723

        ("dd", &["dd", "dt"]),

724

        ("dt", &["dd", "dt"]),

725

];

726

727

2490

    let mut root_node = XmlNode::default();

728

729

    // Strip UTF-8 BOM if present (some W3C test files have it)

730

2490

    let xml = xml.strip_prefix('\u{FEFF}').unwrap_or(xml);

731

732

    // Search for "<?xml" and "?>" tags and delete them from the XML

733

2490

    let mut xml = xml.trim();

734

2490

    if xml.starts_with("<?") {

735

25

        let pos = xml.find("?>").ok_or(XmlError::MalformedHierarchy(

736

25

            MalformedHierarchyError {

737

25

                expected: "<?xml".into(),

738

25

                got: "?>".into(),

739

25

},

740

25

        ))?;

741

19

        xml = &xml[(pos + 2)..];

742

2465

743

744

    // Delete <!DOCTYPE ...> if necessary (case-insensitive)

745

2484

    let mut xml = xml.trim();

746

2484

    if xml.len() > 9 && xml.is_char_boundary(9) && xml[..9].to_ascii_lowercase().starts_with("<!doctype") {

747

3

        let pos = xml.find('>').ok_or(XmlError::MalformedHierarchy(

748

3

            MalformedHierarchyError {

749

3

                expected: "<!DOCTYPE".into(),

750

3

                got: ">".into(),

751

3

},

752

3

        ))?;

753

2

        xml = &xml[(pos + 1)..];

754

2481

    } else if xml.starts_with("<!--") {

755

        // Skip HTML comments at the start

756

14

        if let Some(end) = xml.find("-->") {

757

10

            xml = &xml[(end + 3)..];

758

10

            xml = xml.trim();

759

13

760

2467

761

762

2483

    let tokenizer = Tokenizer::from_fragment(xml, 0..xml.len());

763

764

    // OPTIMIZED: Use a stack of raw pointers to avoid O(n*d) traversal on every token.

765

    // This is safe because:

766

    // 1. All pointers point into `root_node` which is owned and not moved

767

    // 2. We never hold multiple mutable references simultaneously

768

    // 3. The stack is only used within this function

769

2483

    let mut node_stack: Vec<*mut XmlNode> = vec![&raw mut root_node];

770

771

    // Track which hierarchy level is a void element (shouldn't be pushed to hierarchy)

772

2483

    let mut last_was_void = false;

773

774

340507

    for token in tokenizer {

775

338083

        let token = token.map_err(|e| XmlError::ParserError(translate_xmlparser_error(e)))?;

776

161255

        match token {

777

106916

            ElementStart { local, .. } => {

778

106916

                let tag_name = local.to_string();

779

106916

                let is_void_element = VOID_ELEMENTS.contains(&tag_name.as_str());

780

781

                // HTML5-lite: If last element was a void element (like <img src="...">),

782

                // pop it from hierarchy before processing the new element

783

106916

                if last_was_void {

784

4

                    node_stack.pop();

785

4

                    last_was_void = false;

786

106912

787

788

                // HTML5-lite: Check if we need to auto-close the current element

789

106916

                if node_stack.len() > 1 {

790

                    // SAFETY: We only access the last element, which is valid

791

104534

                    let current_element = unsafe { &*node_stack[node_stack.len() - 1] };

792

104534

                    let current_tag = current_element.node_type.as_str();

793

794

                    // Check if current element should auto-close when encountering this new tag

795

1044889

                    for (element, closes_on) in AUTO_CLOSE_RULES {

796

940420

                        if current_tag == *element && closes_on.contains(&tag_name.as_str()) {

797

                            // Auto-close the current element

798

65

                            node_stack.pop();

799

65

                            break;

800

940355

801

802

2382

803

804

                // SAFETY: We access the last element which is valid

805

106916

                if let Some(&current_parent_ptr) = node_stack.last() {

806

106916

                    let current_parent = unsafe { &mut *current_parent_ptr };

807

808

106916

                    current_parent.children.push(XmlNodeChild::Element(XmlNode {

809

106916

                        node_type: tag_name.into(),

810

106916

                        attributes: StringPairVec::new().into(),

811

106916

                        children: Vec::new().into(),

812

106916

                    }));

813

814

                    // Get pointer to the newly added child

815

106916

                    let children_len = current_parent.children.len();

816

106916

                    if let Some(XmlNodeChild::Element(ref mut new_child)) = current_parent.children.as_mut().get_mut(children_len - 1) {

817

106916

                        node_stack.push(std::ptr::from_mut::<XmlNode>(new_child));

818

106916

819

820

106916

                    last_was_void = is_void_element;

821

822

823

            ElementEnd { end: Empty, .. } => {

824

                // Pop hierarchy for all elements (including void elements after their attributes)

825

52394

                if node_stack.len() > 1 {

826

52394

                    node_stack.pop();

827

52394

828

52394

                last_was_void = false;

829

830

            ElementEnd {

831

54349

                end: Close(_, close_value),

832

..

833

            } => {

834

                // HTML5-lite: If last element was a void element, pop it first

835

54349

                if last_was_void {

836

38

                    node_stack.pop();

837

38

                    last_was_void = false;

838

54311

839

840

                // HTML5-lite: Check if this is a void element - if so, ignore the closing tag

841

54349

                let is_void_element = VOID_ELEMENTS.contains(&close_value.as_str());

842

54349

                if is_void_element {

843

                    // Void elements shouldn't have closing tags, but tolerate them

844

38

                    continue;

845

54311

846

847

                // HTML5-lite: Auto-close any elements that should be closed

848

                // Walk up the hierarchy and auto-close elements until we find a match

849

54311

                let close_value_str = close_value.as_str();

850

851

                // Find matching element in stack (skip root at index 0)

852

54311

                let mut found_idx = None;

853

54356

                for i in (1..node_stack.len()).rev() {

854

                    // SAFETY: All pointers in stack are valid

855

54352

                    let node = unsafe { &*node_stack[i] };

856

54352

                    if node.node_type.as_str() == close_value_str {

857

54299

                        found_idx = Some(i);

858

54299

                        break;

859

53

860

861

862

54311

                if let Some(idx) = found_idx {

863

54299

                    // Pop all elements from current position to the matching element (inclusive)

864

54299

                    node_stack.truncate(idx);

865

54299

866

                // If no match found, just ignore (lenient HTML parsing)

867

868

54311

                last_was_void = false;

869

870

14380

            Attribute { local, value, .. } => {

871

                // SAFETY: Last element in stack is valid

872

14380

                if let Some(&last_ptr) = node_stack.last() {

873

14380

                    let last = unsafe { &mut *last_ptr };

874

14380

                    // NOTE: Only lowercase the key ("local"), not the value!

875

14380

                    // Decode XML entities in attribute values as well

876

14380

                    last.attributes.push(azul_core::window::AzStringPair {

877

14380

                        key: local.to_string().into(),

878

14380

                        value: AzString::from(&*decode_xml_entities(value.as_str())),

879

14380

});

880

14380

881

882

55473

            Text { text } => {

883

                // HTML5-lite: If last element was a void element, pop it before adding text

884

55473

                if last_was_void {

885

36

                    node_stack.pop();

886

36

                    last_was_void = false;

887

55437

888

889

                // IMPORTANT: Preserve ALL text nodes including whitespace-only nodes.

890

                // Whether whitespace is significant depends on the CSS `white-space` property,

891

                // which is determined during layout, not during parsing.

892

//

893

                // For example: <pre><span>    </span></pre> must preserve the 4 spaces.

894

//

895

                // We only skip completely EMPTY text nodes (zero-length strings).

896

55473

                let text_str = text.as_str();

897

898

55473

                if !text_str.is_empty() {

899

                    // SAFETY: Last element in stack is valid

900

55473

                    if let Some(&current_parent_ptr) = node_stack.last() {

901

55473

                        let current_parent = unsafe { &mut *current_parent_ptr };

902

55473

                        // Decode XML entities (e.g., &lt; -> <, &gt; -> >, etc.)

903

55473

                        let decoded_text = decode_xml_entities(text_str);

904

55473

                        // Add text as a child node

905

55473

                        current_parent

906

55473

                            .children

907

55473

                            .push(XmlNodeChild::Text(AzString::from(&*decoded_text)));

908

55473

909

910

911

54512

            _ => {}

912

913

914

915

    // Clean up: if we ended with a void element, pop it

916

2424

    if last_was_void {

917

5

        node_stack.pop();

918

2419

919

920

    // A well-formed document unwinds back to just the root sentinel. If an element was

921

    // left open (e.g. a bare "<svg" with no closing bracket, which the fragment tokenizer

922

    // yields as one ElementStart then cleanly ends), node_stack still holds it — reject

923

    // it instead of returning a "valid" partial tree.

924

2424

    if node_stack.len() != 1 {

925

13

        return Err(XmlError::UnclosedRootNode);

926

2411

927

928

2411

    Ok(root_node.children.into())

929

2490

930

931

#[cfg(feature = "xml")]

932

/// # Errors

933

///

934

/// Returns an `XmlError` if the XML cannot be parsed.

935

5

pub fn parse_xml(s: &str) -> Result<Xml, XmlError> {

936

    Ok(Xml {

937

5

        root: parse_xml_string(s)?.into(),

938

})

939

5

940

941

#[cfg(not(feature = "xml"))]

942

pub fn parse_xml(s: &str) -> Result<Xml, XmlError> {

943

    Err(XmlError::NoParserAvailable)

944

945

946

// to_string(&self) -> String

947

948

#[cfg(feature = "xml")]

949

7

#[must_use] pub fn translate_roxmltree_expandedname(

950

7

    e: roxmltree::ExpandedName<'_, '_>,

951

7

) -> XmlQualifiedName {

952

7

    let ns: Option<AzString> = e.namespace().map(|e| e.to_string().into());

953

7

    XmlQualifiedName {

954

7

        local_name: e.name().to_string().into(),

955

7

        namespace: ns.into(),

956

7

957

7

958

959

#[cfg(feature = "xml")]

960

2

fn translate_roxmltree_attribute(e: roxmltree::Attribute<'_, '_>) -> XmlQualifiedName {

961

    XmlQualifiedName {

962

2

        local_name: e.name().to_string().into(),

963

2

        namespace: e.namespace().map(|e| e.to_string().into()).into(),

964

965

2

966

967

#[cfg(feature = "xml")]

968

117

fn translate_xmlparser_streamerror(e: xmlparser::StreamError) -> XmlStreamError {

969

117

    match e {

970

8

        xmlparser::StreamError::UnexpectedEndOfStream => XmlStreamError::UnexpectedEndOfStream,

971

59

        xmlparser::StreamError::InvalidName => XmlStreamError::InvalidName,

972

1

        xmlparser::StreamError::InvalidReference => XmlStreamError::InvalidReference,

973

1

        xmlparser::StreamError::InvalidExternalID => XmlStreamError::InvalidExternalID,

974

1

        xmlparser::StreamError::InvalidCommentData => XmlStreamError::InvalidCommentData,

975

1

        xmlparser::StreamError::InvalidCommentEnd => XmlStreamError::InvalidCommentEnd,

976

8

        xmlparser::StreamError::InvalidCharacterData => XmlStreamError::InvalidCharacterData,

977

11

        xmlparser::StreamError::NonXmlChar(c, tp) => XmlStreamError::NonXmlChar(NonXmlCharError {

978

11

            ch: c.into(),

979

11

            pos: translate_xmlparser_textpos(tp),

980

11

}),

981

1

        xmlparser::StreamError::InvalidChar(a, b, tp) => {

982

1

            XmlStreamError::InvalidChar(InvalidCharError {

983

1

                expected: a,

984

1

                got: b,

985

1

                pos: translate_xmlparser_textpos(tp),

986

1

})

987

988

1

        xmlparser::StreamError::InvalidCharMultiple(a, b, tp) => {

989

1

            XmlStreamError::InvalidCharMultiple(InvalidCharMultipleError {

990

1

                expected: a,

991

1

                got: b.to_vec().into(),

992

1

                pos: translate_xmlparser_textpos(tp),

993

1

})

994

995

8

        xmlparser::StreamError::InvalidQuote(a, tp) => {

996

8

            XmlStreamError::InvalidQuote(InvalidQuoteError {

997

8

                got: a,

998

8

                pos: translate_xmlparser_textpos(tp),

999

8

})

1000

1001

1

        xmlparser::StreamError::InvalidSpace(a, tp) => {

1002

1

            XmlStreamError::InvalidSpace(InvalidSpaceError {

1003

1

                got: a,

1004

1

                pos: translate_xmlparser_textpos(tp),

1005

1

})

1006

1007

16

        xmlparser::StreamError::InvalidString(a, tp) => {

1008

16

            XmlStreamError::InvalidString(InvalidStringError {

1009

16

                got: a.to_string().into(),

1010

16

                pos: translate_xmlparser_textpos(tp),

1011

16

})

1012

1013

1014

117

1015

1016

#[cfg(feature = "xml")]

1017

113

fn translate_xmlparser_error(e: xmlparser::Error) -> XmlParseError {

1018

113

    match e {

1019

1

        xmlparser::Error::InvalidDeclaration(se, tp) => {

1020

1

            XmlParseError::InvalidDeclaration(XmlTextError {

1021

1

                stream_error: translate_xmlparser_streamerror(se),

1022

1

                pos: translate_xmlparser_textpos(tp),

1023

1

})

1024

1025

9

        xmlparser::Error::InvalidComment(se, tp) => XmlParseError::InvalidComment(XmlTextError {

1026

9

            stream_error: translate_xmlparser_streamerror(se),

1027

9

            pos: translate_xmlparser_textpos(tp),

1028

9

}),

1029

5

        xmlparser::Error::InvalidPI(se, tp) => XmlParseError::InvalidPI(XmlTextError {

1030

5

            stream_error: translate_xmlparser_streamerror(se),

1031

5

            pos: translate_xmlparser_textpos(tp),

1032

5

}),

1033

1

        xmlparser::Error::InvalidDoctype(se, tp) => XmlParseError::InvalidDoctype(XmlTextError {

1034

1

            stream_error: translate_xmlparser_streamerror(se),

1035

1

            pos: translate_xmlparser_textpos(tp),

1036

1

}),

1037

1

        xmlparser::Error::InvalidEntity(se, tp) => XmlParseError::InvalidEntity(XmlTextError {

1038

1

            stream_error: translate_xmlparser_streamerror(se),

1039

1

            pos: translate_xmlparser_textpos(tp),

1040

1

}),

1041

52

        xmlparser::Error::InvalidElement(se, tp) => XmlParseError::InvalidElement(XmlTextError {

1042

52

            stream_error: translate_xmlparser_streamerror(se),

1043

52

            pos: translate_xmlparser_textpos(tp),

1044

52

}),

1045

9

        xmlparser::Error::InvalidAttribute(se, tp) => {

1046

9

            XmlParseError::InvalidAttribute(XmlTextError {

1047

9

                stream_error: translate_xmlparser_streamerror(se),

1048

9

                pos: translate_xmlparser_textpos(tp),

1049

9

})

1050

1051

8

        xmlparser::Error::InvalidCdata(se, tp) => XmlParseError::InvalidCdata(XmlTextError {

1052

8

            stream_error: translate_xmlparser_streamerror(se),

1053

8

            pos: translate_xmlparser_textpos(tp),

1054

8

}),

1055

18

        xmlparser::Error::InvalidCharData(se, tp) => XmlParseError::InvalidCharData(XmlTextError {

1056

18

            stream_error: translate_xmlparser_streamerror(se),

1057

18

            pos: translate_xmlparser_textpos(tp),

1058

18

}),

1059

9

        xmlparser::Error::UnknownToken(tp) => {

1060

9

            XmlParseError::UnknownToken(translate_xmlparser_textpos(tp))

1061

1062

1063

113

1064

1065

#[cfg(feature = "xml")]

1066

31

#[must_use] pub fn translate_roxmltree_error(e: roxmltree::Error) -> XmlError {

1067

31

    match e {

1068

1

        roxmltree::Error::InvalidXmlPrefixUri(s) => {

1069

1

            XmlError::InvalidXmlPrefixUri(translate_roxml_textpos(s))

1070

1071

1

        roxmltree::Error::UnexpectedXmlUri(s) => {

1072

1

            XmlError::UnexpectedXmlUri(translate_roxml_textpos(s))

1073

1074

1

        roxmltree::Error::UnexpectedXmlnsUri(s) => {

1075

1

            XmlError::UnexpectedXmlnsUri(translate_roxml_textpos(s))

1076

1077

1

        roxmltree::Error::InvalidElementNamePrefix(s) => {

1078

1

            XmlError::InvalidElementNamePrefix(translate_roxml_textpos(s))

1079

1080

1

        roxmltree::Error::DuplicatedNamespace(s, tp) => {

1081

1

            XmlError::DuplicatedNamespace(DuplicatedNamespaceError {

1082

1

                ns: s.into(),

1083

1

                pos: translate_roxml_textpos(tp),

1084

1

})

1085

1086

1

        roxmltree::Error::UnknownNamespace(s, tp) => {

1087

1

            XmlError::UnknownNamespace(UnknownNamespaceError {

1088

1

                ns: s.into(),

1089

1

                pos: translate_roxml_textpos(tp),

1090

1

})

1091

1092

1

        roxmltree::Error::UnexpectedCloseTag(expected, actual, pos) => {

1093

1

            XmlError::UnexpectedCloseTag(UnexpectedCloseTagError {

1094

1

                expected: expected.into(),

1095

1

                actual: actual.into(),

1096

1

                pos: translate_roxml_textpos(pos),

1097

1

})

1098

1099

1

        roxmltree::Error::UnexpectedEntityCloseTag(s) => {

1100

1

            XmlError::UnexpectedEntityCloseTag(translate_roxml_textpos(s))

1101

1102

1

        roxmltree::Error::UnknownEntityReference(s, tp) => {

1103

1

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

1104

1

                entity: s.into(),

1105

1

                pos: translate_roxml_textpos(tp),

1106

1

})

1107

1108

1

        roxmltree::Error::MalformedEntityReference(s) => {

1109

1

            XmlError::MalformedEntityReference(translate_roxml_textpos(s))

1110

1111

1

        roxmltree::Error::EntityReferenceLoop(s) => {

1112

1

            XmlError::EntityReferenceLoop(translate_roxml_textpos(s))

1113

1114

1

        roxmltree::Error::InvalidAttributeValue(s) => {

1115

1

            XmlError::InvalidAttributeValue(translate_roxml_textpos(s))

1116

1117

1

        roxmltree::Error::DuplicatedAttribute(s, tp) => {

1118

1

            XmlError::DuplicatedAttribute(DuplicatedAttributeError {

1119

1

                attribute: s.into(),

1120

1

                pos: translate_roxml_textpos(tp),

1121

1

})

1122

1123

1

        roxmltree::Error::NoRootNode => XmlError::NoRootNode,

1124

1

        roxmltree::Error::DtdDetected => XmlError::DtdDetected,

1125

1

        roxmltree::Error::UnclosedRootNode => XmlError::UnclosedRootNode,

1126

1

        roxmltree::Error::UnexpectedDeclaration(tp) => {

1127

1

            XmlError::UnexpectedDeclaration(translate_roxml_textpos(tp))

1128

1129

1

        roxmltree::Error::NodesLimitReached => XmlError::NodesLimitReached,

1130

1

        roxmltree::Error::AttributesLimitReached => XmlError::AttributesLimitReached,

1131

1

        roxmltree::Error::NamespacesLimitReached => XmlError::NamespacesLimitReached,

1132

1

        roxmltree::Error::InvalidName(tp) => XmlError::InvalidName(translate_roxml_textpos(tp)),

1133

1

        roxmltree::Error::NonXmlChar(_, tp) => XmlError::NonXmlChar(translate_roxml_textpos(tp)),

1134

1

        roxmltree::Error::InvalidChar(_, _, tp) => {

1135

1

            XmlError::InvalidChar(translate_roxml_textpos(tp))

1136

1137

1

        roxmltree::Error::InvalidChar2(_, _, tp) => {

1138

1

            XmlError::InvalidChar2(translate_roxml_textpos(tp))

1139

1140

1

        roxmltree::Error::InvalidString(_, tp) => {

1141

1

            XmlError::InvalidString(translate_roxml_textpos(tp))

1142

1143

1

        roxmltree::Error::InvalidExternalID(tp) => {

1144

1

            XmlError::InvalidExternalID(translate_roxml_textpos(tp))

1145

1146

1

        roxmltree::Error::InvalidComment(tp) => {

1147

1

            XmlError::InvalidComment(translate_roxml_textpos(tp))

1148

1149

1

        roxmltree::Error::InvalidCharacterData(tp) => {

1150

1

            XmlError::InvalidCharacterData(translate_roxml_textpos(tp))

1151

1152

1

        roxmltree::Error::UnknownToken(tp) => XmlError::UnknownToken(translate_roxml_textpos(tp)),

1153

1

        roxmltree::Error::UnexpectedEndOfStream => XmlError::UnexpectedEndOfStream,

1154

1

        roxmltree::Error::EntityResolver(tp, s) => {

1155

            // New in roxmltree 0.21: EntityResolver error variant

1156

            // For now, treat as a generic entity reference error

1157

1

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

1158

1

                entity: s.into(),

1159

1

                pos: translate_roxml_textpos(tp),

1160

1

})

1161

1162

1163

31

1164

1165

#[cfg(feature = "xml")]

1166

#[inline]

1167

156

const fn translate_xmlparser_textpos(o: xmlparser::TextPos) -> XmlTextPos {

1168

156

    XmlTextPos {

1169

156

        row: o.row,

1170

156

        col: o.col,

1171

156

1172

156

1173

1174

#[cfg(feature = "xml")]

1175

#[inline]

1176

29

const fn translate_roxml_textpos(o: roxmltree::TextPos) -> XmlTextPos {

1177

29

    XmlTextPos {

1178

29

        row: o.row,

1179

29

        col: o.col,

1180

29

1181

29

1182

1183

/// Extension trait to add XML parsing capabilities to Dom

1184

///

1185

/// This trait provides methods to parse XML/XHTML strings and convert them

1186

/// into Azul DOM trees. It's implemented as a trait to avoid circular dependencies

1187

/// between azul-core and azul-layout.

1188

#[cfg(feature = "xml")]

1189

pub trait DomXmlExt {

1190

    /// Parse XML/XHTML string into a DOM tree

1191

///

1192

    /// This method parses the XML string and converts it to an Azul `StyledDom`.

1193

    /// On error, it returns a `StyledDom` displaying the error message.

1194

///

1195

    /// # Arguments

1196

    /// * `xml` - The XML/XHTML string to parse

1197

///

1198

    /// # Returns

1199

    /// A `StyledDom` tree representing the parsed XML, or an error DOM on parse failure

1200

    fn from_xml_string<S: AsRef<str>>(xml: S) -> StyledDom;

1201

1202

1203

#[cfg(feature = "xml")]

1204

impl DomXmlExt for Dom {

1205

233

    fn from_xml_string<S: AsRef<str>>(xml: S) -> StyledDom {

1206

233

        let component_map = ComponentMap::with_builtin();

1207

233

        let dom_xml = domxml_from_str(xml.as_ref(), &component_map);

1208

233

        dom_xml.parsed_dom

1209

233

1210

1211

1212

// ============================================================================

1213

// Adversarial unit tests (autotest). Inline so the private helpers

1214

// (`decode_xml_entities*`, `parse_xml_to_fast_dom_with_css`, `peak_rss_bytes`,

1215

// `translate_*`) are reachable.

1216

// ============================================================================

1217

1218

#[cfg(test)]

1219

mod autotest_generated {

1220

    use azul_core::dom::{FastDom, NodeData, NodeType, TabIndex};

1221

1222

    use super::*;

1223

1224

    // ------------------------------------------------------------------

1225

    // helpers

1226

    // ------------------------------------------------------------------

1227

1228

    /// Element children of an `XmlNodeChild` slice (skips text nodes).

1229

    #[cfg(feature = "xml")]

1230

    fn elements(children: &[XmlNodeChild]) -> Vec<&XmlNode> {

1231

        children

1232

            .iter()

1233

            .filter_map(XmlNodeChild::as_element)

1234

            .collect()

1235

1236

1237

    /// Text children of an `XmlNodeChild` slice (skips element nodes).

1238

    #[cfg(feature = "xml")]

1239

    fn texts(children: &[XmlNodeChild]) -> Vec<&str> {

1240

        children.iter().filter_map(XmlNodeChild::as_text).collect()

1241

1242

1243

    /// `<html><body>…</body></html>` around `body`.

1244

///

1245

    /// Every fixture goes through this so the document's first 9 bytes are

1246

    /// ASCII: `parse_xml*` slices `xml[..9]` for the DOCTYPE sniff without a

1247

    /// char-boundary check (see

1248

    /// `parse_entrypoints_do_not_panic_on_short_multibyte_input`).

1249

    fn doc(body: &str) -> String {

1250

        format!("<html><body>{body}</body></html>")

1251

1252

1253

    /// Flat node arena of a `FastDom`.

1254

    fn nodes(dom: &FastDom) -> &[NodeData] {

1255

        dom.node_data.as_ref()

1256

1257

1258

    /// Text content of a `NodeType::Text` node (`None` for every other kind).

1259

    fn text_of(nd: &NodeData) -> Option<String> {

1260

        match nd.get_node_type() {

1261

            NodeType::Text(_) => nd.get_node_type().format(),

1262

            _ => None,

1263

1264

1265

1266

    /// Minimal XML escaper — the inverse of `decode_xml_entities`.

1267

    #[cfg(feature = "xml")]

1268

    fn escape(s: &str) -> String {

1269

        let mut out = String::with_capacity(s.len());

1270

        for c in s.chars() {

1271

            match c {

1272

                '&' => out.push_str("&amp;"),

1273

                '<' => out.push_str("&lt;"),

1274

                '>' => out.push_str("&gt;"),

1275

                '"' => out.push_str("&quot;"),

1276

                '\'' => out.push_str("&apos;"),

1277

                _ => out.push(c),

1278

1279

1280

out

1281

1282

1283

    /// Non-grammar / hostile fragments. All ASCII on purpose so they exercise

1284

    /// the tokenizer rather than the `xml[..9]` slice.

1285

    const GARBAGE: &[&str] = &[

1286

        "<<<<>>>>",

1287

        "!!!not xml at all!!!",

1288

        "<a b=c>",

1289

        "</>",

1290

        "</div>",

1291

        "<a></a",

1292

        "&&&&&&&&&&&&",

1293

        "]]>",

1294

        "<!--",

1295

        "<![CDATA[",

1296

        "<?",

1297

        "<!DOCTYPE",

1298

        "\u{0}\u{1}\u{2}",

1299

        "<a><<a><<<a>",

1300

        "= = = = = = = = = =",

1301

];

1302

1303

    // ------------------------------------------------------------------

1304

    // decode_xml_entities / decode_xml_entities_slow

1305

    // ------------------------------------------------------------------

1306

1307

    #[test]

1308

    fn decode_xml_entities_borrows_when_there_is_no_ampersand() {

1309

        for s in ["", "hello", "  ", "日本語 🙂", "<tag/>", "a;b;c;"] {

1310

            assert!(

1311

                matches!(decode_xml_entities(s), std::borrow::Cow::Borrowed(_)),

1312

                "{s:?} has no '&' and must take the zero-alloc path"

1313

);

1314

            assert_eq!(&*decode_xml_entities(s), s);

1315

1316

1317

1318

    #[test]

1319

    fn decode_xml_entities_decodes_the_five_named_entities_and_nbsp() {

1320

        assert_eq!(&*decode_xml_entities("&lt;"), "<");

1321

        assert_eq!(&*decode_xml_entities("&gt;"), ">");

1322

        assert_eq!(&*decode_xml_entities("&amp;"), "&");

1323

        assert_eq!(&*decode_xml_entities("&apos;"), "'");

1324

        assert_eq!(&*decode_xml_entities("&quot;"), "\"");

1325

        assert_eq!(&*decode_xml_entities("&nbsp;"), "\u{00A0}");

1326

        assert_eq!(

1327

            &*decode_xml_entities("a&lt;b&gt;c&amp;d&quot;e&apos;f"),

1328

            "a<b>c&d\"e'f"

1329

);

1330

1331

1332

    #[test]

1333

    fn decode_xml_entities_decodes_numeric_references() {

1334

        // decimal, lowercase hex, uppercase hex marker

1335

        assert_eq!(&*decode_xml_entities("&#60;"), "<");

1336

        assert_eq!(&*decode_xml_entities("&#x3C;"), "<");

1337

        assert_eq!(&*decode_xml_entities("&#X3c;"), "<");

1338

        assert_eq!(&*decode_xml_entities("&#65;"), "A");

1339

        // boundary code points: NUL, BMP max, astral, and the last legal scalar

1340

        assert_eq!(&*decode_xml_entities("&#0;"), "\u{0}");

1341

        assert_eq!(&*decode_xml_entities("&#xFFFF;"), "\u{FFFF}");

1342

        assert_eq!(&*decode_xml_entities("&#65536;"), "\u{10000}");

1343

        assert_eq!(&*decode_xml_entities("&#1114111;"), "\u{10FFFF}");

1344

        assert_eq!(&*decode_xml_entities("&#x10FFFF;"), "\u{10FFFF}");

1345

        // combining marks survive

1346

        assert_eq!(&*decode_xml_entities("e&#x301;"), "e\u{301}");

1347

1348

1349

    #[test]

1350

    fn decode_xml_entities_keeps_out_of_range_and_surrogate_code_points_verbatim() {

1351

        // Every one of these must round-trip to itself: no panic, no

1352

        // replacement char, no silent truncation to a wrong scalar.

1353

        for s in [

1354

            "&#xD800;",      // lone high surrogate

1355

            "&#xDFFF;",      // lone low surrogate

1356

            "&#55296;",      // decimal surrogate

1357

            "&#x110000;",    // one past the last scalar

1358

            "&#1114112;",    // decimal, one past the last scalar

1359

            "&#123456789;",  // entity name is exactly 10 bytes (the length cap)

1360

            "&#4294967296;", // u32::MAX + 1

1361

            "&#99999999999999;",

1362

            "&#x;",

1363

            "&#;",

1364

            "&#xZZ;",

1365

            "&#-1;",

1366

] {

1367

            assert_eq!(

1368

                &*decode_xml_entities(s),

1369

s,

1370

                "{s:?} is not a decodable reference and must be preserved byte-for-byte"

1371

);

1372

1373

1374

1375

    #[test]

1376

    fn decode_xml_entities_keeps_unterminated_and_unknown_entities_verbatim() {

1377

        for s in [

1378

            "&",

1379

            "&&",

1380

            "&lt",

1381

            "&#",

1382

            "&#x",

1383

            "&foo;",

1384

            "&LT;", // entity table is case-sensitive

1385

            "&Amp;",

1386

            "& lt;",

1387

            "a & b",

1388

            "&;",

1389

] {

1390

            assert_eq!(&*decode_xml_entities(s), s, "{s:?} must be preserved");

1391

1392

        // Trailing garbage after a valid entity is still emitted.

1393

        assert_eq!(&*decode_xml_entities("&lt;&"), "<&");

1394

1395

1396

    #[test]

1397

    fn decode_xml_entities_does_not_double_decode() {

1398

        // A single pass only. `&amp;lt;` is the escaped form of the literal

1399

        // text `&lt;` and must NOT collapse to `<` — that would be an

1400

        // injection vector for anything that escapes user text once.

1401

        assert_eq!(&*decode_xml_entities("&amp;lt;"), "&lt;");

1402

        assert_eq!(&*decode_xml_entities("&amp;amp;"), "&amp;");

1403

        assert_eq!(&*decode_xml_entities("&amp;#60;"), "&#60;");

1404

1405

1406

    #[test]

1407

    fn decode_xml_entities_handles_pathological_input_without_panicking() {

1408

        // Entity name far past the 10-byte cap: bails out and preserves input.

1409

        let long_name = format!("&{};", "a".repeat(10_000));

1410

        assert_eq!(&*decode_xml_entities(&long_name), long_name);

1411

1412

        // Unterminated '&' followed by a megabyte of text.

1413

        let long_tail = format!("&{}", "x".repeat(1_000_000));

1414

        assert_eq!(decode_xml_entities(&long_tail).len(), long_tail.len());

1415

1416

        // Multibyte / astral / combining input mixed with entities. The entity

1417

        // scanner uses `char::is_alphanumeric`, so multibyte chars can land in

1418

        // the accumulator — slicing must stay on char boundaries.

1419

        for s in [

1420

            "&\u{1F600}\u{1F600};",

1421

            "&½;",

1422

            "&日本;",

1423

            "&#\u{1F600};",

1424

            "&e\u{301};",

1425

            "🙂&amp;🙂",

1426

] {

1427

            let out = decode_xml_entities(s);

1428

            assert!(

1429

                !out.is_empty(),

1430

                "{s:?} decoded to nothing (input was non-empty)"

1431

);

1432

1433

1434

        // Alternating entities at scale must not go quadratic-and-panic.

1435

        let many = "&lt;".repeat(50_000);

1436

        assert_eq!(decode_xml_entities(&many).chars().count(), 50_000);

1437

1438

1439

    #[test]

1440

    fn decode_xml_entities_slow_matches_the_fast_path() {

1441

        // The fast path is only a `contains('&')` short-circuit: for '&'-free

1442

        // input the slow path must be the identity, and for everything else

1443

        // the two must agree exactly.

1444

        for s in [

1445

"",

1446

            "plain",

1447

            "日本語 🙂",

1448

            "&lt;",

1449

            "&amp;lt;",

1450

            "&#x1F600;",

1451

            "&unknown;",

1452

            "&",

1453

] {

1454

            assert_eq!(

1455

                &*decode_xml_entities(s),

1456

                &*decode_xml_entities_slow(s),

1457

                "fast/slow path disagree on {s:?}"

1458

);

1459

1460

        for s in ["", "plain", "日本語 🙂", "a;b", "<>"] {

1461

            assert_eq!(&*decode_xml_entities_slow(s), s);

1462

1463

1464

1465

    // ------------------------------------------------------------------

1466

    // KNOWN BUG: unchecked `xml[..9]` slice in the DOCTYPE sniff

1467

    // ------------------------------------------------------------------

1468

1469

    /// `parse_xml_string` (line ~737) and `parse_xml_to_fast_dom_with_css`

1470

    /// (line ~328) both do

1471

///

1472

    /// ```ignore

1473

    /// if xml.len() > 9 && xml[..9].to_ascii_lowercase().starts_with("<!doctype")

1474

    /// ```

1475

///

1476

    /// `&str[..9]` panics when byte 9 is not a UTF-8 char boundary, so any

1477

    /// input longer than 9 bytes whose third-or-so character is multibyte

1478

    /// aborts the parse with `byte index 9 is not a char boundary` instead of

1479

    /// returning `Err`. `domxml_from_str`, which documents that it "deliberately

1480

    /// never fails", inherits the panic.

1481

///

1482

    /// The fix belongs in the source (`xml.is_char_boundary(9)` guard, or

1483

    /// `xml.get(..9)`), so this test asserts the correct invariant and is

1484

    /// expected to be RED until that lands.

1485

    #[cfg(feature = "xml")]

1486

    #[test]

1487

    fn parse_entrypoints_do_not_panic_on_short_multibyte_input() {

1488

        // 3 x 4-byte emoji = 12 bytes; boundaries are 0/4/8/12, so 9 is inside

1489

        // the third character.

1490

        const INPUT: &str = "😀😀😀";

1491

        assert!(INPUT.len() > 9 && !INPUT.is_char_boundary(9));

1492

1493

        let a = std::panic::catch_unwind(|| parse_xml_string(INPUT).is_ok());

1494

        let b = std::panic::catch_unwind(|| parse_xml_to_fast_dom(INPUT).is_ok());

1495

1496

        assert!(

1497

            a.is_ok(),

1498

            "parse_xml_string panicked on {INPUT:?}: the DOCTYPE sniff slices \

1499

             xml[..9] without an is_char_boundary check"

1500

);

1501

        assert!(

1502

            b.is_ok(),

1503

            "parse_xml_to_fast_dom panicked on {INPUT:?}: same unchecked \

1504

             xml[..9] slice"

1505

);

1506

1507

1508

    // ------------------------------------------------------------------

1509

    // parse_xml_string

1510

    // ------------------------------------------------------------------

1511

1512

    #[cfg(feature = "xml")]

1513

    #[test]

1514

    fn parse_xml_string_accepts_empty_and_whitespace_only_input() {

1515

        for s in ["", " ", "   ", "\t\n", "\r\n\r\n", "\u{FEFF}", "\u{FEFF}   "] {

1516

            let parsed = parse_xml_string(s)

1517

                .unwrap_or_else(|e| panic!("{s:?} should parse to an empty tree, got {e}"));

1518

            assert!(parsed.is_empty(), "{s:?} produced {} roots", parsed.len());

1519

1520

1521

1522

    #[cfg(feature = "xml")]

1523

    #[test]

1524

    fn parse_xml_string_parses_a_minimal_document() {

1525

        let parsed = parse_xml_string(&doc("<div>hi</div>")).expect("valid document");

1526

        let roots = elements(&parsed);

1527

        assert_eq!(roots.len(), 1);

1528

        assert_eq!(roots[0].node_type.as_str(), "html");

1529

1530

        let body = elements(roots[0].children.as_ref());

1531

        assert_eq!(body.len(), 1);

1532

        assert_eq!(body[0].node_type.as_str(), "body");

1533

1534

        let div = elements(body[0].children.as_ref());

1535

        assert_eq!(div.len(), 1);

1536

        assert_eq!(div[0].node_type.as_str(), "div");

1537

        assert_eq!(texts(div[0].children.as_ref()), vec!["hi"]);

1538

1539

1540

    #[cfg(feature = "xml")]

1541

    #[test]

1542

    fn parse_xml_string_rejects_unclosed_elements() {

1543

        // A well-formed document unwinds to the root sentinel; anything left

1544

        // open must be an error rather than a silently-truncated tree.

1545

        assert!(matches!(

1546

            parse_xml_string("<div>"),

1547

            Err(XmlError::UnclosedRootNode)

1548

));

1549

        assert!(matches!(

1550

            parse_xml_string("<html><body><div>"),

1551

            Err(XmlError::UnclosedRootNode)

1552

));

1553

        assert!(

1554

            parse_xml_string("<html><body><div>text").is_err(),

1555

            "an unclosed element must not yield a partial 'valid' tree"

1556

);

1557

1558

1559

    #[cfg(feature = "xml")]

1560

    #[test]

1561

    fn parse_xml_string_rejects_truncated_declaration_and_doctype() {

1562

        assert!(matches!(

1563

            parse_xml_string("<?xml version=\"1.0\""),

1564

            Err(XmlError::MalformedHierarchy(_))

1565

));

1566

        assert!(matches!(

1567

            parse_xml_string("<!DOCTYPE html PUBLIC \"x\""),

1568

            Err(XmlError::MalformedHierarchy(_))

1569

));

1570

        // ...but the complete forms are stripped and the rest parses.

1571

        for prefix in [

1572

            "<?xml version=\"1.0\"?>",

1573

            "<!DOCTYPE html>",

1574

            "<!doctype HTML>",

1575

            "<!-- leading comment -->",

1576

            "\u{FEFF}",

1577

] {

1578

            let src = format!("{prefix}{}", doc("<div/>"));

1579

            let parsed = parse_xml_string(&src)

1580

                .unwrap_or_else(|e| panic!("{prefix:?} prefix should be stripped, got {e}"));

1581

            let roots = elements(&parsed);

1582

            assert_eq!(roots.len(), 1, "{prefix:?} -> {roots:?}");

1583

            assert_eq!(roots[0].node_type.as_str(), "html");

1584

1585

1586

1587

    #[cfg(feature = "xml")]

1588

    #[test]

1589

    fn parse_xml_string_is_deterministic_on_garbage() {

1590

        for g in GARBAGE {

1591

            // The contract is "Err or a tree", never a panic and never a

1592

            // different answer for the same bytes.

1593

            let a = parse_xml_string(g);

1594

            let b = parse_xml_string(g);

1595

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} parsed non-deterministically");

1596

            assert_eq!(a.ok(), b.ok(), "{g:?} produced two different trees");

1597

1598

1599

1600

    #[cfg(feature = "xml")]

1601

    #[test]

1602

    fn parse_xml_string_trims_leading_and_trailing_whitespace() {

1603

        let padded = format!("  \t\n{}\n\t  ", doc("<div/>"));

1604

        let a = parse_xml_string(&padded).expect("padded document");

1605

        let b = parse_xml_string(&doc("<div/>")).expect("bare document");

1606

        assert_eq!(a, b, "surrounding whitespace must not change the tree");

1607

1608

1609

    #[cfg(feature = "xml")]

1610

    #[test]

1611

    fn parse_xml_string_keeps_trailing_junk_as_text() {

1612

        // Lenient HTML-ish parsing: trailing junk becomes a text node at the

1613

        // root rather than an error or a dropped document.

1614

        let parsed = parse_xml_string(&format!("{};garbage", doc("<div/>"))).expect("lenient parse");

1615

        assert_eq!(elements(&parsed).len(), 1);

1616

        assert_eq!(texts(&parsed), vec![";garbage"]);

1617

1618

1619

    #[cfg(feature = "xml")]

1620

    #[test]

1621

    fn parse_xml_string_round_trips_escaped_text() {

1622

        for raw in [

1623

            "a",

1624

            "<b>bold</b> & \"quotes\" 'apos'",

1625

            "&&&&",

1626

            "  spaced  ",

1627

            "日本語 🙂 combining e\u{301}",

1628

            "1 < 2 > 0 && true",

1629

] {

1630

            let src = doc(&escape(raw));

1631

            let parsed = parse_xml_string(&src)

1632

                .unwrap_or_else(|e| panic!("{src:?} should parse, got {e}"));

1633

            let html = elements(&parsed);

1634

            let body = elements(html[0].children.as_ref());

1635

            assert_eq!(

1636

                texts(body[0].children.as_ref()),

1637

                vec![raw],

1638

                "escape -> parse must be the identity for {raw:?}"

1639

);

1640

1641

1642

1643

    #[cfg(feature = "xml")]

1644

    #[test]

1645

    fn parse_xml_string_decodes_attribute_entities() {

1646

        let parsed = parse_xml_string(&doc(

1647

            r#"<div t="&amp;&lt;&gt;&quot;&apos;x" u="&nosuch;" v="&#x1F600;"></div>"#,

1648

))

1649

        .expect("valid document");

1650

        let html = elements(&parsed);

1651

        let body = elements(html[0].children.as_ref());

1652

        let div = elements(body[0].children.as_ref());

1653

        let attrs = &div[0].attributes;

1654

1655

        assert_eq!(attrs.get_key("t").map(AzString::as_str), Some("&<>\"'x"));

1656

        assert_eq!(attrs.get_key("u").map(AzString::as_str), Some("&nosuch;"));

1657

        assert_eq!(attrs.get_key("v").map(AzString::as_str), Some("😀"));

1658

1659

1660

    #[cfg(feature = "xml")]

1661

    #[test]

1662

    fn parse_xml_string_tolerates_extra_and_mismatched_close_tags() {

1663

        let nested = doc("<div></span></div>");

1664

        let paragraphs = doc("<p>one<p>two");

1665

        for src in [

1666

            "<a></a></a>",

1667

            "<a></a></b>",

1668

            nested.as_str(),

1669

            paragraphs.as_str(),

1670

            "<br></br>",

1671

            "<br>",

1672

            "<br><br><br>",

1673

] {

1674

            let a = parse_xml_string(src);

1675

            let b = parse_xml_string(src);

1676

            assert_eq!(a.is_ok(), b.is_ok(), "{src:?} is non-deterministic");

1677

            assert_eq!(a.ok(), b.ok(), "{src:?} produced two different trees");

1678

1679

        // A bare void element is a complete document (auto-closed at EOF).

1680

        let parsed = parse_xml_string("<br>").expect("bare void element");

1681

        assert_eq!(elements(&parsed).len(), 1);

1682

        assert_eq!(elements(&parsed)[0].node_type.as_str(), "br");

1683

1684

1685

    #[cfg(feature = "xml")]

1686

    #[test]

1687

    fn parse_xml_string_handles_deep_nesting_without_stack_overflow() {

1688

        // Building is iterative, but dropping the resulting `XmlNode` tree is

1689

        // recursive, so this pins the depth the *whole* lifecycle survives.

1690

        // (The arena path is exercised at 10k in

1691

        // `parse_xml_to_fast_dom_handles_ten_thousand_nested_elements`.)

1692

        const DEPTH: usize = 1_000;

1693

        let mut src = String::with_capacity(DEPTH * 12);

1694

        for _ in 0..DEPTH {

1695

            src.push_str("<a>");

1696

1697

        for _ in 0..DEPTH {

1698

            src.push_str("</a>");

1699

1700

1701

        let parsed = parse_xml_string(&src).expect("balanced nesting is valid");

1702

        let mut depth = 0_usize;

1703

1704

            let mut cursor: Vec<&XmlNode> = elements(&parsed);

1705

            while !cursor.is_empty() {

1706

                depth += 1;

1707

                let node: &XmlNode = cursor[0];

1708

                cursor = elements(node.children.as_ref());

1709

1710

1711

        assert_eq!(depth, DEPTH, "every nesting level must be preserved");

1712

        // Dropping the tree is the recursive half of the lifecycle — a deeper

1713

        // tree would blow the stack here, not during the (iterative) parse.

1714

        drop(parsed);

1715

1716

1717

    #[cfg(feature = "xml")]

1718

    #[test]

1719

    fn parse_xml_string_handles_a_one_million_char_text_node() {

1720

        let payload = "x".repeat(1_000_000);

1721

        let parsed = parse_xml_string(&doc(&payload)).expect("long text is valid");

1722

        let html = elements(&parsed);

1723

        let body = elements(html[0].children.as_ref());

1724

        let t = texts(body[0].children.as_ref());

1725

        assert_eq!(t.len(), 1);

1726

        assert_eq!(t[0].len(), 1_000_000);

1727

1728

1729

    #[cfg(feature = "xml")]

1730

    #[test]

1731

    fn parse_xml_string_handles_many_sibling_elements() {

1732

        const N: usize = 2_000;

1733

        let parsed = parse_xml_string(&doc(&"<i>x</i>".repeat(N))).expect("wide tree is valid");

1734

        let html = elements(&parsed);

1735

        let body = elements(html[0].children.as_ref());

1736

        assert_eq!(elements(body[0].children.as_ref()).len(), N);

1737

1738

1739

    // ------------------------------------------------------------------

1740

    // parse_xml

1741

    // ------------------------------------------------------------------

1742

1743

    #[cfg(feature = "xml")]

1744

    #[test]

1745

    fn parse_xml_agrees_with_parse_xml_string() {

1746

        let one = doc("<div>hi</div>");

1747

        let two = doc("<i/><i/>");

1748

        for src in ["", "   ", one.as_str(), two.as_str()] {

1749

            let via_xml = parse_xml(src).expect("valid");

1750

            let via_string = parse_xml_string(src).expect("valid");

1751

            assert_eq!(

1752

                via_xml.root.as_ref(),

1753

                via_string.as_slice(),

1754

                "parse_xml must be a thin wrapper over parse_xml_string for {src:?}"

1755

);

1756

1757

        assert!(parse_xml("<div>").is_err());

1758

1759

1760

    #[cfg(not(feature = "xml"))]

1761

    #[test]

1762

    fn parse_xml_without_the_xml_feature_reports_no_parser() {

1763

        for s in ["", "   ", "<div/>", "garbage"] {

1764

            assert!(matches!(parse_xml(s), Err(XmlError::NoParserAvailable)));

1765

1766

1767

1768

    // ------------------------------------------------------------------

1769

    // parse_xml_to_fast_dom / parse_xml_to_fast_dom_with_css

1770

    // ------------------------------------------------------------------

1771

1772

    #[test]

1773

    fn parse_xml_to_fast_dom_accepts_empty_and_whitespace_only_input() {

1774

        for s in ["", " ", "   ", "\t\n", "\u{FEFF}", "\u{FEFF}  \n "] {

1775

            let dom = parse_xml_to_fast_dom(s)

1776

                .unwrap_or_else(|e| panic!("{s:?} should yield an empty arena, got {e}"));

1777

            assert!(nodes(&dom).is_empty(), "{s:?} produced {} nodes", nodes(&dom).len());

1778

            assert_eq!(dom.node_hierarchy.as_ref().len(), nodes(&dom).len());

1779

1780

1781

1782

    #[test]

1783

    fn parse_xml_to_fast_dom_builds_the_expected_arena() {

1784

        let dom = parse_xml_to_fast_dom(&doc("<div>hi</div>")).expect("valid document");

1785

        let n = nodes(&dom);

1786

        assert_eq!(n.len(), 4, "html + body + div + text");

1787

        assert_eq!(

1788

            dom.node_hierarchy.as_ref().len(),

1789

            n.len(),

1790

            "hierarchy and node_data arenas must stay parallel"

1791

);

1792

        assert!(matches!(n[0].get_node_type(), NodeType::Html));

1793

        assert!(matches!(n[1].get_node_type(), NodeType::Body));

1794

        assert!(matches!(n[2].get_node_type(), NodeType::Div));

1795

        assert_eq!(text_of(&n[3]).as_deref(), Some("hi"));

1796

1797

1798

    #[test]

1799

    fn parse_xml_to_fast_dom_lowercases_tag_names() {

1800

        let dom = parse_xml_to_fast_dom("<HTML><BODY><DiV/></BODY></HTML>").expect("valid");

1801

        let n = nodes(&dom);

1802

        assert_eq!(n.len(), 3);

1803

        assert!(matches!(n[0].get_node_type(), NodeType::Html));

1804

        assert!(matches!(n[1].get_node_type(), NodeType::Body));

1805

        assert!(matches!(n[2].get_node_type(), NodeType::Div));

1806

1807

1808

    #[test]

1809

    fn parse_xml_to_fast_dom_skips_head_but_collects_style_css() {

1810

        let src = "<html><head><title>T</title>\

1811

                   <style>div { width: 10px; }</style></head>\

1812

                   <body>x</body></html>";

1813

        let (dom, css) = parse_xml_to_fast_dom_with_css(src).expect("valid document");

1814

        let n = nodes(&dom);

1815

1816

        assert_eq!(n.len(), 3, "html + body + text; <head> subtree is dropped");

1817

        assert!(

1818

            !n.iter()

1819

                .any(|nd| matches!(nd.get_node_type(), NodeType::Head | NodeType::Title)),

1820

            "no <head>/<title> node may reach the arena"

1821

);

1822

        assert_eq!(text_of(&n[2]).as_deref(), Some("x"));

1823

        assert_eq!(css.len(), 1, "the <style> body must still be collected");

1824

        assert!(!css[0].rules.as_ref().is_empty(), "the CSS must have parsed");

1825

1826

1827

    #[test]

1828

    fn parse_xml_to_fast_dom_splits_ids_and_classes_on_whitespace() {

1829

        let dom = parse_xml_to_fast_dom(&doc(r#"<div id="a b" class="c  d

1830

        e"></div>"#))

1831

        .expect("valid document");

1832

        let div = &nodes(&dom)[2];

1833

1834

        assert!(div.has_id("a") && div.has_id("b"));

1835

        assert!(div.has_class("c") && div.has_class("d") && div.has_class("e"));

1836

        assert!(!div.has_id("a b"), "the raw joined value must not survive");

1837

        assert_eq!(div.get_ids_and_classes().as_ref().len(), 5);

1838

1839

1840

    /// Reads the tab index of the `<div>` in `doc("<div {attrs}></div>")`.

1841

    fn tab_index_with(attrs: &str) -> Option<TabIndex> {

1842

        let dom = parse_xml_to_fast_dom(&doc(&format!("<div {attrs}></div>")))

1843

            .unwrap_or_else(|e| panic!("{attrs:?} should parse, got {e}"));

1844

        nodes(&dom)[2].get_tab_index()

1845

1846

1847

    #[test]

1848

    fn parse_xml_to_fast_dom_maps_tabindex_boundaries() {

1849

        assert_eq!(tab_index_with(r#"tabindex="0""#), Some(TabIndex::Auto));

1850

        assert_eq!(tab_index_with(r#"tabindex="-0""#), Some(TabIndex::Auto));

1851

        assert_eq!(

1852

            tab_index_with(r#"tabindex="1""#),

1853

            Some(TabIndex::OverrideInParent(1))

1854

);

1855

        assert_eq!(

1856

            tab_index_with(r#"tabindex="+3""#),

1857

            Some(TabIndex::OverrideInParent(3)),

1858

            "isize::from_str accepts a leading '+'"

1859

);

1860

        assert_eq!(

1861

            tab_index_with(r#"tabindex="-1""#),

1862

            Some(TabIndex::NoKeyboardFocus)

1863

);

1864

        assert_eq!(

1865

            tab_index_with(r#"tabindex="-9223372036854775808""#),

1866

            Some(TabIndex::NoKeyboardFocus),

1867

            "i64::MIN is still just 'negative'"

1868

);

1869

1870

        // NodeFlags packs the override value into bits [27:0].

1871

        const MAX_EXACT: u32 = (1 << 28) - 1;

1872

        assert_eq!(

1873

            tab_index_with(&format!(r#"tabindex="{MAX_EXACT}""#)),

1874

            Some(TabIndex::OverrideInParent(MAX_EXACT))

1875

);

1876

        // Past that it truncates rather than saturating or panicking. Two

1877

        // lossy steps stack up here: `isize as u32` in the XML parser, then

1878

        // the 28-bit mask in `NodeFlags::set_tab_index`. Pinned as-is because

1879

        // the safety property is "bounded and deterministic", not "exact".

1880

        assert_eq!(

1881

            tab_index_with(r#"tabindex="268435456""#),

1882

            Some(TabIndex::OverrideInParent(0)),

1883

            "1 << 28 truncates to 0"

1884

);

1885

        assert_eq!(

1886

            tab_index_with(r#"tabindex="9223372036854775807""#),

1887

            Some(TabIndex::OverrideInParent(MAX_EXACT)),

1888

            "i64::MAX -> u32::MAX -> 28-bit mask"

1889

);

1890

1891

1892

    #[test]

1893

    fn parse_xml_to_fast_dom_ignores_unparseable_tabindex() {

1894

        let baseline = tab_index_with("");

1895

        for junk in [

1896

            r#"tabindex="""#,

1897

            r#"tabindex="NaN""#,

1898

            r#"tabindex="inf""#,

1899

            r#"tabindex="-inf""#,

1900

            r#"tabindex="1.0""#,

1901

            r#"tabindex="1e5""#,

1902

            r#"tabindex=" 3 ""#,

1903

            r#"tabindex="0x10""#,

1904

            r#"tabindex="99999999999999999999999999""#,

1905

            r#"tabindex="-99999999999999999999999999""#,

1906

            r#"tabindex="🙂""#,

1907

] {

1908

            assert_eq!(

1909

                tab_index_with(junk),

1910

                baseline,

1911

                "{junk} must leave the tab index untouched"

1912

);

1913

1914

1915

1916

    #[test]

1917

    fn parse_xml_to_fast_dom_parses_bool_attributes_case_sensitively() {

1918

        assert_eq!(

1919

            tab_index_with(r#"focusable="true""#),

1920

            Some(TabIndex::Auto)

1921

);

1922

        assert_eq!(

1923

            tab_index_with(r#"focusable="false""#),

1924

            Some(TabIndex::NoKeyboardFocus)

1925

);

1926

        for junk in [r#"focusable="TRUE""#, r#"focusable="1""#, r#"focusable="yes""#] {

1927

            assert_eq!(

1928

                tab_index_with(junk),

1929

                tab_index_with(""),

1930

                "{junk} is not a bool literal and must be ignored"

1931

);

1932

1933

1934

        let editable = |v: &str| {

1935

            let dom = parse_xml_to_fast_dom(&doc(&format!(r#"<div contenteditable="{v}"></div>"#)))

1936

                .expect("valid");

1937

            nodes(&dom)[2].is_contenteditable()

1938

};

1939

        assert!(editable("true"));

1940

        assert!(!editable("false"));

1941

        assert!(!editable("TRUE"));

1942

        assert!(!editable(""));

1943

        assert!(!editable("1"));

1944

1945

1946

    #[test]

1947

    fn parse_xml_to_fast_dom_survives_malformed_style_attributes() {

1948

        let big = "a:b;".repeat(2_000);

1949

        for style in [

1950

"",

1951

            ";;;;",

1952

            "::::",

1953

            ":",

1954

            "width",

1955

            "width:",

1956

            ":10px",

1957

            "a:b:c",

1958

            ";:;:;:",

1959

            "width:10px",

1960

            "width:10px;;;height:;;",

1961

            "width:not-a-length",

1962

            "🙂:🙂",

1963

            big.as_str(),

1964

] {

1965

            let dom = parse_xml_to_fast_dom(&doc(&format!(r#"<div style="{style}"></div>"#)))

1966

                .unwrap_or_else(|e| panic!("style={style:?} should parse, got {e}"));

1967

            assert_eq!(

1968

                nodes(&dom).len(),

1969

3,

1970

                "style={style:?} must not change the node count"

1971

);

1972

1973

1974

1975

    #[test]

1976

    fn parse_xml_to_fast_dom_survives_unbalanced_tags() {

1977

        // The interesting case: elements opened inside <head> are pushed onto

1978

        // the tag stack but never opened in the builder, so the EOF unwind

1979

        // calls close_node() more often than open_node() ran. That must be a

1980

        // no-op, not an underflow.

1981

        let dom = parse_xml_to_fast_dom("<html><head><title>").expect("lenient parse");

1982

        assert_eq!(nodes(&dom).len(), 1, "only <html> survives");

1983

        assert!(matches!(nodes(&dom)[0].get_node_type(), NodeType::Html));

1984

1985

        for src in [

1986

            "</div>",

1987

            "</div></div></div>",

1988

            "<a></a></a>",

1989

            "<html><body></body></body></html>",

1990

            "<html><head><head><head>",

1991

            "<html><body><div></span></div></body></html>",

1992

] {

1993

            let a = parse_xml_to_fast_dom(src);

1994

            let b = parse_xml_to_fast_dom(src);

1995

            assert_eq!(a.is_ok(), b.is_ok(), "{src:?} is non-deterministic");

1996

            if let (Ok(a), Ok(b)) = (&a, &b) {

1997

                assert_eq!(nodes(a).len(), nodes(b).len(), "{src:?} node count drifted");

1998

1999

2000

2001

2002

    #[test]

2003

    fn parse_xml_to_fast_dom_is_deterministic_on_garbage() {

2004

        for g in GARBAGE {

2005

            let a = parse_xml_to_fast_dom(g);

2006

            let b = parse_xml_to_fast_dom(g);

2007

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} parsed non-deterministically");

2008

            if let (Ok(a), Ok(b)) = (&a, &b) {

2009

                assert_eq!(nodes(a).len(), nodes(b).len(), "{g:?} node count drifted");

2010

2011

2012

2013

2014

    #[test]

2015

    fn parse_xml_to_fast_dom_handles_ten_thousand_nested_elements() {

2016

        // The arena path is iterative on the way in and flat on the way out,

2017

        // so it should hold a depth the recursive XmlNode tree cannot.

2018

        const DEPTH: usize = 10_000;

2019

        let mut src = String::with_capacity(DEPTH * 12 + 32);

2020

        src.push_str("<html><body>");

2021

        for _ in 0..DEPTH {

2022

            src.push_str("<div>");

2023

2024

        for _ in 0..DEPTH {

2025

            src.push_str("</div>");

2026

2027

        src.push_str("</body></html>");

2028

2029

        let dom = parse_xml_to_fast_dom(&src).expect("balanced nesting is valid");

2030

        assert_eq!(nodes(&dom).len(), DEPTH + 2);

2031

2032

2033

    #[test]

2034

    fn parse_xml_to_fast_dom_handles_a_one_million_char_document() {

2035

        let payload = "x".repeat(1_000_000);

2036

        let dom = parse_xml_to_fast_dom(&doc(&payload)).expect("long text is valid");

2037

        let n = nodes(&dom);

2038

        assert_eq!(n.len(), 3, "html + body + one text node");

2039

        assert_eq!(text_of(&n[2]).map(|s| s.len()), Some(1_000_000));

2040

2041

2042

    #[test]

2043

    fn parse_xml_to_fast_dom_strips_bom_declaration_doctype_and_comments() {

2044

        let expected = nodes(&parse_xml_to_fast_dom(&doc("<div/>")).expect("baseline")).len();

2045

        for prefix in [

2046

            "\u{FEFF}",

2047

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>",

2048

            "<!DOCTYPE html>",

2049

            "<!doctype HTML>",

2050

            "<!DoCtYpE html SYSTEM \"about:legacy-compat\">",

2051

            "<!-- leading comment -->",

2052

] {

2053

            let src = format!("{prefix}{}", doc("<div/>"));

2054

            let dom = parse_xml_to_fast_dom(&src)

2055

                .unwrap_or_else(|e| panic!("{prefix:?} should be stripped, got {e}"));

2056

            assert_eq!(nodes(&dom).len(), expected, "{prefix:?} changed the arena");

2057

2058

2059

2060

    #[test]

2061

    fn parse_xml_to_fast_dom_preserves_unicode_text() {

2062

        for payload in [

2063

            "日本語",

2064

            "🙂🙂🙂🙂",

2065

            "e\u{301}\u{302}\u{303}",

2066

            "\u{200B}\u{FEFF}mid-string BOM",

2067

            "ﷺ",

2068

] {

2069

            let dom = parse_xml_to_fast_dom(&doc(payload))

2070

                .unwrap_or_else(|e| panic!("{payload:?} should parse, got {e}"));

2071

            let n = nodes(&dom);

2072

            assert_eq!(n.len(), 3, "{payload:?}");

2073

            assert_eq!(text_of(&n[2]).as_deref(), Some(payload));

2074

2075

2076

2077

    #[test]

2078

    fn parse_xml_to_fast_dom_treats_numeric_looking_documents_as_text() {

2079

        // Boundary numeric strings are markup content here, not numbers: they

2080

        // must survive verbatim rather than being coerced or rejected.

2081

        for payload in [

2082

            "0",

2083

            "-0",

2084

            "9223372036854775807",

2085

            "-9223372036854775808",

2086

            "18446744073709551616",

2087

            "1e309",

2088

            "-1e-309",

2089

            "NaN",

2090

            "inf",

2091

            "-inf",

2092

] {

2093

            let dom = parse_xml_to_fast_dom(&doc(payload))

2094

                .unwrap_or_else(|e| panic!("{payload:?} should parse, got {e}"));

2095

            assert_eq!(text_of(&nodes(&dom)[2]).as_deref(), Some(payload));

2096

2097

2098

2099

    // ------------------------------------------------------------------

2100

    // parse_xml_to_styled_dom

2101

    // ------------------------------------------------------------------

2102

2103

    #[test]

2104

    fn icon_tag_yields_unnamed_icon_nodes_with_spec_text_children() {

2105

        use azul_core::dom::NodeType;

2106

2107

        // The tokenizer stays fully generic: `<icon>spec</icon>` is an

2108

        // un-named Icon node with its spec preserved as a text child.

2109

        // The RESOLVER consumes the spec (see the resolution test below).

2110

        let fast = parse_xml_to_fast_dom(

2111

            "<html><body><icon> content_copy </icon><p>x</p></body></html>",

2112

2113

        .expect("icon markup must parse");

2114

2115

        let icon_names: Vec<&str> = nodes(&fast)

2116

            .iter()

2117

            .filter_map(|nd| match nd.get_node_type() {

2118

                NodeType::Icon(name) => Some(name.as_ref().as_str()),

2119

                _ => None,

2120

})

2121

            .collect();

2122

        assert_eq!(icon_names, vec![""], "the builder must not interpret the spec");

2123

2124

        let spec_preserved = nodes(&fast).iter().any(|nd| {

2125

            matches!(nd.get_node_type(), NodeType::Text(t) if t.as_ref().as_str().trim() == "content_copy")

2126

});

2127

        assert!(spec_preserved, "the spec text child must be preserved for the resolver");

2128

2129

2130

    #[test]

2131

    fn icon_resolution_consumes_the_spec_text_like_a_ligature_font() {

2132

        use azul_core::{

2133

            dom::NodeType,

2134

            icon::{resolve_icons_in_styled_dom, IconProviderHandle, SharedIconProvider},

2135

            refany::{OptionRefAny, RefAny},

2136

            styled_dom::StyledDom,

2137

};

2138

        use azul_css::system::SystemStyle;

2139

2140

        // Marker resolver: registered icons become a Text("RESOLVED") node,

2141

        // unregistered ones become Text("MISSING") — enough to observe both

2142

        // the spec-derived LOOKUP and the replacement without a real font.

2143

        extern "C" fn marker_resolver(

2144

            data: OptionRefAny,

2145

            original: &StyledDom,

2146

            _: &SystemStyle,

2147

        ) -> StyledDom {

2148

            let mut replacement = original.clone();

2149

            let marker = if data.is_some() { "RESOLVED" } else { "MISSING" };

2150

            if let Some(node) = replacement.node_data.as_mut().get_mut(0) {

2151

                node.set_node_type(NodeType::Text(azul_css::css::BoxOrStatic::heap(

2152

                    marker.into(),

2153

                )));

2154

2155

            replacement

2156

2157

2158

        let mut provider = IconProviderHandle::with_resolver(marker_resolver);

2159

        provider.register_icon("testpack", "content_copy", RefAny::new(1u8));

2160

        let provider = SharedIconProvider::from_handle(provider);

2161

2162

        // Both the bare-name spec and the pack-qualified fallback-list spec

2163

        // (`missing:x` first — must fall through to `testpack:content_copy`).

2164

        let mut styled = parse_xml_to_styled_dom(

2165

            "<html><body>\

2166

             <icon> content_copy </icon>\

2167

             <icon>missing:x, testpack:CONTENT_COPY</icon>\

2168

             <icon>unknown_icon</icon>\

2169

             </body></html>",

2170

2171

        .expect("icon markup must cascade");

2172

2173

        resolve_icons_in_styled_dom(&mut styled, &provider, &SystemStyle::default());

2174

2175

        let texts: Vec<String> = styled

2176

            .node_data

2177

            .as_ref()

2178

            .iter()

2179

            .filter_map(|nd| match nd.get_node_type() {

2180

                NodeType::Text(t) => Some(t.as_ref().as_str().to_string()),

2181

                _ => None,

2182

})

2183

            .collect();

2184

2185

        let resolved = texts.iter().filter(|t| t.as_str() == "RESOLVED").count();

2186

        let missing = texts.iter().filter(|t| t.as_str() == "MISSING").count();

2187

        assert_eq!(resolved, 2, "bare + pack-qualified specs must both resolve: {texts:?}");

2188

        assert_eq!(missing, 1, "the unknown spec resolves to no data: {texts:?}");

2189

2190

        // The spec text was consumed — it must not survive as renderable text.

2191

        assert!(

2192

            !texts.iter().any(|t| t.contains("content_copy") || t.contains("unknown_icon")),

2193

            "spec text children must be cleared after resolution: {texts:?}"

2194

);

2195

2196

2197

    #[test]

2198

    fn parse_xml_to_styled_dom_accepts_empty_and_whitespace_only_input() {

2199

        for s in ["", "   ", "\t\n", "\u{FEFF}"] {

2200

            let styled = parse_xml_to_styled_dom(s)

2201

                .unwrap_or_else(|e| panic!("{s:?} should cascade cleanly, got {e}"));

2202

            assert!(styled.node_data.as_ref().is_empty(), "{s:?}");

2203

2204

2205

2206

    #[test]

2207

    fn parse_xml_to_styled_dom_keeps_the_fast_dom_node_count() {

2208

        for src in [

2209

            doc("<div>hi</div>"),

2210

            doc("<div><span>a</span><span>b</span></div>"),

2211

            "<html><head><style>div { width: 10px; }</style></head><body><div/></body></html>"

2212

                .to_string(),

2213

] {

2214

            let fast = parse_xml_to_fast_dom(&src).expect("fast path");

2215

            let styled = parse_xml_to_styled_dom(&src).expect("styled path");

2216

            assert_eq!(

2217

                styled.node_data.as_ref().len(),

2218

                nodes(&fast).len(),

2219

                "the cascade must not add or drop nodes for {src:?}"

2220

);

2221

            assert_eq!(

2222

                styled.node_hierarchy.as_ref().len(),

2223

                styled.node_data.as_ref().len()

2224

);

2225

2226

2227

2228

    #[test]

2229

    fn parse_xml_to_styled_dom_is_deterministic_on_garbage() {

2230

        for g in GARBAGE {

2231

            let a = parse_xml_to_styled_dom(g);

2232

            let b = parse_xml_to_styled_dom(g);

2233

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} cascaded non-deterministically");

2234

2235

2236

2237

    // ------------------------------------------------------------------

2238

    // dom_from_parsed_xml

2239

    // ------------------------------------------------------------------

2240

2241

    #[test]

2242

    fn dom_from_parsed_xml_reports_errors_instead_of_panicking() {

2243

        // No <html>/<body>: the documented behaviour is an error Dom, not a

2244

        // panic and not an empty tree.

2245

        for root in [

2246

            Vec::new(),

2247

            vec![XmlNodeChild::Text("bare text".into())],

2248

            vec![XmlNodeChild::Element(XmlNode::create("div"))],

2249

            vec![XmlNodeChild::Element(XmlNode::create("html"))],

2250

] {

2251

            let dom = dom_from_parsed_xml(Xml { root: root.into() });

2252

            assert!(

2253

                matches!(dom.root.get_node_type(), NodeType::Body),

2254

                "the error Dom is rendered as a <body> with a label"

2255

);

2256

            assert_eq!(dom.children.as_ref().len(), 1);

2257

2258

2259

2260

    #[test]

2261

    fn dom_from_parsed_xml_builds_a_dom_for_a_minimal_document() {

2262

        let body = XmlNode::create("body")

2263

            .with_children(vec![XmlNodeChild::Element(XmlNode::create("div"))]);

2264

        let html = XmlNode::create("html").with_children(vec![XmlNodeChild::Element(body)]);

2265

        let dom = dom_from_parsed_xml(Xml {

2266

            root: vec![XmlNodeChild::Element(html)].into(),

2267

});

2268

2269

        assert!(matches!(dom.root.get_node_type(), NodeType::Html));

2270

        assert_eq!(dom.children.as_ref().len(), 1, "the <body> subtree");

2271

2272

2273

    #[test]

2274

    fn dom_from_parsed_xml_caps_recursion_on_deeply_nested_input() {

2275

        // MAX_XML_NESTING_DEPTH is 512; past it the builder drops children

2276

        // instead of blowing the native stack.

2277

        const DEPTH: usize = 550;

2278

        let mut node = XmlNode::create("div");

2279

        for _ in 0..DEPTH {

2280

            node = XmlNode::create("div").with_children(vec![XmlNodeChild::Element(node)]);

2281

2282

        let body = XmlNode::create("body").with_children(vec![XmlNodeChild::Element(node)]);

2283

        let html = XmlNode::create("html").with_children(vec![XmlNodeChild::Element(body)]);

2284

2285

        let dom = dom_from_parsed_xml(Xml {

2286

            root: vec![XmlNodeChild::Element(html)].into(),

2287

});

2288

        assert!(matches!(dom.root.get_node_type(), NodeType::Html));

2289

2290

2291

    // ------------------------------------------------------------------

2292

    // domxml_from_str / domxml_from_file / DomXmlExt

2293

    // ------------------------------------------------------------------

2294

2295

    #[cfg(feature = "xml")]

2296

    #[test]

2297

    fn domxml_from_str_never_fails() {

2298

        let map = ComponentMap::with_builtin();

2299

        let mut cases: Vec<String> = GARBAGE.iter().map(|s| (*s).to_string()).collect();

2300

        cases.push(String::new());

2301

        cases.push("   ".to_string());

2302

        cases.push("<svg".to_string());

2303

        cases.push("<?xml".to_string());

2304

        cases.push(doc("<div>hi</div>"));

2305

2306

        for src in cases {

2307

            let dom_xml = domxml_from_str(&src, &map);

2308

            assert!(

2309

                !dom_xml.parsed_dom.node_data.as_ref().is_empty(),

2310

                "{src:?} produced an empty StyledDom; errors must render as a label"

2311

);

2312

2313

2314

2315

    #[cfg(all(feature = "std", feature = "xml"))]

2316

    #[test]

2317

    fn domxml_from_file_renders_io_errors_as_a_dom() {

2318

        let map = ComponentMap::with_builtin();

2319

        for path in [

2320

            "/nonexistent-azul-autotest-dir/definitely-not-here.xml",

2321

"",

2322

            "/",

2323

            "/proc/self/nonexistent-🙂",

2324

] {

2325

            let dom_xml = domxml_from_file(path, &map);

2326

            assert!(

2327

                !dom_xml.parsed_dom.node_data.as_ref().is_empty(),

2328

                "{path:?} must render the io::Error as a label, not fail"

2329

);

2330

2331

2332

2333

    #[cfg(feature = "xml")]

2334

    #[test]

2335

    fn dom_xml_ext_matches_domxml_from_str() {

2336

        let map = ComponentMap::with_builtin();

2337

        let valid = doc("<div>hi</div>");

2338

        for src in ["", "<svg", valid.as_str()] {

2339

            let via_ext = <Dom as DomXmlExt>::from_xml_string(src);

2340

            let via_fn = domxml_from_str(src, &map).parsed_dom;

2341

            assert_eq!(

2342

                via_ext.node_data.as_ref().len(),

2343

                via_fn.node_data.as_ref().len(),

2344

                "the extension trait must be a pure delegation for {src:?}"

2345

);

2346

2347

2348

2349

    // ------------------------------------------------------------------

2350

    // peak_rss_bytes

2351

    // ------------------------------------------------------------------

2352

2353

    #[test]

2354

    fn peak_rss_bytes_never_panics_and_never_goes_backwards() {

2355

        let a = peak_rss_bytes();

2356

        let _ballast = "x".repeat(4 * 1024 * 1024);

2357

        let b = peak_rss_bytes();

2358

2359

        #[cfg(all(unix, feature = "probe"))]

2360

        assert!(

2361

            b >= a,

2362

            "ru_maxrss is a high-water mark and must never decrease ({a} -> {b})"

2363

);

2364

        #[cfg(not(all(unix, feature = "probe")))]

2365

        assert_eq!(

2366

            (a, b),

2367

            (0, 0),

2368

            "without the probe feature the stub must be a constant 0"

2369

);

2370

2371

2372

    // ------------------------------------------------------------------

2373

    // translate_* (xmlparser / roxmltree -> FFI-stable azul types)

2374

    // ------------------------------------------------------------------

2375

2376

    #[cfg(feature = "xml")]

2377

    #[test]

2378

    fn translate_textpos_round_trips_boundary_values() {

2379

        for (row, col) in [

2380

            (0, 0),

2381

            (1, 1),

2382

            (0, u32::MAX),

2383

            (u32::MAX, 0),

2384

            (u32::MAX, u32::MAX),

2385

] {

2386

            let expected = XmlTextPos { row, col };

2387

            assert_eq!(

2388

                translate_xmlparser_textpos(xmlparser::TextPos::new(row, col)),

2389

                expected

2390

);

2391

            assert_eq!(

2392

                translate_roxml_textpos(roxmltree::TextPos::new(row, col)),

2393

                expected

2394

);

2395

2396

2397

2398

    #[cfg(feature = "xml")]

2399

    #[test]

2400

    fn translate_roxmltree_expandedname_preserves_name_and_namespace() {

2401

        let plain: roxmltree::ExpandedName<'_, '_> = "rect".into();

2402

        let out = translate_roxmltree_expandedname(plain);

2403

        assert_eq!(out.local_name.as_str(), "rect");

2404

        assert!(out.namespace.as_ref().is_none());

2405

2406

        let ns: roxmltree::ExpandedName<'_, '_> = ("http://www.w3.org/2000/svg", "rect").into();

2407

        let out = translate_roxmltree_expandedname(ns);

2408

        assert_eq!(out.local_name.as_str(), "rect");

2409

        assert_eq!(

2410

            out.namespace.as_ref().map(AzString::as_str),

2411

            Some("http://www.w3.org/2000/svg")

2412

);

2413

2414

        // Degenerate names must survive untouched, not be normalised away.

2415

        for name in ["", " ", "日本語-🙂", "a:b"] {

2416

            let e: roxmltree::ExpandedName<'_, '_> = name.into();

2417

            assert_eq!(translate_roxmltree_expandedname(e).local_name.as_str(), name);

2418

2419

        let empty_ns: roxmltree::ExpandedName<'_, '_> = ("", "x").into();

2420

        assert_eq!(

2421

            translate_roxmltree_expandedname(empty_ns)

2422

                .namespace

2423

                .as_ref()

2424

                .map(AzString::as_str),

2425

            Some(""),

2426

            "an empty namespace URI is Some(\"\"), not None"

2427

);

2428

2429

2430

    #[cfg(feature = "xml")]

2431

    #[test]

2432

    fn translate_roxmltree_attribute_preserves_name_and_namespace() {

2433

        let rdoc = roxmltree::Document::parse(r#"<e xmlns:x="urn:x" x:a="1" b="2"/>"#)

2434

            .expect("valid XML");

2435

        let attrs: Vec<XmlQualifiedName> = rdoc

2436

            .root_element()

2437

            .attributes()

2438

            .map(translate_roxmltree_attribute)

2439

            .collect();

2440

2441

        assert_eq!(attrs.len(), 2, "xmlns declarations are not attributes");

2442

        let a = attrs

2443

            .iter()

2444

            .find(|q| q.local_name.as_str() == "a")

2445

            .expect("x:a");

2446

        assert_eq!(a.namespace.as_ref().map(AzString::as_str), Some("urn:x"));

2447

        let b = attrs

2448

            .iter()

2449

            .find(|q| q.local_name.as_str() == "b")

2450

            .expect("b");

2451

        assert!(

2452

            b.namespace.as_ref().is_none(),

2453

            "an unprefixed attribute has no namespace"

2454

);

2455

2456

2457

    #[cfg(feature = "xml")]

2458

    #[test]

2459

    fn translate_xmlparser_streamerror_maps_every_variant() {

2460

        use xmlparser::StreamError as Se;

2461

2462

        let p = xmlparser::TextPos::new(3, 7);

2463

        let x = XmlTextPos { row: 3, col: 7 };

2464

2465

        assert_eq!(

2466

            translate_xmlparser_streamerror(Se::UnexpectedEndOfStream),

2467

            XmlStreamError::UnexpectedEndOfStream

2468

);

2469

        assert_eq!(

2470

            translate_xmlparser_streamerror(Se::InvalidName),

2471

            XmlStreamError::InvalidName

2472

);

2473

        assert_eq!(

2474

            translate_xmlparser_streamerror(Se::InvalidReference),

2475

            XmlStreamError::InvalidReference

2476

);

2477

        assert_eq!(

2478

            translate_xmlparser_streamerror(Se::InvalidExternalID),

2479

            XmlStreamError::InvalidExternalID

2480

);

2481

        assert_eq!(

2482

            translate_xmlparser_streamerror(Se::InvalidCommentData),

2483

            XmlStreamError::InvalidCommentData

2484

);

2485

        assert_eq!(

2486

            translate_xmlparser_streamerror(Se::InvalidCommentEnd),

2487

            XmlStreamError::InvalidCommentEnd

2488

);

2489

        assert_eq!(

2490

            translate_xmlparser_streamerror(Se::InvalidCharacterData),

2491

            XmlStreamError::InvalidCharacterData

2492

);

2493

        // Astral char -> u32 (the FFI-stable representation) without loss.

2494

        assert_eq!(

2495

            translate_xmlparser_streamerror(Se::NonXmlChar('\u{1F600}', p)),

2496

            XmlStreamError::NonXmlChar(NonXmlCharError {

2497

                ch: 0x1F600,

2498

                pos: x

2499

})

2500

);

2501

        assert_eq!(

2502

            translate_xmlparser_streamerror(Se::InvalidQuote(b'`', p)),

2503

            XmlStreamError::InvalidQuote(InvalidQuoteError { got: b'`', pos: x })

2504

);

2505

        assert_eq!(

2506

            translate_xmlparser_streamerror(Se::InvalidSpace(b'\t', p)),

2507

            XmlStreamError::InvalidSpace(InvalidSpaceError { got: b'\t', pos: x })

2508

);

2509

        assert_eq!(

2510

            translate_xmlparser_streamerror(Se::InvalidString("?>", p)),

2511

            XmlStreamError::InvalidString(InvalidStringError {

2512

                got: "?>".into(),

2513

                pos: x

2514

})

2515

);

2516

        // NOTE: xmlparser documents InvalidChar/InvalidCharMultiple as

2517

        // (actual, expected, pos), but the translation stores the first field

2518

        // as `expected` and the second as `got` — i.e. the two are swapped.

2519

        // Characterised here rather than "fixed" in the test: it only affects

2520

        // error-message wording, and pinning it makes the swap visible if the

2521

        // mapping is ever corrected.

2522

        assert_eq!(

2523

            translate_xmlparser_streamerror(Se::InvalidChar(b'a', b'b', p)),

2524

            XmlStreamError::InvalidChar(InvalidCharError {

2525

                expected: b'a',

2526

                got: b'b',

2527

                pos: x

2528

})

2529

);

2530

        assert_eq!(

2531

            translate_xmlparser_streamerror(Se::InvalidCharMultiple(b'a', &b"xy"[..], p)),

2532

            XmlStreamError::InvalidCharMultiple(InvalidCharMultipleError {

2533

                expected: b'a',

2534

                got: vec![b'x', b'y'].into(),

2535

                pos: x

2536

})

2537

);

2538

2539

2540

    #[cfg(feature = "xml")]

2541

    #[test]

2542

    fn translate_xmlparser_error_maps_every_variant() {

2543

        use xmlparser::{Error as Xe, StreamError as Se};

2544

2545

        let p = xmlparser::TextPos::new(9, 4);

2546

        let x = XmlTextPos { row: 9, col: 4 };

2547

        let te = XmlTextError {

2548

            stream_error: XmlStreamError::InvalidName,

2549

            pos: x,

2550

};

2551

2552

        assert_eq!(

2553

            translate_xmlparser_error(Xe::InvalidDeclaration(Se::InvalidName, p)),

2554

            XmlParseError::InvalidDeclaration(te.clone())

2555

);

2556

        assert_eq!(

2557

            translate_xmlparser_error(Xe::InvalidComment(Se::InvalidName, p)),

2558

            XmlParseError::InvalidComment(te.clone())

2559

);

2560

        assert_eq!(

2561

            translate_xmlparser_error(Xe::InvalidPI(Se::InvalidName, p)),

2562

            XmlParseError::InvalidPI(te.clone())

2563

);

2564

        assert_eq!(

2565

            translate_xmlparser_error(Xe::InvalidDoctype(Se::InvalidName, p)),

2566

            XmlParseError::InvalidDoctype(te.clone())

2567

);

2568

        assert_eq!(

2569

            translate_xmlparser_error(Xe::InvalidEntity(Se::InvalidName, p)),

2570

            XmlParseError::InvalidEntity(te.clone())

2571

);

2572

        assert_eq!(

2573

            translate_xmlparser_error(Xe::InvalidElement(Se::InvalidName, p)),

2574

            XmlParseError::InvalidElement(te.clone())

2575

);

2576

        assert_eq!(

2577

            translate_xmlparser_error(Xe::InvalidAttribute(Se::InvalidName, p)),

2578

            XmlParseError::InvalidAttribute(te.clone())

2579

);

2580

        assert_eq!(

2581

            translate_xmlparser_error(Xe::InvalidCdata(Se::InvalidName, p)),

2582

            XmlParseError::InvalidCdata(te.clone())

2583

);

2584

        assert_eq!(

2585

            translate_xmlparser_error(Xe::InvalidCharData(Se::InvalidName, p)),

2586

            XmlParseError::InvalidCharData(te)

2587

);

2588

        assert_eq!(

2589

            translate_xmlparser_error(Xe::UnknownToken(p)),

2590

            XmlParseError::UnknownToken(x)

2591

);

2592

2593

2594

    #[cfg(feature = "xml")]

2595

    #[test]

2596

    fn translate_roxmltree_error_maps_every_variant() {

2597

        use roxmltree::Error as Re;

2598

2599

        let p = roxmltree::TextPos::new(2, 5);

2600

        let x = XmlTextPos { row: 2, col: 5 };

2601

2602

        assert_eq!(

2603

            translate_roxmltree_error(Re::InvalidXmlPrefixUri(p)),

2604

            XmlError::InvalidXmlPrefixUri(x)

2605

);

2606

        assert_eq!(

2607

            translate_roxmltree_error(Re::UnexpectedXmlUri(p)),

2608

            XmlError::UnexpectedXmlUri(x)

2609

);

2610

        assert_eq!(

2611

            translate_roxmltree_error(Re::UnexpectedXmlnsUri(p)),

2612

            XmlError::UnexpectedXmlnsUri(x)

2613

);

2614

        assert_eq!(

2615

            translate_roxmltree_error(Re::InvalidElementNamePrefix(p)),

2616

            XmlError::InvalidElementNamePrefix(x)

2617

);

2618

        assert_eq!(

2619

            translate_roxmltree_error(Re::DuplicatedNamespace(String::from("ns"), p)),

2620

            XmlError::DuplicatedNamespace(DuplicatedNamespaceError {

2621

                ns: "ns".into(),

2622

                pos: x

2623

})

2624

);

2625

        assert_eq!(

2626

            translate_roxmltree_error(Re::UnknownNamespace(String::from("ns"), p)),

2627

            XmlError::UnknownNamespace(UnknownNamespaceError {

2628

                ns: "ns".into(),

2629

                pos: x

2630

})

2631

);

2632

        assert_eq!(

2633

            translate_roxmltree_error(Re::UnexpectedCloseTag(

2634

                String::from("a"),

2635

                String::from("b"),

2636

2637

)),

2638

            XmlError::UnexpectedCloseTag(UnexpectedCloseTagError {

2639

                expected: "a".into(),

2640

                actual: "b".into(),

2641

                pos: x

2642

})

2643

);

2644

        assert_eq!(

2645

            translate_roxmltree_error(Re::UnexpectedEntityCloseTag(p)),

2646

            XmlError::UnexpectedEntityCloseTag(x)

2647

);

2648

        assert_eq!(

2649

            translate_roxmltree_error(Re::UnknownEntityReference(String::from("e"), p)),

2650

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

2651

                entity: "e".into(),

2652

                pos: x

2653

})

2654

);

2655

        assert_eq!(

2656

            translate_roxmltree_error(Re::MalformedEntityReference(p)),

2657

            XmlError::MalformedEntityReference(x)

2658

);

2659

        assert_eq!(

2660

            translate_roxmltree_error(Re::EntityReferenceLoop(p)),

2661

            XmlError::EntityReferenceLoop(x)

2662

);

2663

        assert_eq!(

2664

            translate_roxmltree_error(Re::InvalidAttributeValue(p)),

2665

            XmlError::InvalidAttributeValue(x)

2666

);

2667

        assert_eq!(

2668

            translate_roxmltree_error(Re::DuplicatedAttribute(String::from("a"), p)),

2669

            XmlError::DuplicatedAttribute(DuplicatedAttributeError {

2670

                attribute: "a".into(),

2671

                pos: x

2672

})

2673

);

2674

        assert_eq!(

2675

            translate_roxmltree_error(Re::NoRootNode),

2676

            XmlError::NoRootNode

2677

);

2678

        assert_eq!(

2679

            translate_roxmltree_error(Re::DtdDetected),

2680

            XmlError::DtdDetected

2681

);

2682

        assert_eq!(

2683

            translate_roxmltree_error(Re::UnclosedRootNode),

2684

            XmlError::UnclosedRootNode

2685

);

2686

        assert_eq!(

2687

            translate_roxmltree_error(Re::UnexpectedDeclaration(p)),

2688

            XmlError::UnexpectedDeclaration(x)

2689

);

2690

        assert_eq!(

2691

            translate_roxmltree_error(Re::NodesLimitReached),

2692

            XmlError::NodesLimitReached

2693

);

2694

        assert_eq!(

2695

            translate_roxmltree_error(Re::AttributesLimitReached),

2696

            XmlError::AttributesLimitReached

2697

);

2698

        assert_eq!(

2699

            translate_roxmltree_error(Re::NamespacesLimitReached),

2700

            XmlError::NamespacesLimitReached

2701

);

2702

        assert_eq!(

2703

            translate_roxmltree_error(Re::InvalidName(p)),

2704

            XmlError::InvalidName(x)

2705

);

2706

        assert_eq!(

2707

            translate_roxmltree_error(Re::NonXmlChar('\u{0}', p)),

2708

            XmlError::NonXmlChar(x)

2709

);

2710

        assert_eq!(

2711

            translate_roxmltree_error(Re::InvalidChar(b'a', b'b', p)),

2712

            XmlError::InvalidChar(x)

2713

);

2714

        assert_eq!(

2715

            translate_roxmltree_error(Re::InvalidChar2("ab", b'c', p)),

2716

            XmlError::InvalidChar2(x)

2717

);

2718

        assert_eq!(

2719

            translate_roxmltree_error(Re::InvalidString("s", p)),

2720

            XmlError::InvalidString(x)

2721

);

2722

        assert_eq!(

2723

            translate_roxmltree_error(Re::InvalidExternalID(p)),

2724

            XmlError::InvalidExternalID(x)

2725

);

2726

        assert_eq!(

2727

            translate_roxmltree_error(Re::InvalidComment(p)),

2728

            XmlError::InvalidComment(x)

2729

);

2730

        assert_eq!(

2731

            translate_roxmltree_error(Re::InvalidCharacterData(p)),

2732

            XmlError::InvalidCharacterData(x)

2733

);

2734

        assert_eq!(

2735

            translate_roxmltree_error(Re::UnknownToken(p)),

2736

            XmlError::UnknownToken(x)

2737

);

2738

        assert_eq!(

2739

            translate_roxmltree_error(Re::UnexpectedEndOfStream),

2740

            XmlError::UnexpectedEndOfStream

2741

);

2742

        // roxmltree 0.21's EntityResolver is folded into UnknownEntityReference.

2743

        assert_eq!(

2744

            translate_roxmltree_error(Re::EntityResolver(p, String::from("e"))),

2745

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

2746

                entity: "e".into(),

2747

                pos: x

2748

})

2749

);

2750

2751