second

Author: AndyGauge

Cargo.toml

@@ -53,6 +53,7 @@ sha2 = "0.10"
 tar = "0.4"
 tempfile = "3.14"
 thiserror = "2"
+anyhow = "1.0"
 threadpool = "1.8"
 toml = "0.8"
 tokio = { version = "1", features = ["full"] }

src/algorithms/randomness/rand-passwd.md

@@ -22,3 +22,7 @@ fn main() {
 ```
 
 [`Alphanumeric`]: https://docs.rs/rand/*/rand/distributions/struct.Alphanumeric.html
+
+
+
+

src/compression/tar/tar-compress.md

@@ -11,6 +11,8 @@ under `backup/logs` path with [`Builder::append_dir_all`].
 data prior to writing it into `archive.tar.gz`.
 
 ```rust,edition2018,no_run
+extern crate flate2;
+extern crate tar;
 
 use std::fs::File;
 use flate2::Compression;
@@ -29,6 +31,8 @@ fn main() -> Result<(), std::io::Error> {
 To add the contents without renaming them, an empty string can be used as the first argument of [`Builder::append_dir_all`]:
 
 ```rust,edition2018,no_run
+extern crate flate2;
+extern crate tar;
 
 use std::fs::File;
 use flate2::Compression;

src/compression/tar/tar-strip-prefix.md

@@ -7,20 +7,16 @@ the specified path prefix (`bundle/logs`).  Finally, extract the [`tar::Entry`]
 via [`Entry::unpack`].
 
 ```rust,edition2018,no_run
-# use error_chain::error_chain;
+extern crate anyhow;
+extern crate flate2;
+extern crate tar;
+use anyhow::Result;
 use std::fs::File;
 use std::path::PathBuf;
 use flate2::read::GzDecoder;
 use tar::Archive;
-# 
-# error_chain! {
-#   foreign_links {
-#     Io(std::io::Error);
-#     StripPrefixError(::std::path::StripPrefixError);
-#   }
-# }
 
-fn main() -> Result<(), std::io::Error> {
+fn main() -> Result<()> {
     let file = File::open("archive.tar.gz")?;
     let mut archive = Archive::new(GzDecoder::new(file));
     let prefix = "bundle/logs";

src/concurrency/parallel/rayon-thumbnails.md

@@ -10,33 +10,25 @@ images in parallel using [`par_iter`] calling  [`DynamicImage::resize`].
 
 ```rust,edition2018,no_run
 extern crate rayon;
+extern crate image;
+extern crate glob;
+extern crate anyhow;
 use rayon::prelude::*;
-
-# use error_chain::error_chain;
+use anyhow::{Result, anyhow, Context};
 
 use std::path::Path;
 use std::fs::create_dir_all;
-
-# use error_chain::ChainedError;
 use glob::{glob_with, MatchOptions};
 use image::{FilterType, ImageError};
 
-# error_chain! {
-#     foreign_links {
-#         Image(ImageError);
-#         Io(std::io::Error);
-#         Glob(glob::PatternError);
-#     }
-# }
-
 fn main() -> Result<()> {
     let options: MatchOptions = Default::default();
     let files: Vec<_> = glob_with("*.jpg", options)?
         .filter_map(|x| x.ok())
         .collect();
 
     if files.len() == 0 {
-        error_chain::bail!("No .jpg files found in current directory");
+        return Err(anyhow!("No .jpg files found in current directory"));
     }
 
     let thumb_dir = "thumbnails";
@@ -48,12 +40,12 @@ fn main() -> Result<()> {
         .par_iter()
         .map(|path| {
             make_thumbnail(path, thumb_dir, 300)
-                .map_err(|e| e.chain_err(|| path.display().to_string()))
+                .with_context(|| format!("Failed to process {}", path.display()))
         })
         .filter_map(|x| x.err())
         .collect();
 
-    image_failures.iter().for_each(|x| println!("{}", x.display_chain()));
+    image_failures.iter().for_each(|x| println!("{}", x));
 
     println!("{} thumbnails saved successfully", files.len() - image_failures.len());
     Ok(())

src/concurrency/thread/global-mut-state.md

@@ -10,18 +10,18 @@ race conditions. A [`MutexGuard`] must be acquired to read or mutate the
 value stored in a [`Mutex`].
 
 ```rust,edition2018
-# use error_chain::error_chain;
+extern crate anyhow;
+extern crate lazy_static;
+use anyhow::{Result, anyhow};
 use lazy_static::lazy_static;
 use std::sync::Mutex;
-#
-# error_chain!{ }
 
 lazy_static! {
     static ref FRUIT: Mutex<Vec<String>> = Mutex::new(Vec::new());
 }
 
 fn insert(fruit: &str) -> Result<()> {
-    let mut db = FRUIT.lock().map_err(|_| "Failed to acquire MutexGuard")?;
+    let mut db = FRUIT.lock().map_err(|_| anyhow!("Failed to acquire MutexGuard"))?;
     db.push(fruit.to_string());
     Ok(())
 }
@@ -31,7 +31,7 @@ fn main() -> Result<()> {
     insert("orange")?;
     insert("peach")?;
     {
-        let db = FRUIT.lock().map_err(|_| "Failed to acquire MutexGuard")?;
+        let db = FRUIT.lock().map_err(|_| anyhow!("Failed to acquire MutexGuard"))?;
 
         db.iter().enumerate().for_each(|(i, item)| println!("{}: {}", i, item));
     }

src/concurrency/thread/threadpool-fractal.md

@@ -19,71 +19,66 @@ Create [`ThreadPool`] with thread count equal to number of cores with [`num_cpus
 ```rust,edition2018,no_run
 extern crate num;
 extern crate num_cpus;
-# use error_chain::error_chain;
+extern crate anyhow;
+extern crate threadpool;
+extern crate image;
+use anyhow::Result;
 use std::sync::mpsc::{channel, RecvError};
 use threadpool::ThreadPool;
 use num::complex::Complex;
 use image::{ImageBuffer, Pixel, Rgb};
-#
-# error_chain! {
-#     foreign_links {
-#         MpscRecv(RecvError);
-#         Io(std::io::Error);
-#         Image(image::ImageError);
-#     }
-# }
-#
-# // Function converting intensity values to RGB
-# // Based on http://www.efg2.com/Lab/ScienceAndEngineering/Spectra.htm
-# fn wavelength_to_rgb(wavelength: u32) -> Rgb<u8> {
-#     let wave = wavelength as f32;
-#
-#     let (r, g, b) = match wavelength {
-#         380..=439 => ((440. - wave) / (440. - 380.), 0.0, 1.0),
-#         440..=489 => (0.0, (wave - 440.) / (490. - 440.), 1.0),
-#         490..=509 => (0.0, 1.0, (510. - wave) / (510. - 490.)),
-#         510..=579 => ((wave - 510.) / (580. - 510.), 1.0, 0.0),
-#         580..=644 => (1.0, (645. - wave) / (645. - 580.), 0.0),
-#         645..=780 => (1.0, 0.0, 0.0),
-#         _ => (0.0, 0.0, 0.0),
-#     };
-#
-#     let factor = match wavelength {
-#         380..=419 => 0.3 + 0.7 * (wave - 380.) / (420. - 380.),
-#         701..=780 => 0.3 + 0.7 * (780. - wave) / (780. - 700.),
-#         _ => 1.0,
-#     };
-#
-#     let (r, g, b) = (normalize(r, factor), normalize(g, factor), normalize(b, factor));
-#     Rgb::from_channels(r, g, b, 0)
-# }
-#
-# // Maps Julia set distance estimation to intensity values
-# fn julia(c: Complex<f32>, x: u32, y: u32, width: u32, height: u32, max_iter: u32) -> u32 {
-#     let width = width as f32;
-#     let height = height as f32;
-#
-#     let mut z = Complex {
-#         // scale and translate the point to image coordinates
-#         re: 3.0 * (x as f32 - 0.5 * width) / width,
-#         im: 2.0 * (y as f32 - 0.5 * height) / height,
-#     };
-#
-#     let mut i = 0;
-#     for t in 0..max_iter {
-#         if z.norm() >= 2.0 {
-#             break;
-#         }
-#         z = z * z + c;
-#         i = t;
-#     }
-#     i
-# }
-#
-# // Normalizes color intensity values within RGB range
-# fn normalize(color: f32, factor: f32) -> u8 {
-#     ((color * factor).powf(0.8) * 255.) as u8
-# }
+
+// Function converting intensity values to RGB
+// Based on http://www.efg2.com/Lab/ScienceAndEngineering/Spectra.htm
+fn wavelength_to_rgb(wavelength: u32) -> Rgb<u8> {
+    let wave = wavelength as f32;
+
+    let (r, g, b) = match wavelength {
+        380..=439 => ((440. - wave) / (440. - 380.), 0.0, 1.0),
+        440..=489 => (0.0, (wave - 440.) / (490. - 440.), 1.0),
+        490..=509 => (0.0, 1.0, (510. - wave) / (510. - 490.)),
+        510..=579 => ((wave - 510.) / (580. - 510.), 1.0, 0.0),
+        580..=644 => (1.0, (645. - wave) / (645. - 580.), 0.0),
+        645..=780 => (1.0, 0.0, 0.0),
+        _ => (0.0, 0.0, 0.0),
+    };
+
+    let factor = match wavelength {
+        380..=419 => 0.3 + 0.7 * (wave - 380.) / (420. - 380.),
+        701..=780 => 0.3 + 0.7 * (780. - wave) / (780. - 700.),
+        _ => 1.0,
+    };
+
+    let (r, g, b) = (normalize(r, factor), normalize(g, factor), normalize(b, factor));
+    Rgb::from_channels(r, g, b, 0)
+}
+
+// Maps Julia set distance estimation to intensity values
+fn julia(c: Complex<f32>, x: u32, y: u32, width: u32, height: u32, max_iter: u32) -> u32 {
+    let width = width as f32;
+    let height = height as f32;
+
+    let mut z = Complex {
+        // scale and translate the point to image coordinates
+        re: 3.0 * (x as f32 - 0.5 * width) / width,
+        im: 2.0 * (y as f32 - 0.5 * height) / height,
+    };
+
+    let mut i = 0;
+    for t in 0..max_iter {
+        if z.norm() >= 2.0 {
+            break;
+        }
+        z = z * z + c;
+        i = t;
+    }
+    i
+}
+
+// Normalizes color intensity values within RGB range
+fn normalize(color: f32, factor: f32) -> u8 {
+    ((color * factor).powf(0.8) * 255.) as u8
+}
 
 fn main() -> Result<()> {
     let (width, height) = (1920, 1080);

src/concurrency/thread/threadpool-walk.md

@@ -11,6 +11,8 @@ and computing SHA256 hash.
 ```rust,edition2018,no_run
 extern crate num_cpus;
 extern crate ring;
+extern crate threadpool;
+extern crate walkdir;
 use walkdir::WalkDir;
 use std::fs::File;
 use std::io::{BufReader, Read, Error};

src/cryptography/hashing/sha-digest.md

@@ -8,18 +8,12 @@ the file's contents using [`digest::Context`].
 ```rust,edition2018
 extern crate ring;
 extern crate data_encoding;
-use error_chain::error_chain;
+extern crate anyhow;
+use anyhow::Result;
 use ring::digest::{Context, Digest, SHA256};
 use data_encoding::HEXUPPER;
 use std::fs::File;
 use std::io::{BufReader, Read, Write};
-#
-# error_chain! {
-#     foreign_links {
-#         Io(std::io::Error);
-#         Decode(data_encoding::DecodeError);
-#     }
-# }
 
 fn sha256_digest<R: Read>(mut reader: R) -> Result<Digest> {
     let mut context = Context::new(&SHA256);

src/database/postgres/aggregate_data.md

@@ -5,6 +5,7 @@
 This recipe lists the nationalities of the first 7999 artists in the database of the [`Museum of Modern Art`] in descending order.
 
 ```rust,edition2018,no_run
+extern crate postgres;
 use postgres::{Client, Error, NoTls};
 
 struct Nation {