Struct ingredient::IngredientParser

pub struct IngredientParser {
    pub units: HashSet<String>,
    pub adjectives: HashSet<String>,
    pub is_rich_text: bool,
}

Fields

units: HashSet<String>

adjectives: HashSet<String>

is_rich_text: bool

Implementations

impl IngredientParser

pub fn new(is_rich_text: bool) -> Self

pub fn from_str(self, input: &str) -> Ingredient

wrapper for [self.parse_ingredient]

use ingredient::{from_str};
assert_eq!(from_str("one whole egg").to_string(),"1 whole egg");

pub fn parse_amount(&self, input: &str) -> Vec<Measure>

Parses one or two amounts, e.g. 12 grams or 120 grams / 1 cup. Used by [self.parse_ingredient].

use ingredient::{IngredientParser,unit::Measure};
let ip = IngredientParser::new(false);
assert_eq!(
   ip.parse_amount("120 grams"),
   vec![Measure::parse_new("grams",120.0)]
 );
assert_eq!(
   ip.parse_amount("120 grams / 1 cup"),
   vec![Measure::parse_new("grams",120.0),Measure::parse_new("cup", 1.0)]
 );
assert_eq!(
   ip.parse_amount("120 grams / 1 cup / 1 whole"),
   vec![Measure::parse_new("grams",120.0),Measure::parse_new("cup", 1.0),Measure::parse_new("whole", 1.0)]
 );

pub fn parse_ingredient(self, input: &str) -> Res<&str, Ingredient>

Parse an ingredient line item, such as 120 grams / 1 cup whole wheat flour, sifted lightly.

returns an Ingredient, Can be used as a wrapper to return verbose errors.

supported formats include:

• 1 g name
• 1 g / 1g name, modifier
• 1 g; 1 g name
• ¼ g name
• 1/4 g name
• 1 ¼ g name
• 1 1/4 g name
• 1 g (1 g) name
• 1 g name (about 1 g; 1 g)
• name
• 1 name

use ingredient::{IngredientParser, ingredient::Ingredient, unit::Measure};
let ip = IngredientParser::new(false);
assert_eq!(
    ip.parse_ingredient("1¼  cups / 155.5 grams flour"),
    Ok((
        "",
        Ingredient {
            name: "flour".to_string(),
            amounts: vec![
                Measure::parse_new("cups", 1.25),
                Measure::parse_new("grams", 155.5),
            ],
            modifier: None,
        }
    ))
);

Trait Implementations

impl Clone for IngredientParser

fn clone(&self) -> IngredientParser

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IngredientParser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IngredientParser

fn default() -> IngredientParser

Returns the “default value” for a type.

impl PartialEq<IngredientParser> for IngredientParser

fn eq(&self, other: &IngredientParser) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for IngredientParser