Working with Environment Variables

We’ll improve minigrep by adding an extra feature: an option for case-insensitive searching that the user can turn on via an environment variable. We could make this feature a command line option and require that users enter it each time they want it to apply, but instead we’ll use an environment variable. Doing so allows our users to set the environment variable once and have all their searches be case insensitive in that terminal session.

Writing a Failing Test for the Case-Insensitive search Function

We want to add a new search_case_insensitive function that we’ll call when the environment variable is on. We’ll continue to follow the TDD process, so the first step is again to write a failing test. We’ll add a new test for the new search_case_insensitive function and rename our old test from one_result to case_sensitive to clarify the differences between the two tests, as shown in Listing 12-20.

Filename: src/lib.rs

  1. use std::error::Error;
  2. use std::fs;
  4. pub struct Config {
  5.     pub query: String,
  6.     pub filename: String,
  7. }
  9. impl Config {
  10.     pub fn new(args: &[String]) -> Result<Config, &str> {
  11.         if args.len() < 3 {
  12.             return Err("not enough arguments");
  13.         }
  15.         let query = args[1].clone();
  16.         let filename = args[2].clone();
  18.         Ok(Config { query, filename })
  19.     }
  20. }
  22. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  23.     let contents = fs::read_to_string(config.filename)?;
  25.     for line in search(&config.query, &contents) {
  26.         println!("{}", line);
  27.     }
  29.     Ok(())
  30. }
  32. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  33.     let mut results = Vec::new();
  35.     for line in contents.lines() {
  36.         if line.contains(query) {
  37.             results.push(line);
  38.         }
  39.     }
  41.     results
  42. }
  44. #[cfg(test)]
  45. mod tests {
  46.     use super::*;
  48.     #[test]
  49.     fn case_sensitive() {
  50.         let query = "duct";
  51.         let contents = "\
  52. Rust:
  53. safe, fast, productive.
  54. Pick three.
  55. Duct tape.";
  57.         assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  58.     }
  60.     #[test]
  61.     fn case_insensitive() {
  62.         let query = "rUsT";
  63.         let contents = "\
  64. Rust:
  65. safe, fast, productive.
  66. Pick three.
  67. Trust me.";
  69.         assert_eq!(
  70.             vec!["Rust:", "Trust me."],
  71.             search_case_insensitive(query, contents)
  72.         );
  73.     }
  74. }

Listing 12-20: Adding a new failing test for the case-insensitive function we’re about to add

Note that we’ve edited the old test’s contents too. We’ve added a new line with the text "Duct tape." using a capital D that shouldn’t match the query "duct" when we’re searching in a case-sensitive manner. Changing the old test in this way helps ensure that we don’t accidentally break the case-sensitive search functionality that we’ve already implemented. This test should pass now and should continue to pass as we work on the case-insensitive search.

The new test for the case-insensitive search uses "rUsT" as its query. In the search_case_insensitive function we’re about to add, the query "rUsT" should match the line containing "Rust:" with a capital R and match the line "Trust me." even though both have different casing from the query. This is our failing test, and it will fail to compile because we haven’t yet defined the search_case_insensitive function. Feel free to add a skeleton implementation that always returns an empty vector, similar to the way we did for the search function in Listing 12-16 to see the test compile and fail.

Implementing the search_case_insensitive Function

The search_case_insensitive function, shown in Listing 12-21, will be almost the same as the search function. The only difference is that we’ll lowercase the query and each line so whatever the case of the input arguments, they’ll be the same case when we check whether the line contains the query.

