From f4bb3798777fb5c7a9c21d2bf827b32e0c714d2e Mon Sep 17 00:00:00 2001
From: Ben Pfaff <blp@cs.stanford.edu>
Date: Sat, 25 Apr 2026 15:07:31 -0700
Subject: [PATCH] remove most debug prints from graph code

---
 rust/pspp/src/spv/read/graph.rs        | 41 ++++++++++----------------
 rust/pspp/src/spv/read/graph/frames.rs | 38 ------------------------
 2 files changed, 15 insertions(+), 64 deletions(-)

diff --git a/rust/pspp/src/spv/read/graph.rs b/rust/pspp/src/spv/read/graph.rs
index 87d04f6ebb..238e1fc1d2 100644
--- a/rust/pspp/src/spv/read/graph.rs
+++ b/rust/pspp/src/spv/read/graph.rs
@@ -233,11 +233,9 @@ impl Visualization {
             let n = inputs.len();
             inputs.retain(|input| !input.decode(series, &mut domains));
             if n == inputs.len() {
-                dbg!(&inputs);
                 todo!()
             }
         }
-        //dbg!(&domains);
         domains
     }
 
@@ -490,7 +488,6 @@ impl Visualization {
         mut csv_data: Option<IndexMap<String, DataSeries>>,
         warn: &mut dyn FnMut(GraphWarning),
     ) -> Result<svg::Document, GraphError> {
-        //dbg!(self.graph());
         let _styles = self.decode_styles();
         for delimited_source in self
             .children
@@ -518,11 +515,6 @@ impl Visualization {
             .as_ref()
             .map_or(&EN, |lang| Locale::for_lang(lang));
         let series = self.decode_series(locale, data, warn);
-        /*
-            for (name, series) in &series {
-                dbg!(name, &series.values);
-        }*/
-        dbg!(&series);
         let domains = self.decode_domains(&series, warn);
         let _styles = self
             .children
@@ -659,8 +651,6 @@ impl Visualization {
             .map(|f| f.decode(&series))
             .unwrap_or_default();
 
-        dbg!(&faceting);
-
         let x_facets = FacetIterator::new(&faceting[Axis2::X]);
         let nx_facets = x_facets.len();
         let y_facets = FacetIterator::new(&faceting[Axis2::Y]);
@@ -1118,6 +1108,7 @@ enum VisChild {
     Graph(Graph),
     LabelFrame(LabelFrame),
     Container(Container),
+    StyleCycle(StyleCycle),
     Style(Style),
     Location(Location),
     #[serde(other)]
@@ -1630,7 +1621,6 @@ impl RawDomain for CategoricalDomain {
                 }
                 CategoricalDomainChild::DomainReference(domain) => {
                     let Some(domain) = domains.get(domain.reference.as_str()) else {
-                        dbg!(&domain);
                         return false;
                     };
 
@@ -2387,6 +2377,20 @@ struct ValueMapEntry {
     to: String,
 }
 
+#[derive(Clone, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct StyleCycle {
+    #[serde(default)]
+    cycles: Vec<Cycle>,
+}
+
+#[derive(Clone, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+struct Cycle {
+    #[serde(default)]
+    styles: Vec<Style>,
+}
+
 #[derive(Clone, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 struct Style {
@@ -2671,13 +2675,11 @@ impl<'a> Element<'a> {
                 variables[axis] = Some(series.clone());
             }
         }
-        dbg!(&variables);
         let mut ignore_minmax = EnumMap::default();
         for statistic in &raw.statistics {
             match statistic {
                 Statistic::BinStatistic(bin_statistic) => {
                     if let Some(x) = &mut variables[Axis3::X] {
-                        dbg!(&*x);
                         assert!(!x.categorical);
                         let mut min = None;
                         let mut max = None;
@@ -2693,7 +2695,6 @@ impl<'a> Element<'a> {
                                 n += 1;
                             }
                         }
-                        dbg!((min, max, n));
                         if let Some(min) = min.copied()
                             && let Some(max) = max.copied()
                             && max > min
@@ -2711,7 +2712,6 @@ impl<'a> Element<'a> {
                             let bin_width =
                                 bin_widths.entry(x.name.clone()).or_insert(binning.width);
                             *bin_width = bin_width.min(binning.width);
-                            dbg!(&binning);
                             for value in &mut x.values {
                                 if let Datum::Number(Some(number)) = &value.value {
                                     value.value = Datum::Number(binning.bin(*number));
@@ -2723,7 +2723,6 @@ impl<'a> Element<'a> {
                 }
                 Statistic::SummaryStatistic(summary_statistic) => {
                     if let Some(mut x) = variables[Axis3::X].take() {
-                        dbg!();
                         let mut frequencies = BTreeMap::<Datum<String>, f64>::new();
                         assert!(x.categorical);
                         for value in &x.values {
@@ -2731,10 +2730,8 @@ impl<'a> Element<'a> {
                                 *frequencies.entry(value.value.clone()).or_default() += 1.0;
                             }
                         }
-                        dbg!(&frequencies);
 
                         if summary_statistic.convert_interval_to_single_value {
-                            dbg!();
                             x.values = frequencies
                                 .keys()
                                 .map(|value| SeriesValue {
@@ -4186,7 +4183,6 @@ impl<'a> FrameType<'a> {
                 let text = label_frame.text();
                 layout.set_text(&text);
                 let (w, h) = layout.size();
-                println!("{text} => ({w},{h})");
                 enum_map! { Axis2::X => w as f64 / 1024.0, Axis2::Y => h as f64 / 1024.0}
             }
             FrameType::Legend(_) => enum_map! { Axis2::X => 100.0, Axis2::Y => 200.0 },
@@ -4825,12 +4821,10 @@ impl crate::output::Graph {
 
     pub fn csv_data(&self) -> Result<Option<IndexMap<String, DataSeries>>, GraphError> {
         if let Some(csv) = &self.csv {
-            dbg!();
             let mut reader = csv::Reader::from_reader(Cursor::new(&csv));
             let headers = reader.headers().unwrap(); // XXX
             let mut variables = vec![DataSeries::default(); headers.len()];
             for row in reader.records() {
-                dbg!(&row);
                 let row = row.unwrap(); // XXX
                 for (column, s) in row.iter().enumerate() {
                     let value = match s.parse::<f64>() {
@@ -4913,8 +4907,6 @@ impl crate::output::Graph {
                         .map(|series| series.data.len())
                         .max()
                         .unwrap_or_default();
-                    dbg!(&name);
-                    dbg!(rows);
                     let empty = Datum::String(String::new());
                     for row in 0..rows {
                         w.create_element("row").write_inner_content(|w| {
@@ -4940,7 +4932,6 @@ impl crate::output::Graph {
             Ok(())
         }
 
-        eprintln!();
         let mut reader = Reader::from_reader(self.xml.as_slice());
         let mut writer = Writer::new(Vec::new());
         loop {
@@ -5111,7 +5102,6 @@ mod tests {
             (0.0..100.0, (0.0, 20.0, 6)),
         ] {
             let expected = Scaling::new(base, interval, n_ticks);
-            dbg!(&range, &expected);
             let scaling = Scaling::for_range(&range);
             assert_eq!(scaling, expected);
             assert_eq!(scaling.ticks().count(), scaling.n_ticks);
@@ -5131,7 +5121,6 @@ mod tests {
             (0.0..100.0, (0.0, 40.0 / 3.0, 8)),
         ] {
             let expected = Binning::new(start, width, n);
-            dbg!(&range, &expected);
             let binning = Binning::for_range(&range, sturges_rule(50.0).unwrap());
             assert_eq!(binning.start, expected.start);
             assert_relative_eq!(binning.width, expected.width);
diff --git a/rust/pspp/src/spv/read/graph/frames.rs b/rust/pspp/src/spv/read/graph/frames.rs
index 9f74f77222..9bfdad3a51 100644
--- a/rust/pspp/src/spv/read/graph/frames.rs
+++ b/rust/pspp/src/spv/read/graph/frames.rs
@@ -214,7 +214,6 @@ impl<'a> Frames<'a> {
                 } else {
                     value
                 };
-                println!("set {:?} {axis:?} {component:?} to {value:?}", &frame.id);
                 new_position[axis].set(component, value);
             }
         }
@@ -250,7 +249,6 @@ impl<'a> Frames<'a> {
                 .as_ref()
                 .is_none_or(|location| location.is_size_to_content())
             {
-                println!("set {axis:?} default size");
                 position[axis].set_start(0.0);
                 position[axis].set_end(default);
             }
@@ -261,28 +259,8 @@ impl<'a> Frames<'a> {
         while let n = self.missing_values()
             && n > 0
         {
-            println!();
-            println!("round {n}");
-            for frame in &self.frames {
-                println!(
-                    "{:?}: X {:?} {:?} {:?}",
-                    &frame.id,
-                    &frame.position[Axis2::X].start(),
-                    &frame.position[Axis2::X].end(),
-                    &frame.position[Axis2::X].length()
-                );
-                println!(
-                    "{:?}: Y {:?} {:?} {:?}",
-                    &frame.id,
-                    &frame.position[Axis2::Y].start(),
-                    &frame.position[Axis2::Y].end(),
-                    &frame.position[Axis2::Y].length()
-                );
-            }
             self.update_round();
             if self.missing_values() == n {
-                println!("no change");
-                dbg!(strict);
                 if !strict {
                     break;
                 }
@@ -290,11 +268,9 @@ impl<'a> Frames<'a> {
                 let size = self.preferred_size(&self.frames[0], false);
                 for (axis, position) in &mut self.frames[0].position {
                     if position.start().is_none() {
-                        println!("set {axis:?} start non-strict");
                         position.set_start(0.0);
                     }
                     if position.length().is_none() {
-                        println!("set {axis:?} length non-strict");
                         position.set_length(size[axis].unwrap_or_default());
                     }
                 }
@@ -516,7 +492,6 @@ impl Position {
 
         let frame = &frames[index];
         if self.start().is_some() && self.end().is_some() {
-            println!("{:?}: known", &frame.id);
             return;
         }
 
@@ -524,13 +499,8 @@ impl Position {
         let unknown_end = frame.locations[axis][Component::End].is_none();
         let unknown_length =
             frame.locations[axis][Component::Length].is_none() && self.length().is_none();
-        println!(
-            "{:?} {axis:?}: {unknown_start:?} {unknown_end:?} {unknown_length:?}",
-            &frame.id
-        );
         match (unknown_start, unknown_end, unknown_length) {
             (true, true, true) => {
-                println!("{:?}: clone parent {axis:?}", &frame.id);
                 *self = parent.clone();
             }
             (true, true, false) => {
@@ -539,17 +509,12 @@ impl Position {
                 {
                     // We know where the parent starts, and another frame is
                     // attached to our end, so start us where our parent starts.
-                    println!(
-                        "set default {:?} {axis:?} start to {parent_start}",
-                        &frame.id
-                    );
                     self.set(Component::Start, parent_start);
                 } else if let Some(parent_end) = parent.end()
                     && is_attached(frames, index, axis, Component::End)
                 {
                     // We know where the parent ends, and another frame is
                     // attached to our start, so end us where our parent ends.
-                    println!("set default {:?} {axis:?} end to {parent_end}", &frame.id);
                     self.set(Component::End, parent_end);
                 } else if let Some(length) = self.length()
                     && let Some(parent_length) = parent.length()
@@ -557,19 +522,16 @@ impl Position {
                 {
                     // We have our parent's location, and no other frame is
                     // before or after us, so center us within the parent.
-                    println!("center {:?} {axis:?}", &frame.id);
                     self.set_start(parent_start + parent_length / 2.0 - length / 2.0);
                 }
             }
             (true, false, true) => {
                 if let Some(parent_start) = parent.start() {
-                    println!("set start {:?} {axis} to parent {parent_start}", &frame.id);
                     self.set(Component::Start, parent_start);
                 }
             }
             (false, true, true) => {
                 if let Some(parent_end) = parent.end() {
-                    println!("set end {:?} {axis} to parent {parent_end}", &frame.id);
                     self.set(Component::End, parent_end);
                 }
             }
-- 
2.47.3