Merge pull request #93 from cooklang/feat/shopping-list-checked-support

feat: shopping list checked file support and comment syntax update

Author: dubadub

bindings/Cargo.toml

@@ -5,13 +5,13 @@ edition = "2021"
 authors = ["dubadub <dubovskoy.a@gmail.com>"]
 description = "Cooklang Uniffi bindings"
 license = "MIT"
-keywords = ["cooklang", "unuffi"]
+keywords = ["cooklang", "uniffi"]
 repository = "https://github.com/cooklang/cooklang-rs"
 readme = "README.md"
 
 [dependencies]
 anyhow = "1.0"
-cooklang = { path = "..", default-features = false, features = ["aisle"] }
+cooklang = { path = "..", default-features = false, features = ["aisle", "shopping_list"] }
 uniffi = "0.28.1"
 
 [lib]

bindings/src/lib.rs

@@ -5,6 +5,7 @@ use cooklang::metadata::StdKey as OriginalStdKey;
 
 pub mod aisle;
 pub mod model;
+pub mod shopping_list;
 
 use aisle::*;
 use model::*;
@@ -580,6 +581,116 @@ fn parse_fraction(s: &str) -> Option<f64> {
     None
 }
 
+// ---------------------------------------------------------------------------
+// Shopping list functions
+// ---------------------------------------------------------------------------
+
+/// Parses a `.shopping-list` file into a ShoppingList structure
+///
+/// The format supports recipe references (lines starting with `./`) and
+/// free-hand ingredients, with indentation-based nesting for sub-recipes.
+///
+/// # Arguments
+/// * `input` - The raw shopping list text
+///
+/// # Returns
+/// A parsed ShoppingList, or an error string if parsing fails
+#[uniffi::export]
+pub fn parse_shopping_list(
+    input: String,
+) -> Result<shopping_list::ShoppingList, String> {
+    shopping_list::parse_shopping_list_impl(&input)
+}
+
+/// Serializes a ShoppingList back to the `.shopping-list` text format
+///
+/// # Arguments
+/// * `list` - The shopping list to serialize
+///
+/// # Returns
+/// The formatted text, or an error string if serialization fails
+#[uniffi::export]
+pub fn write_shopping_list(
+    list: &shopping_list::ShoppingList,
+) -> Result<String, String> {
+    shopping_list::write_shopping_list_impl(list)
+}
+
+/// Parses a `.shopping-checked` log file into a list of check entries
+///
+/// The format is an append-only log with `+ name` (checked) and `- name`
+/// (unchecked) entries.
+///
+/// # Arguments
+/// * `input` - The raw checked log text
+///
+/// # Returns
+/// A list of check/uncheck entries in order
+#[uniffi::export]
+pub fn parse_shopping_checked(input: String) -> Vec<shopping_list::CheckEntry> {
+    shopping_list::parse_checked_impl(&input)
+}
+
+/// Replays a checked log and returns the set of currently checked ingredient
+/// names (lowercased)
+///
+/// Later entries override earlier ones for the same ingredient.
+///
+/// # Arguments
+/// * `entries` - The check log entries to replay
+///
+/// # Returns
+/// Set of ingredient names that are currently checked
+#[uniffi::export]
+pub fn shopping_checked_set(
+    entries: &[shopping_list::CheckEntry],
+) -> Vec<String> {
+    // UniFFI doesn't expose HashSet, so we return a Vec. Sort for
+    // deterministic ordering across the FFI boundary.
+    let mut names: Vec<String> = shopping_list::checked_set_impl(entries)
+        .into_iter()
+        .collect();
+    names.sort();
+    names
+}
+
+/// Serializes a single check entry to string format
+///
+/// # Arguments
+/// * `entry` - The check entry to serialize
+///
+/// # Returns
+/// The formatted string (e.g., `"+ salt\n"` or `"- pepper\n"`)
+#[uniffi::export]
+pub fn write_shopping_check_entry(
+    entry: &shopping_list::CheckEntry,
+) -> Result<String, String> {
+    shopping_list::write_check_entry_impl(entry)
+}
+
+/// Compacts a checked log against the set of currently-visible ingredient
+/// names.
+///
+/// Removes entries for ingredients that are no longer in the shopping list,
+/// and collapses the log so each ingredient appears at most once.
+///
+/// # Arguments
+/// * `entries` - The current check log entries
+/// * `current_ingredients` - The fully-aggregated ingredient names as shown
+///   to the user. A raw on-disk `ShoppingList` only stores recipe
+///   references, so callers must expand recipes first and pass the
+///   resulting ingredient names here.
+///
+/// # Returns
+/// A compacted list of check entries
+#[uniffi::export]
+pub fn compact_shopping_checked(
+    entries: &[shopping_list::CheckEntry],
+    current_ingredients: &[String],
+) -> Vec<shopping_list::CheckEntry> {
+    shopping_list::compact_checked_impl(entries, current_ingredients)
+}
+
 uniffi::setup_scaffolding!();
 
 #[cfg(test)]
@@ -1337,4 +1448,177 @@ Serve the @./pasta/spaghetti{1%portion} with sauce
             })
         );
     }