Filename: src/lib.rs

  1. use std::error::Error;
  2. use std::fs;
  4. pub struct Config {
  5.     pub query: String,
  6.     pub filename: String,
  7. }
  9. impl Config {
  10.     pub fn new(args: &[String]) -> Result<Config, &str> {
  11.         if args.len() < 3 {
  12.             return Err("not enough arguments");
  13.         }
  15.         let query = args[1].clone();
  16.         let filename = args[2].clone();
  18.         Ok(Config { query, filename })
  19.     }
  20. }
  22. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  23.     let contents = fs::read_to_string(config.filename)?;
  25.     for line in search(&config.query, &contents) {
  26.         println!("{}", line);
  27.     }
  29.     Ok(())
  30. }
  32. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  33.     let mut results = Vec::new();
  35.     for line in contents.lines() {
  36.         if line.contains(query) {
  37.             results.push(line);
  38.         }
  39.     }
  41.     results
  42. }
  44. pub fn search_case_insensitive<'a>(
  45.     query: &str,
  46.     contents: &'a str,
  47. ) -> Vec<&'a str> {
  48.     let query = query.to_lowercase();
  49.     let mut results = Vec::new();
  51.     for line in contents.lines() {
  52.         if line.to_lowercase().contains(&query) {
  53.             results.push(line);
  54.         }
  55.     }
  57.     results
  58. }
  60. #[cfg(test)]
  61. mod tests {
  62.     use super::*;
  64.     #[test]
  65.     fn case_sensitive() {
  66.         let query = "duct";
  67.         let contents = "\
  68. Rust:
  69. safe, fast, productive.
  70. Pick three.
  71. Duct tape.";
  73.         assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  74.     }
  76.     #[test]
  77.     fn case_insensitive() {
  78.         let query = "rUsT";
  79.         let contents = "\
  80. Rust:
  81. safe, fast, productive.
  82. Pick three.
  83. Trust me.";
  85.         assert_eq!(
  86.             vec!["Rust:", "Trust me."],
  87.             search_case_insensitive(query, contents)
  88.         );
  89.     }
  90. }

Listing 12-21: Defining the search_case_insensitive function to lowercase the query and the line before comparing them

First, we lowercase the query string and store it in a shadowed variable with the same name. Calling to_lowercase on the query is necessary so no matter whether the user’s query is "rust", "RUST", "Rust", or "rUsT", we’ll treat the query as if it were "rust" and be insensitive to the case. While to_lowercase will handle basic Unicode, it won’t be 100% accurate. If we were writing a real application, we’d want to do a bit more work here, but this section is about environment variables, not Unicode, so we’ll leave it at that here.

Note that query is now a String rather than a string slice, because calling to_lowercase creates new data rather than referencing existing data. Say the query is "rUsT", as an example: that string slice doesn’t contain a lowercase u or t for us to use, so we have to allocate a new String containing "rust". When we pass query as an argument to the contains method now, we need to add an ampersand because the signature of contains is defined to take a string slice.

Next, we add a call to to_lowercase on each line before we check whether it contains query to lowercase all characters. Now that we’ve converted line and query to lowercase, we’ll find matches no matter what the case of the query is.

Let’s see if this implementation passes the tests:

  1. $ cargo test
  2.    Compiling minigrep v0.1.0 (file:///projects/minigrep)
  3.     Finished test [unoptimized + debuginfo] target(s) in 1.33s
  4.      Running target/debug/deps/minigrep-4672b652f7794785
  6. running 2 tests
  7. test tests::case_insensitive ... ok
  8. test tests::case_sensitive ... ok
  10. test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
  12.      Running target/debug/deps/minigrep-4672b652f7794785
  14. running 0 tests
  16. test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
  18.    Doc-tests minigrep
  20. running 0 tests
  22. test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Great! They passed. Now, let’s call the new search_case_insensitive function from the run function. First, we’ll add a configuration option to the Config struct to switch between case-sensitive and case-insensitive search. Adding this field will cause compiler errors because we aren’t initializing this field anywhere yet:

Filename: src/lib.rs

  1. use std::error::Error;
  2. use std::fs;
  4. pub struct Config {
  5.     pub query: String,
  6.     pub filename: String,
  7.     pub case_sensitive: bool,
  8. }
  10. impl Config {
  11.     pub fn new(args: &[String]) -> Result<Config, &str> {
  12.         if args.len() < 3 {
  13.             return Err("not enough arguments");
  14.         }
  16.         let query = args[1].clone();
  17.         let filename = args[2].clone();
  19.         Ok(Config { query, filename })
  20.     }
  21. }
  23. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  24.     let contents = fs::read_to_string(config.filename)?;
  26.     let results = if config.case_sensitive {
  27.         search(&config.query, &contents)
  28.     } else {
  29.         search_case_insensitive(&config.query, &contents)
  30.     };
  32.     for line in results {
  33.         println!("{}", line);
  34.     }
  36.     Ok(())
  37. }
  39. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  40.     let mut results = Vec::new();
  42.     for line in contents.lines() {
  43.         if line.contains(query) {
  44.             results.push(line);
  45.         }
  46.     }
  48.     results
  49. }
  51. pub fn search_case_insensitive<'a>(
  52.     query: &str,
  53.     contents: &'a str,
  54. ) -> Vec<&'a str> {
  55.     let query = query.to_lowercase();
  56.     let mut results = Vec::new();
  58.     for line in contents.lines() {
  59.         if line.to_lowercase().contains(&query) {
  60.             results.push(line);
  61.         }
  62.     }
  64.     results
  65. }
  67. #[cfg(test)]
  68. mod tests {
  69.     use super::*;
  71.     #[test]
  72.     fn case_sensitive() {
  73.         let query = "duct";
  74.         let contents = "\
  75. Rust:
  76. safe, fast, productive.
  77. Pick three.
  78. Duct tape.";
  80.         assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  81.     }
  83.     #[test]
  84.     fn case_insensitive() {
  85.         let query = "rUsT";
  86.         let contents = "\
  87. Rust:
  88. safe, fast, productive.
  89. Pick three.
  90. Trust me.";
  92.         assert_eq!(
  93.             vec!["Rust:", "Trust me."],
  94.             search_case_insensitive(query, contents)
  95.         );
  96.     }
  97. }

