disable serde and debug by default

serde and debug is not helpful except for tests

Author: alexkazik

Cargo.toml

@@ -14,14 +14,15 @@ readme = "README.md"
 pest = "2.5.7"
 pest_derive = "2.5.7"
 thiserror = "1.0.40"
-serde = { version = "1.0.159", features = ["derive"] }
-serde_json = "1.0.95"
+serde = { version = "1.0.159", features = ["derive"], optional = true }
+serde_json = { version = "1.0.95", optional = true }
 html-escape = "0.2"
 ownable = "1.0.0"
 
 [features]
 default = ["source-span"]
 source-span = []
+test = ["dep:serde", "dep:serde_json"]
 
 [dev-dependencies]
 indoc = "2.0.1"

examples/simple_parser/main.rs

@@ -1,61 +1,74 @@
-use clap::Parser;
-use html_parser::{Dom, Result};
-use std::{
-    fs::File,
-    io::{self, Read},
-    path::PathBuf,
-};
-
-#[derive(Debug, Parser)]
-/// A simple and general purpose html/xhtml parser.
-struct Opt {
-    #[arg(short, long)]
-    /// Pretty-print the output.
-    pretty_print: bool,
-
-    #[arg(short, long)]
-    /// Debug the parser, this will print errors to the console.
-    debug: bool,
-
-    /// Path to the file, or stdin (piped content).
-    ///
-    /// This argument can either be a path to the html-file that you would like to parse or the
-    /// result of stdin. Note: Content over stdin needs to be finite, for now, as it is collected
-    /// into a string and then processed by the parser.
-    input: Option<PathBuf>,
+fn main() -> html_parser::Result<()> {
+    #[cfg(feature = "test")]
+    {
+        real::main()
+    }
+
+    #[cfg(not(feature = "test"))]
+    panic!("this example requires the `test` feature to be enabled");
 }
 
-fn main() -> Result<()> {
-    let opt = Opt::parse();
+#[cfg(feature = "test")]
+mod real {
+    use clap::Parser;
+    use html_parser::{Dom, Result};
+    use std::{
+        fs::File,
+        io::{self, Read},
+        path::PathBuf,
+    };
 
-    let mut content = String::with_capacity(100_000);
+    #[derive(Debug, Parser)]
+    /// A simple and general purpose html/xhtml parser.
+    struct Opt {
+        #[arg(short, long)]
+        /// Pretty-print the output.
+        pretty_print: bool,
 
-    // If input is provided then use that as a path
-    if let Some(path) = opt.input {
-        let mut file = File::open(path)?;
-        file.read_to_string(&mut content)?;
+        #[arg(short, long)]
+        /// Debug the parser, this will print errors to the console.
+        debug: bool,
 
-    // Else read from stdin, this enables piping
-    // ex: `cat index.html | html_parser`
-    } else {
-        let stdin = io::stdin();
-        let mut handle = stdin.lock();
-        handle.read_to_string(&mut content)?;
-    };
+        /// Path to the file, or stdin (piped content).
+        ///
+        /// This argument can either be a path to the html-file that you would like to parse or the
+        /// result of stdin. Note: Content over stdin needs to be finite, for now, as it is collected
+        /// into a string and then processed by the parser.
+        input: Option<PathBuf>,
+    }
+
+    pub(super) fn main() -> Result<()> {
+        let opt = Opt::parse();
+
+        let mut content = String::with_capacity(100_000);
 
-    let dom = Dom::parse(&content)?;
+        // If input is provided then use that as a path
+        if let Some(path) = opt.input {
+            let mut file = File::open(path)?;
+            file.read_to_string(&mut content)?;
 
-    if opt.debug {
-        for error in &dom.errors {
-            println!("# {}", error);
+        // Else read from stdin, this enables piping
+        // ex: `cat index.html | html_parser`
+        } else {
+            let stdin = io::stdin();
+            let mut handle = stdin.lock();
+            handle.read_to_string(&mut content)?;
+        };
+
+        let dom = Dom::parse(&content)?;
+
+        if opt.debug {
+            for error in &dom.errors {
+                println!("# {}", error);
+            }
         }
-    }
 
-    if opt.pretty_print {
-        println!("{}", dom.to_json_pretty()?);
-    } else {
-        println!("{}", dom.to_json()?);
-    }
+        if opt.pretty_print {
+            println!("{}", dom.to_json_pretty()?);
+        } else {
+            println!("{}", dom.to_json()?);
+        }
 
-    Ok(())
+        Ok(())
+    }
 }

src/dom/element.rs

@@ -6,13 +6,15 @@ use crate::dom::vecmap::VecMap;
 use crate::{Attribute, Text, VecSet};
 use html_escape::decode_html_entities;
 use ownable::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::Serialize;
 use std::borrow::Cow;
 use std::default::Default;
 
 /// Normal: `<div></div>` or Void: `<meta/>`and `<meta>`
-#[derive(Debug, Clone, Serialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
+#[derive(Clone, PartialEq)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(rename_all = "camelCase"))]
 // TODO: Align with: https://html.spec.whatwg.org/multipage/syntax.html#elements-2
 pub enum ElementVariant {
     /// A normal element can have children, ex: <div></div>.
@@ -24,11 +26,12 @@ pub enum ElementVariant {
 pub type Attributes<'a> = VecMap<Cow<'a, str>, Option<Attribute<'a>>>;
 
 /// Most of the parsed html nodes are elements, except for text
-#[derive(Debug, Serialize, PartialEq, IntoOwned, ToBorrowed, ToOwned)]
-#[serde(rename_all = "camelCase")]
+#[derive(PartialEq, IntoOwned, ToBorrowed, ToOwned)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(rename_all = "camelCase"))]
 pub struct Element<'a> {
     /// The id of the element
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "test", serde(skip_serializing_if = "Option::is_none"))]
     pub id: Option<Attribute<'a>>,
 
     /// The name / tag of the element
@@ -39,20 +42,20 @@ pub struct Element<'a> {
     pub variant: ElementVariant,
 
     /// All of the elements attributes, except id and class
-    #[serde(skip_serializing_if = "VecMap::is_empty")]
+    #[cfg_attr(feature = "test", serde(skip_serializing_if = "VecMap::is_empty"))]
     pub attributes: Attributes<'a>,
 
     /// All of the elements classes
-    #[serde(skip_serializing_if = "VecSet::is_empty")]
+    #[cfg_attr(feature = "test", serde(skip_serializing_if = "VecSet::is_empty"))]
     pub classes: VecSet<Attribute<'a>>,
 
     /// All of the elements child nodes
-    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[cfg_attr(feature = "test", serde(skip_serializing_if = "Vec::is_empty"))]
     pub children: Vec<Node<'a>>,
 
     #[cfg(feature = "source-span")]
     /// Span of the element in the parsed source
-    #[serde(skip)]
+    #[cfg_attr(feature = "test", serde(skip))]
     pub source_span: SourceSpan<'a>,
 }
 

src/dom/html.rs

@@ -1,12 +1,14 @@
 use html_escape::{decode_html_entities, encode_text};
 use ownable::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::Serialize;
 use std::borrow::{Borrow, Cow};
 use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
 
-#[derive(Default, Debug, Serialize, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
-#[serde(transparent)]
+#[derive(Default, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(transparent))]
 pub struct Attribute<'a>(pub Cow<'a, str>);
 
 impl<'a> Attribute<'a> {
@@ -53,8 +55,9 @@ impl Borrow<str> for Attribute<'_> {
     }
 }
 
