I’ll show you how I wrote each of the functions I described in the previous section, starting with the find_files function. You will notice that it filters out files that have the extension .dat using the type OsStr, which is a Rust type for an operating system’s preferred representation of a string that might not be a valid UTF-8 string. The type OsStr is borrowed, and the owned version is OsString. These are similar to the Path and PathBuf distinctions. Both versions encapsulate the complexities of dealing with filenames on both Windows and Unix platforms. In the following code, you’ll see that I use Path::extension, which returns Option<&OsStr>:

fn find_files(paths: &[String]) -> MyResult<Vec<PathBuf>> {
    let dat = OsStr::new("dat"); 
    let mut files = vec![]; 

    for path in paths {
        match fs::metadata(path) {
            Err(e) => return Err(format!("{}: {}", path, e).into()), 
            Ok(_) => files.extend( 
                WalkDir::new(path)  
                    .into_iter()
                    .filter_map(Result::ok) 
                    .filter(|e| {
                        e.file_type().is_file() 
                            && e.path().extension() != Some(dat)
                    })
                    .map(|e| e.path().into()), 
            ),
        }
    }

    files.sort(); 
    files.dedup(); 
    Ok(files) 
}

Create an OsStr value for the string dat.

Create a mutable vector for the results.

If fs::metadata fails, return a useful error message.

Use Vec::extend to add the results from WalkDir to the results.

Use walkdir::WalkDir to find all the entries from the starting path.

This will ignore any errors for unreadable files or directories, which is the behavior of the original program.

Take only regular files that do not have the .dat extension.

The walkdir::DirEntry::path function returns a Path, so convert it into a PathBuf.

Use Vec::sort to sort the entries in place.

Use Vec::dedup to remove consecutive repeated values.

Return the sorted, unique files.

The files found by the preceding function are the inputs to the read_fortunes function:

fn read_fortunes(paths: &[PathBuf]) -> MyResult<Vec<Fortune>> {
    let mut fortunes = vec![]; 
    let mut buffer = vec![];

    for path in paths { 
        let basename = 
            path.file_name().unwrap().to_string_lossy().into_owned();
        let file = File::open(path).map_err(|e| {
            format!("{}: {}", path.to_string_lossy().into_owned(), e)
        })?; 

        for line in BufReader::new(file).lines().filter_map(Result::ok) 
        {
            if line == "%" { 
                if !buffer.is_empty() { 
                    fortunes.push(Fortune {
                        source: basename.clone(),
                        text: buffer.join("\n"),
                    });
                    buffer.clear();
                }
            } else {
                buffer.push(line.to_string()); 
            }
        }
    }

    Ok(fortunes)
}

Create mutable vectors for the fortunes and a record buffer.

Iterate through the given filenames.

Convert Path::file_name from OsStr to String, using the lossy version in case this is not valid UTF-8. The result is a clone-on-write smart pointer, so use Cow::into_owned to clone the data if it is not already owned.

Open the file or return an error message.

Iterate through the lines of the file.

A sole percent sign (%) indicates the end of a record.

If the buffer is not empty, set the text to the buffer lines joined on newlines and then clear the buffer.

Otherwise, add the current line to the buffer.

Here is how I wrote the pick_fortune function:

fn pick_fortune(fortunes: &[Fortune], seed: Option<u64>) -> Option<String> {
    if let Some(val) = seed { 
        let mut rng = StdRng::seed_from_u64(val); 
        fortunes.choose(&mut rng).map(|f| f.text.to_string()) 
    } else {
        let mut rng = rand::thread_rng(); 
        fortunes.choose(&mut rng).map(|f| f.text.to_string())
    }
}

Check if the user has supplied a seed.

If so, create a PRNG using the provided seed.

Use the PRNG to select one of the fortunes.

Otherwise, use a PRNG seeded by the system.

I can bring all these ideas together in my run like so:

pub fn run(config: Config) -> MyResult<()> {
    let files = find_files(&config.sources)?;
    let fortunes = read_fortunes(&files)?;
    if let Some(pattern) = config.pattern { 
        let mut prev_source = None; 
        for fortune in fortunes 
            .iter()
            .filter(|fortune| pattern.is_match(&fortune.text))
        {
            if prev_source.as_ref().map_or(true, |s| s != &fortune.source) { 
                eprintln!("({})\n%", fortune.source);
                prev_source = Some(fortune.source.clone()); 
            }
            println!("{}\n%", fortune.text); 
        }
    } else {
        println!( 
            "{}",
            pick_fortune(&fortunes, config.seed)
                .or_else(|| Some("No fortunes found".to_string()))
                .unwrap()
        );
    }
    Ok(())
}

Check if the user has provided a pattern option.

Initialize a mutable variable to remember the last fortune source.

Iterate over the found fortunes and filter for those matching the provided regular expression.

Print the source header if the current source is not the same as the previous one seen.

Store the current fortune source.

Print the text of the fortune.

Print a random fortune or a message that states that there are no fortunes to be found.

At this point, the program passes all the provided tests. I provided more guidance on this challenge because of the many steps involved in finding and reading files and then printing all the matching records or using a PRNG to randomly select one. I hope you enjoyed that as much as I did.