Note that we added the case_sensitive field that holds a Boolean. Next, we need the run function to check the case_sensitive field’s value and use that to decide whether to call the search function or the search_case_insensitive function, as shown in Listing 12-22. Note this still won’t compile yet.

Filename: src/lib.rs

  1. use std::error::Error;
  2. use std::fs;
  4. pub struct Config {
  5.     pub query: String,
  6.     pub filename: String,
  7.     pub case_sensitive: bool,
  8. }
  10. impl Config {
  11.     pub fn new(args: &[String]) -> Result<Config, &str> {
  12.         if args.len() < 3 {
  13.             return Err("not enough arguments");
  14.         }
  16.         let query = args[1].clone();
  17.         let filename = args[2].clone();
  19.         Ok(Config { query, filename })
  20.     }
  21. }
  23. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  24.     let contents = fs::read_to_string(config.filename)?;
  26.     let results = if config.case_sensitive {
  27.         search(&config.query, &contents)
  28.     } else {
  29.         search_case_insensitive(&config.query, &contents)
  30.     };
  32.     for line in results {
  33.         println!("{}", line);
  34.     }
  36.     Ok(())
  37. }
  39. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  40.     let mut results = Vec::new();
  42.     for line in contents.lines() {
  43.         if line.contains(query) {
  44.             results.push(line);
  45.         }
  46.     }
  48.     results
  49. }
  51. pub fn search_case_insensitive<'a>(
  52.     query: &str,
  53.     contents: &'a str,
  54. ) -> Vec<&'a str> {
  55.     let query = query.to_lowercase();
  56.     let mut results = Vec::new();
  58.     for line in contents.lines() {
  59.         if line.to_lowercase().contains(&query) {
  60.             results.push(line);
  61.         }
  62.     }
  64.     results
  65. }
  67. #[cfg(test)]
  68. mod tests {
  69.     use super::*;
  71.     #[test]
  72.     fn case_sensitive() {
  73.         let query = "duct";
  74.         let contents = "\
  75. Rust:
  76. safe, fast, productive.
  77. Pick three.
  78. Duct tape.";
  80.         assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  81.     }
  83.     #[test]
  84.     fn case_insensitive() {
  85.         let query = "rUsT";
  86.         let contents = "\
  87. Rust:
  88. safe, fast, productive.
  89. Pick three.
  90. Trust me.";
  92.         assert_eq!(
  93.             vec!["Rust:", "Trust me."],
  94.             search_case_insensitive(query, contents)
  95.         );
  96.     }
  97. }

Listing 12-22: Calling either search or search_case_insensitive based on the value in config.case_sensitive

Finally, we need to check for the environment variable. The functions for working with environment variables are in the env module in the standard library, so we want to bring that module into scope with a use std::env; line at the top of src/lib.rs. Then we’ll use the var function from the env module to check for an environment variable named CASE_INSENSITIVE, as shown in Listing 12-23.

