Format code with cargo fmt

1 files changed, 80 insertions, 73 deletions

diff --git a/src/hitomezashi.rs b/src/hitomezashi.rs
index 7b74998..d8a8c42 100644
--- a/src/hitomezashi.rs
+++ b/src/hitomezashi.rs
@@ -1,19 +1,19 @@
 /*
-	hitomezashi-rs  Generates classical colored Hitomezashi stitch patterns
-	Copyright (C) 2024  Nicholas Johnson
+    hitomezashi-rs  Generates classical colored Hitomezashi stitch patterns
+    Copyright (C) 2024  Nicholas Johnson
 
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
 
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU General Public License for more details.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
 
-	You should have received a copy of the GNU General Public License
-	along with this program.  If not, see <https://www.gnu.org/licenses/>.
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
 use rand::distributions::{Bernoulli, Distribution};
@@ -22,68 +22,75 @@ const TRANSPARENT_SQUARE: char = ' ';
 const OPAQUE_SQUARE: char = '█';
 
 fn print_square(is_transparent: bool) {
-	print!("{}", if is_transparent { TRANSPARENT_SQUARE } else { OPAQUE_SQUARE });
+    print!(
+        "{}",
+        if is_transparent {
+            TRANSPARENT_SQUARE
+        } else {
+            OPAQUE_SQUARE
+        }
+    );
 }
 
 pub fn hitomezashi(width: usize, height: usize, skew: Option<f64>) {
-	let skew: f64 = match skew {
-		Some(n) => { n }
-		None => { 0.5 }
-	};
-
-	let mut rng = rand::thread_rng();
-	let brn = Bernoulli::new(skew).unwrap();
-
-	// the first square (upper left corner) is always opaque
-	let init_bit: bool = false;
-
-	let mut row_bits: Vec<bool> = Vec::with_capacity(height - 1);
-
-	for _ in 0..(height - 1) {
-		row_bits.push(brn.sample(&mut rng));
-	}
-
-	let mut col_bits: Vec<bool> = Vec::with_capacity(width - 1);
-
-	for _ in 0..(width - 1) {
-		col_bits.push(brn.sample(&mut rng));
-	}
-
-	let mut alt_bits: Vec<bool> = Vec::with_capacity(width - 1);
-
-	for col in 0..width {
-		alt_bits.push(col % 2 == 1);
-	}
-
-	// each new row of the pattern depends on the bits directly above it
-	let mut above_bits: Vec<bool> = Vec::with_capacity(width);
-
-	above_bits.push(init_bit);
-	print_square(above_bits[0]);
-
-	for col in 1..width {
-	/* each square in the first row is derived from the square to its left. the column bits
-	 * represent whether there's a stitch between the two squares. if there's a stitch, the squares
-	 * are different, otherwise they are the same. */
-		above_bits.push(above_bits[col - 1] ^ col_bits[col - 1]);
-		print_square(above_bits[col]);
-	}
-
-	println!();
-
-	// height-1 because the first row has already been printed
-	for row in 0..(height - 1) {
-		/* each square in each successive row is derived from the square above it. the row bits
-		 * represent whether there's a stitch between the two squares. if there's a stitch, the
-		 * squares are different, otherwise they are the same. */
-		above_bits
-			.iter_mut()
-			.zip(alt_bits.iter())
-			.for_each(|(x1, &x2)| {
-				*x1 ^= x2 ^ row_bits[row];
-				print_square(*x1);
-			});
-
-		println!();
-	}
+    let skew: f64 = match skew {
+        Some(n) => n,
+        None => 0.5,
+    };
+
+    let mut rng = rand::thread_rng();
+    let brn = Bernoulli::new(skew).unwrap();
+
+    // the first square (upper left corner) is always opaque
+    let init_bit: bool = false;
+
+    let mut row_bits: Vec<bool> = Vec::with_capacity(height - 1);
+
+    for _ in 0..(height - 1) {
+        row_bits.push(brn.sample(&mut rng));
+    }
+
+    let mut col_bits: Vec<bool> = Vec::with_capacity(width - 1);
+
+    for _ in 0..(width - 1) {
+        col_bits.push(brn.sample(&mut rng));
+    }
+
+    let mut alt_bits: Vec<bool> = Vec::with_capacity(width - 1);
+
+    for col in 0..width {
+        alt_bits.push(col % 2 == 1);
+    }
+
+    // each new row of the pattern depends on the bits directly above it
+    let mut above_bits: Vec<bool> = Vec::with_capacity(width);
+
+    above_bits.push(init_bit);
+    print_square(above_bits[0]);
+
+    for col in 1..width {
+        /* each square in the first row is derived from the square to its left. the column bits
+         * represent whether there's a stitch between the two squares. if there's a stitch, the squares
+         * are different, otherwise they are the same. */
+        above_bits.push(above_bits[col - 1] ^ col_bits[col - 1]);
+        print_square(above_bits[col]);
+    }
+
+    println!();
+
+    // height-1 because the first row has already been printed
+    for row in 0..(height - 1) {
+        /* each square in each successive row is derived from the square above it. the row bits
+         * represent whether there's a stitch between the two squares. if there's a stitch, the
+         * squares are different, otherwise they are the same. */
+        above_bits
+            .iter_mut()
+            .zip(alt_bits.iter())
+            .for_each(|(x1, &x2)| {
+                *x1 ^= x2 ^ row_bits[row];
+                print_square(*x1);
+            });
+
+        println!();
+    }
 }