feat(aisle): case-insensitive matching and preserve config order

- Make ingredient matching case-insensitive so "Chili flakes" matches
  "chili flakes" in aisle.conf (consistent with pantry behavior)
- Preserve aisle.conf category order in shopping lists instead of
  sorting alphabetically
- Add indexmap dependency for insertion-order preservation
- Add tests for both behaviors

Author: dubadub

Cargo.lock

@@ -24,6 +24,7 @@ finl_unicode = { version = "1.2", features = [
 ], default-features = false }
 smallvec = { version = "1" }
 unicase = "2.7.0"
+indexmap = { version = "2", features = ["serde"] }
 yansi = "1.0.1"
 serde_yaml = "0.9.34"
 toml = { version = "0.8", optional = true }

Cargo.toml

@@ -65,7 +65,7 @@ impl AisleConf<'_> {
     /// Returns a reversed configuration, where each key is an ingredient
     /// and the value is its category.
     #[deprecated = "Use `ingredients_info` instead"]
-    pub fn reverse(&self) -> HashMap<&str, &str> {
+    pub fn reverse(&self) -> HashMap<String, &str> {
         self.ingredients_info()
             .into_iter()
             .map(|(n, i)| (n, i.name))
@@ -74,7 +74,10 @@ impl AisleConf<'_> {
 
     /// Returns a reversed configuration, where each ingredient has a
     /// corresponding [`IngredientInfo`]
-    pub fn ingredients_info(&self) -> HashMap<&str, IngredientInfo<'_>> {
+    ///
+    /// The keys are lowercase for case-insensitive lookups. Use
+    /// `name.to_lowercase()` when looking up ingredients.
+    pub fn ingredients_info(&self) -> HashMap<String, IngredientInfo<'_>> {
         let mut map = HashMap::with_capacity(self.len.get());
         for cat in &self.categories {
             for igr in &cat.ingredients {
@@ -88,7 +91,8 @@ impl AisleConf<'_> {
                         common_name,
                         category: cat.name,
                     };
-                    map.insert(*name, info);
+                    // Store lowercase key for case-insensitive lookups
+                    map.insert(name.to_lowercase(), info);
                 }
             }
         }
@@ -481,15 +485,33 @@ tuna|chicken of the sea
 "#;
         let a = parse(input).unwrap();
         let p = a.ingredients_info();
+        // Keys are lowercase for case-insensitive lookup
         assert_eq!(
             vec!["tuna", "tuna"],
             ["tuna", "chicken of the sea"]
                 .iter()
-                .map(|igr| p.get(igr).unwrap().common_name)
+                .map(|igr| p.get(&igr.to_lowercase()).unwrap().common_name)
                 .collect::<Vec<&str>>()
         )
     }
 
