NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Uses quick-xml 0.26

Browse Source
pull/315/head
Thomas Tanon 2 years ago committed by GitHub
parent e5b15031b6
commit 65ed5471da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 127 additions and 140 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 13
      Cargo.lock
  2. 2
      lib/sparesults/Cargo.toml
  3. 252
      lib/sparesults/src/xml.rs

13
Cargo.lock generated
Unescape View File

@ -1317,6 +1317,15 @@ dependencies = [
"memchr",
]
[[package]]
name = "quick-xml"
version = "0.26.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f50b1c63b38611e7d4d7f68b82d3ad0cc71a2ad2e7f61fc10f1328d917c93cd"
dependencies = [
"memchr",
]
[[package]]
name = "quote"
version = "1.0.21"
@ -1460,7 +1469,7 @@ checksum = "26defbc05a1e9d167f86d07adc70a717f108e46ef4c1ec6742d96c63c726ebb6"
dependencies = [
"oxilangtag",
"oxiri",
"quick-xml",
"quick-xml 0.23.1",
"rio_api",
]
@ -1664,7 +1673,7 @@ version = "0.1.2"
dependencies = [
"json-event-parser",
"oxrdf",
"quick-xml",
"quick-xml 0.26.0",
]
[[package]]

2
lib/sparesults/Cargo.toml
Unescape View File

@ -19,7 +19,7 @@ rdf-star = ["oxrdf/rdf-star"]
[dependencies]
json-event-parser = "0.1"
oxrdf = { version = "0.1.1", path="../oxrdf" }
quick-xml = "0.23"
quick-xml = "0.26"
[package.metadata.docs.rs]
all-features = true

252
lib/sparesults/src/xml.rs
Unescape View File