+
+    #[test]
+    fn test_parse_shopping_list() {
+        use crate::shopping_list::ShoppingListItem;
+
+        let list = crate::parse_shopping_list(
+            "./Breakfast/Easy Pancakes{2}\n  ./Shared/Guacamole\n./Thai Green Curry\n".to_string(),
+        )
+        .unwrap();
+
+        assert_eq!(list.items.len(), 2);
+
+        // First item: Easy Pancakes with multiplier and one child
+        match &list.items[0] {
+            ShoppingListItem::Recipe {
+                path,
+                multiplier,
+                children,
+            } => {
+                assert_eq!(path, "Breakfast/Easy Pancakes");
+                assert_eq!(*multiplier, Some(2.0));
+                assert_eq!(children.len(), 1);
+                match &children[0] {
+                    ShoppingListItem::Recipe {
+                        path, multiplier, ..
+                    } => {
+                        assert_eq!(path, "Shared/Guacamole");
+                        assert_eq!(*multiplier, None);
+                    }
+                    _ => panic!("Expected recipe child"),
+                }
+            }
+            _ => panic!("Expected recipe item"),
+        }
+
+        // Second item: Thai Green Curry, no children
+        match &list.items[1] {
+            ShoppingListItem::Recipe {
+                path,
+                multiplier,
+                children,
+            } => {
+                assert_eq!(path, "Thai Green Curry");
+                assert_eq!(*multiplier, None);
+                assert!(children.is_empty());
+            }
+            _ => panic!("Expected recipe item"),
+        }
+    }
+
+    #[test]
+    fn test_write_shopping_list() {
+        use crate::shopping_list::{ShoppingList, ShoppingListItem};
+
+        let list = ShoppingList {
+            items: vec![
+                ShoppingListItem::Recipe {
+                    path: "Breakfast/Pancakes".to_string(),
+                    multiplier: Some(2.0),
+                    children: vec![ShoppingListItem::Recipe {
+                        path: "Shared/Syrup".to_string(),
+                        multiplier: None,
+                        children: vec![],
+                    }],
+                },
+                ShoppingListItem::Ingredient {
+                    name: "salt".to_string(),
+                    quantity: Some("2%tsp".to_string()),
+                },
+            ],
+        };
+
+        let output = crate::write_shopping_list(&list).unwrap();
+        assert_eq!(
+            output,
+            "./Breakfast/Pancakes{2}\n  ./Shared/Syrup\nsalt{2%tsp}\n"
+        );
+    }
+
+    #[test]
+    fn test_shopping_list_roundtrip() {
+        let input =
+            "./Meal Plan.menu\n  ./Breakfast/Pancakes{2}\n    ./Shared/Guacamole\n  ./Dinner/Curry\n";
+        let list = crate::parse_shopping_list(input.to_string()).unwrap();
+        let output = crate::write_shopping_list(&list).unwrap();
+        assert_eq!(output, input);
+    }
+
+    #[test]
+    fn test_parse_shopping_checked() {
+        use crate::shopping_list::CheckEntry;
+
+        let entries = crate::parse_shopping_checked(
+            "+ salt\n+ pepper\n- salt\n+ garlic\n".to_string(),
+        );
+
+        assert_eq!(entries.len(), 4);
+        assert!(matches!(&entries[0], CheckEntry::Checked { name } if name == "salt"));
+        assert!(matches!(&entries[1], CheckEntry::Checked { name } if name == "pepper"));
+        assert!(matches!(&entries[2], CheckEntry::Unchecked { name } if name == "salt"));
+        assert!(matches!(&entries[3], CheckEntry::Checked { name } if name == "garlic"));
+    }
+
+    #[test]
+    fn test_shopping_checked_set() {
+        use crate::shopping_list::CheckEntry;
+
+        let entries = vec![
+            CheckEntry::Checked {
+                name: "salt".to_string(),
+            },
+            CheckEntry::Checked {
+                name: "pepper".to_string(),
+            },
+            CheckEntry::Unchecked {
+                name: "salt".to_string(),
+            },
+        ];
+
+        let checked = crate::shopping_checked_set(&entries);
+        // salt was unchecked, pepper stays checked
+        assert!(!checked.contains(&"salt".to_string()));
+        assert!(checked.contains(&"pepper".to_string()));
+    }
+
+    #[test]
+    fn test_write_shopping_check_entry() {
+        use crate::shopping_list::CheckEntry;
+
+        let entry = CheckEntry::Checked {
+            name: "salt".to_string(),
+        };
+        assert_eq!(
+            crate::write_shopping_check_entry(&entry).unwrap(),
+            "+ salt\n"
+        );
+
+        let entry = CheckEntry::Unchecked {
+            name: "pepper".to_string(),
+        };
+        assert_eq!(
+            crate::write_shopping_check_entry(&entry).unwrap(),
+            "- pepper\n"
+        );
+    }
+
+    #[test]
+    fn test_compact_shopping_checked() {
+        use crate::shopping_list::CheckEntry;
+
+        let entries = vec![
+            CheckEntry::Checked {
+                name: "salt".to_string(),
+            },
+            CheckEntry::Checked {
+                name: "pepper".to_string(),
+            },
+            CheckEntry::Checked {
+                name: "removed ingredient".to_string(),
+            },
+        ];
+
+        // Caller has already aggregated the user-visible ingredient names
+        // (e.g. by expanding recipe references and categorizing against an
+        // aisle config). Only "salt" is currently in the list.
+        let current_ingredients = vec!["salt".to_string()];
+
+        let compacted = crate::compact_shopping_checked(&entries, &current_ingredients);
+        // Only "salt" should remain — it's checked and still in the list.
+        // "pepper" and "removed ingredient" are not in the list.
+        assert_eq!(compacted.len(), 1);
+        assert!(matches!(&compacted[0], CheckEntry::Checked { name } if name == "salt"));
+    }
 }