Switch to eyre for error handling

Cargo.toml

@@ -74,9 +74,11 @@ required-features = ["cxx-bindings"]
 
 [dependencies]
 clap = { version = "4.0", features = ["derive"] }
+color-eyre = "0.6.5"
 cxx = { version = "1.0", optional = true }
 delaunator = "1.0"
-geo = "0.30"
+eyre = "0.6.12"
+geo = "0.31"
 hex = "0.4"
 itertools = "0.14"
 kdtree = "0.7"
@@ -85,7 +87,7 @@ petgraph = "0.8"
 rand = "0.9"
 rand_distr = "0.5"
 rectangle-pack = "0.4"
-rhai = { version = "1.13", features = ["only_i64", "no_index", "no_object", "no_time", "no_function", "no_module", "no_custom_syntax"] }
+rhai = { version = "1.23", features = ["only_i64", "no_index", "no_object", "no_time", "no_function", "no_module", "no_custom_syntax", "sync"] }
 svg = "0.18"
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
@@ -100,7 +102,7 @@ fs_extra = { version = "1.3", optional = true }
 glob = { version = "0.3", optional = true }
 
 [dev-dependencies]
-ctor = "0.5"
+ctor = "0.6"
 float-cmp = "0.10"
 
 [features]

generative/dla.rs

@@ -255,42 +255,41 @@ impl Model {
     }
 }
 
-pub fn format_tgf(writer: &mut BufWriter<Box<dyn Write>>, graph: GraphType) {
+pub fn format_tgf(writer: &mut BufWriter<Box<dyn Write>>, graph: GraphType) -> eyre::Result<()> {
     // let (nodes, edges) = graph.into_nodes_edges();
     for idx in graph.node_indices() {
         let particle = graph
             .node_weight(idx)
-            .expect("Got index to nonexistent node.");
+            .ok_or_else(|| eyre::eyre!("Got index {idx:?} to nonexistent node"))?;
         let label = idx.index();
         writeln!(
             writer,
             "{label}\tPOINT({} {})",
             particle.coordinates[0], particle.coordinates[1]
-        )
-        .expect("Failed to write node label");
+        )?;
     }
-    writeln!(writer, "#").expect("Failed to write node/edge separator");
+    writeln!(writer, "#")?;
     for edge in graph.edge_references() {
         writeln!(
             writer,
             "{}\t {}",
             edge.source().index(),
             edge.target().index()
-        )
-        .expect("Failed to write edge");
+        )?;
     }
+    Ok(())
 }
 
-pub fn format_wkt(writer: &mut BufWriter<Box<dyn Write>>, graph: GraphType) {
+pub fn format_wkt(writer: &mut BufWriter<Box<dyn Write>>, graph: GraphType) -> eyre::Result<()> {
     for idx in graph.node_indices() {
         let particle = graph
             .node_weight(idx)
-            .expect("Got index to nonexistent node.");
+            .ok_or_else(|| eyre::eyre!("Got index {idx:?} to nonexistent node"))?;
         writeln!(
             writer,
             "POINT ({} {})",
             particle.coordinates[0], particle.coordinates[1]
-        )
-        .expect("Failed to write node WKT.");
+        )?;
     }
+    Ok(())
 }

generative/io/stdio.rs

@@ -2,30 +2,22 @@ use std::fs::File;
 use std::io::{BufReader, BufWriter, Read, Write};
 use std::path::PathBuf;
 
-pub fn get_output_writer(output: &Option<PathBuf>) -> Result<BufWriter<Box<dyn Write>>, String> {
+pub fn get_output_writer(output: &Option<PathBuf>) -> eyre::Result<BufWriter<Box<dyn Write>>> {
     match output {
-        Some(path) => match File::create(path) {
-            Err(why) => Err(format!(
-                "Couldn't create: '{}' because: '{}'",
-                path.display(),
-                why
-            )),
-            Ok(file) => Ok(BufWriter::new(Box::new(file))),
-        },
+        Some(path) => {
+            let file = File::create(path)?;
+            Ok(BufWriter::new(Box::new(file)))
+        }
         None => Ok(BufWriter::new(Box::new(std::io::stdout()))),
     }
 }
 
-pub fn get_input_reader(input: &Option<PathBuf>) -> Result<BufReader<Box<dyn Read>>, String> {
+pub fn get_input_reader(input: &Option<PathBuf>) -> eyre::Result<BufReader<Box<dyn Read>>> {
     match input {
-        Some(path) => match File::open(path) {
-            Err(why) => Err(format!(
-                "Couldn't open: '{}' because: '{}'",
-                path.display(),
-                why
-            )),
-            Ok(file) => Ok(BufReader::new(Box::new(file))),
-        },
+        Some(path) => {
+            let file = File::open(path)?;
+            Ok(BufReader::new(Box::new(file)))
+        }
         None => Ok(BufReader::new(Box::new(std::io::stdin()))),
     }
 }

generative/io/tgf.rs

@@ -34,7 +34,8 @@ pub fn write_graph<Direction, W>(
     mut writer: W,
     graph: &GeometryGraph<Direction>,
     format: &GraphFormat,
-) where
+) -> eyre::Result<()>
+where
     W: Write,
     Direction: EdgeType,
 {
@@ -44,7 +45,10 @@ pub fn write_graph<Direction, W>(
     }
 }
 
-pub fn write_tgf_graph<Direction, W>(writer: &mut W, graph: &GeometryGraph<Direction>)
+pub fn write_tgf_graph<Direction, W>(
+    writer: &mut W,
+    graph: &GeometryGraph<Direction>,
+) -> eyre::Result<()>
 where
     W: Write,
     Direction: EdgeType,
@@ -55,22 +59,24 @@ where
             .node_weight(idx)
             .expect("Got index to nonexistent node.");
         let index = idx.index();
-        writeln!(writer, "{}\tPOINT({} {})", index, coord.x(), coord.y())
-            .expect("Failed to write node label");
+        writeln!(writer, "{}\tPOINT({} {})", index, coord.x(), coord.y())?;
     }