+    #[test]
+    fn case_insensitive_lookup() {
+        let input = r#"[spices]
+chili flakes
+"#;
+        let a = parse(input).unwrap();
+        let p = a.ingredients_info();
+        // All case variants should find the same ingredient
+        assert!(p.get("chili flakes").is_some());
+        assert!(p.get(&"Chili flakes".to_lowercase()).is_some());
+        assert!(p.get(&"CHILI FLAKES".to_lowercase()).is_some());
+        assert_eq!(
+            p.get("chili flakes").unwrap().common_name,
+            p.get(&"Chili Flakes".to_lowercase()).unwrap().common_name
+        );
+    }
+
     #[test]
     fn duplicate_ingredient() {
         // lf/crlf problem :)

src/aisle.rs

@@ -2,6 +2,7 @@
 
 use std::collections::BTreeMap;
 
+use indexmap::IndexMap;
 use serde::Serialize;
 
 use crate::{
@@ -344,12 +345,24 @@ impl IngredientList {
 
     /// Split this list into different categories.
     ///
+    /// Categories are returned in the same order as they appear in the aisle configuration.
     /// Ingredients without category will be placed in `"other"`.
     pub fn categorize(self, aisle: &AisleConf) -> CategorizedIngredientList {
-        let iifno = aisle.ingredients_info();
-        let mut categorized = CategorizedIngredientList::default();
+        let iinfo = aisle.ingredients_info();
+
+        // Pre-create categories in aisle.conf order
+        let mut categorized = CategorizedIngredientList {
+            categories: aisle
+                .categories
+                .iter()
+                .map(|cat| (cat.name.to_string(), IngredientList::new()))
+                .collect(),
+            other: IngredientList::new(),
+        };
+
         for (name, quantity) in self.0 {
-            if let Some(info) = iifno.get(name.as_str()) {
+            // Use lowercase for case-insensitive lookup
+            if let Some(info) = iinfo.get(&name.to_lowercase()) {
                 categorized
                     .categories
                     .entry(info.category.to_string())
@@ -360,6 +373,9 @@ impl IngredientList {
                 categorized.other.0.insert(name, quantity);
             }
         }
+
+        // Remove empty categories
+        categorized.categories.retain(|_, list| !list.is_empty());
         categorized
     }
 
@@ -369,12 +385,15 @@ impl IngredientList {
     }
 
     /// Replace names of ingredients with common names given by aisle configuration.
+    ///
+    /// Matching is case-insensitive.
     pub fn use_common_names(self, aisle: &AisleConf, converter: &Converter) -> Self {
         let ingredients_info = aisle.ingredients_info();
         let mut normalized = Self::new();
-        for (ingredient_name, quantity) in self.iter(){
+        for (ingredient_name, quantity) in self.iter() {
+            // Use lowercase for case-insensitive lookup
             let common_name = ingredients_info
-                .get(ingredient_name.as_str())
+                .get(&ingredient_name.to_lowercase())
                 .map(|info| info.common_name.to_string())
                 .unwrap_or(ingredient_name.to_string());
             normalized.add_ingredient(common_name, quantity, converter);
@@ -401,8 +420,8 @@ impl IntoIterator for IngredientList {
 pub struct CategorizedIngredientList {
     /// One ingredient list per category
     ///
-    /// Because this is a [`BTreeMap`], the categories are sorted by name
-    pub categories: BTreeMap<String, IngredientList>,
+    /// Categories are ordered according to the aisle configuration file order.
+    pub categories: IndexMap<String, IngredientList>,
     /// Ingredients with no category assigned
     pub other: IngredientList,
 }
@@ -420,7 +439,7 @@ impl CategorizedIngredientList {
 
 /// See [`CategorizedIngredientList::iter`]
 pub struct CategorizedIter<'a> {
-    categories: std::collections::btree_map::Iter<'a, String, IngredientList>,
+    categories: indexmap::map::Iter<'a, String, IngredientList>,
     other: Option<&'a IngredientList>,
 }
 
@@ -457,7 +476,7 @@ impl IntoIterator for CategorizedIngredientList {
 
 /// See [`CategorizedIngredientList::into_iter`]
 pub struct CategorizedIntoIter {
-    categories: std::collections::btree_map::IntoIter<String, IngredientList>,
+    categories: indexmap::map::IntoIter<String, IngredientList>,
     other: Option<IngredientList>,
 }
 
@@ -474,11 +493,141 @@ impl Iterator for CategorizedIntoIter {
     }
 }
 
-#[cfg(all(test, feature = "pantry"))]
+#[cfg(test)]
 mod tests {
     use super::*;
     use crate::{CooklangParser, Extensions};
 
+    #[test]
+    fn test_categorize_preserves_aisle_order() {
+        let converter = Converter::bundled();
+        let parser = CooklangParser::new(Extensions::all(), converter.clone());
+
+        // Recipe with ingredients from different categories
+        let recipe = parser
+            .parse("@milk{1%l} @apple{2} @chicken{500%g}")
+            .into_output()
+            .unwrap();
+
+        // Aisle config: produce first, then dairy, then meat
+        let aisle_conf = r#"
+[produce]
+apple
+banana
+
+[dairy]
+milk
+butter
+
+[meat]
+chicken
+beef
+"#;
+        let aisle = crate::aisle::parse(aisle_conf).unwrap();
+
+        let mut list = IngredientList::new();
+        list.add_recipe(&recipe, &converter, false);
+        let categorized = list.categorize(&aisle);
+
+        // Categories should be in aisle.conf order: produce, dairy, meat
+        let category_names: Vec<&str> = categorized.iter().map(|(name, _)| name).collect();
+        assert_eq!(category_names, vec!["produce", "dairy", "meat"]);
+    }
+
+    #[test]
+    fn test_categorize_case_insensitive() {
+        let converter = Converter::bundled();
+        let parser = CooklangParser::new(Extensions::all(), converter.clone());
+
+        // Recipe with "Chili flakes" (capital C)
+        let recipe = parser
+            .parse("@Chili flakes{1%tsp}")
+            .into_output()
+            .unwrap();
+
+        // Aisle config has "chili flakes" (lowercase)
+        let aisle_conf = r#"
+[spices]
+chili flakes
+"#;
+        let aisle = crate::aisle::parse(aisle_conf).unwrap();
+
+        let mut list = IngredientList::new();
+        list.add_recipe(&recipe, &converter, false);
+        let categorized = list.categorize(&aisle);
+
+        // Should find the category despite case difference
+        let category_names: Vec<&str> = categorized.iter().map(|(name, _)| name).collect();
+        assert_eq!(category_names, vec!["spices"]);
+
+        // Ingredient should use common name from config
+        let spices = categorized.categories.get("spices").unwrap();
+        assert!(spices.iter().any(|(name, _)| name == "chili flakes"));
+    }
+
+    #[test]
+    fn test_use_common_names_case_insensitive() {
+        let converter = Converter::bundled();
+        let parser = CooklangParser::new(Extensions::all(), converter.clone());
+
+        // Recipe with various case variations
+        let recipe = parser
+            .parse("@CHILI FLAKES{1%tsp} @Olive Oil{2%tbsp}")
+            .into_output()
+            .unwrap();
+
+        // Aisle config with specific casing
+        let aisle_conf = r#"
+[spices]
+chili flakes
+
+[oils]
+olive oil
+"#;
+        let aisle = crate::aisle::parse(aisle_conf).unwrap();
+
+        let mut list = IngredientList::new();
+        list.add_recipe(&recipe, &converter, false);
+        let normalized = list.use_common_names(&aisle, &converter);
+
+        // Both should be normalized to lowercase common names
+        let names: Vec<&String> = normalized.iter().map(|(name, _)| name).collect();
+        assert!(names.contains(&&"chili flakes".to_string()));
+        assert!(names.contains(&&"olive oil".to_string()));
+    }
+
+    #[test]
+    fn test_uncategorized_items_go_to_other() {
+        let converter = Converter::bundled();
+        let parser = CooklangParser::new(Extensions::all(), converter.clone());
+
+        // Recipe with both categorized and uncategorized ingredients
+        let recipe = parser
+            .parse("@apple{2} @mystery ingredient{1}")
+            .into_output()
+            .unwrap();
+
+        let aisle_conf = r#"
+[produce]
+apple
+"#;
+        let aisle = crate::aisle::parse(aisle_conf).unwrap();
+
+        let mut list = IngredientList::new();
+        list.add_recipe(&recipe, &converter, false);
+        let categorized = list.categorize(&aisle);
+
+        // "other" should appear at the end
+        let category_names: Vec<&str> = categorized.iter().map(|(name, _)| name).collect();
+        assert_eq!(category_names, vec!["produce", "other"]);
+    }
+}
+
+#[cfg(all(test, feature = "pantry"))]
+mod pantry_tests {
+    use super::*;
+    use crate::{CooklangParser, Extensions};
+
     #[test]
     fn test_subtract_pantry_unlimited() {
         let converter = Converter::bundled();