nom_xml/
debug.rs

1// debug.rs
2use crate::{
3    attribute::{Attribute, AttributeValue, Prefix},
4    misc::{Misc, MiscState},
5    processing_instruction::ProcessingInstruction,
6    prolog::{
7        content_particle::ContentParticle,
8        declaration_content::{DeclarationContent, Mixed},
9        doctype::DocType,
10        external_id::ExternalID,
11        id::ID,
12        subset::{
13            entity::{
14                entity_declaration::{EntityDecl, EntityDeclaration},
15                entity_definition::EntityDefinition,
16                entity_value::EntityValue,
17            },
18            markup_declaration::MarkupDeclaration,
19            Subset,
20        },
21        textdecl::TextDecl,
22        xmldecl::{Standalone, XmlDecl},
23    },
24    reference::Reference,
25    Document, Name, Tag,
26};
27use std::fmt::{self, Formatter};
28
29fn fmt_indented(f: &mut String, indent: usize, s: &str) {
30    f.push_str(&" ".repeat(indent));
31    f.push_str(s);
32}
33impl fmt::Debug for Tag {
34    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
35        let mut s = String::new();
36        self.fmt_indented_tag(&mut s, 0);
37        write!(f, "{}", s)
38    }
39}
40impl Tag {
41    fn fmt_indented_tag(&self, f: &mut String, indent: usize) {
42        let Tag {
43            name,
44            attributes,
45            state,
46        } = self;
47
48        fmt_indented(f, indent, "Tag {\n");
49        fmt_indented(
50            f,
51            indent + 4,
52            &format!("name: \n{}\n", name.fmt_qualified_name(indent + 8)),
53        );
54        fmt_indented(f, indent + 4, "attributes: ");
55
56        match attributes {
57            Some(attrs) => {
58                let mut s = String::new();
59                for attr in attrs {
60                    attr.fmt_indented_attribute(&mut s, indent + 8);
61                }
62                f.push_str(&format!("Some([\n{}", s));
63                fmt_indented(f, indent + 4, "]),\n");
64            }
65            None => f.push_str("None,\n"),
66        }
67
68        fmt_indented(f, indent + 4, &format!("state: {:?},\n", state));
69        fmt_indented(f, indent, "},\n");
70    }
71}
72
73impl fmt::Debug for Name {
74    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
75        write!(f, "{}", self.fmt_qualified_name(0))
76    }
77}
78
79impl Name {
80    fn fmt_qualified_name(&self, indent: usize) -> String {
81        let Name { prefix, local_part } = self;
82        let mut f = String::new();
83
84        fmt_indented(&mut f, indent, "Name {\n");
85
86        match prefix {
87            Some(p) => {
88                fmt_indented(&mut f, indent + 4, &format!("prefix: Some(\"{}\"),\n", p));
89            }
90            None => {
91                fmt_indented(&mut f, indent + 4, "prefix: None,\n");
92            }
93        }
94        fmt_indented(
95            &mut f,
96            indent + 4,
97            &format!("local_part: \"{}\",\n", local_part),
98        );
99        fmt_indented(&mut f, indent, "}");
100
101        f
102    }
103}
104
105impl fmt::Debug for MiscState {
106    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
107        let mut s = String::new();
108        self.fmt_indented_misc_state(&mut s, 0);
109        write!(f, "{}", s)
110    }
111}
112
113impl MiscState {
114    fn fmt_indented_misc_state(&self, f: &mut String, _indent: usize) {
115        match self {
116            MiscState::BeforeDoctype => {
117                f.push_str("BeforeDoctype");
118            }
119            MiscState::AfterDoctype => {
120                f.push_str("AfterDoctype");
121            }
122        }
123    }
124}
125
126impl fmt::Debug for Misc {
127    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
128        let mut s = String::new();
129        self.fmt_indented_misc(&mut s, 0);
130        write!(f, "{}", s)
131    }
132}
133
134impl Misc {
135    fn fmt_indented_misc(&self, f: &mut String, indent: usize) {
136        fmt_indented(f, indent, "Misc {\n");
137        fmt_indented(f, indent + 4, &format!("content: {:?}", self.content));
138        fmt_indented(f, indent + 4, &format!("state: {:?},\n", self.state));
139        fmt_indented(f, indent, "},\n");
140    }
141}
142
143impl fmt::Debug for Document {
144    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
145        let mut s = String::new();
146        self.fmt_indented_doc(&mut s, 0);
147        writeln!(f, "{}", s)
148    }
149}
150
151impl Document {
152    fn fmt_indented_doc(&self, f: &mut String, indent: usize) {
153        match self {
154            Document::Prolog {
155                xml_decl,
156                misc,
157                doc_type,
158            } => {
159                if xml_decl.is_some() || misc.is_some() || doc_type.is_some() {
160                    fmt_indented(f, indent, "Prolog {\n");
161                    if let Some(xml_decl) = xml_decl {
162                        xml_decl.fmt_indented_xml_decl(f, indent + 4);
163                    }
164
165                    if let Some(misc_vec) = misc {
166                        for misc in misc_vec {
167                            misc.fmt_indented_misc(f, indent + 4);
168                        }
169                    }
170                    if let Some(doc_type) = doc_type {
171                        doc_type.fmt_indented_doc_type(f, indent + 4);
172                    }
173                    fmt_indented(f, indent, "},\n");
174                }
175            }
176            Document::Element(tag1, document, tag2) => {
177                fmt_indented(f, indent, "Document::Element(\n");
178                tag1.fmt_indented_tag(f, indent + 4);
179                document.fmt_indented_doc(f, indent + 4);
180                tag2.fmt_indented_tag(f, indent + 4);
181                fmt_indented(f, indent, "),\n");
182            }
183            Document::Content(content) => {
184                fmt_indented(
185                    f,
186                    indent,
187                    &format!(
188                        "Content(\"{}\"),\n",
189                        content.clone().map_or("".to_string(), |c| c)
190                    ),
191                );
192            }
193            Document::Nested(documents) => {
194                fmt_indented(f, indent, "Nested([\n");
195                for document in documents.iter() {
196                    document.fmt_indented_doc(f, indent + 4);
197                }
198                fmt_indented(f, indent, "]),\n");
199            }
200            Document::Comment(comment) => {
201                fmt_indented(f, indent, &format!("Comment(\"{}\"),\n", comment));
202            }
203            Document::Empty => {
204                fmt_indented(f, indent, "Empty");
205            }
206            Document::EmptyTag(tag) => {
207                fmt_indented(f, indent, "EmptyTag(\n");
208                tag.fmt_indented_tag(f, indent + 4);
209                fmt_indented(f, indent, "),\n");
210            }
211
212            Document::ProcessingInstruction(ProcessingInstruction { target, data }) => {
213                fmt_indented(f, indent, "ProcessingInstruction {\n");
214                fmt_indented(f, indent + 4, &format!("target: \"{:?}\",\n", target));
215                fmt_indented(
216                    f,
217                    indent + 4,
218                    &match data {
219                        Some(c) => format!("data: \"{}\",\n", c),
220                        None => "data: None,\n".to_string(),
221                    },
222                );
223                fmt_indented(f, indent, "},\n");
224            }
225
226            Document::CDATA(cdata) => {
227                fmt_indented(f, indent, &format!("CDATA(\"{}\"),\n", cdata.clone()));
228            }
229        }
230    }
231}
232
233impl DeclarationContent {
234    fn fmt_indented_dec_content(&self, f: &mut String, indent: usize) {
235        match self {
236            DeclarationContent::Mixed(mixed) => {
237                fmt_indented(f, indent, " DeclarationContent::Mixed(\n");
238                mixed.fmt_indented_mixed(f, indent + 4);
239                fmt_indented(f, indent, "),\n");
240            }
241            DeclarationContent::Children(children) => {
242                fmt_indented(f, indent, " DeclarationContent::Children (\n");
243                let mut s = String::new();
244                children.fmt_indented_content_particle(&mut s, indent);
245                fmt_indented(f, indent, &format!("{}\n", s));
246                fmt_indented(f, indent, "),\n");
247            }
248            DeclarationContent::Empty => {
249                fmt_indented(f, indent, "DeclarationContent::Empty,\n");
250            }
251            DeclarationContent::Any => {
252                fmt_indented(f, indent, "DeclarationContent::Any,\n");
253            }
254        }
255    }
256}
257
258impl fmt::Debug for DeclarationContent {
259    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
260        let mut s = String::new();
261        self.fmt_indented_dec_content(&mut s, 0);
262        writeln!(f, "{}", s)
263    }
264}
265
266impl Mixed {
267    fn fmt_indented_mixed(&self, f: &mut String, indent: usize) {
268        match self {
269            Mixed::PCDATA => {
270                fmt_indented(f, indent, "PCDATA,\n");
271            }
272            Mixed::Names(names) => {
273                fmt_indented(f, indent, "Names([\n");
274                for name in names {
275                    let formatted_name = name.fmt_qualified_name(indent + 4); // Assuming you have this function
276                    f.push_str(&format!("{},\n", formatted_name));
277                }
278                fmt_indented(f, indent, "]),\n");
279            }
280        }
281    }
282}
283
284impl fmt::Debug for Mixed {
285    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
286        let mut s = String::new();
287        self.fmt_indented_mixed(&mut s, 0);
288        write!(f, "{}", s)
289    }
290}
291
292impl ContentParticle {
293    fn fmt_indented_content_particle(&self, f: &mut String, indent: usize) {
294        match self {
295            ContentParticle::Name(name, conditional_state) => {
296                fmt_indented(f, indent, "ContentParticle::Name {\n");
297                fmt_indented(f, indent + 4, "name: \n");
298                let formatted_name = name.fmt_qualified_name(indent + 8);
299                f.push_str(&formatted_name);
300                f.push('\n');
301                fmt_indented(
302                    f,
303                    indent + 4,
304                    &format!("conditional_state: {:?},\n", conditional_state),
305                );
306                fmt_indented(f, indent, "},\n");
307            }
308            ContentParticle::Choice(particles, conditional_state) => {
309                fmt_indented(f, indent, "ContentParticle::Choice {\n");
310                fmt_indented(f, indent + 4, "particles: [\n");
311                for item in particles {
312                    item.fmt_indented_content_particle(f, indent + 8);
313                }
314                fmt_indented(f, indent + 4, "],\n");
315                fmt_indented(
316                    f,
317                    indent + 4,
318                    &format!("conditional_state: {:?},\n", conditional_state),
319                );
320                fmt_indented(f, indent, "},\n");
321            }
322            ContentParticle::Sequence(particles, conditional_state) => {
323                fmt_indented(f, 4, "ContentParticle::Sequence {\n");
324                fmt_indented(f, indent + 8, "particles: [\n");
325                for item in particles {
326                    item.fmt_indented_content_particle(f, indent + 12);
327                }
328                fmt_indented(f, indent + 8, "],\n");
329                fmt_indented(
330                    f,
331                    indent + 4,
332                    &format!("conditional_state: {:?},\n", conditional_state),
333                );
334                fmt_indented(f, indent + 4, "},\n");
335            }
336        }
337    }
338}
339
340impl fmt::Debug for Standalone {
341    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
342        match self {
343            Standalone::Yes => write!(f, "Yes"),
344            Standalone::No => write!(f, "No"),
345        }
346    }
347}
348impl TextDecl {
349    fn _fmt_indented_text_decl(&self, f: &mut String, indent: usize) {
350        fmt_indented(f, indent, "TextDecl {\n");
351        fmt_indented(f, indent + 4, &format!("version: {:?},\n", self.version));
352        fmt_indented(f, indent + 4, &format!("encoding: {:?},\n", self.encoding));
353        fmt_indented(f, indent, "},\n");
354    }
355}
356
357impl XmlDecl {
358    fn fmt_indented_xml_decl(&self, f: &mut String, indent: usize) {
359        fmt_indented(f, indent, "XmlDecl {\n");
360        fmt_indented(f, indent + 4, &format!("version: {:?},\n", self.version));
361        fmt_indented(f, indent + 4, &format!("encoding: {:?},\n", self.encoding));
362        fmt_indented(
363            f,
364            indent + 4,
365            &format!("standalone: {:?},\n", self.standalone),
366        );
367        fmt_indented(f, indent, "},\n");
368    }
369}
370
371impl std::fmt::Debug for DocType {
372    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
373        f.debug_struct("DocType")
374            .field("name", &self.name)
375            .field("external_id", &self.external_id)
376            .field("subset", &self.subset)
377            .finish()
378    }
379}
380
381impl DocType {
382    fn fmt_indented_doc_type(&self, f: &mut String, indent: usize) {
383        fmt_indented(f, indent, "DocType {\n");
384        fmt_indented(
385            f,
386            indent + 4,
387            &format!("name: \n{}\n", self.name.fmt_qualified_name(indent + 8)),
388        );
389        fmt_indented(
390            f,
391            indent + 4,
392            &format!("external_id: {:?},\n", self.external_id),
393        );
394        fmt_indented(f, indent + 4, "subset: Some([\n");
395        for element in self.subset.as_ref().unwrap_or(&Vec::new()).iter() {
396            element.fmt_subset(f, indent + 8);
397        }
398        fmt_indented(f, indent + 4, "]),\n");
399        fmt_indented(f, indent, "},\n");
400    }
401}
402impl ExternalID {
403    fn fmt_indented_external_id(&self, f: &mut String, indent: usize) {
404        match self {
405            ExternalID::System(system) => {
406                fmt_indented(f, indent, &format!("System({:?}),\n", system));
407            }
408            ExternalID::Public {
409                pubid,
410                system_identifier,
411            } => {
412                fmt_indented(f, indent, "Public {\n");
413                fmt_indented(f, indent + 4, &format!("pubid: {:?},\n", pubid));
414                fmt_indented(f, indent + 4, "system_identifier: ");
415                system_identifier.fmt_indented_external_id(f, indent + 8);
416                fmt_indented(f, indent, "},\n");
417            }
418        }
419    }
420}
421
422impl std::fmt::Debug for ID {
423    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424        match self {
425            ID::ExternalID(external_id) => f.debug_tuple("ExternalID").field(&external_id).finish(),
426            ID::PublicID(pubid_literal) => f.debug_tuple("PublicID").field(&pubid_literal).finish(),
427        }
428    }
429}
430
431impl ID {
432    fn fmt_indented_id(&self, f: &mut String, indent: usize) {
433        match self {
434            ID::ExternalID(external_id) => {
435                fmt_indented(f, indent, "ExternalID {\n");
436                external_id.fmt_indented_external_id(f, indent + 4); // Assumes a function like `fmt_indented_external_id` exists for `ExternalID`
437                fmt_indented(f, indent, "},\n");
438            }
439            ID::PublicID(pubid_literal) => {
440                fmt_indented(f, indent, &format!("PublicID({:?}),\n", pubid_literal));
441            }
442        }
443    }
444}
445
446impl fmt::Debug for Subset {
447    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
448        let mut s = String::new();
449        self.fmt_subset(&mut s, 0);
450        write!(f, "{}", s)
451    }
452}
453
454impl Subset {
455    fn fmt_subset(&self, f: &mut String, indent: usize) {
456        match self {
457            Subset::MarkupDecl(markup_declaration) => {
458                markup_declaration.fmt_markup_decl(f, indent);
459            }
460            Subset::DeclSep {
461                reference,
462                expansion,
463            } => {
464                fmt_indented(f, indent, "DeclSep {\n");
465                fmt_indented(f, indent + 4, &format!("reference: {:?},\n", reference));
466                fmt_indented(f, indent + 4, "expansion: ");
467                if let Some(inner) = expansion.as_deref() {
468                    let mut s = String::new();
469                    inner.fmt_subset(&mut s, indent + 8);
470                    f.push_str(&format!("Some(\n{}\n", s));
471                    fmt_indented(f, indent + 4, "),\n");
472                } else {
473                    f.push_str("None,\n");
474                }
475                fmt_indented(f, indent, "},\n");
476            }
477            Subset::None => {
478                fmt_indented(f, indent, "None");
479            }
480        }
481    }
482}
483
484impl MarkupDeclaration {
485    fn fmt_markup_decl(&self, f: &mut String, indent: usize) {
486        match self {
487            MarkupDeclaration::Element { name, content_spec } => {
488                fmt_indented(f, indent, "MarkupDeclaration::Element {\n");
489                fmt_indented(
490                    f,
491                    indent + 4,
492                    &format!("name: \n{}\n", name.fmt_qualified_name(indent + 8)),
493                );
494                fmt_indented(f, indent + 4, "content_spec: ");
495                match content_spec {
496                    Some(spec) => {
497                        let mut s = String::new();
498                        spec.fmt_indented_dec_content(&mut s, indent + 8);
499                        f.push_str(&format!("Some(\n{}\n", s));
500                        fmt_indented(f, indent + 4, "),\n");
501                    }
502                    None => f.push_str("None,\n"),
503                }
504                fmt_indented(f, indent, "},\n");
505            }
506
507            MarkupDeclaration::AttList { name, att_defs } => {
508                fmt_indented(f, indent, "AttList {\n");
509                fmt_indented(
510                    f,
511                    indent + 4,
512                    &format!("name: \n{}\n", name.fmt_qualified_name(indent + 8)),
513                );
514                fmt_indented(f, indent + 4, "att_defs: [\n");
515                if let Some(def) = att_defs {
516                    for def_item in def.iter() {
517                        def_item.fmt_indented_attribute(f, indent + 8);
518                    }
519                }
520                fmt_indented(f, indent + 4, "],\n");
521                fmt_indented(f, indent, "},\n");
522            }
523            MarkupDeclaration::Notation { name, id } => {
524                fmt_indented(f, indent, "Notation {\n");
525                fmt_indented(
526                    f,
527                    indent + 4,
528                    &format!("name: \n{}\n", name.fmt_qualified_name(indent + 8)),
529                );
530                fmt_indented(f, indent + 4, "id: ");
531
532                // Use the fmt_indented_id function here
533                id.fmt_indented_id(f, indent + 8);
534
535                fmt_indented(f, indent, "},\n");
536            }
537
538            MarkupDeclaration::Entity(entity_declaration) => match entity_declaration {
539                EntityDecl::General(general_declaration) => {
540                    fmt_indented(f, indent, "Entity::General {\n");
541                    let mut s = String::new();
542                    general_declaration.fmt_indented_entity_declaration(&mut s, indent + 4);
543                    f.push_str(&format!("{}\n", s));
544                    fmt_indented(f, indent, "},\n");
545                }
546                EntityDecl::Parameter(parameter_declaration) => {
547                    fmt_indented(f, indent, "Entity::Parameter {\n");
548                    fmt_indented(f, indent + 4, &format!("{parameter_declaration:?}\n"));
549                    fmt_indented(f, indent, "},\n");
550                }
551            },
552
553            MarkupDeclaration::ProcessingInstruction(ProcessingInstruction { target, data }) => {
554                fmt_indented(f, indent, "ProcessingInstruction {\n");
555                fmt_indented(f, indent + 4, &format!("target: {:?},\n", target));
556                fmt_indented(f, indent + 4, &format!("data: {:?},\n", data));
557                fmt_indented(f, indent, "},\n");
558            }
559            MarkupDeclaration::Comment(comment) => {
560                fmt_indented(f, indent, "Comment(\n");
561                match comment {
562                    Document::Comment(comment_str) => {
563                        fmt_indented(f, indent + 4, &format!("{:?}\n", comment_str));
564                    }
565                    _ => {
566                        fmt_indented(f, indent + 4, "Unsupported comment variant,\n");
567                    }
568                }
569                fmt_indented(f, indent, "),\n");
570            }
571        }
572    }
573}
574
575impl fmt::Debug for MarkupDeclaration {
576    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
577        let mut s = String::new();
578        self.fmt_markup_decl(&mut s, 0);
579        write!(f, "{}", s)
580    }
581}
582
583impl std::fmt::Debug for XmlDecl {
584    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
585        f.debug_struct("XmlDecl")
586            .field("version", &self.version)
587            .field("encoding", &self.encoding)
588            .field("standalone", &self.standalone)
589            .finish()
590    }
591}
592impl std::fmt::Debug for TextDecl {
593    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
594        f.debug_struct("TextDecl")
595            .field("version", &self.version)
596            .field("encoding", &self.encoding)
597            .finish()
598    }
599}
600
601impl std::fmt::Debug for AttributeValue {
602    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
603        let mut debug_string = String::new();
604        self.fmt_indented_attribute_value(&mut debug_string, 4);
605        write!(f, "{}", debug_string)
606    }
607}
608
609impl AttributeValue {
610    fn fmt_indented_attribute_value(&self, f: &mut String, indent: usize) {
611        match self {
612            AttributeValue::Value(value) => {
613                fmt_indented(f, indent - 4, "Value(\n");
614                fmt_indented(f, indent, &format!("{:?}\n", value));
615                fmt_indented(f, indent - 4, "),\n");
616            }
617            AttributeValue::Values(values) => {
618                fmt_indented(f, indent - 4, "Values(\n");
619                for value in values {
620                    value.fmt_indented_attribute_value(f, indent);
621                }
622                fmt_indented(f, indent - 4, "),\n");
623            }
624            AttributeValue::Reference(reference) => {
625                fmt_indented(f, indent, "Reference(\n");
626                fmt_indented(f, indent + 4, &format!("{:?},\n", reference));
627                fmt_indented(f, indent, "),\n");
628            }
629            AttributeValue::EmptyExternalReference => {
630                fmt_indented(f, indent, "EmptyExternalReference\n");
631            }
632        }
633    }
634}
635
636impl Attribute {
637    fn fmt_indented_attribute(&self, f: &mut String, indent: usize) {
638        match self {
639            Attribute::Definition {
640                name,
641                att_type,
642                default_decl,
643                source,
644            } => {
645                fmt_indented(f, indent, "Definition {\n");
646                fmt_indented(f, indent + 4, "name: \n");
647                let formatted_name = name.fmt_qualified_name(indent + 8);
648                f.push_str(&formatted_name);
649                f.push('\n');
650                fmt_indented(f, indent + 4, &format!("att_type: {:?},\n", att_type));
651                fmt_indented(
652                    f,
653                    indent + 4,
654                    &format!("default_decl: {:?},\n", default_decl),
655                );
656                fmt_indented(f, indent + 4, &format!("source: {:?},\n", source));
657                fmt_indented(f, indent, "},\n");
658            }
659            Attribute::Reference(reference) => {
660                fmt_indented(f, indent, &format!("Reference: {:?},\n", reference));
661            }
662            Attribute::Required => {
663                fmt_indented(f, indent, "REQUIRED,\n");
664            }
665            Attribute::Implied => {
666                fmt_indented(f, indent, "IMPLIED,\n");
667            }
668            Attribute::Instance { name, value } => {
669                fmt_indented(f, indent, "Instance {\n");
670                fmt_indented(f, indent + 4, "name: \n");
671                let formatted_name = name.fmt_qualified_name(indent + 8);
672                f.push_str(&formatted_name);
673                f.push('\n');
674                fmt_indented(f, indent + 4, "value:\n");
675                value.fmt_indented_attribute_value(f, indent + 12);
676                fmt_indented(f, indent, "},\n");
677            }
678            Attribute::Namespace { prefix, uri } => {
679                fmt_indented(f, indent, "Namespace {\n");
680                fmt_indented(f, indent + 4, &format!("prefix: {:?},\n", prefix));
681                uri.fmt_indented_attribute_value(f, indent + 4);
682                fmt_indented(f, indent, "},\n");
683            }
684        }
685    }
686}
687
688impl fmt::Debug for Attribute {
689    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
690        let mut s = String::new();
691        self.fmt_indented_attribute(&mut s, 0);
692        write!(f, "{}", s)
693    }
694}
695
696impl fmt::Debug for Prefix {
697    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
698        match self {
699            Prefix::Default => write!(f, "Default"),
700            Prefix::Prefix(p) => write!(f, "Prefix({:?})", p),
701        }
702    }
703}
704
705// impl fmt::Debug for Reference {
706//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
707//         match self {
708//             Reference::EntityRef(name) => f
709//                 .debug_struct("EntityRef")
710//                 .field("name", &format_args!("\n{}", name.fmt_qualified_name(12)))
711//                 .finish(),
712
713//             Reference::CharRef(value) => f.debug_struct("CharRef").field("value", value).finish(),
714//         }
715//     }
716// }
717
718impl fmt::Debug for Reference {
719    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
720        let mut s = String::new();
721        self.fmt_indented_reference(&mut s, 0);
722        write!(f, "{}", s)
723    }
724}
725
726impl Reference {
727    fn fmt_indented_reference(&self, f: &mut String, indent: usize) {
728        match self {
729            Reference::EntityRef(name) => {
730                fmt_indented(f, indent, "EntityRef {\n");
731                fmt_indented(f, indent + 4, "name:\n");
732                let name_str = name.fmt_qualified_name(indent + 10);
733                f.push_str(&name_str);
734                f.push('\n');
735                fmt_indented(f, indent, "},\n");
736            }
737            Reference::CharRef(value) => {
738                fmt_indented(f, indent, "CharRef {\n");
739                fmt_indented(f, indent + 4, &format!("value: {:?},\n", value));
740                fmt_indented(f, indent, "},\n");
741            }
742        }
743    }
744}
745
746impl fmt::Debug for EntityDeclaration {
747    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
748        let mut s = String::new();
749        self.fmt_indented_entity_declaration(&mut s, 0);
750        write!(f, "{}", s.trim_end())
751    }
752}
753
754impl EntityDeclaration {
755    fn fmt_indented_entity_declaration(&self, f: &mut String, indent: usize) {
756        fmt_indented(f, indent, "EntityDeclaration {\n");
757        fmt_indented(
758            f,
759            indent + 8,
760            &format!("name: \n{}\n", self.name.fmt_qualified_name(indent + 12)),
761        );
762        fmt_indented(f, indent + 4, "entity_def:\n");
763        let mut s = String::new();
764        self.entity_def
765            .fmt_indented_entity_definition(&mut s, indent + 8);
766        f.push_str(&s.to_string());
767        fmt_indented(f, indent + 4, "},");
768    }
769}
770
771impl std::fmt::Debug for EntityDefinition {
772    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
773        let mut s = String::new();
774        self.fmt_indented_entity_definition(&mut s, 0);
775        write!(f, "{}", s)
776    }
777}
778
779impl EntityDefinition {
780    fn fmt_indented_entity_definition(&self, f: &mut String, indent: usize) {
781        match self {
782            EntityDefinition::EntityValue(value) => {
783                fmt_indented(f, indent, "EntityDefinition::EntityValue(\n");
784                value.fmt_indented_entity_value(f, indent + 4);
785                fmt_indented(f, indent, ")\n");
786            }
787            EntityDefinition::External {
788                id,
789                n_data,
790                text_decl,
791            } => {
792                fmt_indented(f, indent, "EntityDefinition::External {\n");
793                fmt_indented(f, indent + 4, &format!("id: {:?},\n", id));
794                fmt_indented(f, indent + 4, &format!("n_data: {:?},\n", n_data));
795                fmt_indented(f, indent + 4, &format!("text_decl: {:?},\n", text_decl));
796                fmt_indented(f, indent, "},\n");
797            }
798        }
799    }
800}
801
802impl std::fmt::Debug for EntityValue {
803    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
804        let mut s = String::new();
805        self.fmt_indented_entity_value(&mut s, 0);
806        write!(f, "{}", s)
807    }
808}
809
810impl EntityValue {
811    fn fmt_indented_entity_value(&self, f: &mut String, indent: usize) {
812        match self {
813            EntityValue::Value(value) => {
814                fmt_indented(f, indent, "Value(\n");
815                fmt_indented(f, indent, &format!("{value:?}\n"));
816                fmt_indented(f, indent + 4, "),\n");
817            }
818            EntityValue::Reference(reference) => {
819                fmt_indented(f, indent, "Reference(\n");
820                fmt_indented(f, indent + 4, &format!("{reference:?},\n"));
821                fmt_indented(f, indent, "),\n");
822            }
823            EntityValue::ParameterReference(reference) => {
824                fmt_indented(f, indent, "PerameterReference(\n");
825                fmt_indented(f, indent + 4, &format!("{reference:?},\n"));
826                fmt_indented(f, indent, "),\n");
827            }
828            EntityValue::Document(document) => {
829                fmt_indented(f, indent, "Document(\n");
830                fmt_indented(f, indent + 4, &format!("{document:?}"));
831                fmt_indented(f, indent, ")");
832            }
833            EntityValue::MarkupDecl(subset) => {
834                // Handle the new variant here
835                fmt_indented(f, indent, "MarkupDecl(\n");
836                fmt_indented(f, indent + 4, &format!("{subset:?},\n"));
837                fmt_indented(f, indent, "),\n");
838            }
839        }
840    }
841}
nom_xml/debug.rs

nom_xml/
debug.rs