-    writeln!(writer, "#").expect("Failed to write node/edge separator");
+    writeln!(writer, "#")?;
     for edge in graph.edge_references() {
         writeln!(
             writer,
             "{}\t{}",
             edge.source().index(),
             edge.target().index()
-        )
-        .expect("Failed to write edge");
+        )?;
     }
+    Ok(())
 }
 
-pub fn write_wkt_graph<Direction, W>(writer: W, graph: &GeometryGraph<Direction>)
+pub fn write_wkt_graph<Direction, W>(
+    writer: W,
+    graph: &GeometryGraph<Direction>,
+) -> eyre::Result<()>
 where
     W: Write,
     Direction: EdgeType,
@@ -79,7 +85,7 @@ where
         .edge_references()
         .map(|e| Line::new(graph[e.source()], graph[e.target()]))
         .map(Geometry::Line);
-    write_wkt_geometries(writer, edges);
+    write_wkt_geometries(writer, edges)
 }
 
 fn read_raw_node(line: String) -> Result<(usize, Point), String> {

generative/io/wkt.rs

@@ -166,7 +166,7 @@ where
     }
 }
 
-pub fn write_geometries<W, G>(writer: W, geometries: G, format: GeometryFormat)
+pub fn write_geometries<W, G>(writer: W, geometries: G, format: GeometryFormat) -> eyre::Result<()>
 where
     W: Write,
     G: IntoIterator<Item = Geometry<f64>>,
@@ -370,45 +370,47 @@ where
 /// Write the given geometries with the given Writer in WKT format
 ///
 /// Each geometry will be written on its own line.
-pub fn write_wkt_geometries<W, G>(mut writer: W, geometries: G)
+pub fn write_wkt_geometries<W, G>(mut writer: W, geometries: G) -> eyre::Result<()>
 where
     W: Write,
     G: IntoIterator<Item = Geometry<f64>>,
 {
     for geometry in geometries {
         let wkt_geom = geometry.to_wkt();
-        writeln!(writer, "{wkt_geom}").expect("Writing failed");
+        writeln!(writer, "{wkt_geom}")?;
     }
+    Ok(())
 }
 
-fn write_wkbhex_geometries<W, G>(mut writer: W, geometries: G)
+fn write_wkbhex_geometries<W, G>(mut writer: W, geometries: G) -> eyre::Result<()>
 where
     W: Write,
     G: IntoIterator<Item = Geometry<f64>>,
 {
     for geom in geometries {
         match geom_to_wkb(&geom) {
             Ok(buffer) => {
-                writeln!(writer, "{}", encode_upper(buffer)).unwrap();
+                writeln!(writer, "{}", encode_upper(buffer))?;
             }
             Err(e) => {
                 tracing::warn!("Failed to serialize geometry to WKB: {e:?}");
             }
         }
     }
+    Ok(())
 }
 
-fn write_wkbraw_geometries<W, G>(mut writer: W, geometries: G)
+fn write_wkbraw_geometries<W, G>(mut writer: W, geometries: G) -> eyre::Result<()>
 where
     W: Write,
     G: IntoIterator<Item = Geometry<f64>>,
 {
     for geom in geometries {
         // TODO: What's this about the endianity byte?
-        if let Err(e) = write_geom_to_wkb(&geom, &mut writer) {
-            tracing::warn!("Failed to write geometry: {e:?}");
-        }
+        write_geom_to_wkb(&geom, &mut writer)
+            .map_err(|e| eyre::eyre!("Failed to write WKB geometry: {e:?}"))?;
     }
+    Ok(())
 }
 
 pub fn read_wkt_geometries_and_styles<R>(reader: R) -> WktGeometriesAndStyles<R>
@@ -521,7 +523,7 @@ mod tests {
         let geometries = read_wkbhex_geometries(&input_wkbhex[..]);
 
         let mut output_buffer = Vec::<u8>::new();
-        write_wkbhex_geometries(&mut output_buffer, geometries);
+        write_wkbhex_geometries(&mut output_buffer, geometries).unwrap();
 
         assert_eq!(output_buffer, input_wkbhex);
     }
