Ferris Talk #15: Bedingte Kompilierung in Rust

fn main() {
  // Note that you can combine configuration 
  // predicates with all, any, and not.
  #[cfg(not(any(traditional, vegetarian, vegan)))]
  {
    println!(r"You haven't specified whether the
recipe should be traditional, vegetarian, or vegan.");

    panic!();
  }

  #[cfg(any(all(traditional, vegetarian), 
        all(traditional, vegan), 
        all(vegetarian, vegan)))]
  {
    println!(r"You've specified more than one
recipe type. Please specify only one.");

    panic!();
  }

  print_ingredients();
  print_preparation();
}

fn print_ingredients() {
  println!("Ingredients for Caesar Salad:");
    
  println!("- Romaine lettuce");
  println!("- Croutons");
  println!("- Lemon juice");
  println!("- Olive oil");
  println!("- Salt");
  println!("- Black pepper");

  // We combine config predicates again
  #[cfg(any(traditional, vegetarian))]
  println!("- Parmesan cheese");
  #[cfg(any(vegan))]
  println!("- Vegan Parmesan cheese substitute");

  // Note that the cfg attribute can be applied 
  // to any item, not just a line of code. In 
  // this case, we're using it to conditionally
  // include a block of code. You could also 
  // conditionally define a module, struct, 
  // trait, function, etc.
  #[cfg(traditional)]
  {
    println!("- Anchovies");
    println!("- Egg yolks");
  }

  #[cfg(vegetarian)]
  {
    println!("- Capers");
    println!("- Egg yolks");
  }

  #[cfg(vegan)]
  {
    println!("- Capers");
    println!("- Vegan mayonnaise");
  }
}

