Merge pull request #30 from cooklang/feat/servings

feat: enabled scaling

Author: dubadub

bindings/src/lib.rs

@@ -1,9 +1,6 @@
 use std::sync::Arc;
 
 use cooklang::aisle::parse as parse_aisle_config_original;
-use cooklang::analysis::parse_events;
-use cooklang::parser::PullParser;
-use cooklang::{Converter, Extensions};
 
 pub mod aisle;
 pub mod model;
@@ -12,43 +9,29 @@ use aisle::*;
 use model::*;
 
 #[uniffi::export]
-pub fn parse_recipe(input: String) -> CooklangRecipe {
-    let extensions = Extensions::empty();
-    let converter = Converter::empty();
-
-    let mut parser = PullParser::new(&input, extensions);
-    let parsed = parse_events(
-        &mut parser,
-        &input,
-        extensions,
-        &converter,
-        Default::default(),
-    )
-    .unwrap_output();
-
-    into_simple_recipe(&parsed)
+pub fn parse_recipe(input: String, scaling_factor: u32) -> CooklangRecipe {
+    let parser = cooklang::CooklangParser::canonical();
+
+    let (parsed, _warnings) = parser.parse(&input).into_result().unwrap();
+
+    let scaled = parsed.scale(scaling_factor, parser.converter());
+
+    into_simple_recipe(&scaled)
 }
 
 #[uniffi::export]
-pub fn parse_metadata(input: String) -> CooklangMetadata {
+pub fn parse_metadata(input: String, scaling_factor: u32) -> CooklangMetadata {
     let mut metadata = CooklangMetadata::new();
-    let extensions = Extensions::empty();
-    let converter = Converter::empty();
+    let parser = cooklang::CooklangParser::canonical();
 
-    let parser = PullParser::new(&input, extensions);
+    let (parsed, _warnings) = parser.parse(&input)
+        .into_result()
+        .unwrap();
 
-    let parsed = parse_events(
-        parser.into_meta_iter(),
-        &input,
-        extensions,
-        &converter,
-        Default::default(),
-    )
-    .map(|c| c.metadata.map)
-    .unwrap_output();
+    let scaled = parsed.scale(scaling_factor, parser.converter());
 
     // converting IndexMap into HashMap
-    let _ = &(parsed).iter().for_each(|(key, value)| {
+    let _ = &(scaled.metadata.map).iter().for_each(|(key, value)| {
         if let (Some(key), Some(value)) = (key.as_str(), value.as_str()) {
             metadata.insert(key.to_string(), value.to_string());
         }
@@ -116,7 +99,7 @@ pub fn parse_aisle_config(input: String) -> Arc<AisleConf> {
 }
 
 #[uniffi::export]
-pub fn combine_ingredients(ingredients: &Vec<Ingredient>) -> IngredientList {
+pub fn combine_ingredients(ingredients: &[Ingredient]) -> IngredientList {
     let indices = (0..ingredients.len()).map(|i| i as u32).collect();
     combine_ingredients_selected(ingredients, &indices)
 }
@@ -149,6 +132,7 @@ mod tests {
 a test @step @salt{1%mg} more text
 "#
             .to_string(),
+            1
         );
 
         assert_eq!(
@@ -225,6 +209,7 @@ source: https://google.com
 a test @step @salt{1%mg} more text
 "#
             .to_string(),
+            1
         );
 
         assert_eq!(
@@ -372,6 +357,7 @@ dried oregano
 Cook @onions{3%large} until brown
 "#
             .to_string(),
+            1
         );
 
         let first_section = recipe
@@ -430,6 +416,7 @@ add @tomatoes{400%g}
 simmer for 10 minutes
 "#
             .to_string(),
+            1
         );
         let first_section = recipe
             .sections
@@ -494,6 +481,7 @@ Mix @flour{200%g} and @water{50%ml} together until smooth.
 Combine @cheese{100%g} and @spinach{50%g}, then season to taste.
 "#
             .to_string(),
+            1
         );
 
         let mut sections = recipe.sections.into_iter();

bindings/src/model.rs

@@ -2,9 +2,9 @@ use std::collections::HashMap;
 
 use cooklang::model::Item as OriginalItem;
 use cooklang::quantity::{
-    Quantity as OriginalQuantity, ScalableValue as OriginalScalableValue, Value as OriginalValue,
+    Quantity as OriginalQuantity, Value as OriginalValue
 };
-use cooklang::ScalableRecipe as OriginalRecipe;
+use cooklang::ScaledRecipe as OriginalRecipe;
 
 #[derive(uniffi::Record, Debug)]
 pub struct CooklangRecipe {
@@ -174,19 +174,19 @@ trait Amountable {
     fn extract_amount(&self) -> Amount;
 }
 
-impl Amountable for OriginalQuantity<OriginalScalableValue> {
+impl Amountable for OriginalQuantity<OriginalValue> {
     fn extract_amount(&self) -> Amount {
-        let quantity = extract_quantity(self.value());
+        let quantity = extract_value(self.value());
 
         let units = self.unit().as_ref().map(|u| u.to_string());
 
         Amount { quantity, units }
     }
 }
 
-impl Amountable for OriginalScalableValue {
+impl Amountable for OriginalValue {
     fn extract_amount(&self) -> Amount {
-        let quantity = extract_quantity(self);
+        let quantity = extract_value(self);
 
         Amount {
             quantity,
@@ -195,14 +195,6 @@ impl Amountable for OriginalScalableValue {
     }
 }
 
-fn extract_quantity(value: &OriginalScalableValue) -> Value {
-    match value {
-        OriginalScalableValue::Fixed(value) => extract_value(value),
-        OriginalScalableValue::Linear(value) => extract_value(value),
-        OriginalScalableValue::ByServings(values) => extract_value(values.first().unwrap()),
-    }
-}
-
 fn extract_value(value: &OriginalValue) -> Value {
     match value {
         OriginalValue::Number(num) => Value::Number { value: num.value() },
@@ -427,8 +419,8 @@ pub(crate) fn into_simple_recipe(recipe: &OriginalRecipe) -> CooklangRecipe {
     }
 }
 
-impl From<&cooklang::Ingredient<OriginalScalableValue>> for Ingredient {
-    fn from(ingredient: &cooklang::Ingredient<OriginalScalableValue>) -> Self {
+impl From<&cooklang::Ingredient<OriginalValue>> for Ingredient {
+    fn from(ingredient: &cooklang::Ingredient<OriginalValue>) -> Self {
         Ingredient {
             name: ingredient.name.clone(),
             amount: ingredient.quantity.as_ref().map(|q| q.extract_amount()),
@@ -437,17 +429,17 @@ impl From<&cooklang::Ingredient<OriginalScalableValue>> for Ingredient {
     }
 }
 
-impl From<&cooklang::Cookware<OriginalScalableValue>> for Cookware {
-    fn from(cookware: &cooklang::Cookware<OriginalScalableValue>) -> Self {
+impl From<&cooklang::Cookware<OriginalValue>> for Cookware {
+    fn from(cookware: &cooklang::Cookware<OriginalValue>) -> Self {
         Cookware {
             name: cookware.name.clone(),
             amount: cookware.quantity.as_ref().map(|q| q.extract_amount()),
         }
     }
 }
 
-impl From<&cooklang::Timer<OriginalScalableValue>> for Timer {
-    fn from(timer: &cooklang::Timer<OriginalScalableValue>) -> Self {
+impl From<&cooklang::Timer<OriginalValue>> for Timer {
+    fn from(timer: &cooklang::Timer<OriginalValue>) -> Self {
         Timer {
             name: Some(timer.name.clone().unwrap_or_default()),
             amount: timer.quantity.as_ref().map(|q| q.extract_amount()),

extensions.md

@@ -112,21 +112,6 @@ special keys are between square brackets.
     >> [duplicate]: default
     @water{1} @&water{2}
     ```
-- `auto scale` | `auto_scale`
-  - `true`. All quantities in ingredients have the implicit auto scale
-    marker[^1] (`*`). This does not apply when the quantity has a text value,
-    because text can't be scaled automatically.
-    ```cooklang
-    >> [auto scale]: true
-    @water{1}
-    -- is the same as
-    >> [auto scale]: false
-    @water{1*}
-    ```
-
-    Note that ingredients with fixed scaling for each serving size[^1] are not
-    affected by the auto scale mode.
-  - `false` | `default`. The default cooklang behaviour.
 
 ## Temperature
 Find temperatures in the text, without any markers. In the future this may be

src/analysis/event_consumer.rs

@@ -74,7 +74,6 @@ pub fn parse_events<'i, 'c>(
 
         define_mode: DefineMode::All,
         duplicate_mode: DuplicateMode::New,
-        auto_scale_ingredients: false,
         old_style_metadata: true,
         old_style_metadata_used: vec![],
         ctx: SourceReport::empty(),
@@ -96,7 +95,6 @@ struct RecipeCollector<'i, 'c> {
 
     define_mode: DefineMode,
     duplicate_mode: DuplicateMode,
-    auto_scale_ingredients: bool,
     old_style_metadata: bool,
     old_style_metadata_used: Vec<Span>,
     ctx: SourceReport,
@@ -360,19 +358,14 @@ impl<'i> RecipeCollector<'i, '_> {
                     "reference" | "ref" => self.duplicate_mode = DuplicateMode::Reference,
                     _ => self.ctx.error(invalid_value(vec!["new", "reference"])),
                 },
-                "auto scale" | "auto_scale" => match value_t.as_ref() {
-                    "true" => self.auto_scale_ingredients = true,
-                    "false" | "default" => self.auto_scale_ingredients = false,
-                    _ => self.ctx.error(invalid_value(vec!["true", "false"])),
-                },
                 _ => {
                     self.ctx.warn(
                         warning!(
                             format!("Unknown config metadata key: {key_t}"),
                             label!(key.span())
                         )
                         .hint(
-                            "Possible config keys are '[mode]', '[duplicate]' and '[auto scale]'",
+                            "Possible config keys are '[mode]' and '[duplicate]''",
                         ),
                     );
                     if self.old_style_metadata {
@@ -1030,77 +1023,33 @@ impl<'i> RecipeCollector<'i, '_> {
     }
 
     fn value(&mut self, value: parser::QuantityValue, is_ingredient: bool) -> ScalableValue {
-        let mut marker_span = None;
-        match &value {
-            parser::QuantityValue::Single {
-                value,
-                auto_scale: Some(auto_scale_marker),
-            } => {
-                marker_span = Some(*auto_scale_marker);
-                if value.is_text() {
-                    self.ctx.error(
-                        error!(
-                            "Text value with auto scale marker",
-                            label!(auto_scale_marker, "remove this")
-                        )
-                        .hint("Text cannot be scaled"),
-                    );
-                }
-            }
-            parser::QuantityValue::Many(v) => {
-                const CONFLICT: &str = "Many values conflict";
-                if let crate::scale::Servings(Some(s)) = &self.content.data {
-                    if s.len() != v.len() {
-                        let mut err = error!(
-                            format!(
-                                "{CONFLICT}: {} servings defined but {} values in the quantity",
-                                s.len(),
-                                v.len()
-                            ),
-                            label!(value.span(), "number of values do not match servings")
-                        );
+        let parser::QuantityValue { value, scaling_lock } = value;
+        let has_scaling_lock = scaling_lock.is_some();
+        let is_text = value.is_text();
 
-                        let meta_span = self
-                            .locations
-                            .metadata
-                            .get(&StdKey::Servings)
-                            .map(|(_, value)| value.span());
-                        if let Some(meta_span) = meta_span {
-                            err = err.label(label!(meta_span, "servings defined here"))
-                        }
-                        self.ctx.error(err);
-                    }
-                } else {
-                    self.ctx.error(error!(
-                        format!(
-                            "{CONFLICT}: no servings defined but {} values in the quantity",
-                            v.len()
-                        ),
-                        label!(value.span())
-                    ));
-                }
-            }
-            _ => {}
+        // For ingredients without text values and without scaling lock, use Linear
+        if is_ingredient && !is_text && !has_scaling_lock {
+            return ScalableValue::Linear(value.into_inner());
         }
-        let mut v = ScalableValue::from_ast(value);
 
-        if is_ingredient && self.auto_scale_ingredients {
-            match v {
-                ScalableValue::Fixed(value) if !value.is_text() => v = ScalableValue::Linear(value),
-                ScalableValue::Linear(_) => {
-                    self.ctx.warn(
-                        warning!(
-                            "Redundant auto scale marker",
-                            label!(marker_span.unwrap(), "remove this")
-                        )
-                        .hint("Every ingredient is already marked to auto scale"),
-                    );
-                }
-                _ => {}
-            };
+        // Warn if scaling lock is used unnecessarily (on non-ingredients or text values)
+        if has_scaling_lock {
+            let mut warning = warning!(
+                "Unnecessary scaling lock modifier",
+                label!(value.span(), "this scaling lock has no effect")
+            );
+
+            if !is_ingredient {
+                warning.add_hint("Only ingredients can be scaled, scaling lock is not needed here");
+            } else if is_text {
+                warning.add_hint("Text values cannot be scaled, scaling lock is not needed here");
+            }
+
+            self.ctx.warn(warning);
         }
 
-        v
+        // Everything else uses Fixed
+        ScalableValue::Fixed(value.into_inner())
     }
 
     fn resolve_reference<C: RefComponent>(

src/parser/mod.rs

@@ -29,13 +29,12 @@
 //!
 //! note       = OpenParen (!CloseParen ANY)* CloseParen
 //!
-//! quantity   = num_val Whitespace !(unit_sep | auto_scale | val_sep) unit
-//!            | val (val_sep val)* auto_scale? (unit_sep unit)?
+//! quantity   = sc_lock? num_val Whitespace !unit_sep unit
+//!            | val (unit_sep unit)?
+//! sc_lock    = Whitespace Eq Whitespace
 //!
 //! unit       = (!CloseBrace ANY)*
 //!
-//! val_sep    = Whitespace Or Whitespace
-//! auto_scale = Whitespace Star Whitespace
 //! unit_sep   = Whitespace Percent Whitespace
 //!
 //! val        = num_val | text_val