postcss-rs
diff --git a/‎Cargo.lock
Lines changed: 63 additions & 0 deletions b/‎Cargo.lock
Lines changed: 63 additions & 0 deletions
diff --git a/‎assets/simple.css
Lines changed: 9 additions & 0 deletions b/‎assets/simple.css
Lines changed: 9 additions & 0 deletions
diff --git a/‎assets/test.css
Lines changed: 0 additions & 4 deletions b/‎assets/test.css
Lines changed: 0 additions & 4 deletions
diff --git a/‎crates/recursive-parser/Cargo.toml
Lines changed: 3 additions & 1 deletion b/‎crates/recursive-parser/Cargo.toml
Lines changed: 3 additions & 1 deletion
diff --git a/‎crates/recursive-parser/src/ast_util.rs
Lines changed: 168 additions & 0 deletions b/‎crates/recursive-parser/src/ast_util.rs
Lines changed: 168 additions & 0 deletions
@@ -10,6 +10,7 @@ edition = "2021"
 # cssparser = "0.29.0"
 tokenizer = { path = "../tokenizer" }
 mimalloc-rust = "0.1"
+anyhow = "1.0.47"
 
 [profile.release]
 lto = true
@@ -18,7 +19,8 @@ panic = "abort"
 
 [dev-dependencies]
 criterion = "0.3.5"
+similar-asserts = "1.1.0"
 
 [[bench]]
 name = "parse"
-harness = false
+harness = false
@@ -0,0 +1,168 @@
+use anyhow::Result;
+use std::io::Write;
+
+use crate::{parser, visitor::Visit};
+#[derive(Default)]
+pub struct AstPrinter<W: Write> {
+  level: usize,
+  writer: W,
+}
+
+impl<W: Write> AstPrinter<W> {
+  pub fn new(level: usize, writer: W) -> Self {
+    Self { level, writer }
+  }
+
+  pub fn print<'a>(&mut self, root: &'a parser::Root<'a>) -> Result<()> {
+    self.visit_root(root)?;
+    Ok(())
+  }
+
+  pub fn result(self) -> W {
+    self.writer
+  }
+}
+
+impl<'a, W: Write> Visit<'a, Result<()>> for AstPrinter<W> {
+  fn visit_root(&mut self, root: &parser::Root) -> Result<()> {
+    writeln!(
+      self.writer,
+      "{}Root@{:?}",
+      " ".repeat(self.level * 2),
+      root.start..root.end
+    )?;
+    self.level += 1;
+    for child in &root.children {
+      match child {
+        parser::RuleOrAtRuleOrDecl::Rule(rule) => {
+          self.visit_rule(rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::AtRule(at_rule) => {
+          self.visit_at_rule(at_rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::Declaration(decl) => {
+          self.visit_declaration(decl)?;
+        }
+      }
+    }
+    self.level -= 1;
+    Ok(())
+  }
+
+  fn visit_rule(&mut self, rule: &parser::Rule) -> Result<()> {
+    writeln!(
+      self.writer,
+      "{}Rule@{:?}",
+      " ".repeat(self.level * 2),
+      rule.start..rule.end
+    )?;
+    self.level += 1;
+    writeln!(
+      self.writer,
+      "{}selector: `{}`",
+      " ".repeat(self.level * 2),
+      rule.selector.content,
+    )?;
+    for child in &rule.children {
+      match child {
+        parser::RuleOrAtRuleOrDecl::Rule(rule) => {
+          self.visit_rule(rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::AtRule(at_rule) => {
+          self.visit_at_rule(at_rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::Declaration(decl) => {
+          self.visit_declaration(decl)?;
+        }
+      }
+    }
+    self.level -= 1;
+    Ok(())
+  }
+
+  fn visit_at_rule(&mut self, at_rule: &parser::AtRule) -> Result<()> {
+    writeln!(
+      self.writer,
+      "{}AtRule@{:?}",
+      " ".repeat(self.level * 2),
+      at_rule.start..at_rule.end
+    )?;
+    self.level += 1;
+    writeln!(
+      self.writer,
+      "{}name: `{}`",
+      " ".repeat(self.level * 2),
+      at_rule.name,
+    )?;
+    writeln!(
+      self.writer,
+      "{}params: `{}`",
+      " ".repeat(self.level * 2),
+      at_rule.params,
+    )?;
+    for child in &at_rule.children {
+      match child {
+        parser::RuleOrAtRuleOrDecl::Rule(rule) => {
+          self.visit_rule(rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::AtRule(at_rule) => {
+          self.visit_at_rule(at_rule)?;
+        }
+        parser::RuleOrAtRuleOrDecl::Declaration(decl) => {
+          self.visit_declaration(decl)?;
+        }
+      }
+    }
+    self.level -= 1;
+    Ok(())
+  }
+
+  fn visit_declaration(&mut self, decl: &parser::Declaration) -> Result<()> {
+    writeln!(
+      self.writer,
+      "{}Declaration@{:?}",
+      " ".repeat(self.level * 2),
+      decl.start..decl.end
+    )?;
+    self.level += 1;
+    writeln!(
+      self.writer,
+      "{}prop: `{}`",
+      " ".repeat(self.level * 2),
+      decl.prop.content,
+    )?;
+    writeln!(
+      self.writer,
+      "{}value: `{}`",
+      " ".repeat(self.level * 2),
+      decl.value.content,
+    )?;
+    self.level -= 1;
+    Ok(())
+  }
+}
+
+#[derive(Debug, Default)]
+pub struct WrapString(pub String);
+impl WrapString {
+  pub fn inner_string(mut self) -> String {
+    self.0
+  }
+}
+
+impl From<String> for WrapString {
+  fn from(string: String) -> Self {
+    Self(string)
+  }
+}
+
+impl Write for WrapString {
+  fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+    self.0 += std::str::from_utf8(buf).unwrap();
+    Ok(buf.len())
+  }
+
+  fn flush(&mut self) -> std::io::Result<()> {
+    Ok(())
+  }
+}