fn print_preparation() {
  println!("\nPreparation:");

  println!(r"1. Wash and tear the romaine
lettuce into bite-size pieces.");
  println!(r"2. In a bowl, combine lemon juice,
olive oil, salt, and pepper.");
    
  // Instead of the config attribute, we can also 
  // use the cfg! macro. Note that it does NOT 
  // remove any code. The macro only evaluates 
  // to true or false at compile time.
  // The following code might not be the best 
  // option in real life, but it's a good
  // example of how to use the cfg! macro.
  match (cfg!(traditional), 
         cfg!(vegetarian), 
         cfg!(vegan)) {
    (true, false, false) => 
      println!(r"3. Add grated Parmesan cheese,
anchovies, and egg yolks to the bowl."),
    (false, true, false) => 
       println!(r"3. Add grated Parmesan cheese,
capers, and egg yolks to the bowl."),
    (false, false, true) => 
       println!(r"3. Add vegan Parmesan cheese 
substitute, capers, and vegan mayonnaise to the bowl."),
    _ => panic!(r"More than one recipe type? 
This should never happen!"),
    };

    println!(r"4. Mix well until the ingredients
are well-combined.");
    println!(r"5. Add the croutons and romaine
lettuce to the bowl.");
    println!(r"6. Toss until the lettuce is 
well-coated with the dressing.");
    println!(r"7. Serve immediately and enjoy
your Caesar Salad!");
}

[package]
name = "salad_maker_with_features"
version = "0.1.0"
edition = "2021"

[features]
default = []
traditional = []
vegetarian = []
vegan = []
all = ["traditional", "vegetarian", "vegan"]

[dependencies]

fn main() {
  // Note that we are now checking cargo features
  #[cfg(not(any(feature = "traditional", 
                feature = "vegetarian", 
                feature = "vegan")))]
  {
    println!(r"You haven't specified whether the
recipe should be traditional, vegetarian, or vegan.");
    panic!();
  }

  #[cfg(any(all(feature = "traditional", 
                feature = "vegetarian"), 
            all(feature = "traditional", 
                feature = "vegan"), 
            all(feature = "vegetarian", 
                feature = "vegan")))]
  {
    println!(r"You've specified more than one
recipe type. Please specify only one.");
    panic!();
  }

  print_ingredients();
  print_preparation();
}

fn print_ingredients() {
  println!("Ingredients for Caesar Salad:");
    
    [...]

  // We combine config predicates again
  #[cfg(any(feature = "traditional", 
            feature = "vegetarian"))]
  println!("- Parmesan cheese");
  #[cfg(any(feature = "vegan"))]
  println!("- Vegan Parmesan cheese substitute");

  #[cfg(feature = "traditional")]
  {
      println!("- Anchovies");
      println!("- Egg yolks");
  }

  [...]
}

fn print_preparation() {
  println!("\nPreparation:");

  println!(r"1. Wash and tear the romaine
lettuce into bite-size pieces.");
  println!(r"2. In a bowl, combine lemon juice,
olive oil, salt, and pepper.");
    
  match (cfg!(feature = "traditional"), 
         cfg!(feature = "vegetarian"), 
         cfg!(feature = "vegan")) {
    (true, false, false) 
      => println!(r"3. Add grated Parmesan cheese,
anchovies, and egg yolks to the bowl."),
    (false, true, false) 
      => println!(r"3. Add grated Parmesan cheese, 
capers, and egg yolks to the bowl."),
    (false, false, true) => 
       println!(r"3. Add vegan Parmesan cheese
substitute, capers, and vegan mayonnaise to the bowl."),
    _ => panic!(r"More than one recipe type? 
This should never happen!"),
  };

  [...]
}

#[derive(Debug, PartialEq, Eq)]
pub enum RecipeType { Traditional, Vegetarian, Vegan, }

pub mod caesar_salad {
  use super::*;

  // Get ingredients for a Caesar salad
  pub fn get_ingredients(recipe_type: RecipeType) 
    -> Vec<&'static str> 
  {
    let mut ingredients = vec![
      "Romaine lettuce", "Croutons", "Lemon juice",
      "Olive oil", "Salt", "Black pepper",
    ];

    ingredients.push(match recipe_type {
      RecipeType::Traditional | 
      RecipeType::Vegetarian => "Parmesan cheese",
      _ => "Vegan Parmesan cheese substitute",
    });

    ingredients.extend_from_slice(match recipe_type {
      RecipeType::Traditional 
        => &["Anchovies", "Egg yolks"],
      RecipeType::Vegetarian 
        => &["Capers", "Egg yolks"],
      _ => &["Capers", "Vegan mayonnaise"],
    });

    ingredients
  }
}

// The code for automated tests must only be
// compiled when the test suite is run (cargo test).
#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn no_anchovies_in_vegetarian() {
    let ingredients = 
      caesar_salad::get_ingredients(RecipeType::Vegetarian);
    // Make sure there are no anchovies in a 
    //vegetarian salad
    assert!(!ingredients.contains(&"Anchovies"));
  }

  // Add additional tests here
}

toml
[package]
name = "recipe_reader"
version = "0.1.0"
edition = "2021"

[features]
default = ["json"]
all = ["json", "yaml"]
json = ["dep:serde_json"]
yaml = ["dep:serde_yaml"]

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = { version = "1", optional = true }
serde_yaml = { version = "0", optional = true }
anyhow = "1"

[dev-dependencies]
mockall = "0"

#[cfg(any(feature = "json", feature = "yaml"))]
use std::{fs::File, io::Read};

use anyhow::Result;
use serde::Deserialize;

// We only reference automock when testing
#[cfg(test)]
use mockall::automock;

#[derive(Debug, Deserialize)]
pub struct Recipe {
  pub title: String,
  pub ingredients: Option<Vec<String>>,
  pub steps: Option<Vec<String>>,
}

// We add the automock attribute to the trait
// ONLY when testing. This is where cfg_attr
// comes in handy.
#[cfg_attr(test, automock)]
pub trait RecipeReader {
  fn read_from_file(&self, path: &str) -> Result<Recipe>;
}

// The json module with the JsonRecipeReader is
// only compiled when the json feature is enabled.
#[cfg(feature = "json")]
pub mod json
{
  use super::*;

  pub struct JsonRecipeReader();

  impl RecipeReader for JsonRecipeReader {
     fn read_from_file(&self, path: &str) 
       -> Result<Recipe> {
       let mut contents = String::new();
       File::open(path)?.read_to_string(&mut contents)?;
       Ok(serde_json::from_str(&contents)?)
     }
  }
}

// The yaml module with the YamlRecipeReader is
// only compiled when the yaml feature is enabled.
#[cfg(feature = "yaml")]
pub mod yaml
{
  use super::*;
    
  pub struct YamlRecipeReader();

  impl RecipeReader for YamlRecipeReader {
    fn read_from_file(&self, path: &str) 
      -> Result<Recipe> 
    {
      let mut contents = String::new();
      File::open(path)?.read_to_string(&mut contents)?;
      Ok(serde_yaml::from_str(&contents)?)
    }
  }
}

pub struct RecipeMarkdownFactory();

impl RecipeMarkdownFactory {
  pub fn file_to_markdown(&self, 
                          path: &str, 
                          reader: impl RecipeReader) 
    -> Result<String> 
  {
    // Read recipe from file using a reader
    let recipe = reader.read_from_file(path)?;

    // Convert recipe into markdown
    let mut markdown = String::new();
    markdown.push_str(&format!("# {}\n\n", 
                      recipe.title));
    if let Some(i) = recipe.ingredients {
      markdown.push_str("## Ingredients\n\n");
      for ingredient in i {
        markdown.push_str(&format!("* {ingredient}\n"));
      }
      markdown.push('\n');
    }

    if let Some(s) = recipe.steps{
      markdown.push_str("## Steps\n\n");
      for (i, step) in s.iter().enumerate() {
        markdown.push_str(&format!("{}. {step}\n",
                          i + 1));
      }
    }

    Ok(markdown)
  }
}

// The code for automated tests must only be 
// compiled when the test suite is run (cargo test).
#[cfg(test)]
mod tests {
  use mockall::predicate::eq;

  use super::*;

  // Parts of the tests are only compiled when the 
  // corresponding feature is enabled.
  #[cfg(feature = "json")]
  use super::json::*;
  #[cfg(feature = "yaml")]
  use super::yaml::*;

  #[cfg(any(feature = "json", feature = "yaml"))]
  fn get_expected_markdown() -> String {
    let mut markdown = String::new();
    File::open("caesar_expected.md")
      .unwrap().read_to_string(&mut markdown).unwrap();
    markdown
  }

  #[cfg(feature = "json")]
  #[test]
  fn json_caesar_salad_to_markdown() {
    let reader = JsonRecipeReader();
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = 
    markdown_factory
     .file_to_markdown("caesar_salad.json", 
                       reader).unwrap();

    assert_eq!(markdown, get_expected_markdown());
  }

  #[cfg(feature = "yaml")]
  #[test]
  fn yaml_caesar_salad_to_markdown() {
    let reader = YamlRecipeReader();
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = 
      markdown_factory
        .file_to_markdown("caesar_salad.yaml", 
                          reader).unwrap();

    assert_eq!(markdown, get_expected_markdown());
  }

  #[test]
  fn no_ingredients() {
    // Here we use the mockall crate to create a mock
    // of the RecipeReader trait. We can then use this
    // mock to test the RecipeMarkdownFactory without
    // having to read from a file.
    let mut reader_mock = MockRecipeReader::new();
    reader_mock
      .expect_read_from_file()
      .with(eq("no_ingredients.json"))
      .returning(|_| {
        Ok(Recipe {
          title: "No Ingredients".to_string(),
          ingredients: None,
          steps: Some(vec!["Step 1".to_string(), 
                           "Step 2".to_string()]),
        })
    });
        
    let markdown_factory = RecipeMarkdownFactory();
    let markdown = markdown_factory
     .file_to_markdown("no_ingredients.json", 
                       reader_mock).unwrap();

    assert!(!markdown.contains("## Ingredients"));
  }
}

use recipe_reader::{yaml, RecipeMarkdownFactory};

fn main() {
  let reader = yaml::YamlRecipeReader();
  let factory = RecipeMarkdownFactory();
  let markdown = 
    factory.file_to_markdown("caesar_salad.yaml", 
                             reader).unwrap();
  println!("{markdown}");
}

error[E0432]: unresolved import [code]recipe_reader::yaml[/code]
  --> src/main.rs:1:21
   |
1  | use recipe_reader::{yaml, RecipeMarkdownFactory};
   |                     ^^^^ no `yaml` in the root
   |
note: found an item that was configured out             <<< NEW IN 1.72
  --> /home/rainer/github/rust-samples/cfg/04_recipe_reader/src/lib.rs:39:9
   |
39 | pub mod yaml                                       <<< NEW IN 1.72
   |         ^^^^                                       <<< NEW IN 1.72
   = note: the item is gated behind the `yaml` feature  <<< NEW IN 1.72