Filename: src/lib.rs

  1. use std::env;
  2. // --snip--
  4. use std::error::Error;
  5. use std::fs;
  7. pub struct Config {
  8.     pub query: String,
  9.     pub filename: String,
  10.     pub case_sensitive: bool,
  11. }
  13. impl Config {
  14.     pub fn new(args: &[String]) -> Result<Config, &str> {
  15.         if args.len() < 3 {
  16.             return Err("not enough arguments");
  17.         }
  19.         let query = args[1].clone();
  20.         let filename = args[2].clone();
  22.         let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
  24.         Ok(Config {
  25.             query,
  26.             filename,
  27.             case_sensitive,
  28.         })
  29.     }
  30. }
  32. pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
  33.     let contents = fs::read_to_string(config.filename)?;
  35.     let results = if config.case_sensitive {
  36.         search(&config.query, &contents)
  37.     } else {
  38.         search_case_insensitive(&config.query, &contents)
  39.     };
  41.     for line in results {
  42.         println!("{}", line);
  43.     }
  45.     Ok(())
  46. }
  48. pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  49.     let mut results = Vec::new();
  51.     for line in contents.lines() {
  52.         if line.contains(query) {
  53.             results.push(line);
  54.         }
  55.     }
  57.     results
  58. }
  60. pub fn search_case_insensitive<'a>(
  61.     query: &str,
  62.     contents: &'a str,
  63. ) -> Vec<&'a str> {
  64.     let query = query.to_lowercase();
  65.     let mut results = Vec::new();
  67.     for line in contents.lines() {
  68.         if line.to_lowercase().contains(&query) {
  69.             results.push(line);
  70.         }
  71.     }
  73.     results
  74. }
  76. #[cfg(test)]
  77. mod tests {
  78.     use super::*;
  80.     #[test]
  81.     fn case_sensitive() {
  82.         let query = "duct";
  83.         let contents = "\
  84. Rust:
  85. safe, fast, productive.
  86. Pick three.
  87. Duct tape.";
  89.         assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  90.     }
  92.     #[test]
  93.     fn case_insensitive() {
  94.         let query = "rUsT";
  95.         let contents = "\
  96. Rust:
  97. safe, fast, productive.
  98. Pick three.
  99. Trust me.";
  101.         assert_eq!(
  102.             vec!["Rust:", "Trust me."],
  103.             search_case_insensitive(query, contents)
  104.         );
  105.     }
  106. }

Listing 12-23: Checking for an environment variable named CASE_INSENSITIVE

Here, we create a new variable case_sensitive. To set its value, we call the env::var function and pass it the name of the CASE_INSENSITIVE environment variable. The env::var function returns a Result that will be the successful Ok variant that contains the value of the environment variable if the environment variable is set. It will return the Err variant if the environment variable is not set.

We’re using the is_err method on the Result to check whether it’s an error and therefore unset, which means it should do a case-sensitive search. If the CASE_INSENSITIVE environment variable is set to anything, is_err will return false and the program will perform a case-insensitive search. We don’t care about the value of the environment variable, just whether it’s set or unset, so we’re checking is_err rather than using unwrap, expect, or any of the other methods we’ve seen on Result.

We pass the value in the case_sensitive variable to the Config instance so the run function can read that value and decide whether to call search or search_case_insensitive, as we implemented in Listing 12-22.

Let’s give it a try! First, we’ll run our program without the environment variable set and with the query to, which should match any line that contains the word “to” in all lowercase:

  1. $ cargo run to poem.txt
  2.    Compiling minigrep v0.1.0 (file:///projects/minigrep)
  3.     Finished dev [unoptimized + debuginfo] target(s) in 0.0s
  4.      Running `target/debug/minigrep to poem.txt`
  5. Are you nobody, too?
  6. How dreary to be somebody!

Looks like that still works! Now, let’s run the program with CASE_INSENSITIVE set to 1 but with the same query to.

If you’re using PowerShell, you will need to set the environment variable and run the program as separate commands:

  1. PS> $Env:CASE_INSENSITIVE=1; cargo run to poem.txt

This will make CASE_INSENSITIVE persist for the remainder of your shell session. It can be unset with the Remove-Item cmdlet:

  1. PS> Remove-Item Env:CASE_INSENSITIVE

We should get lines that contain “to” that might have uppercase letters:

  1. $ CASE_INSENSITIVE=1 cargo run to poem.txt
  2.     Finished dev [unoptimized + debuginfo] target(s) in 0.0s
  3.      Running `target/debug/minigrep to poem.txt`
  4. Are you nobody, too?
  5. How dreary to be somebody!
  6. To tell your name the livelong day
  7. To an admiring bog!

Excellent, we also got lines containing “To”! Our minigrep program can now do case-insensitive searching controlled by an environment variable. Now you know how to manage options set using either command line arguments or environment variables.

Some programs allow arguments and environment variables for the same configuration. In those cases, the programs decide that one or the other takes precedence. For another exercise on your own, try controlling case insensitivity through either a command line argument or an environment variable. Decide whether the command line argument or the environment variable should take precedence if the program is run with one set to case sensitive and one set to case insensitive.

The std::env module contains many more useful features for dealing with environment variables: check out its documentation to see what is available.