initial commit

Author: bitfield

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "up2code"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.89"
+regex = "1.11.0"

Cargo.toml

@@ -0,0 +1,33 @@
+use regex::Regex;
+use std::{env, fs, sync::LazyLock};
+
+static LISTINGS: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(
+        r"(?m)^```rust\n(?<code>[^`]+?)\n?```\n\(\[Listing `(?<listing>[\s\S]+?)`\]\((?<link>.*?)\)",
+    )
+    .unwrap()
+});
+
+fn main() -> anyhow::Result<()> {
+    let paths: Vec<String> = env::args().skip(1).collect();
+    if paths.is_empty() {
+        eprintln!("Usage: up2code [PATH, ...]");
+        return Ok(());
+    }
+    for path in &paths {
+        let text = fs::read_to_string(path)?;
+        // println!("{text}");
+        LISTINGS.captures_iter(&text).for_each(|m| {
+            if let Some(code) = m.name("code") {
+                println!("Code: {}", code.as_str());
+            }
+            if let Some(listing) = m.name("listing") {
+                println!("Listing: {}", listing.as_str());
+            }
+            if let Some(link) = m.name("link") {
+                println!("Link: {}", link.as_str());
+            }
+        });
+    }
+    Ok(())
+}

src/main.rs

@@ -0,0 +1,34 @@
+The conventional answer to this in Rust is to put our unit tests inside a module (`mod tests`, let's say, though the name is up to us), and then protect that module with a `cfg(test)` attribute:
+
+\vspace{5pt}
+```rust
+#[cfg(test)]
+mod tests {
+    // tests go here
+}
+```
+
+`cfg` turns compilation on or off for the item it's attached to, based on the value of some expression. `cfg(test)` means the `tests` module will be compiled only if we're running in `cargo test` mode. Otherwise it will be ignored entirely, saving time, energy, and the planet.
+
+### Anatomy of a test module
+
+So here's what our test looks like once we've moved it into its own module:
+
+\vspace{5pt}
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io;
+
+    #[test]
+    fn count_lines_fn_counts_lines_in_input() {
+        let input = io::Cursor::new("line 1\nline2\n");
+        let lines = count_lines(input);
+        assert_eq!(2, lines);
+    }
+}
+```
+([Listing `counter_2`](https://github.com/bitfield/tsr-tools/blob/main/counter_2/src/lib.rs))
+
+A module can have its own `use` declarations, which is handy since we often want to `use` things in tests that we don't need in the library itself (`std::io` in this example).