@@ -536,7 +538,7 @@ mod tests {
         let geometries = read_wkbraw_geometries(buffer.as_slice());
 
         let mut output_buffer = Vec::<u8>::new();
-        write_wkbraw_geometries(&mut output_buffer, geometries);
+        write_wkbraw_geometries(&mut output_buffer, geometries).unwrap();
 
         assert_eq!(output_buffer, buffer);
     }

generative/snap.rs

@@ -367,7 +367,7 @@ mod tests {
         D: EdgeType,
     {
         let mut buffer = BufWriter::new(Vec::new());
-        write_tgf_graph(&mut buffer, graph);
+        write_tgf_graph(&mut buffer, graph).unwrap();
         let buffer = buffer.into_inner().unwrap();
         String::from_utf8_lossy(&buffer).to_string()
     }

generative/triangulation.rs

@@ -256,8 +256,8 @@ mod tests {
         #[cfg(feature = "test-io")]
         {
             let lines = triangulation.lines().map(geo::Geometry::Line);
-            crate::io::write_wkt_geometries(std::io::stdout(), geometries);
-            crate::io::write_wkt_geometries(std::io::stdout(), lines);
+            crate::io::write_wkt_geometries(std::io::stdout(), geometries).unwrap();
+            crate::io::write_wkt_geometries(std::io::stdout(), lines).unwrap();
         }
 
         let triangles = [3, 5, 4, 4, 2, 3, 2, 1, 3, 1, 0, 3];
@@ -372,7 +372,7 @@ mod tests {
                 .iter()
                 .map(|(a, b)| geo::Line::new(points[*a], points[*b]))
                 .map(geo::Geometry::Line);
-            crate::io::write_wkt_geometries(std::io::stdout(), lines);
+            crate::io::write_wkt_geometries(std::io::stdout(), lines).unwrap();
         }
     }
 }

tools/bitwise.rs

@@ -66,7 +66,14 @@ fn expression(engine: &Engine, ast: &AST, x: i64, y: i64) -> Result<i64, Box<Eva
     engine.eval_ast_with_scope::<i64>(&mut scope, ast)
 }
 
-fn write_line<W>(writer: W, format: GeometryFormat, x1: i64, y1: i64, x2: i64, y2: i64)
+fn write_line<W>(
+    writer: W,
+    format: GeometryFormat,
+    x1: i64,
+    y1: i64,
+    x2: i64,
+    y2: i64,
+) -> eyre::Result<()>
 where
     W: Write,
 {
@@ -75,16 +82,16 @@ where
         Point::new(x2 as f64, y2 as f64),
     );
     let geometries = std::iter::once(Geometry::Line(line));
-    write_geometries(writer, geometries, format);
+    write_geometries(writer, geometries, format)
 }
 
-fn write_point<W>(writer: W, format: GeometryFormat, x1: i64, y1: i64)
+fn write_point<W>(writer: W, format: GeometryFormat, x1: i64, y1: i64) -> eyre::Result<()>
 where
     W: Write,
 {
     let point = Point::new(x1 as f64, y1 as f64);
     let geometries = std::iter::once(Geometry::Point(point));
-    write_geometries(writer, geometries, format);
+    write_geometries(writer, geometries, format)
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, ValueEnum)]
@@ -128,9 +135,9 @@ fn neighbor(x: i64, y: i64, n: Neighbor) -> (i64, i64) {
     }
 }
 
-fn main() -> Result<(), Box<EvalAltResult>> {
+fn main() -> eyre::Result<()> {
+    color_eyre::install()?;
     let args = CmdlineOptions::parse();
-
     let filter = tracing_subscriber::EnvFilter::builder()
         .with_default_directive(args.log_level.into())
         .from_env_lossy();
@@ -147,7 +154,7 @@ fn main() -> Result<(), Box<EvalAltResult>> {
     let ys = args.y_min..args.y_max;
     let cross = xs.cartesian_product(ys);
 
-    let mut writer = get_output_writer(&args.output).unwrap();
+    let mut writer = get_output_writer(&args.output)?;
     if args.points {
         let geometries = cross.filter_map(|(x, y)| {
             if let Ok(value) = expression(&engine, &ast, x, y) {
@@ -163,7 +170,7 @@ fn main() -> Result<(), Box<EvalAltResult>> {
             None
         });
 
-        write_geometries(writer, geometries, args.output_format);
+        write_geometries(writer, geometries, args.output_format)?;
     } else {
         tracing::info!(
             "Searching neighbors in order: {:?}",
@@ -175,13 +182,13 @@ fn main() -> Result<(), Box<EvalAltResult>> {
                 for n in args.neighbor_search_order.iter() {
                     let (x2, y2) = neighbor(x, y, n.clone());
                     if expression(&engine, &ast, x2, y2)? > 0 {
-                        write_line(&mut writer, args.output_format, x, y, x2, y2);
+                        write_line(&mut writer, args.output_format, x, y, x2, y2)?;
                         wrote_line = true;
                         break;
                     }
                 }
                 if !wrote_line {
-                    write_point(&mut writer, args.output_format, x, y);
+                    write_point(&mut writer, args.output_format, x, y)?;
                 }
             }
         }