rusteerio 0.0.0-stage → 0.1.0

package/native/vendor/html5gum-0.8.4/src/error.rs

@@ -0,0 +1,96 @@
+macro_rules! impl_error {
+    ($(
+        $string:literal <=> $variant:ident,
+    )*) => {
+        /// All [parsing errors](https://html.spec.whatwg.org/#parse-errors) this tokenizer can emit.
+        #[derive(Debug, Eq, PartialEq, Clone, Copy)]
+        pub enum Error {
+            $(
+                #[doc = "This error corresponds to the `$literal` error found in the WHATWG spec."]
+                $variant
+            ),*
+        }
+        impl std::str::FromStr for Error {
+            type Err = ();
+
+            /// Parse a `kebap-case` error code as typically written in the WHATWG spec into an
+            /// enum variant.
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    $( $string => Ok(Self::$variant), )*
+                    _ => Err(())
+                }
+            }
+        }
+
+        impl Error {
+            /// Convert an enum variant back into the `kebap-case` error code as typically written
+            /// in the WHATWG spec.
+            #[must_use]
+            pub fn as_str(&self) -> &'static str {
+                match *self {
+                    $( Self::$variant => $string, )*
+                }
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Error {
+    /// Convert an enum variant back into the `kebap-case` error code as typically written
+    /// in the WHATWG spec.
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
+
+impl_error! {
+    "abrupt-closing-of-empty-comment" <=> AbruptClosingOfEmptyComment,
+    "abrupt-doctype-public-identifier" <=> AbruptDoctypePublicIdentifier,
+    "abrupt-doctype-system-identifier" <=> AbruptDoctypeSystemIdentifier,
+    "absence-of-digits-in-numeric-character-reference" <=> AbsenceOfDigitsInNumericCharacterReference,
+    "cdata-in-html-content" <=> CdataInHtmlContent,
+    "character-reference-outside-unicode-range" <=> CharacterReferenceOutsideUnicodeRange,
+    "control-character-reference" <=> ControlCharacterReference,
+    "end-tag-with-attributes" <=> EndTagWithAttributes,
+    "end-tag-with-trailing-solidus" <=> EndTagWithTrailingSolidus,
+    "eof-before-tag-name" <=> EofBeforeTagName,
+    "eof-in-cdata" <=> EofInCdata,
+    "eof-in-comment" <=> EofInComment,
+    "eof-in-doctype" <=> EofInDoctype,
+    "eof-in-script-html-comment-like-text" <=> EofInScriptHtmlCommentLikeText,
+    "eof-in-tag" <=> EofInTag,
+    "incorrectly-closed-comment" <=> IncorrectlyClosedComment,
+    "incorrectly-opened-comment" <=> IncorrectlyOpenedComment,
+    "invalid-character-sequence-after-doctype-name" <=> InvalidCharacterSequenceAfterDoctypeName,
+    "invalid-first-character-of-tag-name" <=> InvalidFirstCharacterOfTagName,
+    "missing-attribute-value" <=> MissingAttributeValue,
+    "missing-doctype-name" <=> MissingDoctypeName,
+    "missing-doctype-public-identifier" <=> MissingDoctypePublicIdentifier,
+    "missing-doctype-system-identifier" <=> MissingDoctypeSystemIdentifier,
+    "missing-end-tag-name" <=> MissingEndTagName,
+    "missing-quote-before-doctype-public-identifier" <=> MissingQuoteBeforeDoctypePublicIdentifier,
+    "missing-quote-before-doctype-system-identifier" <=> MissingQuoteBeforeDoctypeSystemIdentifier,
+    "missing-semicolon-after-character-reference" <=> MissingSemicolonAfterCharacterReference,
+    "missing-whitespace-after-doctype-public-keyword" <=> MissingWhitespaceAfterDoctypePublicKeyword,
+    "missing-whitespace-after-doctype-system-keyword" <=> MissingWhitespaceAfterDoctypeSystemKeyword,
+    "missing-whitespace-before-doctype-name" <=> MissingWhitespaceBeforeDoctypeName,
+    "missing-whitespace-between-attributes" <=> MissingWhitespaceBetweenAttributes,
+    "missing-whitespace-between-doctype-public-and-system-identifiers" <=> MissingWhitespaceBetweenDoctypePublicAndSystemIdentifiers,
+    "nested-comment" <=> NestedComment,
+    "noncharacter-character-reference" <=> NoncharacterCharacterReference,
+    "noncharacter-in-input-stream" <=> NoncharacterInInputStream,
+    "null-character-reference" <=> NullCharacterReference,
+    "surrogate-character-reference" <=> SurrogateCharacterReference,
+    "surrogate-in-input-stream" <=> SurrogateInInputStream,
+    "unexpected-character-after-doctype-system-identifier" <=> UnexpectedCharacterAfterDoctypeSystemIdentifier,
+    "unexpected-character-in-attribute-name" <=> UnexpectedCharacterInAttributeName,
+    "unexpected-character-in-unquoted-attribute-value" <=> UnexpectedCharacterInUnquotedAttributeValue,
+    "unexpected-equals-sign-before-attribute-name" <=> UnexpectedEqualsSignBeforeAttributeName,
+    "unexpected-null-character" <=> UnexpectedNullCharacter,
+    "unexpected-question-mark-instead-of-tag-name" <=> UnexpectedQuestionMarkInsteadOfTagName,
+    "unexpected-solidus-in-tag" <=> UnexpectedSolidusInTag,
+    "unknown-named-character-reference" <=> UnknownNamedCharacterReference,
+    "duplicate-attribute" <=> DuplicateAttribute,
+    "control-character-in-input-stream" <=> ControlCharacterInInputStream,
+}

package/native/vendor/html5gum-0.8.4/src/htmlstring.rs

@@ -0,0 +1,130 @@
+use std::borrow::{Borrow, BorrowMut};
+use std::fmt::{Debug, Formatter};
+use std::ops::{Deref, DerefMut};
+
+/// A wrapper around a bytestring.
+///
+/// This newtype only exists to provide a nicer `Debug` impl
+#[derive(Clone, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct HtmlString(pub Vec<u8>);
+
+impl Deref for HtmlString {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for HtmlString {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Debug for HtmlString {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "b\"")?;
+        for &byte in &self.0 {
+            for ch in std::ascii::escape_default(byte) {
+                write!(f, "{}", ch as char)?;
+            }
+        }
+
+        write!(f, "\"")
+    }
+}
+
+impl Borrow<[u8]> for HtmlString {
+    fn borrow(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl BorrowMut<[u8]> for HtmlString {
+    fn borrow_mut(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
+impl AsRef<[u8]> for HtmlString {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl<const N: usize> PartialEq<&[u8; N]> for HtmlString {
+    fn eq(&self, other: &&[u8; N]) -> bool {
+        self.0 == *other
+    }
+}
+
+impl<const N: usize> PartialEq<HtmlString> for &[u8; N] {
+    fn eq(&self, other: &HtmlString) -> bool {
+        other.0 == *self
+    }
+}
+
+impl PartialEq<&[u8]> for HtmlString {
+    fn eq(&self, other: &&[u8]) -> bool {
+        self.0 == *other
+    }
+}
+
+impl PartialEq<HtmlString> for &[u8] {
+    fn eq(&self, other: &HtmlString) -> bool {
+        *self == other.0
+    }
+}
+
+impl PartialEq<Vec<u8>> for HtmlString {
+    fn eq(&self, other: &Vec<u8>) -> bool {
+        self.0 == *other
+    }
+}
+
+impl PartialEq<HtmlString> for Vec<u8> {
+    fn eq(&self, other: &HtmlString) -> bool {
+        *self == other.0
+    }
+}
+
+#[test]
+fn test_eq_html_str_and_byte_literal() {
+    assert!(HtmlString(b"hello world".to_vec()) == b"hello world");
+}
+
+#[test]
+fn test_eq_byte_literal_and_html_str() {
+    assert!(b"hello world" == HtmlString(b"hello world".to_vec()));
+}
+
+#[test]
+fn test_eq_html_str_and_byte_slice() {
+    assert!(HtmlString(b"hello world".to_vec()) == b"hello world".as_slice());
+}
+
+#[test]
+fn test_eq_byte_slice_and_html_str() {
+    assert!(b"hello world".as_slice() == HtmlString(b"hello world".to_vec()));
+}
+
+#[test]
+fn test_borrowing() {
+    use crate::StartTag;
+    // demonstrate a usecase for Borrow/BorrowMut
+    let tag = StartTag::<()>::default();
+    assert!(!tag.attributes.contains_key(b"href".as_slice()));
+}
+
+impl From<Vec<u8>> for HtmlString {
+    fn from(vec: Vec<u8>) -> HtmlString {
+        HtmlString(vec)
+    }
+}
+
+impl From<HtmlString> for Vec<u8> {
+    fn from(other: HtmlString) -> Vec<u8> {
+        other.0
+    }
+}

package/native/vendor/html5gum-0.8.4/src/lib.rs

@@ -0,0 +1,66 @@
+#![warn(missing_docs)]
+// This is an HTML parser. HTML can be untrusted input from the internet.
+#![forbid(unsafe_code)]
+//
+// Relative links in the README.md don't work in rustdoc, so we have to override them.
+#![doc = concat!("[LICENSE]: ", blob_url_prefix!(), "LICENSE")]
+#![doc = concat!("[examples/tokenize_with_state_switches.rs]: ", blob_url_prefix!(), "examples/tokenize_with_state_switches.rs")]
+#![doc = concat!("[examples/custom_emitter.rs]: ", blob_url_prefix!(), "examples/custom_emitter.rs")]
+#![doc = concat!("[examples/callback_emitter.rs]: ", blob_url_prefix!(), "examples/callback_emitter.rs")]
+#![doc = concat!("[examples/scraper.rs]: ", blob_url_prefix!(), "examples/scraper.rs")]
+#![cfg_attr(doc, doc = include_str!("../README.md"))]
+//
+#![warn(clippy::all)]
+#![warn(
+    absolute_paths_not_starting_with_crate,
+    rustdoc::invalid_html_tags,
+    missing_copy_implementations,
+    missing_debug_implementations,
+    semicolon_in_expressions_from_macros,
+    unreachable_pub,
+    unused_extern_crates,
+    variant_size_differences
+)]
+#![allow(clippy::module_name_repetitions)]
+#![allow(clippy::missing_errors_doc)]
+
+macro_rules! blob_url_prefix {
+    () => {
+        concat!(
+            "https://github.com/untitaker/html5gum/blob/",
+            env!("CARGO_PKG_VERSION"),
+            "/"
+        )
+    };
+}
+
+// miraculously makes warnings disappear as blob_url_prefix is used in #![doc]
+use blob_url_prefix;
+
+mod arrayvec;
+mod char_validator;
+pub mod emitters;
+mod entities;
+mod error;
+mod htmlstring;
+mod machine;
+mod machine_helper;
+mod read_helper;
+mod reader;
+mod span;
+mod state;
+mod tokenizer;
+mod utils;
+
+#[cfg(debug_assertions)]
+#[doc(hidden)]
+pub mod testutils;
+
+pub use emitters::default::{DefaultEmitter, Doctype, EndTag, StartTag, Token};
+pub use emitters::{naive_next_state, Emitter, ForwardingEmitter};
+pub use error::Error;
+pub use htmlstring::HtmlString;
+pub use reader::{IoReader, Readable, Reader, StringReader};
+pub use span::{Span, SpanBound, Spanned};
+pub use state::State;
+pub use tokenizer::Tokenizer;