wip: more cleanup, more tests

packages/autofmt/src/component.rs

@@ -1,78 +1,85 @@
-use crate::{util::*, write_ident};
+use crate::Buffer;
 use dioxus_rsx::*;
 use quote::ToTokens;
-use std::fmt::{self, Write};
+use std::fmt::{self, Result, Write};
 
-pub fn write_component(
-    component: &Component,
-    buf: &mut String,
-    indent: usize,
-    lines: &[&str],
-) -> Result<(), fmt::Error> {
-    let Component {
-        name,
-        body,
-        children,
-        manual_props,
-        prop_gen_args,
-    } = component;
-    let mut name = name.to_token_stream().to_string();
-    name.retain(|c| !c.is_whitespace());
-    write_tabs(buf, indent)?;
-    write!(buf, "{name}")?;
-    if let Some(generics) = prop_gen_args {
-        let mut written = generics.to_token_stream().to_string();
-        written.retain(|c| !c.is_whitespace());
-        write!(buf, "{}", written)?;
-    }
-    write!(buf, " {{")?;
-    if !body.is_empty() || !children.is_empty() {
-        writeln!(buf)?;
-    }
-    for field in body {
-        write_tabs(buf, indent + 1)?;
-        let name = &field.name;
-        match &field.content {
-            ContentField::ManExpr(exp) => {
-                let out = prettyplease::unparse_expr(exp);
-                writeln!(buf, "{}: {},", name, out)?;
-            }
-            ContentField::Formatted(s) => {
-                writeln!(buf, "{}: \"{}\",", name, s.value())?;
-            }
-            ContentField::OnHandlerRaw(exp) => {
-                let out = prettyplease::unparse_expr(exp);
-                let mut lines = out.split('\n').peekable();
-                let first = lines.next().unwrap();
-                write!(buf, "{}: {}", name, first)?;
-                for line in lines {
-                    writeln!(buf)?;
-                    write_tabs(buf, indent + 1)?;
-                    write!(buf, "{}", line)?;
+impl Buffer {
+    pub fn write_component(
+        &mut self,
+        Component {
+            name,
+            body,
+            children,
+            manual_props,
+            prop_gen_args,
+        }: &Component,
+        lines: &[&str],
+    ) -> Result {
+        let mut name = name.to_token_stream().to_string();
+        name.retain(|c| !c.is_whitespace());
+        self.tab()?;
+        write!(self.buf, "{name}")?;
+
+        if let Some(generics) = prop_gen_args {
+            let mut written = generics.to_token_stream().to_string();
+            written.retain(|c| !c.is_whitespace());
+            write!(self.buf, "{}", written)?;
+        }
+
+        write!(self.buf, " {{")?;
+
+        if !body.is_empty() || !children.is_empty() {
+            self.new_line()?;
+        }
+
+        for field in body {
+            self.indented_tab()?;
+            let name = &field.name;
+            match &field.content {
+                ContentField::ManExpr(exp) => {
+                    let out = prettyplease::unparse_expr(exp);
+                    writeln!(self.buf, "{}: {},", name, out)?;
+                }
+                ContentField::Formatted(s) => {
+                    writeln!(self.buf, "{}: \"{}\",", name, s.value())?;
+                }
+                ContentField::OnHandlerRaw(exp) => {
+                    let out = prettyplease::unparse_expr(exp);
+                    let mut lines = out.split('\n').peekable();
+                    let first = lines.next().unwrap();
+                    write!(self.buf, "{}: {}", name, first)?;
+                    for line in lines {
+                        self.new_line()?;
+                        self.indented_tab()?;
+                        write!(self.buf, "{}", line)?;
+                    }
+                    writeln!(self.buf, ",")?;
                 }
-                writeln!(buf, ",")?;
             }
         }
-    }
-    if let Some(exp) = manual_props {
-        write_tabs(buf, indent + 1)?;
-        let out = prettyplease::unparse_expr(exp);
-        let mut lines = out.split('\n').peekable();
-        let first = lines.next().unwrap();
-        write!(buf, "..{}", first)?;
-        for line in lines {
-            writeln!(buf)?;
-            write_tabs(buf, indent + 1)?;
-            write!(buf, "{}", line)?;
+
+        if let Some(exp) = manual_props {
+            self.indented_tab()?;
+            let out = prettyplease::unparse_expr(exp);
+            let mut lines = out.split('\n').peekable();
+            let first = lines.next().unwrap();
+            write!(self.buf, "..{}", first)?;
+            for line in lines {
+                self.new_line()?;
+                self.indented_tab()?;
+                write!(self.buf, "{}", line)?;
+            }
+            self.new_line()?;
         }
-        writeln!(buf)?;
+
+        for child in children {
+            self.write_indented_ident(lines, child)?;
+        }
+
+        if !body.is_empty() || !children.is_empty() {
+            self.tab()?;
+        }
+        writeln!(self.buf, "}}")?;
+        Ok(())
     }
-    for child in children {
-        write_ident(buf, lines, child, indent + 1)?;
-    }
-    if !body.is_empty() || !children.is_empty() {
-        write_tabs(buf, indent)?;
-    }
-    writeln!(buf, "}}")?;
-    Ok(())
 }