wip: more polish on display

packages/core/src/nodes.rs

@@ -754,13 +754,12 @@ impl Debug for NodeFactory<'_> {
 impl Debug for VNode<'_> {
     fn fmt(&self, s: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         match &self {
-            VNode::Element(el) => {
+            VNode::Element(el) => s
-                //
+                .debug_struct("VElement")
-                s.debug_struct("VElement")
                 .field("name", &el.tag_name)
                 .field("key", &el.key)
-                    .finish()
+                .finish(),
-            }
+
             VNode::Text(t) => write!(s, "VText {{ text: {} }}", t.text),
             VNode::Anchor(_) => write!(s, "VAnchor"),
 

packages/core/src/vdomdisplay.rs

@@ -1,24 +1,18 @@
 use crate::innerlude::*;
 
+pub(crate) struct ScopeRenderer<'a> {
+    pub skip_components: bool,
+    pub show_fragments: bool,
+    pub _scope: &'a Scope,
+    pub _pre_render: bool,
+    pub _newline: bool,
+    pub _indent: bool,
+    pub _max_depth: usize,
+}
+
 // this is more or less a debug tool, but it'll render the entire tree to the terminal
-impl std::fmt::Display for VirtualDom {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        struct ScopeRenderer<'a> {
-            scope: &'a Scope,
-            cfg: Cfg,
-        }
-
-        struct Cfg {
-            pre_render: bool,
-            newline: bool,
-            indent: bool,
-            max_depth: usize,
-            skip_components: bool,
-            show_fragments: bool,
-        }
-
 impl<'a> ScopeRenderer<'a> {
-            fn html_render(
+    pub fn render(
         &self,
         vdom: &VirtualDom,
         node: &VNode,
@@ -76,32 +70,32 @@ impl std::fmt::Display for VirtualDom {
                 }
 
                 for child in el.children {
-                            self.html_render(vdom, child, f, il + 1)?;
+                    self.render(vdom, child, f, il + 1)?;
                 }
                 write_indent(f, il);
 
                 write!(f, "}}\n")?;
             }
             VNode::Fragment(frag) => {
-                        if self.cfg.show_fragments {
+                if self.show_fragments {
                     write_indent(f, il);
                     write!(f, "Fragment {{\n")?;
                     for child in frag.children {
-                                self.html_render(vdom, child, f, il + 1)?;
+                        self.render(vdom, child, f, il + 1)?;
                     }
                     write_indent(f, il);
                     write!(f, "}}\n")?;
                 } else {
                     for child in frag.children {
-                                self.html_render(vdom, child, f, il)?;
+                        self.render(vdom, child, f, il)?;
                     }
                 }
             }
             VNode::Component(vcomp) => {
                 let idx = vcomp.associated_scope.get().unwrap();
-                        if !self.cfg.skip_components {
+                if !self.skip_components {
                     let new_node = vdom.get_scope(idx).unwrap().root_node();
-                            self.html_render(vdom, new_node, f, il)?;
+                    self.render(vdom, new_node, f, il)?;
                 }
             }
             VNode::Suspended { .. } => {
@@ -111,21 +105,3 @@ impl std::fmt::Display for VirtualDom {
         Ok(())
     }
 }
-
-        let base = self.base_scope();
-        let root = base.root_node();
-        let renderer = ScopeRenderer {
-            scope: base,
-            cfg: Cfg {
-                show_fragments: false,
-                pre_render: false,
-                newline: true,
-                indent: true,
-                max_depth: usize::MAX,
-                skip_components: false,
-            },
-        };
-
-        renderer.html_render(self, root, f, 0)
-    }
-}

packages/core/src/virtual_dom.rs

@@ -356,3 +356,25 @@ impl VirtualDom {
         }
     }
 }
+
+impl std::fmt::Display for VirtualDom {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let base = self.base_scope();
+        let root = base.root_node();
+
+        use crate::vdomdisplay::ScopeRenderer;
+
+        let renderer = ScopeRenderer {
+            show_fragments: false,
+            skip_components: false,
+
+            _scope: base,
+            _pre_render: false,
+            _newline: true,
+            _indent: true,
+            _max_depth: usize::MAX,
+        };
+
+        renderer.render(self, root, f, 0)
+    }
+}