rodarte_minigrep/

lib.rs

//! # Minigrep
//!
//! A library to perform simple text searching against a string content target.

use std::{env, error, fs};

/// Main structure that holds the data required for the process to work.
#[derive(Debug, PartialEq)]
pub struct Config {
  /// What are we searching for in the string content target?
  pub query: String,
  /// Where does the content target live in my file system?
  pub file_path: String,
  /// Should the searching process be case sensitive (`false`) or insensitive (`true`)?
  pub ignore_case: bool,
}

impl Config {
  /// Tries to build an instance of `Config` by reading the first three arguments passed to the command.
  ///
  /// 1. The first argument is **ignored** as the project name is NOT used in this application.
  /// 2. The second argument will be bound to the `query` field
  /// 3. The third argument will be bound to the `file_path` field.
  ///
  /// An optional `IGNORE_CASE` environment value is accepted if case-insensitive searching is desired.
  /// You may set `IGNORE_CASE` to any valid value in order to trigger this behavior, which sets the `ignore_case` field to `true`
  ///
  /// # Examples
  /// ```
  /// use minigrep::{run, Config};
  ///
  /// let args = vec![
  ///   String::from("target/debug/minigrep"),
  ///   String::from("foo"),
  ///   String::from("/path/to/file.txt")
  /// ].into_iter();
  ///
  /// let result = Config::build(args);
  ///
  /// if let Ok(config) = result {
  ///   assert!(!config.ignore_case);
  ///   run(config);
  /// }
  /// ```
  ///
  /// # Errors
  /// The function returns an `Err` if it fails to find at least two arguments inside the iterator
  ///
  /// ```
  /// use minigrep::Config;
  ///
  /// let args = vec![
  ///   String::from("target/debug/minigrep"),
  ///   String::from("foo")
  /// ].into_iter();
  ///
  /// let result = Config::build(args);
  ///
  /// assert_eq!(result, Err("Need to provide a second 'file_path' argument"));
  /// ```
  pub fn build(
    mut args: impl Iterator<Item = String>,
  ) -> Result<Self, &'static str> {
    args.next();

    let query: String = match args.next() {
      Some(q) => q,
      None => return Err("Need to provide a first 'query' argument"),
    };

    let file_path: String = match args.next() {
      Some(f) => f,
      None => return Err("Need to provide a second 'file_path' argument"),
    };

    let ignore_case: bool = env::var("IGNORE_CASE").is_ok();

    Ok(Config {
      query,
      file_path,
      ignore_case,
    })
  }
}

/// Entrypoint function that bootstraps the searching application using a `Config` instance.
///
/// It reads the file defined in `config.file_path` and runs either the `search` or `search_case_insensitive`
/// functions, depending on what `config.ignore_case` is set to.
///
/// If `config.ignore_case` is `true`, `search_case_insensitive` is called for a case-insensitive search is done.
/// If `config.ignore_case` is `false`, `search` is called and a case-sensitive search is done.
///
/// Matching lines are printed to standard output
///
/// # Example
///
/// ```
/// use minigrep::{run, Config};
///
/// let args = vec![
///   String::from("target/debug/minigrep"),
///   String::from("foo"),
///   String::from("/path/to/file.txt")
/// ].into_iter();
///
/// let result = Config::build(args);
///
/// if let Ok(config) = result {
///   run(config);
/// }
/// ```
///
/// # Errors
/// An `Err` variant is returned if `fs::read_to_string` fails to read the file.
pub fn run(config: Config) -> Result<(), Box<dyn error::Error>> {
  let contents: String = fs::read_to_string(config.file_path)?;

  let results: Vec<&str> = if !config.ignore_case {
    search(&config.query, &contents)
  } else {
    search_case_insensitive(&config.query, &contents)
  };

  for line in results {
    println!("{line}");
  }

  Ok(())
}

/// Performs a case-sensitive search of a `query` string against a target `contents` string,
/// returning a vector with the matching lines.
///
/// # Example
///
/// ```
/// use minigrep::search;
///
/// let query = "rust";
///
/// let contents = "\
/// RUST is cool. This should NOT match.
/// rUsT is awesome. This should NOT match.
/// rust is nice. This should match.
/// ";
///
/// let results = search(query, contents);
///
/// assert_eq!(results, vec!["rust is nice. This should match."]);
/// ```
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
  contents
    .lines()
    .filter(|&line| line.contains(query))
    .collect()
}

/// Performs a case-insensitive search of a `query` string against a target `contents` string,
/// returning a vector with the matching lines.
///
/// # Example
///
/// ```
/// use minigrep::search_case_insensitive;
///
/// let query = "rust";
///
/// let contents = "\
/// I am quite RUsTy. This should match.
/// I am a rUStacean. This should match.
/// Python is nice. This should NOT match.
/// ";
///
/// let results = search_case_insensitive(query, contents);
///
/// assert_eq!(
///   results,
///   vec![
///     "I am quite RUsTy. This should match.",
///     "I am a rUStacean. This should match."
///   ]
/// );
/// ```
pub fn search_case_insensitive<'a>(
  query: &str,
  contents: &'a str,
) -> Vec<&'a str> {
  let query: String = query.to_lowercase();
  let mut results: Vec<&str> = Vec::new();
  for line in contents.lines() {
    if line.to_lowercase().contains(&query) {
      results.push(line)
    }
  }
  results
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn case_sensitive() {
    let query: &str = "duct";
    let contents: &str = "\
Rust:
safe, fast, productive.
Pick three.
Duct tape.";

    assert_eq!(vec!["safe, fast, productive."], search(query, contents));
  }

  #[test]
  fn case_insensitive() {
    let query: &str = "rUsT";
    let contents: &str = "\
Rust:
safe, fast, productive.
Pick three.
Trust me.";

    assert_eq!(
      vec!["Rust:", "Trust me."],
      search_case_insensitive(query, contents)
    );
  }
}