From 568a7c2611d3e19abb96ae67a400ca931aedc1d0 Mon Sep 17 00:00:00 2001 From: Astro Date: Tue, 19 Apr 2022 20:45:44 +0200 Subject: [PATCH] minidom: remove unused parser module --- minidom/src/parser.rs | 187 ------------------------------------------ 1 file changed, 187 deletions(-) delete mode 100644 minidom/src/parser.rs diff --git a/minidom/src/parser.rs b/minidom/src/parser.rs deleted file mode 100644 index 3f976677..00000000 --- a/minidom/src/parser.rs +++ /dev/null @@ -1,187 +0,0 @@ -// Copyright (c) 2020 Maxime “pep” Buquet -// Copyright (c) 2020 Emmanuel Gil Peyrot -// -// This Source Code Form is subject to the terms of the Mozilla Public -// License, v. 2.0. If a copy of the MPL was not distributed with this -// file, You can obtain one at http://mozilla.org/MPL/2.0/. - -//! Provides a `Parser` type, which takes bytes and returns Elements. It also keeps a hold of -//! ascendant elements to be able to handle namespaces properly. - -use crate::element::Element; -use crate::error::{Error, ParserError, Result}; -use crate::tree_builder::TreeBuilder; - -use rxml::{PushDriver, RawParser}; -use std::str; - -/// Parser -#[derive(Debug)] -pub struct Parser { - driver: PushDriver, - tree_builder: TreeBuilder, - state: ParserState, -} - -/// Describes the state of the parser. -/// -/// This parser will only accept one-level documents. The root element is kept for convenience, to -/// be able to pass namespaces down to children who are themselves children. -#[derive(Debug)] -pub enum ParserState { - /// Not enough data has been processed to find the first element. - Empty, - - /// The normal state. the root element has been identified and children are processed. - Root { - /// Root element. Kept for future reference - root: Element, - - /// Child element - child: Option, - - /// XXX: Weird flag to say if we've already sent what we could send or if there's more to - /// send. This Variant needs to be changed. - sent: bool, - }, - - /// Something was passed in the buffer that made the parser get into an error state. - Error, - - /// The root element has been closed. No feed-ing can happen past this point. - Closed, -} - -/// Result of polling the parser -#[derive(Debug)] -pub enum ParserResult { - /// Buffer is not empty but needs more data - Partial, - - /// An Element has been generated from the buffer. - Single(Element), -} - -/* -/// Split and parse it. -fn split_stream_stream_stream_features(string: String) -> (Element, Element) { - let mut stuff = string.splitn(2, '>'); - let stream_opening_str = stuff.next().unwrap().to_string() + "/>"; - let rest = stuff.next().unwrap().to_string(); - let stream_opening: Element = stream_opening_str.parse().unwrap(); - let rest: Element = rest.parse().unwrap(); - println!("opening: {}", String::from(&stream_opening)); - println!("features: {}", String::from(&rest)); - (stream_opening, rest) -} -*/ - -fn maybe_split_prolog(string: &str) -> &str { - if string.starts_with("'); - stuff.next(); - stuff.next().unwrap() - } else { - string - } -} - -impl Parser { - /// Creates a new Parser - pub fn new() -> Parser { - Parser { - driver: PushDriver::default(), - tree_builder: TreeBuilder::new(), - state: ParserState::Empty, - } - } - - /// Feed bytes to the parser. - pub fn feed(&mut self, bytes: BytesMut) -> Result<()> { - self.driver.feed(bytes); - bytes.clear(); - - let state = match self.state { - ParserState::Empty => { - // TODO: Try splitting xml prolog and stream header - let foo = self.buffer.borrow(); - let header = maybe_split_prolog(str::from_utf8(foo.as_ref())?); - println!("FOO: header: {:?}", header); - let mut reader = EventReader::from_str(header); - let root = Element::from_reader(&mut reader); - match root { - Ok(root) => { - println!("FOO: elem: {:?}", root); - ParserState::Root { - root, - child: None, - sent: false, - } - } - Err(e) => { - println!("FOO: err: {:?}", e); - ParserState::Empty - } - } - } - ParserState::Closed => return Err(Error::ParserError(ParserError::Closed)), - _ => ParserState::Empty, - }; - - self.state = state; - Ok(()) - } - - /// Returns Elements to the application. - pub fn poll(&mut self) -> Result> { - match &self.state { - ParserState::Empty if self.buffer.borrow().len() != 0 => { - Ok(Some(ParserResult::Partial)) - } - ParserState::Empty | ParserState::Closed | ParserState::Error => Ok(None), - ParserState::Root { - root, child: None, .. - } => Ok(Some(ParserResult::Single(root.clone()))), - ParserState::Root { - child: Some(child), .. - } => Ok(Some(ParserResult::Single(child.clone()))), - } - } - - /// Resets the parser - pub fn reset(&mut self) { - *self = Parser::new(); - } -} - -#[cfg(test)] -mod tests { - use super::*; - use bytes::{BufMut, BytesMut}; - - #[test] - fn test_prolog() { - let mut parser = Parser::new(); - let mut buf = BytesMut::new(); - buf.put(&b""[..]); - buf.put(&b""[..]); - match parser.feed(buf) { - Ok(_) => (), - _ => panic!(), - } - - let elem = Element::builder("stream:stream", "http://etherx.jabber.org/streams") - .prefix_ns(None, "jabber:client") - .attr("xml:lang", "en") - .attr("version", "1.0") - .attr("to", "foo.bar") - .build(); - - println!("BAR: elem: {:?}", elem); - - match parser.poll() { - Ok(Some(ParserResult::Single(e))) => assert_eq!(e, elem), - _ => panic!(), - } - } -}