-#[derive(Default, Serialize, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
-#[serde(transparent)]
+#[derive(Default, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
+#[cfg_attr(feature = "test", derive(Serialize))]
+#[cfg_attr(feature = "test", serde(transparent))]
 pub struct Text<'a>(pub Cow<'a, str>);
 
 impl<'a> Text<'a> {

src/dom/mod.rs

@@ -1,5 +1,6 @@
 use ownable::{IntoOwned, ToBorrowed, ToOwned};
 use pest::{Parser, iterators::Pair, iterators::Pairs};
+#[cfg(feature = "test")]
 use serde::Serialize;
 use std::borrow::Cow;
 use std::default::Default;
@@ -27,8 +28,9 @@ use element::{Element, ElementVariant};
 use node::Node;
 
 /// Document, DocumentFragment or Empty
-#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
+#[derive(Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(rename_all = "camelCase"))]
 pub enum DomVariant {
     /// This means that the parsed html had the representation of an html document. The doctype is optional but a document should only have one root node with the name of html.
     /// Example:
@@ -53,19 +55,20 @@ pub enum DomVariant {
 }
 
 /// **The main struct** & the result of the parsed html
-#[derive(Debug, Serialize, PartialEq, ToBorrowed, ToOwned, IntoOwned)]
-#[serde(rename_all = "camelCase")]
+#[derive(PartialEq, ToBorrowed, ToOwned, IntoOwned)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(rename_all = "camelCase"))]
 pub struct Dom<'a> {
     /// The type of the tree that was parsed
     #[ownable(clone)]
     pub tree_type: DomVariant,
 
     /// All of the root children in the tree
-    #[serde(skip_serializing_if = "Vec::is_empty")]
+    #[cfg_attr(feature = "test", serde(skip_serializing_if = "Vec::is_empty"))]
     pub children: Vec<Node<'a>>,
 
     /// A collection of all errors during parsing
-    #[serde(skip_serializing)]
+    #[cfg_attr(feature = "test", serde(skip_serializing))]
     #[ownable(clone)]
     pub errors: Vec<String>,
 }
@@ -89,10 +92,12 @@ impl<'a> Dom<'a> {
         Self::build_dom(pairs)
     }
 
+    #[cfg(feature = "test")]
     pub fn to_json(&self) -> Result<String> {
         Ok(serde_json::to_string(self)?)
     }
 
+    #[cfg(feature = "test")]
     pub fn to_json_pretty(&self) -> Result<String> {
         Ok(serde_json::to_string_pretty(self)?)
     }
@@ -178,7 +183,10 @@ impl<'a> Dom<'a> {
                     } else {
                         // Anything else (i.e. Text() or Element() ) can't happen at the top level;
                         // if we had seen one, we would have set the document type above
-                        unreachable!("[build dom] empty document with an Element {:?}", node)
+                        unreachable!(
+                            "[build dom] empty document with an Element {:?}",
+                            node.to_html()
+                        )
                     }
                 }
             }

