Deryks _dev

Take the path from the command line

cargo run -- somefile.rs opens that file.

Three edits, all small.

editor/src/main.rstop of the file

use eframe::egui;
use std::env;
use std::fs;
use std::io;

Alphabetical, and rustfmt will sort a contiguous block of use lines for you. Keeping them ordered is the sort of small consistency a reviewer notices without being able to say why the file feels tidy.

Second — read the argument at the top of main:

editor/src/main.rstop of main

fn main() -> eframe::Result {
    let path = env::args()
        .nth(1)
        .unwrap_or_else(|| "scratch.md".to_owned());
    let options = eframe::NativeOptions {

Three things in three lines:

• env::args() is an iterator over the command-line arguments — the same kind of thing as self.text.chars() in lesson 4.
• .nth(1) takes the second one, because argument zero is the program's own name. It returns Option<String>: there might not be a second argument, and lesson 4'sOption is how Rust says so.
• .unwrap_or_else(…) is the Option equivalent of "or else use this". Some(p) gives you p; None runs the closure and uses that instead.

Third — use it instead of the literal:

editor/src/main.rsat the bottom of main

        Box::new(|_cc| Ok(Box::new(Editor::open("scratch.md")))),
        Box::new(|_cc| Ok(Box::new(Editor::open(&path)))),

cargo run -- src/main.rs
→ your editor, showing its own source again — by request this time
cargo run
→ no argument, so scratch.md as before

The -- separates cargo's arguments from your program's. Without it, cargo would try to interpret src/main.rs itself.

Open a file that doesn't exist

Find the bug. No code change — just look at what happens.

Now that any path works, try a path that isn't there yet:

cargo run -- notes.md
→ the window opens containing:

could not open notes.md

No such file or directory (os error 2)

Go on — press Ctrl+S and then look:

cat editor/notes.md
→ could not open notes.md

→ No such file or directory (os error 2)

This has been true sincelesson 2, stage 2, where theErr arm put the error message into text. At the time that was the right call: it was the smallest thing that kept the window open, and it demonstrated that failure could be data rather than a crash. But text is thedocument. Anything you put there is something the user might save.

Tell the two apart

A missing file opens as an empty new document. A broken one says so, without polluting the buffer.

One edit, replacing the body of open:

editor/src/main.rsin Editor::open

    /// Open a file into a new editor. A failure becomes the buffer contents,
    /// so the window always opens.
    /// Open a file into a new editor. A file that doesn't exist yet is not an
    /// error — it's a new file, and starts empty.
    fn open(path: &str) -> Self {
        let text = match fs::read_to_string(path) {
            Ok(contents) => contents,
            Err(error) => format!("could not open {path}\n\n{error}"),
        };
        let (text, status) = match fs::read_to_string(path) {
            Ok(contents) => (contents, String::new()),
            Err(error) if error.kind() == io::ErrorKind::NotFound => {
                (String::new(), format!("new file: {path}"))
            }
            Err(error) => (String::new(), format!("could not open {path}: {error}")),
        };
        Self {
            path: path.to_owned(),
            text,
            status: String::new(),
            status,
        }
    }

Three things worth naming here.

The match guard. Err(error) if error.kind() == … — theif after a pattern is a guard. The arm matches only when the pattern fits and the condition holds. Arms are tried top to bottom, so the specific NotFound case gets first refusal and the bare Err below catches everything else: permissions, a directory where a file should be, invalid UTF-8.

ErrorKind. An io::Error isn't just a message; .kind() returns an enum you can match on. That's what lets you make a decision about why something failed rather than pattern-matching on English text, which breaks the moment someone runs your program in another locale.

The tuple. The match now produces two values at once and they're destructured on the way out — the sametuple destructuring asline_col, doing real work: each arm decides both what the buffer holds and what the user is told, and the compiler checks every arm answers both.

Note what the buffer holds in every arm now: file contents, or nothing at all. Never a message. That's the invariant worth remembering —the document is never a place to put diagnostics, because the document is the thing you save.

cargo run -- notes.md
→ an empty window, status: new file: notes.md
→ type something, Ctrl+S, and cat editor/notes.md — your text, and only your text

That's the NotFound arm. To exercise the other one, point the editor at something that exists but isn't a readable file — a directory:

mkdir editor/adir
cargo run -- adir
→ status: could not open adir: Is a directory (os error 21), buffer empty

Not missing, so not a new file — the general Err arm catches it, reports it, and still leaves the document untouched.

cargo fmt && cargo clippy
Both should be silent.