fix: TreeDisplayWrapper is private (#2433)

Author: robert3005

vortex-array/src/lib.rs

@@ -39,7 +39,7 @@ pub mod stats;
 pub mod stream;
 #[cfg(feature = "test-harness")]
 pub mod test_harness;
-pub mod tree;
+mod tree;
 pub mod validity;
 pub mod variants;
 pub mod visitor;

vortex-array/src/tree.rs

@@ -16,7 +16,7 @@ impl Array {
     }
 }
 
-pub struct TreeDisplayWrapper<'a>(pub &'a Array);
+struct TreeDisplayWrapper<'a>(&'a Array);
 
 impl fmt::Display for TreeDisplayWrapper<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -34,23 +34,20 @@ pub struct TreeFormatter<'a, 'b: 'a> {
     total_size: Option<usize>,
 }
 
-/// TODO(ngates): I think we want to go back to the old explicit style. It gives arrays more
-///  control over how their metadata etc is displayed.
 impl<'a, 'b: 'a> ArrayVisitor for TreeFormatter<'a, 'b> {
     fn visit_child(&mut self, name: &str, array: &Array) -> VortexResult<()> {
         let nbytes = array.nbytes();
         let total_size = self.total_size.unwrap_or(nbytes);
         writeln!(
-            self.fmt,
-            "{}{}: {} nbytes={} ({:.2}%)",
-            self.indent,
+            self,
+            "{}: {} nbytes={} ({:.2}%)",
             name,
             array,
             format_size(nbytes, DECIMAL),
             100f64 * nbytes as f64 / total_size as f64
         )?;
         self.indent(|i| {
-            write!(i.fmt, "{}metadata: ", i.indent)?;
+            write!(i, "metadata: ")?;
             array.vtable().display_metadata(array, i.fmt)?;
             writeln!(i.fmt)
         })?;
@@ -72,9 +69,8 @@ impl<'a, 'b: 'a> ArrayVisitor for TreeFormatter<'a, 'b> {
 
     fn visit_buffer(&mut self, buffer: &ByteBuffer) -> VortexResult<()> {
         Ok(writeln!(
-            self.fmt,
-            "{}buffer (align={}): {}",
-            self.indent,
+            self,
+            "buffer (align={}): {}",
             buffer.alignment(),
             format_size(buffer.len(), DECIMAL)
         )?)

vortex-sampling-compressor/src/compressors/formatter.rs

@@ -0,0 +1,27 @@
+use std::fmt;
+
+pub struct IndentFormatter<'a, 'b: 'a> {
+    fmt: &'a mut fmt::Formatter<'b>,
+    indent: String,
+}
+
+impl<'a, 'b: 'a> IndentFormatter<'a, 'b> {
+    pub fn new(fmt: &'a mut fmt::Formatter<'b>, indent: String) -> Self {
+        IndentFormatter { fmt, indent }
+    }
+
+    pub fn indent<F>(&mut self, indented: F) -> fmt::Result
+    where
+        F: FnOnce(&mut IndentFormatter) -> fmt::Result,
+    {
+        let original_ident = self.indent.clone();
+        self.indent += "  ";
+        let res = indented(self);
+        self.indent = original_ident;
+        res
+    }
+
+    pub fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> fmt::Result {
+        write!(self.fmt, "{}{}", self.indent, fmt)
+    }
+}

vortex-sampling-compressor/src/compressors/mod.rs

@@ -1,14 +1,15 @@
 use std::any::Any;
-use std::fmt::{Debug, Display, Formatter};
+use std::fmt;
+use std::fmt::{Debug, Display};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
 use itertools::{EitherOrBoth, Itertools};
 use vortex_array::aliases::hash_set::HashSet;
-use vortex_array::tree::TreeFormatter;
 use vortex_array::{Array, EncodingId};
 use vortex_error::{vortex_panic, VortexExpect, VortexResult};
 
+use crate::compressors::formatter::IndentFormatter;
 use crate::SamplingCompressor;
 
 pub mod alp;
@@ -20,6 +21,7 @@ pub mod date_time_parts;
 pub mod delta;
 pub mod dict;
 pub mod r#for;
+mod formatter;
 pub mod fsst;
 pub mod list;
 pub mod runend;
@@ -67,7 +69,7 @@ pub struct CompressionTree<'a> {
 }
 
 impl Debug for CompressionTree<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{self}")
     }
 }
@@ -81,17 +83,17 @@ pub trait EncoderMetadata: 'static + Send + Sync {
 }
 
 impl Display for CompressionTree<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let mut fmt = TreeFormatter::new(f, "".to_string());
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut fmt = IndentFormatter::new(f, "".to_string());
         visit_child("root", Some(self), &mut fmt)
     }
 }
 
 fn visit_child(
     name: &str,
     child: Option<&CompressionTree>,
-    fmt: &mut TreeFormatter,
-) -> std::fmt::Result {
+    fmt: &mut IndentFormatter,
+) -> fmt::Result {
     fmt.indent(|f| {
         if let Some(child) = child {
             writeln!(f, "{name}: {}", child.compressor.id())?;