src/dom/node.rs

@@ -3,12 +3,14 @@ use crate::Text;
 use crate::dom::for_each::ForEach;
 use html_escape::decode_html_entities;
 use ownable::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::Serialize;
 use std::array;
 use std::borrow::Cow;
 
-#[derive(Debug, Serialize, PartialEq, IntoOwned, ToBorrowed, ToOwned)]
-#[serde(untagged)]
+#[derive(PartialEq, IntoOwned, ToBorrowed, ToOwned)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(untagged))]
 pub enum Node<'a> {
     Text(Text<'a>),
     Element(Element<'a>),
@@ -188,6 +190,7 @@ impl<'a> Iterator for NodeIntoIterator<'a> {
     }
 }
 
+#[cfg(feature = "test")]
 #[cfg(test)]
 mod tests {
     use super::*;

src/dom/span.rs

@@ -1,10 +1,12 @@
 use ownable::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::Serialize;
 use std::borrow::Cow;
 
 /// Span of the information in the parsed source.
-#[derive(Debug, Default, Clone, Serialize, PartialEq, IntoOwned, ToBorrowed, ToOwned)]
-#[serde(rename_all = "camelCase")]
+#[derive(Default, Clone, PartialEq, IntoOwned, ToBorrowed, ToOwned)]
+#[cfg_attr(feature = "test", derive(Debug, Serialize))]
+#[cfg_attr(feature = "test", serde(rename_all = "camelCase"))]
 pub struct SourceSpan<'a> {
     pub text: Cow<'a, str>,
     pub start_line: usize,

src/dom/vecmap.rs

@@ -1,4 +1,5 @@
 use ownable::traits::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::{Serialize, Serializer};
 use std::borrow::Borrow;
 use std::fmt::{Debug, Formatter};
@@ -166,6 +167,7 @@ where
     }
 }
 
+#[cfg(feature = "test")]
 impl<K, V> Serialize for VecMap<K, V>
 where
     K: Serialize,

src/dom/vecset.rs

@@ -1,5 +1,6 @@
 use crate::VecMap;
 use ownable::traits::{IntoOwned, ToBorrowed, ToOwned};
+#[cfg(feature = "test")]
 use serde::{Serialize, Serializer};
 use std::borrow::Borrow;
 use std::fmt::{Debug, Formatter};
@@ -109,6 +110,7 @@ impl<K: IntoOwned> IntoOwned for VecSet<K> {
     }
 }
 
+#[cfg(feature = "test")]
 impl<K> Serialize for VecSet<K>
 where
     K: Serialize,

src/error.rs

@@ -8,6 +8,7 @@ pub enum Error {
     Cli(String),
     #[error("{0}")]
     IO(#[from] std::io::Error),
+    #[cfg(feature = "test")]
     #[error("{0}")]
     Serde(#[from] serde_json::Error),
 }