@ -5,10 +5,11 @@ use oxrdf::vocab::rdf;
use oxrdf::Variable;
use oxrdf::*;
use quick_xml::events::{BytesDecl, BytesEnd, BytesStart, BytesText, Event};
use quick_xml::Reader;
use quick_xml::Writer;
use quick_xml::{Reader, Writer};
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::io::{self, BufRead, Write};
use std::str;
pub fn write_boolean_xml_result<W: Write>(sink: W, value: bool) -> io::Result<W> {
do_write_boolean_xml_result(sink, value).map_err(map_xml_error)
@ -16,20 +17,20 @@ pub fn write_boolean_xml_result<W: Write>(sink: W, value: bool) -> io::Result<W>
fn do_write_boolean_xml_result<W: Write>(sink: W, value: bool) -> Result<W, quick_xml::Error> {
let mut writer = Writer::new(sink);
writer.write_event(Event::Decl(BytesDecl::new(b"1.0", None, None)))?;
let mut sparql_open = BytesStart::borrowed_name(b"sparql");
writer.write_event(Event::Decl(BytesDecl::new("1.0", None, None)))?;
let mut sparql_open = BytesStart::new("sparql");
sparql_open.push_attribute(("xmlns", "http://www.w3.org/2005/sparql-results#"));
writer.write_event(Event::Start(sparql_open))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"head")))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"head")))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"boolean")))?;
writer.write_event(Event::Text(BytesText::from_plain_str(if value {
writer.write_event(Event::Start(BytesStart::new("head")))?;
writer.write_event(Event::End(BytesEnd::new("head")))?;
writer.write_event(Event::Start(BytesStart::new("boolean")))?;
writer.write_event(Event::Text(BytesText::new(if value {
"true"
} else {
"false"
})))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"boolean")))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"sparql")))?;
writer.write_event(Event::End(BytesEnd::new("boolean")))?;
writer.write_event(Event::End(BytesEnd::new("sparql")))?;
Ok(writer.into_inner())
}
@ -44,18 +45,18 @@ impl<W: Write> XmlSolutionsWriter<W> {
fn do_start(sink: W, variables: Vec<Variable>) -> Result<Self, quick_xml::Error> {
let mut writer = Writer::new(sink);
writer.write_event(Event::Decl(BytesDecl::new(b"1.0", None, None)))?;
let mut sparql_open = BytesStart::borrowed_name(b"sparql");
writer.write_event(Event::Decl(BytesDecl::new("1.0", None, None)))?;
let mut sparql_open = BytesStart::new("sparql");
sparql_open.push_attribute(("xmlns", "http://www.w3.org/2005/sparql-results#"));
writer.write_event(Event::Start(sparql_open))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"head")))?;
writer.write_event(Event::Start(BytesStart::new("head")))?;
for variable in &variables {
let mut variable_tag = BytesStart::borrowed_name(b"variable");
let mut variable_tag = BytesStart::new("variable");
variable_tag.push_attribute(("name", variable.as_str()));
writer.write_event(Event::Empty(variable_tag))?;
}
writer.write_event(Event::End(BytesEnd::borrowed(b"head")))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"results")))?;
writer.write_event(Event::End(BytesEnd::new("head")))?;
writer.write_event(Event::Start(BytesStart::new("results")))?;
Ok(Self { writer })
}
@ -71,17 +72,16 @@ impl<W: Write> XmlSolutionsWriter<W> {
solution: impl IntoIterator<Item = (VariableRef<'a>, TermRef<'a>)>,
) -> Result<(), quick_xml::Error> {
self.writer
.write_event(Event::Start(BytesStart::borrowed_name(b"result")))?;
.write_event(Event::Start(BytesStart::new("result")))?;
for (variable, value) in solution {
let mut binding_tag = BytesStart::borrowed_name(b"binding");
let mut binding_tag = BytesStart::new("binding");
binding_tag.push_attribute(("name", variable.as_str()));
self.writer.write_event(Event::Start(binding_tag))?;
write_xml_term(value, &mut self.writer)?;
self.writer
.write_event(Event::End(BytesEnd::borrowed(b"binding")))?;
.write_event(Event::End(BytesEnd::new("binding")))?;
}
self.writer
.write_event(Event::End(BytesEnd::borrowed(b"result")))
self.writer.write_event(Event::End(BytesEnd::new("result")))
}
pub fn finish(self) -> io::Result<W> {
@ -92,9 +92,9 @@ impl<W: Write> XmlSolutionsWriter<W> {
fn do_finish(mut self) -> Result<W, quick_xml::Error> {
self.writer
.write_event(Event::End(BytesEnd::borrowed(b"results")))?;
.write_event(Event::End(BytesEnd::new("results")))?;
self.writer
.write_event(Event::End(BytesEnd::borrowed(b"sparql")))?;
.write_event(Event::End(BytesEnd::new("sparql")))?;
Ok(self.writer.into_inner())
}
}
@ -105,39 +105,39 @@ fn write_xml_term(
) -> Result<(), quick_xml::Error> {
match term {
TermRef::NamedNode(uri) => {
writer.write_event(Event::Start(BytesStart::borrowed_name(b"uri")))?;
writer.write_event(Event::Text(BytesText::from_plain_str(uri.as_str())))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"uri")))?;
writer.write_event(Event::Start(BytesStart::new("uri")))?;
writer.write_event(Event::Text(BytesText::new(uri.as_str())))?;
writer.write_event(Event::End(BytesEnd::new("uri")))?;
}
TermRef::BlankNode(bnode) => {
writer.write_event(Event::Start(BytesStart::borrowed_name(b"bnode")))?;
writer.write_event(Event::Text(BytesText::from_plain_str(bnode.as_str())))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"bnode")))?;
writer.write_event(Event::Start(BytesStart::new("bnode")))?;
writer.write_event(Event::Text(BytesText::new(bnode.as_str())))?;
writer.write_event(Event::End(BytesEnd::new("bnode")))?;
}
TermRef::Literal(literal) => {
let mut literal_tag = BytesStart::borrowed_name(b"literal");
let mut literal_tag = BytesStart::new("literal");
if let Some(language) = literal.language() {
literal_tag.push_attribute(("xml:lang", language));
} else if !literal.is_plain() {
literal_tag.push_attribute(("datatype", literal.datatype().as_str()));
}
writer.write_event(Event::Start(literal_tag))?;
writer.write_event(Event::Text(BytesText::from_plain_str(literal.value())))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"literal")))?;
writer.write_event(Event::Text(BytesText::new(literal.value())))?;
writer.write_event(Event::End(BytesEnd::new("literal")))?;
}
#[cfg(feature = "rdf-star")]
TermRef::Triple(triple) => {
writer.write_event(Event::Start(BytesStart::borrowed_name(b"triple")))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"subject")))?;
writer.write_event(Event::Start(BytesStart::new("triple")))?;
writer.write_event(Event::Start(BytesStart::new("subject")))?;
write_xml_term(triple.subject.as_ref().into(), writer)?;
writer.write_event(Event::End(BytesEnd::borrowed(b"subject")))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"predicate")))?;
writer.write_event(Event::End(BytesEnd::new("subject")))?;
writer.write_event(Event::Start(BytesStart::new("predicate")))?;
write_xml_term(triple.predicate.as_ref().into(), writer)?;
writer.write_event(Event::End(BytesEnd::borrowed(b"predicate")))?;
writer.write_event(Event::Start(BytesStart::borrowed_name(b"object")))?;
writer.write_event(Event::End(BytesEnd::new("predicate")))?;
writer.write_event(Event::Start(BytesStart::new("object")))?;
write_xml_term(triple.object.as_ref(), writer)?;
writer.write_event(Event::End(BytesEnd::borrowed(b"object")))?;
writer.write_event(Event::End(BytesEnd::borrowed(b"triple")))?;
writer.write_event(Event::End(BytesEnd::new("object")))?;
writer.write_event(Event::End(BytesEnd::new("triple")))?;
}
}
Ok(())
@ -166,49 +166,35 @@ impl<R: BufRead> XmlQueryResultsReader<R> {
reader.expand_empty_elements(true);
let mut buffer = Vec::default();
let mut namespace_buffer = Vec::default();
let mut variables = Vec::default();
let mut state = State::Start;
//Read header
loop {
let event = {
let (ns, event) =
reader.read_namespaced_event(&mut buffer, &mut namespace_buffer)?;
if let Some(ns) = ns {
if ns != b"http://www.w3.org/2005/sparql-results#".as_ref() {
return Err(SyntaxError::msg(format!(
"Unexpected namespace found in RDF/XML query result: {}",
reader.decode(ns)?
))
.into());
}
}
event
};
let event = reader.read_event_into(&mut buffer)?;
match event {
Event::Start(event) => match state {
State::Start => {
if event.name() == b"sparql" {
if event.local_name().as_ref() == b"sparql" {
state = State::Sparql;
} else {
return Err(SyntaxError::msg(format!("Expecting <sparql> tag, found {}", reader.decode(event.name())?)).into());
return Err(SyntaxError::msg(format!("Expecting <sparql> tag, found <{}>", decode(&reader, &event.name())?)).into());
}
}
State::Sparql => {
if event.name() == b"head" {
if event.local_name().as_ref() == b"head" {
state = State::Head;
} else {
return Err(SyntaxError::msg(format!("Expecting <head> tag, found {}", reader.decode(event.name())?)).into());
return Err(SyntaxError::msg(format!("Expecting <head> tag, found <{}>",decode(&reader, &event.name())?)).into());
}
}
State::Head => {
if event.name() == b"variable" {
if event.local_name().as_ref() == b"variable" {
let name = event.attributes()
.filter_map(Result::ok)
.find(|attr| attr.key == b"name")
.find(|attr| attr.key.local_name().as_ref() == b"name")
.ok_or_else(|| SyntaxError::msg("No name attribute found for the <variable> tag"))?
.unescape_and_decode_value(&reader)?;
.decode_and_unescape_value(&reader)?;
let variable = Variable::new(name).map_err(|e| SyntaxError::msg(format!("Invalid variable name: {}", e)))?;
if variables.contains(&variable) {
return Err(SyntaxError::msg(format!(
@ -218,55 +204,54 @@ impl<R: BufRead> XmlQueryResultsReader<R> {
.into());
}
variables.push(variable);
} else if event.name() == b"link" {
} else if event.local_name().as_ref() == b"link" {
// no op
} else {
return Err(SyntaxError::msg(format!("Expecting <variable> or <link> tag, found {}", reader.decode(event.name())?)).into());
return Err(SyntaxError::msg(format!("Expecting <variable> or <link> tag, found <{}>", decode(&reader, &event.name())?)).into());
}
}
State::AfterHead => {
if event.name() == b"boolean" {
if event.local_name().as_ref() == b"boolean" {
state = State::Boolean
} else if event.name() == b"results" {
} else if event.local_name().as_ref() == b"results" {
let mut mapping = BTreeMap::default();
for (i, var) in variables.iter().enumerate() {
mapping.insert(var.as_str().as_bytes().to_vec(), i);
mapping.insert(var.clone().into_string(), i);
}
return Ok(Self::Solutions { variables,
solutions: XmlSolutionsReader {
reader,
buffer,
namespace_buffer,
mapping,
stack: Vec::new(),
subject_stack: Vec::new(),
predicate_stack: Vec::new(),
object_stack: Vec::new(),
}});
} else if event.name() != b"link" && event.name() != b"results" && event.name() != b"boolean" {
return Err(SyntaxError::msg(format!("Expecting sparql tag, found {}", reader.decode(event.name())?)).into());
} else if event.local_name().as_ref() != b"link" && event.local_name().as_ref() != b"results" && event.local_name().as_ref() != b"boolean" {
return Err(SyntaxError::msg(format!("Expecting sparql tag, found <{}>", decode(&reader, &event.name())?)).into());
}
}
State::Boolean => return Err(SyntaxError::msg(format!("Unexpected tag inside of <boolean> tag: {}", reader.decode(event.name())?)).into())
State::Boolean => return Err(SyntaxError::msg(format!("Unexpected tag inside of <boolean> tag: <{}>", decode(&reader, &event.name())?)).into())
},
Event::Text(event) => {
let value = event.unescaped()?;
let value = event.unescape()?;
return match state {
State::Boolean => {
return if value.as_ref() == b"true" {
return if value == "true" {
Ok(Self::Boolean(true))
} else if value.as_ref() == b"false" {
} else if value == "false" {
Ok(Self::Boolean(false))
} else {
Err(SyntaxError::msg(format!("Unexpected boolean value. Found {}", reader.decode(&value)?)).into())
Err(SyntaxError::msg(format!("Unexpected boolean value. Found '{}'", value)).into())
};
}
_ => Err(SyntaxError::msg(format!("Unexpected textual value found: {}", reader.decode(&value)?)).into())
_ => Err(SyntaxError::msg(format!("Unexpected textual value found: '{}'", value)).into())
};
},
Event::End(event) => {
if let State::Head = state {
if event.name() == b"head" {
if event.local_name().as_ref() == b"head" {
state = State::AfterHead
}
} else {
@ -297,8 +282,7 @@ enum State {
pub struct XmlSolutionsReader<R: BufRead> {
reader: Reader<R>,
buffer: Vec<u8>,
namespace_buffer: Vec<u8>,
mapping: BTreeMap<Vec<u8>, usize>,
mapping: BTreeMap<String, usize>,
stack: Vec<State>,
subject_stack: Vec<Term>,
predicate_stack: Vec<Term>,
@ -316,39 +300,32 @@ impl<R: BufRead> XmlSolutionsReader<R> {
let mut lang = None;
let mut datatype = None;
loop {
let (ns, event) = self
.reader
.read_namespaced_event(&mut self.buffer, &mut self.namespace_buffer)?;
if let Some(ns) = ns {
if ns != b"http://www.w3.org/2005/sparql-results#".as_ref() {
return Err(SyntaxError::msg(format!(
"Unexpected namespace found in RDF/XML query result: {}",
self.reader.decode(ns)?
))
.into());
}
}
let event = self.reader.read_event_into(&mut self.buffer)?;
match event {
Event::Start(event) => match state {
State::Start => {
if event.name() == b"result" {
if event.local_name().as_ref() == b"result" {
state = State::Result;
} else {
return Err(SyntaxError::msg(format!(
"Expecting <result>, found {}",
self.reader.decode(event.name())?
"Expecting <result>, found <{}>",
decode(&self.reader, &event.name())?
))
.into());
}
}
State::Result => {
if event.name() == b"binding" {
if event.local_name().as_ref() == b"binding" {
match event
.attributes()
.filter_map(Result::ok)
.find(|attr| attr.key == b"name")
.find(|attr| attr.key.local_name().as_ref() == b"name")
{
Some(attr) => current_var = Some(attr.unescaped_value()?.to_vec()),
Some(attr) => {
current_var = Some(
attr.decode_and_unescape_value(&self.reader)?.to_string(),
)
}
None => {
return Err(SyntaxError::msg(
"No name attribute found for the <binding> tag",
@ -359,8 +336,8 @@ impl<R: BufRead> XmlSolutionsReader<R> {
state = State::Binding;
} else {
return Err(SyntaxError::msg(format!(
"Expecting <binding>, found {}",
self.reader.decode(event.name())?
"Expecting <binding>, found <{}>",
decode(&self.reader, &event.name())?
))
.into());
}
@ -373,46 +350,49 @@ impl<R: BufRead> XmlSolutionsReader<R> {
.into());
}
self.stack.push(state);
if event.name() == b"uri" {
if event.local_name().as_ref() == b"uri" {
state = State::Uri;
} else if event.name() == b"bnode" {
} else if event.local_name().as_ref() == b"bnode" {
state = State::BNode;
} else if event.name() == b"literal" {
} else if event.local_name().as_ref() == b"literal" {
for attr in event.attributes().flatten() {
if attr.key == b"xml:lang" {
lang = Some(attr.unescape_and_decode_value(&self.reader)?);
} else if attr.key == b"datatype" {
let iri = attr.unescape_and_decode_value(&self.reader)?;
datatype = Some(NamedNode::new(&iri).map_err(|e| {
SyntaxError::msg(format!(
"Invalid datatype IRI '{}': {}",
iri, e
))
})?);
if attr.key.as_ref() == b"xml:lang" {
lang = Some(
attr.decode_and_unescape_value(&self.reader)?.to_string(),
);
} else if attr.key.local_name().as_ref() == b"datatype" {
let iri = attr.decode_and_unescape_value(&self.reader)?;
datatype =
Some(NamedNode::new(iri.to_string()).map_err(|e| {
SyntaxError::msg(format!(
"Invalid datatype IRI '{}': {}",
iri, e
))
})?);
}
}
state = State::Literal;
} else if event.name() == b"triple" {
} else if event.local_name().as_ref() == b"triple" {
state = State::Triple;
} else {
return Err(SyntaxError::msg(format!(
"Expecting <uri>, <bnode> or <literal> found {}",
self.reader.decode(event.name())?
"Expecting <uri>, <bnode> or <literal> found <{}>",
decode(&self.reader, &event.name())?
))
.into());
}
}
State::Triple => {
if event.name() == b"subject" {
if event.local_name().as_ref() == b"subject" {
state = State::Subject
} else if event.name() == b"predicate" {
} else if event.local_name().as_ref() == b"predicate" {
state = State::Predicate
} else if event.name() == b"object" {
} else if event.local_name().as_ref() == b"object" {
state = State::Object
} else {
return Err(SyntaxError::msg(format!(
"Expecting <subject>, <predicate> or <object> found {}",
self.reader.decode(event.name())?
"Expecting <subject>, <predicate> or <object> found <{}>",
decode(&self.reader, &event.name())?
))
.into());
}
@ -420,48 +400,39 @@ impl<R: BufRead> XmlSolutionsReader<R> {
_ => (),
},
Event::Text(event) => {
let data = event.unescaped()?;
let data = event.unescape()?;
match state {
State::Uri => {
let iri = self.reader.decode(&data)?;
term = Some(
NamedNode::new(iri)
NamedNode::new(data.to_string())
.map_err(|e| {
SyntaxError::msg(format!(
"Invalid IRI value '{}': {}",
iri, e
data, e
))
})?
.into(),
)
}
State::BNode => {
let bnode = self.reader.decode(&data)?;
term = Some(
BlankNode::new(bnode)
BlankNode::new(data.to_string())
.map_err(|e| {
SyntaxError::msg(format!(
"Invalid blank node value '{}': {}",
bnode, e
data, e
))
})?
.into(),
)
}
State::Literal => {
term = Some(
build_literal(
self.reader.decode(&data)?,
lang.take(),
datatype.take(),
)?
.into(),
);
term = Some(build_literal(data, lang.take(), datatype.take())?.into());
}
_ => {
return Err(SyntaxError::msg(format!(
"Unexpected textual value found: {}",
self.reader.decode(&data)?
data
))
.into());
}
@ -476,7 +447,7 @@ impl<R: BufRead> XmlSolutionsReader<R> {
new_bindings[*var] = term.take()
} else {
return Err(
SyntaxError::msg(format!("The variable '{}' is used in a binding but not declared in the variables list", self.reader.decode(var)?)).into()
SyntaxError::msg(format!("The variable '{}' is used in a binding but not declared in the variables list", var)).into()
);
}
} else {
@ -601,6 +572,13 @@ fn build_literal(
}
}
fn decode<'a, T>(
reader: &Reader<T>,
data: &'a impl AsRef<[u8]>,
) -> Result<Cow<'a, str>, ParseError> {
Ok(reader.decoder().decode(data.as_ref())?)
}
fn map_xml_error(error: quick_xml::Error) -> io::Error {
match error {
quick_xml::Error::Io(error) => error,

Write Preview
Loading…
Cancel
Save