diff options
| -rw-r--r-- | .gitignore | 2 | ||||
| -rw-r--r-- | .gitmodules | 3 | ||||
| -rw-r--r-- | Cargo.toml | 20 | ||||
| -rw-r--r-- | LICENSE-APACHE | 202 | ||||
| -rw-r--r-- | LICENSE-MIT | 19 | ||||
| m--------- | OpenGL-Registry | 0 | ||||
| -rw-r--r-- | rustfmt.toml | 11 | ||||
| -rw-r--r-- | src/command.rs | 263 | ||||
| -rw-r--r-- | src/lib.rs | 158 | ||||
| -rw-r--r-- | src/xml/element.rs | 144 | ||||
| -rw-r--r-- | src/xml/mod.rs | 2 | ||||
| -rw-r--r-- | src/xml/parser.rs | 195 |
12 files changed, 1019 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fffb2f --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/target +/Cargo.lock diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..d53393c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "OpenGL-Registry"] + path = OpenGL-Registry + url = https://github.com/KhronosGroup/OpenGL-Registry diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..cf8a66e --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "opengl-registry" +version = "0.1.0" +license = "MIT OR Apache-2.0" +edition = "2021" + +[features] +default = ["include-xml"] +include-xml = [] + +[package.metadata.docs.rs] +all-features = true +rustdoc-args = ["--cfg", "doc_cfg"] + +[dependencies] +quick-xml = { version = "0.27.1" } +thiserror = "1.0.38" + +[dev-dependencies] +pretty_assertions = "1.3.0" diff --git a/LICENSE-APACHE b/LICENSE-APACHE new file mode 100644 index 0000000..14ef2d6 --- /dev/null +++ b/LICENSE-APACHE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2023 HampusM + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/LICENSE-MIT b/LICENSE-MIT new file mode 100644 index 0000000..170fea6 --- /dev/null +++ b/LICENSE-MIT @@ -0,0 +1,19 @@ +Copyright (c) 2023 HampusM + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/OpenGL-Registry b/OpenGL-Registry new file mode 160000 +Subproject 3549a2b860f9d88cdf20ac3ec263b3e0d76536b diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..4d1e29f --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,11 @@ +max_width = 90 +brace_style = "AlwaysNextLine" +group_imports = "StdExternalCrate" +wrap_comments = true +comment_width = 90 +format_code_in_doc_comments = true +imports_layout = "HorizontalVertical" +imports_granularity = "Module" +newline_style = "Unix" +reorder_impl_items = true + diff --git a/src/command.rs b/src/command.rs new file mode 100644 index 0000000..c7ada95 --- /dev/null +++ b/src/command.rs @@ -0,0 +1,263 @@ +//! OpenGL command. +use crate::xml::element::{Elements, FromElements}; + +/// A command. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Command +{ + prototype: Prototype, + parameters: Vec<Parameter>, +} + +impl Command +{ + /// Returns a new `Command`. + pub fn new( + prototype: Prototype, + parameters: impl IntoIterator<Item = Parameter>, + ) -> Self + { + Self { + prototype, + parameters: parameters.into_iter().collect(), + } + } + + /// Returns the command prototype. + #[must_use] + pub fn prototype(&self) -> &Prototype + { + &self.prototype + } + + /// Returns the command parameters. + #[must_use] + pub fn parameters(&self) -> &[Parameter] + { + &self.parameters + } +} + +impl FromElements for Command +{ + type Error = Error; + + fn from_elements( + elements: &crate::xml::element::Elements, + ) -> Result<Self, Self::Error> + { + let proto_element = elements + .get_first_tagged_element("proto") + .ok_or(Self::Error::MissingPrototype)?; + + let prototype = Prototype::from_elements(proto_element.child_elements())?; + + let parameters = elements + .get_all_tagged_elements_with_name("param") + .into_iter() + .map(|param_element| Parameter::from_elements(param_element.child_elements())) + .collect::<Result<Vec<_>, _>>()?; + + Ok(Self { + prototype, + parameters, + }) + } +} + +/// [`Command`] error. +#[derive(Debug, thiserror::Error)] +pub enum Error +{ + /// No 'proto' element was found. + #[error("No 'proto' element was found")] + MissingPrototype, + + /// Invalid prototype. + #[error("Invalid prototype")] + InvalidPrototype(#[from] PrototypeError), + + /// Invalid parameter. + #[error("Invalid parameter")] + InvalidParameter(#[from] ParameterError), +} + +/// A command prototype. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Prototype +{ + name: String, + return_type: String, +} + +impl Prototype +{ + /// Returns a new `Prototype`. + pub fn new(name: impl Into<String>, return_type: impl Into<String>) -> Self + { + Self { + name: name.into(), + return_type: return_type.into(), + } + } + + /// Returns the command prototype name. + #[must_use] + pub fn name(&self) -> &str + { + &self.name + } + + /// Returns the command prototype return type. + #[must_use] + pub fn return_type(&self) -> &str + { + &self.return_type + } +} + +impl FromElements for Prototype +{ + type Error = PrototypeError; + + fn from_elements( + elements: &crate::xml::element::Elements, + ) -> Result<Self, Self::Error> + { + let name = elements + .get_first_tagged_element("name") + .ok_or(Self::Error::MissingName)? + .child_elements() + .get_first_text_element() + .cloned() + .unwrap_or_default(); + + let return_type = find_type(elements); + + Ok(Self { name, return_type }) + } +} + +/// [`Prototype`] error. +#[derive(Debug, thiserror::Error)] +pub enum PrototypeError +{ + /// No 'name' element was found. + #[error("No 'name' element was found")] + MissingName, +} + +/// A command parameter. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Parameter +{ + name: String, + ty: String, +} + +impl Parameter +{ + /// Returns a new `Parameter`. + pub fn new(name: impl Into<String>, ty: impl Into<String>) -> Self + { + Self { + name: name.into(), + ty: ty.into(), + } + } + + /// Returns the name of the command parameter. + #[must_use] + pub fn name(&self) -> &str + { + &self.name + } + + /// Returns the type of the command parameter. + #[must_use] + pub fn get_type(&self) -> &str + { + &self.ty + } +} + +impl FromElements for Parameter +{ + type Error = ParameterError; + + fn from_elements(elements: &Elements) -> Result<Self, Self::Error> + { + let name = elements + .get_first_tagged_element("name") + .ok_or(Self::Error::MissingName)? + .child_elements() + .get_first_text_element() + .cloned() + .unwrap_or_default(); + + let ty = find_type(elements); + + Ok(Self { name, ty }) + } +} + +/// [`Parameter`] error. +#[derive(Debug, thiserror::Error)] +pub enum ParameterError +{ + /// No 'name' element was found. + #[error("No 'name' element was found")] + MissingName, +} + +fn find_type(elements: &Elements) -> String +{ + let text_type_parts = elements + .get_all_text_elements() + .into_iter() + .map(|text_type_part| text_type_part.trim()) + .filter(|text_type_part| !text_type_part.is_empty()) + .collect::<Vec<_>>(); + + let opt_ptype_text = get_ptype_text(elements); + + opt_ptype_text.map_or_else( + || join_space_strs(text_type_parts.iter()), + |ptype_text| { + let Some(first_part) = text_type_parts.first() else { + return ptype_text.clone(); + }; + + let before = if *first_part == "const" { "const " } else { "" }; + + let after_start_index = usize::from(*first_part == "const"); + + format!( + "{before}{ptype_text} {}", + text_type_parts + .get(after_start_index..) + .map(|parts| join_space_strs(parts.iter())) + .unwrap_or_default() + ) + }, + ) +} + +fn get_ptype_text(elements: &Elements) -> Option<&String> +{ + let ptype_element = elements.get_first_tagged_element("ptype")?; + + ptype_element.child_elements().get_first_text_element() +} + +fn join_space_strs<Strings, StrItem>(strings: Strings) -> String +where + Strings: Iterator<Item = StrItem>, + StrItem: ToString, +{ + strings + .into_iter() + .map(|string| string.to_string()) + .collect::<Vec<_>>() + .join(" ") +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..45f9fc9 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,158 @@ +//! Rust API for the [OpenGL API and Extension Registry]. +//! +//! [OpenGL API and Extension Registry]: https://github.com/KhronosGroup/OpenGL-Registry +#![cfg_attr(doc_cfg, feature(doc_cfg))] +#![deny(clippy::all, clippy::pedantic, missing_docs)] + +use std::fs::File; +use std::io::Read; + +use crate::command::{Command, Error as CommandError}; +use crate::xml::element::{Element, Elements, FromElements}; +use crate::xml::parser::{Error as ParserError, Parser}; + +pub mod command; + +mod xml; + +#[cfg(feature = "include-xml")] +const GL_REGISTRY_XML: &str = include_str!("../OpenGL-Registry/xml/gl.xml"); + +const REGISTRY_TAG_NAME: &str = "registry"; + +/// Representation of the OpenGL registry. +pub struct Registry +{ + commands: Vec<Command>, +} + +impl Registry +{ + /// Retrieves the OpenGL registry from a included XML file. + /// + /// # Errors + /// Returns `Err` if parsing fails in any way. + #[cfg(feature = "include-xml")] + #[cfg_attr(doc_cfg, doc(cfg(feature = "include-xml")))] + pub fn retrieve() -> Result<Registry, RegistryError> + { + Self::retrieve_from_bytes(GL_REGISTRY_XML.as_bytes()) + } + + /// Retrieves the OpenGL registry from XML bytes. + /// + /// # Errors + /// Returns `Err` if parsing fails in any way. + pub fn retrieve_from_bytes(xml_bytes: &[u8]) -> Result<Registry, RegistryError> + { + let mut parser = Parser::new(xml_bytes); + + let elements = parser.parse().map_err(ParsingError)?; + + let registry_element = elements + .get_first_tagged_element(REGISTRY_TAG_NAME) + .ok_or(RegistryError::MissingRegistryElement)?; + + let registry = Registry::from_elements(registry_element.child_elements())?; + + Ok(registry) + } + + /// Retrieves the OpenGL registry from a XML file. + /// + /// # Errors + /// Returns `Err` if: + /// - Parsing fails in any way. + /// - An I/O error occurs. + pub fn retrieve_from_file(xml_file: &mut File) -> Result<Registry, RegistryError> + { + let mut buf = Vec::new(); + + xml_file.read_to_end(&mut buf)?; + + Self::retrieve_from_bytes(&buf) + } + + /// Creates a new `Registry`. + /// + /// # Note + /// This will **NOT** use anything from the actual OpenGL registry. Use the + /// [`Registry::retrieve`] method for that. + pub fn new(commands: impl IntoIterator<Item = Command>) -> Self + { + Self { + commands: commands.into_iter().collect(), + } + } + + /// Returns the available commands. + #[must_use] + pub fn commands(&self) -> &[Command] + { + &self.commands + } +} + +impl FromElements for Registry +{ + type Error = RegistryError; + + fn from_elements(elements: &Elements) -> Result<Self, Self::Error> + { + let commands_element = elements + .get_first_tagged_element("commands") + .ok_or(Self::Error::MissingCommandsElement)?; + + let command_elements = + commands_element + .child_elements() + .into_iter() + .filter_map(|element| match element { + Element::Tagged(tagged_element) + if tagged_element.name() == "command" => + { + Some(tagged_element) + } + _ => None, + }); + + let commands = command_elements + .into_iter() + .map(|command_element| { + Command::from_elements(command_element.child_elements()) + }) + .collect::<Result<Vec<_>, _>>()?; + + Ok(Self { commands }) + } +} + +/// [`Registry`] error. +#[derive(Debug, thiserror::Error)] +pub enum RegistryError +{ + /// No 'registry' element was found. + #[error("No 'registry' element was found")] + MissingRegistryElement, + + /// No 'commands' element was found. + #[error("No 'commands' element was found")] + MissingCommandsElement, + + /// A command is invalid. + #[error("Invalid command")] + InvalidCommand(#[from] CommandError), + + /// Parsing failed. + #[error("Parsing failed")] + ParsingFailed(#[from] ParsingError), + + /// I/O failed. + #[error("I/O failed")] + IOFailed(#[from] std::io::Error), +} + +/// Parsing error. +#[derive(Debug, thiserror::Error)] +#[error(transparent)] +pub struct ParsingError(#[from] ParserError); diff --git a/src/xml/element.rs b/src/xml/element.rs new file mode 100644 index 0000000..f469480 --- /dev/null +++ b/src/xml/element.rs @@ -0,0 +1,144 @@ +#[derive(Debug, PartialEq, Eq)] +pub struct Elements +{ + elements: Vec<Element>, +} + +impl Elements +{ + pub fn get_first_tagged_element(&self, tag_name: &str) -> Option<&Tagged> + { + self.elements.iter().find_map(|element| match element { + Element::Tagged(tagged_element) if tagged_element.name == tag_name => { + Some(tagged_element) + } + _ => None, + }) + } + + pub fn get_all_tagged_elements_with_name(&self, tag_name: &str) -> Vec<&Tagged> + { + self.elements + .iter() + .filter_map(|element| match element { + Element::Tagged(tagged_element) if tagged_element.name == tag_name => { + Some(tagged_element) + } + _ => None, + }) + .collect() + } + + pub fn get_first_text_element(&self) -> Option<&String> + { + self.elements.iter().find_map(|element| match element { + Element::Text(text) => Some(text), + _ => None, + }) + } + + pub fn get_all_text_elements(&self) -> Vec<&String> + { + self.elements + .iter() + .filter_map(|element| match element { + Element::Text(text) => Some(text), + _ => None, + }) + .collect() + } + + pub fn has_tagged_element(&self, tag_name: &str) -> bool + { + self.elements.iter().any(|element| { + matches!( + element, + Element::Tagged(tagged_element) if tagged_element.name == tag_name + ) + }) + } +} + +impl<IntoIter: IntoIterator<Item = Element>> From<IntoIter> for Elements +{ + fn from(into_iter: IntoIter) -> Self + { + Self { + elements: into_iter.into_iter().collect(), + } + } +} + +impl<'elements> IntoIterator for &'elements Elements +{ + type IntoIter = Iter<'elements>; + type Item = &'elements Element; + + fn into_iter(self) -> Self::IntoIter + { + Self::IntoIter { + elements: self.elements.iter(), + } + } +} + +pub struct Iter<'elements> +{ + elements: std::slice::Iter<'elements, Element>, +} + +impl<'elements> Iterator for Iter<'elements> +{ + type Item = &'elements Element; + + fn next(&mut self) -> Option<Self::Item> + { + self.elements.next() + } +} + +#[derive(Debug, PartialEq, Eq)] +pub enum Element +{ + Tagged(Tagged), + Text(String), + Comment(String), +} + +#[derive(Debug, PartialEq, Eq)] +pub struct Tagged +{ + name: String, + child_elements: Elements, +} + +impl Tagged +{ + pub fn new<Name, ChildElements>(name: &Name, child_elements: ChildElements) -> Self + where + Name: ToString, + ChildElements: Into<Elements>, + { + Self { + name: name.to_string(), + child_elements: child_elements.into(), + } + } + + pub fn name(&self) -> &str + { + &self.name + } + + pub fn child_elements(&self) -> &Elements + { + &self.child_elements + } +} + +pub trait FromElements: Sized +{ + type Error; + + fn from_elements(elements: &Elements) -> Result<Self, Self::Error>; +} diff --git a/src/xml/mod.rs b/src/xml/mod.rs new file mode 100644 index 0000000..12368c3 --- /dev/null +++ b/src/xml/mod.rs @@ -0,0 +1,2 @@ +pub mod element; +pub mod parser; diff --git a/src/xml/parser.rs b/src/xml/parser.rs new file mode 100644 index 0000000..d152a6e --- /dev/null +++ b/src/xml/parser.rs @@ -0,0 +1,195 @@ +use std::io::BufRead; + +use quick_xml::events::{BytesStart, BytesText, Event}; +use quick_xml::Reader; + +use crate::xml::element::{Element, Elements, Tagged}; + +/// XML parser. +pub struct Parser<Source> +{ + reader: Reader<Source>, +} + +impl<Source: BufRead> Parser<Source> +{ + pub fn new(src: Source) -> Self + { + Self { + reader: Reader::from_reader(src), + } + } + + pub fn parse(&mut self) -> Result<Elements, Error> + { + let mut buf = Vec::new(); + + let mut elements = Vec::new(); + + loop { + let event = self.reader.read_event_into(&mut buf)?; + + let element = match self.handle_event(event)? { + EventHandlingResult::Element(element) => element, + EventHandlingResult::Event(_) => { + continue; + } + EventHandlingResult::End => { + break; + } + }; + + elements.push(element); + } + + Ok(elements.into()) + } + + fn parse_text(text: &BytesText) -> Result<String, Error> + { + String::from_utf8(text.to_vec()).map_err(|_| Error::TextNotUTF8) + } + + fn parse_tagged(&mut self, start: &BytesStart) -> Result<Element, Error> + { + let mut child_elements = Vec::new(); + + let mut buf = Vec::new(); + + loop { + let event = self.reader.read_event_into(&mut buf)?; + + match event { + Event::End(end) if end.name() == start.name() => { + break; + } + event => match self.handle_event(event)? { + EventHandlingResult::Element(element) => { + child_elements.push(element); + } + EventHandlingResult::End => { + return Err(Error::UnexpectedEndOfFile); + } + EventHandlingResult::Event(_) => {} + }, + } + } + + Ok(Element::Tagged(Tagged::new( + &String::from_utf8(start.name().as_ref().to_vec()) + .map_err(|_| Error::TagNameNotUTF8)?, + child_elements, + ))) + } + + fn handle_event<'a>( + &'a mut self, + event: Event<'a>, + ) -> Result<EventHandlingResult, Error> + { + match event { + Event::Text(text) => Ok(EventHandlingResult::Element(Element::Text( + Self::parse_text(&text)?, + ))), + Event::Start(start) => { + Ok(EventHandlingResult::Element(self.parse_tagged(&start)?)) + } + Event::End(_) => Err(Error::UnexpectedTagEnd), + Event::Eof => Ok(EventHandlingResult::End), + Event::Comment(comment_text) => Ok(EventHandlingResult::Element( + Element::Comment(Self::parse_text(&comment_text)?), + )), + event => Ok(EventHandlingResult::Event(event)), + } + } +} + +#[derive(Debug, thiserror::Error)] +pub enum Error +{ + #[error(transparent)] + QuickXMLFailed(#[from] quick_xml::Error), + + #[error("Text is not UTF-8")] + TextNotUTF8, + + #[error("Tag name is not UTF-8")] + TagNameNotUTF8, + + #[error("Unexpectedly found the end of a tag")] + UnexpectedTagEnd, + + #[error("Unexpected end of file")] + UnexpectedEndOfFile, +} + +enum EventHandlingResult<'event> +{ + Element(Element), + Event(Event<'event>), + End, +} + +#[cfg(test)] +mod tests +{ + use pretty_assertions::assert_eq; + + use super::*; + + #[test] + fn can_parse() + { + let mut parser = Parser::new("<foo>Hello there</foo>".as_bytes()); + + assert_eq!( + parser.parse().expect("Expected Ok"), + Elements::from(vec![Element::Tagged(Tagged::new( + &"foo", + vec![Element::Text("Hello there".to_string())] + ))]) + ); + + let mut parser = Parser::new("<foo><bar>123</bar> Hello</foo>".as_bytes()); + + assert_eq!( + parser.parse().expect("Expected Ok"), + Elements::from(vec![Element::Tagged(Tagged::new( + &"foo", + vec![ + Element::Tagged(Tagged::new( + &"bar", + Elements::from(vec![Element::Text("123".to_string())]) + )), + Element::Text(" Hello".to_string()) + ] + ))]) + ); + + let mut parser = Parser::new("".as_bytes()); + + assert_eq!( + parser.parse().expect("Expected Ok"), + Elements::from(Vec::new()) + ); + + let mut parser = Parser::new( + "<foo><!--XML is awful-->Hello there<bar>123</bar></foo>".as_bytes(), + ); + + assert_eq!( + parser.parse().expect("Expected Ok"), + Elements::from(vec![Element::Tagged(Tagged::new( + &"foo", + vec![ + Element::Comment("XML is awful".to_string()), + Element::Text("Hello there".to_string()), + Element::Tagged(Tagged::new( + &"bar", + vec![Element::Text("123".to_string())] + )), + ] + ))]) + ); + } +} |