Optional unescaping with serde

[pigeonhands]

Currently, trying to use quick_xml::de::from_str with xml that uses entity tags in the doctype fail to parse.

<!DOCTYPE dict[
    <!ENTITY unc "unclassified">
]>

<dict>
    <word>&unc;</word>
</dict>

let data = fs::read_to_string("../data/dict.xml").unwrap();
let parsed : Dict = quick_xml::de::from_str(&data).unwrap();

thread 'main' panicked at 'called Result::unwrap() on an Err value: InvalidXml(EscapeError(UnrecognizedSymbol(1..4, "unc")))'

---

Could a feature flag or an alternate method be added that disables unescaping and instead always just returns the raw string?

[Mingun]

I'll accept a PR which will add an ability to set up entity resolver for Deserializer. In the simplest case resolver is an Fn(&str) -> Option<&str>, like there, but in that case you will not be able to capture entities from the document. So a more powerful solution is to declare Resolver trait that will be able to capture doctypes and then resolves entities.

[pigeonhands]

@Mingun I'm not really sure how to go about this. I have created a fork that implements a resolver but its not going to be able to access the entities defined in the document because that parsing is handled outside the de module.

pigeonhands@ddacb31

[Mingun]

Wow! Your implementation looks promising! I think, it would be better if you create a draft PR so we can discuss on actual implementation in context.

You need to capture DocType events in this match:

quick-xml/src/de/mod.rs

Lines 2745 to 2765 in 2e9123a

	fn trim<'a>(&mut self, event: Event<'a>) -> Option<PayloadEvent<'a>> {
	let (event, trim_next_event) = match event {
	Event::Start(e) => (PayloadEvent::Start(e), true),
	Event::End(e) => (PayloadEvent::End(e), true),
	Event::Eof => (PayloadEvent::Eof, true),
	// Do not trim next text event after Text or CDATA event
	Event::CData(e) => (PayloadEvent::CData(e), false),
	Event::Text(mut e) => {
	// If event is empty after trimming, skip it
	if self.trim_start && e.inplace_trim_start() {
	return None;
	}
	(PayloadEvent::Text(e), false)
	}
	_ => return None,
	};
	self.trim_start = trim_next_event;
	Some(event)
	}

For that change the EntityResolver trait to that (feel free to fix grammar if I made mistakes):

/// Used to resolve unknown entities while parsing
///
/// # Example
/// Add an example here -- you can adapt existing custom_entities.rs example
pub trait EntityResolver {
    /// Called on contents of [`Event::DocType`] to capture declared entities.
    /// Can be called multiple times, for each parsed `<!DOCTYPE >` declaration.
    fn capture(&mut self, doctype: BytesText);

    /// Called when an entity needs to be resolved.
    ///
    /// `None` is returned if a suitable value can not be found.
    /// In that case an [`Error::UnrecognizedSymbol`] will be returned.
    fn resolve<'entity>(&'entity self, entity: &str) -> Option<&'entity str>;
}

resolve method no need to be mutable -- it used only for requesting information. If implementation would need mutation in that case it should use internal mutability, using Cell or something.

[pigeonhands]

@Mingun

resolve method no need to be mutable -- it used only for requesting information. If implementation would need mutation in that case it should use internal mutability, using Cell or something.

I started this a bit to late in the night 😅 It makes a lot more sense now my brain is a bit more functional

I have opened a draft PR #583