chore: Apply fmt/tests

Author: vldm

Diff for: rstml-controll-flow/Cargo.toml

@@ -10,14 +10,11 @@ proc-macro2 = "1.0.47"
 quote = "1.0.21"
 syn = "2.0.15"
 syn_derive = "0.1"
-rstml = { version = "0.11.0", path = "../", features = [
-    "rawtext-stable-hack",
-] }
+rstml = { version = "0.11.0", path = "../", features = ["rawtext-stable-hack"] }
 proc-macro2-diagnostics = "0.10"
 derive-where = "1.2.5"
 
 [features]
-default = ["extendable"]
+default = []
 # If feature activated Node should be parsed through `ExtendableCustomNode::parse2_with_config`
 extendable = []
-

Diff for: src/config.rs

@@ -8,8 +8,8 @@ use crate::rawtext_stable_hack::MacroPattern;
 use crate::{
     atoms::{CloseTag, OpenTag},
     node::{CustomNode, NodeType},
+    Infallible,
 };
-use crate::Infallible;
 
 pub type TransformBlockFn = dyn Fn(ParseStream) -> Result<Option<TokenStream>>;
 pub type ElementWildcardFn = dyn Fn(&OpenTag, &CloseTag) -> bool;
@@ -251,12 +251,12 @@ impl<C> ParserConfig<C> {
     /// Example:
     ///
     /// Imagine one have macro, that used like this:
-    /// ```
+    /// ```no_compile
     /// html! {some_context, provided, [ can use groups, etc], {<div>}, [other context]};
     /// ```
     ///
-    /// One can set `macro_call_pattern` like this:
-    /// ```
+    /// Then one can set `macro_call_pattern` with following arguments:
+    /// ```no_compile
     /// config.macro_call_pattern(quote!(html! // macro name currently is not checked
     ///     {ident, ident, // can use real idents, or any other
     ///         [/* can ignore context of auxilary groups */],
@@ -265,6 +265,8 @@ impl<C> ParserConfig<C> {
     ///     }))
     /// ```
     ///
+    /// And rstml will do the rest for you.
+    ///
     /// Panics if no `%%` token was found.
     ///
     /// If macro_call_patern is set rstml will parse input two times in order to

Diff for: src/lib.rs

@@ -237,9 +237,8 @@ pub mod rawtext_stable_hack;
 pub mod visitor;
 pub use config::ParserConfig;
 pub use error::Error;
-pub use node::atoms;
+pub use node::{atoms, Infallible};
 use node::{CustomNode, Node};
-pub use node::Infallible;
 pub use parser::{recoverable, recoverable::ParsingResult, Parser};
 
 /// Parse the given [`proc-macro::TokenStream`] into a [`Node`] tree.

Diff for: src/node/mod.rs

@@ -22,7 +22,7 @@ pub use node_name::{NodeName, NodeNameFragment};
 pub use node_value::{InvalidBlock, NodeBlock};
 
 pub use self::raw_text::RawText;
-use crate::recoverable::{RecoverableContext, ParseRecoverable};
+use crate::recoverable::{ParseRecoverable, RecoverableContext};
 
 /// Node types.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -264,14 +264,13 @@ pub trait CustomNode: ParseRecoverable + ToTokens {
     /// Recieves a [`ParseStream::fork`].
     ///
     /// [`ParseStream::fork`]: syn::parse::ParseBuffer::fork
-    /// 
     fn peek_element(input: ParseStream) -> bool;
 }
 
 /// Newtype for `std::convert::Infallible` used to implement
 /// `ToTokens`` for `Infallible``.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct Infallible (convert::Infallible);
+pub struct Infallible(convert::Infallible);
 
 impl From<convert::Infallible> for Infallible {
     fn from(s: convert::Infallible) -> Self {
@@ -289,7 +288,7 @@ impl ParseRecoverable for Infallible {
     }
 }
 impl CustomNode for Infallible {
-    fn peek_element( _: ParseStream) -> bool {
+    fn peek_element(_: ParseStream) -> bool {
         false
     }
-}
+}

Diff for: src/parser/mod.rs

@@ -49,13 +49,10 @@ impl<C: CustomNode + std::fmt::Debug> Parser<C> {
         let parser = move |input: ParseStream| Ok(self.parse_syn_stream(input));
         let source = parser.parse2(v.into()).expect("No errors from parser");
 
-        #[cfg(not(feature = "rawtext-stable-hack"))]
-        {
-            return source;
-        }
-        // re-parse using proc_macro2::fallback, only if output without error
         #[cfg(feature = "rawtext-stable-hack")]
-        Self::reparse_raw_text(&self, parser, source)
+        // re-parse using proc_macro2::fallback, only if output without error
+        let source = Self::reparse_raw_text(&self, parser, source);
+        source
     }
     #[cfg(feature = "rawtext-stable-hack")]
     fn reparse_raw_text<Parser>(

Diff for: src/parser/recoverable.rs

@@ -180,11 +180,11 @@ impl RecoverableContext {
     /// [`proc_macro2_diagnostics::Diagnostic`]
     pub fn push_diagnostic(&mut self, diagnostic: impl Into<Diagnostic>) {
         let diag = diagnostic.into();
-        println!(
-            "Push diagnostic: {:?}, backtrace={}",
-            diag,
-            std::backtrace::Backtrace::capture()
-        );
+        // println!(
+        //     "Push diagnostic: {:?}, backtrace={}",
+        //     diag,
+        //     std::backtrace::Backtrace::capture()
+        // );
         self.diagnostics.push(diag);
     }
 }

Diff for: src/rawtext_stable_hack.rs

@@ -32,7 +32,10 @@ pub fn inject_raw_text_default<C: CustomNode>(source: &mut [Node<C>]) {
 
 // Inject raw text to every raw node, recovered using proc-macro2 second
 // parsing;
-pub fn inject_raw_text<C: CustomNode + std::fmt::Debug>(source: &mut [Node<C>], hacked: &[Node<C>]) {
+pub fn inject_raw_text<C: CustomNode + std::fmt::Debug>(
+    source: &mut [Node<C>],
+    hacked: &[Node<C>],
+) {
     assert_eq!(
         source.len(),
         hacked.len(),

Diff for: tests/custom_node.rs

@@ -2,7 +2,7 @@ use quote::{quote, TokenStreamExt};
 use rstml::{
     atoms::{self, OpenTag, OpenTagEnd},
     node::{CustomNode, Node, NodeElement},
-    recoverable::{Recoverable, ParseRecoverable},
+    recoverable::{ParseRecoverable, Recoverable},
     Parser, ParserConfig,
 };
 use syn::{parse_quote, Expr, Token};

Diff for: tests/test.rs

@@ -9,7 +9,7 @@ use rstml::{
         NodeName, NodeType,
     },
     parse2,
-    recoverable::{RecoverableContext, ParseRecoverable},
+    recoverable::{ParseRecoverable, RecoverableContext},
     Parser, ParserConfig,
 };
 use syn::{
@@ -166,7 +166,6 @@ struct TestCustomNode {
     data: TokenStream,
 }
 
-
 impl ToTokens for TestCustomNode {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.bracket.surround(tokens, |c| self.data.to_tokens(c))
@@ -191,7 +190,6 @@ impl CustomNode for TestCustomNode {
     fn peek_element(input: ParseStream) -> bool {
         input.peek(Bracket)
     }
-
 }
 
 macro_rules! test_unquoted {