feat: #175 update cli to use updated parsing

Author: noahbald

Cargo.lock

@@ -7,12 +7,16 @@ missing_docs = { level = "warn" }
 
 [workspace.lints.clippy]
 pedantic = { level = "warn", priority = -1 }
-# Too noisy and not really an issue
-must_use_candidate = "allow"
-return_self_not_must_use = "allow"
+# Willing to accept lossy conversions
+cast_lossless = "allow"
+# Willing to accept lossy conversions
+cast_possible_truncation = "allow"
+# dbg should only be used for debugging
+dbg_macro = "warn"
 # Not a priority for svgo parity
 float_cmp = "allow"
-dbg_macro = "warn"
+# Too noisy and not really an issue
+must_use_candidate = "allow"
 
 [workspace.package]
 authors = ["Noah <[email protected]>"]

Cargo.toml

@@ -32,6 +32,7 @@ clap = { workspace = true }
 etcetera = "0.10"
 ignore = "0.4"
 log = { workspace = true }
+roxmltree = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 typed-arena = { workspace = true }

crates/oxvg/Cargo.toml

@@ -8,10 +8,9 @@ use std::{
 use anyhow::anyhow;
 use ignore::{WalkBuilder, WalkState};
 use oxvg_ast::{
-    implementations::{
-        roxmltree::{parse, parse_file},
-        shared::{Arena, Element, Ref},
-    },
+    arena::Allocator,
+    node::Ref,
+    parse::roxmltree::parse,
     serialize::{Indent, Node as _, Options},
     visitor::Info,
 };
@@ -64,7 +63,7 @@ impl RunCommand for Optimise {
 }
 
 impl Optimise {
-    fn handle_out<W: Write>(dom: Ref<'_>, wr: W) -> anyhow::Result<W> {
+    fn handle_out<W: Write>(dom: Ref, wr: W) -> anyhow::Result<W> {
         Ok(dom.serialize_into(
             wr,
             Options {
@@ -74,17 +73,22 @@ impl Optimise {
         )?)
     }
 
-    fn handle_stdin<'arena>(&self, jobs: &Jobs, arena: Arena<'arena>) -> anyhow::Result<()> {
+    fn handle_stdin(&self, jobs: &Jobs) -> anyhow::Result<()> {
         let mut source = String::new();
         std::io::stdin().read_to_string(&mut source)?;
-        let dom = parse(&source, arena)?;
+        let xml = roxmltree::Document::parse(&source).unwrap();
+        let values = Allocator::new_values();
+        let mut arena = Allocator::new_arena();
+        let mut allocator = Allocator::new(&mut arena, &values);
+        let dom = parse(&xml, &mut allocator)?;
 
-        let info: Info<'arena, Element<'arena>> = Info {
+        let info = Info {
             path: None,
             multipass_count: 0,
-            arena,
+            allocator,
         };
-        jobs.run(&dom, &info)?;
+        jobs.run(dom, &info)
+            .map_err(|e| anyhow::Error::msg(e.to_string()))?;
 
         if let Some(output) = &self.output.as_ref().and_then(|o| {
             eprintln!("Warning: Using empty `-o,--output` with stdin will print to stdout, you can instead omit `-o,--output`.");
@@ -106,23 +110,22 @@ impl Optimise {
         Ok(())
     }
 
-    fn handle_file<'arena>(
-        jobs: &Jobs,
-        path: &PathBuf,
-        output: Option<&PathBuf>,
-        arena: Arena<'arena>,
-    ) -> anyhow::Result<()> {
-        let file = std::fs::File::open(path)?;
-        let input_size = file.metadata()?.len() as f64 / 1000.0;
-        let dom = parse_file(path, arena)?;
-        drop(file);
-
-        let info: Info<'arena, Element<'arena>> = Info {
+    fn handle_file(jobs: &Jobs, path: &PathBuf, output: Option<&PathBuf>) -> anyhow::Result<()> {
+        let file = std::fs::read_to_string(path)?;
+        let input_size = file.len() as f64 / 1000.0;
+        let xml = roxmltree::Document::parse(&file).unwrap();
+        let values = Allocator::new_values();
+        let mut arena = Allocator::new_arena();
+        let mut allocator = Allocator::new(&mut arena, &values);
+        let dom = parse(&xml, &mut allocator).unwrap();
+
+        let info: Info = Info {
             path: Some(path.clone()),
             multipass_count: 0,
-            arena,
+            allocator,
         };
-        jobs.run(&dom, &info)?;
+        jobs.run(dom, &info)
+            .map_err(|e| anyhow::Error::msg(e.to_string()))?;
 
         if let Some(output_path) = output {
             if let Some(parent) = output_path.parent() {
@@ -165,7 +168,6 @@ impl Optimise {
             .build_parallel()
             .run(|| {
                 Box::new(move |path| {
-                    let arena = typed_arena::Arena::new();
                     let Ok(path) = path else {
                         return WalkState::Continue;
                     };
@@ -179,12 +181,12 @@ impl Optimise {
                     let Ok(output_path) = output_path(&path) else {
                         return WalkState::Continue;
                     };
-                    if let Err(err) = Self::handle_file(jobs, &path, output_path.as_ref(), &arena) {
+                    if let Err(err) = Self::handle_file(jobs, &path, output_path.as_ref()) {
                         eprintln!(
                             "{}: \x1b[31m{err}\x1b[0m",
                             path.to_str().unwrap_or_default()
                         );
-                    };
+                    }
                     WalkState::Continue
                 })
             });
@@ -198,8 +200,7 @@ impl Optimise {
                 .first()
                 .is_none_or(|path| path == &PathBuf::from_str(".").unwrap())
         {
-            let arena = typed_arena::Arena::new();
-            return self.handle_stdin(jobs, &arena);
+            return self.handle_stdin(jobs);
         }
         if self.paths.is_empty() {
             return Err(anyhow!(