one fifty five

Author: AndyGauge

.github/workflows/mdbook-test.yml

@@ -17,22 +17,19 @@ jobs:
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           cache: 'true'
-          toolchain: nightly
+          toolchain: stable
 
       - name: Run tests
         id: cargo_test
         run: |
-          cargo +nightly test --test skeptic -- -Z unstable-options --format junit --report-time --test-threads=1 | tee ./TEST-cookbook.xml
+          cargo test --test skeptic -- --test-threads=1
 
-      - name: List files for debugging
+      - name: Test Results
         if: always()
-        run: ls -R
-
-      - name: Publish Test Report
-        uses: mikepenz/action-junit-report@v5.2.0
-        if: always()
-        with:
-          fail_on_failure: true
-          require_tests: true
-          summary: ${{ steps.cargo_test.outputs.summary }}
-          report_paths: '**/TEST-*.xml'
+        run: |
+          if [ ${{ steps.cargo_test.outcome }} == 'success' ]; then
+            echo "✅ All tests passed!"
+          else
+            echo "❌ Some tests failed. Check the logs above for details."
+            exit 1
+          fi

Cargo.toml

@@ -49,6 +49,7 @@ reqwest = { version = "0.12", features = ["blocking", "json", "stream"] }
 ring = "0.17"
 rusqlite = { version = "0.32", features = ["chrono"] }
 same-file = "1.0"
+select = "0.6.0"
 
 semver = "1.0"
 serde = { version = "1.0", features = ["derive"] }
@@ -70,9 +71,9 @@ walkdir = "2.5"
 syslog = "5.0"
 
 [build-dependencies]
-skeptic = { git = "https://github.com/andygauge/rust-skeptic", branch = "rlib-patch" }
+skeptic = { git = "https://github.com/AndyGauge/rust-skeptic", branch = "rlib-patch" }
 walkdir = "2.5"
 
 [dev-dependencies]
-skeptic = { git = "https://github.com/andygauge/rust-skeptic", branch = "rlib-patch" }
+skeptic = { git = "https://github.com/AndyGauge/rust-skeptic", branch = "rlib-patch" }
 walkdir = "2.5"

src/about.md

@@ -56,12 +56,12 @@ Consider this example for "generate random numbers within a range":
 
 [![rand-badge]][rand] [![cat-science-badge]][cat-science]
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    let random_number: u32 = rng.gen();
+    let mut rng = rand::rng();
+    let random_number: u32 = rng.random();
     println!("Random number: {}", random_number);
 }
 ```

src/algorithms/randomness/rand-choose.md

@@ -5,7 +5,7 @@
 Randomly generates a string of given length ASCII characters with custom
 user-defined bytestring, with [`gen_range`].
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 
 const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
@@ -14,7 +14,7 @@ const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
 const PASSWORD_LEN: usize = 30;
 
 fn main() {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     let password: String = (0..PASSWORD_LEN)
         .map(|_| {

src/algorithms/randomness/rand-custom.md

@@ -5,31 +5,28 @@
 Randomly generates a tuple `(i32, bool, f64)` and variable of user defined type `Point`.
 Implements the [`Distribution`] trait on type Point for [`Standard`] in order to allow random generation.
 
-```rust,edition2018,no_run
+```rust,edition2018
 use rand::Rng;
-use rand::distributions::{Distribution, Standard};
 
 #[derive(Debug)]
 struct Point {
     x: i32,
     y: i32,
 }
 
-impl Distribution<Point> for Standard {
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point {
-        let rand_x: i32 = rng.gen();
-        let rand_y: i32 = rng.gen();
+impl Point {
+    fn random<R: Rng>(rng: &mut R) -> Self {
         Point {
-            x: rand_x,
-            y: rand_y,
+            x: rng.random(),
+            y: rng.random(),
         }
     }
 }
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    let rand_tuple = rng.gen::<(i32, bool, f64)>();
-    let rand_point: Point = rng.gen();
+    let mut rng = rand::rng();
+    let rand_tuple = rng.random::<(i32, bool, f64)>();
+    let rand_point = Point::random(&mut rng);
     println!("Random tuple: {:?}", rand_tuple);
     println!("Random Point: {:?}", rand_point);
 }

src/algorithms/randomness/rand-dist.md

@@ -12,14 +12,16 @@ generator [`rand::Rng`].
 The [distributions available are documented here][rand-distributions].
 An example using the [`Normal`] distribution is shown below.
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 use rand_distr::{Distribution, LogNormal, Normal};
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    let normal = Normal::new(2.0, 3.0).unwrap();
-    let log_normal = LogNormal::new(1.0, 0.5).unwrap();
+    let mut rng = rand::rng();
+    let normal = Normal::new(2.0, 3.0)
+        .expect("Failed to create normal distribution");
+    let log_normal = LogNormal::new(1.0, 0.5)
+        .expect("Failed to create log-normal distribution");
 
     let v = normal.sample(&mut rng);
     println!("{} is from a N(2, 9) distribution", v);

src/algorithms/randomness/rand-passwd.md

@@ -5,18 +5,24 @@
 Randomly generates a string of given length ASCII characters in the range `A-Z,
 a-z, 0-9`, with [`Alphanumeric`] sample.
 
-```rust,edition2018,no_run
-use rand::{thread_rng, Rng};
-use rand::distributions::Alphanumeric;
+```rust,edition2018
+use rand::Rng;
 
 fn main() {
-    let rand_string: String = thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(30)
-        .map(char::from)
+    const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+                            abcdefghijklmnopqrstuvwxyz\
+                            0123456789";
+    const PASSWORD_LEN: usize = 30;
+    let mut rng = rand::rng();
+
+    let password: String = (0..PASSWORD_LEN)
+        .map(|_| {
+            let idx = rng.random_range(0..CHARSET.len());
+            CHARSET[idx] as char
+        })
         .collect();
 
-    println!("{}", rand_string);
+    println!("{}", password);
 }
 ```
 

src/algorithms/randomness/rand-range.md

@@ -4,11 +4,11 @@
 
 Generates a random value within half-open `[0, 10)` range (not including `10`) with [`Rng::gen_range`].
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 
 fn main() {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
     println!("Integer: {}", rng.gen_range(0..10));
     println!("Float: {}", rng.gen_range(0.0..10.0));
 }
@@ -18,13 +18,14 @@ fn main() {
 This has the same effect, but may be faster when repeatedly generating numbers
 in the same range.
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 use rand_distr::{Distribution, Uniform};
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    let die = Uniform::from(1..7);
+    let mut rng = rand::rng();
+    let die = Uniform::new_inclusive(1, 6)
+        .expect("Failed to create uniform distribution: invalid range");
 
     loop {
         let throw = die.sample(&mut rng);

src/algorithms/randomness/rand.md

@@ -8,7 +8,7 @@ initialized generator. Integers are uniformly distributed over the range of the
 type, and floating point numbers are uniformly distributed from 0 up to but not
 including 1.
 
-```rust,edition2018,ignore
+```rust,edition2018
 use rand::Rng;
 
 fn main() {

src/concurrency/parallel/rayon-thumbnails.md

@@ -8,7 +8,7 @@ then saves them in a new folder called `thumbnails`.
 [`glob::glob_with`] finds jpeg files in current directory. `rayon` resizes
 images in parallel using [`par_iter`] calling  [`DynamicImage::resize`].
 
-```rust,edition2018,ignore,no_run
+```rust,edition2018,no_run
 use anyhow::Result;
 use std::path::Path;
 use std::fs::create_dir_all;