cooklang 1.0.3 → 1.1.0

data/spec/formatters/hash_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Formatters::Hash do
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:result) { described_class.new(recipe).generate }
+
+    it "generates hash with all required top-level keys" do
+      expect(result).to have_key(:metadata)
+      expect(result).to have_key(:sections)
+      expect(result).to have_key(:ingredients)
+      expect(result).to have_key(:cookware)
+      expect(result).to have_key(:timers)
+      expect(result).to have_key(:data)
+    end
+
+    it "includes expected metadata" do
+      metadata = result[:metadata][:map]
+      expect(metadata["title"]).to eq("Uncle Roger's Ultimate Fried Rice & Dumplings")
+      expect(metadata["servings"]).to eq(4)
+      expect(metadata["difficulty"]).to eq("intermediate")
+    end
+
+    it "parses ingredients with decimal quantities and nil quantities" do
+      ingredients = result[:ingredients]
+
+      # Find MSG with decimal quantity
+      msg = ingredients.find { |i| i[:name] == "msg" }
+      expect(msg[:quantity][:value][:value][:value]).to eq(0.5)
+
+      # Find ingredient with nil quantity (like "some")
+      white_pepper = ingredients.find { |i| i[:name] == "white pepper" }
+      expect(white_pepper[:quantity]).to be_nil
+    end
+
+    it "includes timers with named and decimal durations" do
+      timers = result[:timers]
+      expect(timers.size).to be >= 5
+
+      # Find named timer
+      named_timer = timers.find { |t| t[:name] == "quick scramble" }
+      expect(named_timer).not_to be_nil
+
+      # Find decimal duration timer
+      decimal_timer = timers.find { |t| t[:quantity][:value][:value][:value] == 2.5 }
+      expect(decimal_timer).not_to be_nil
+    end
+
+    it "generates steps with proper indexing" do
+      steps = result[:sections].first[:content]
+      expect(steps.size).to be >= 10
+
+      # Check step numbers are sequential
+      step_numbers = steps.map { |s| s[:value][:number] }
+      expect(step_numbers).to eq((1..step_numbers.size).to_a)
+    end
+  end
+
+  describe "fixed quantities" do
+    let(:recipe) { Cooklang.parse("Add @salt{=1%tsp} and @flour{500%g} and @pepper.") }
+    let(:result) { described_class.new(recipe).generate }
+
+    it "marks fixed ingredients as 'fixed' in data section" do
+      ingredient_data = result[:data][:ingredients]
+
+      # salt is fixed, flour is scaled, pepper has no quantity
+      expect(ingredient_data).to eq(%w[fixed scaled noQuantity])
+    end
+  end
+end

data/spec/formatters/json_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Formatters::Json do
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:json_output) { described_class.new(recipe).generate }
+    let(:parsed) { JSON.parse(json_output) }
+
+    it "generates valid JSON" do
+      expect { JSON.parse(json_output) }.not_to raise_error
+    end
+
+    it "includes metadata with proper JSON types" do
+      expect(parsed["metadata"]["map"]["title"]).to eq("Uncle Roger's Ultimate Fried Rice & Dumplings")
+      expect(parsed["metadata"]["map"]["servings"]).to eq(4)
+    end
+
+    it "converts decimal quantities correctly" do
+      ingredients = parsed["ingredients"]
+
+      # MSG with decimal quantity
+      msg = ingredients.find { |i| i["name"] == "msg" }
+      expect(msg["quantity"]["value"]["value"]["value"]).to eq(0.5)
+
+      # White pepper with null quantity
+      white_pepper = ingredients.find { |i| i["name"] == "white pepper" }
+      expect(white_pepper["quantity"]).to be_nil
+    end
+
+    it "handles named timers and decimal durations" do
+      timers = parsed["timers"]
+
+      # Named timer
+      named_timer = timers.find { |t| t["name"] == "quick scramble" }
+      expect(named_timer["quantity"]["value"]["value"]["value"]).to eq(45.0)
+
+      # Decimal duration
+      decimal_timer = timers.find { |t| t["quantity"]["value"]["value"]["value"] == 2.5 }
+      expect(decimal_timer).not_to be_nil
+    end
+
+    it "formats with indentation when requested" do
+      formatted = described_class.new(recipe).generate(indent: "  ")
+      expect(formatted).to include("  \"metadata\"")
+      # Just check that it's longer than compact format (indentation adds space)
+      compact = described_class.new(recipe).generate
+      expect(formatted.length).to be > compact.length
+    end
+  end
+end

data/spec/formatters/text_spec.rb

@@ -3,187 +3,49 @@
 require "spec_helper"
 
 RSpec.describe Cooklang::Formatters::Text do
-  let(:recipe) do
-    Cooklang::Recipe.new(
-      ingredients: ingredients,
-      steps: steps,
-      cookware: [],
-      timers: [],
-      metadata: {},
-      sections: [],
-      notes: []
-    )
-  end
-  let(:formatter) { described_class.new(recipe) }
-
-  describe "#to_s" do
-    context "with ingredients only" do
-      let(:ingredients) do
-        [
-          Cooklang::Ingredient.new(name: "flour", quantity: 125, unit: "g"),
-          Cooklang::Ingredient.new(name: "milk", quantity: 250, unit: "ml"),
-          Cooklang::Ingredient.new(name: "eggs", quantity: 3),
-          Cooklang::Ingredient.new(name: "butter"),
-          Cooklang::Ingredient.new(name: "sea salt", quantity: 1, unit: "pinch")
-        ]
-      end
-      let(:steps) { [] }
-
-      it "formats ingredients with aligned columns" do
-        expected = <<~OUTPUT.strip
-          Ingredients:
-              flour       125 g
-              milk        250 ml
-              eggs        3
-              butter      some
-              sea salt    1 pinch
-        OUTPUT
-
-        expect(formatter.to_s).to eq(expected)
-      end
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
     end
+    let(:output) { described_class.new(recipe).generate }
 
-    context "with steps only" do
-      let(:ingredients) { [] }
-      let(:steps) do
-        [
-          Cooklang::Step.new(segments: [
-                               { type: "text", value: "Crack the " },
-                               { type: "ingredient", value: "eggs", name: "eggs" },
-                               { type: "text", value: " into a blender" }
-                             ]),
-          Cooklang::Step.new(segments: [
-                               { type: "text", value: "Pour into a bowl and leave to stand for " },
-                               { type: "timer", value: "15 minutes", name: nil },
-                               { type: "text", value: "." }
-                             ])
-        ]
-      end
-
-      it "formats steps with numbered list" do
-        expected = <<~OUTPUT.strip
-          Steps:
-              1. Crack the eggs into a blender
-              2. Pour into a bowl and leave to stand for 15 minutes.
-        OUTPUT
-
-        expect(formatter.to_s).to eq(expected)
-      end
+    it "includes Ingredients and Steps sections" do
+      expect(output).to include("Ingredients:")
+      expect(output).to include("Steps:")
     end
 
-    context "with both ingredients and steps" do
-      let(:ingredients) do
-        [
-          Cooklang::Ingredient.new(name: "butter"),
-          Cooklang::Ingredient.new(name: "eggs", quantity: 3),
-          Cooklang::Ingredient.new(name: "flour", quantity: 125, unit: "g"),
-          Cooklang::Ingredient.new(name: "milk", quantity: 250, unit: "ml"),
-          Cooklang::Ingredient.new(name: "sea salt", quantity: 1, unit: "pinch")
-        ]
-      end
-      let(:steps) do
-        [
-          Cooklang::Step.new(segments: [
-                               { type: "text", value: "Crack the " },
-                               { type: "ingredient", value: "eggs", name: "eggs" },
-                               { type: "text", value: " into a blender, then add the " },
-                               { type: "ingredient", value: "flour", name: "flour" },
-                               { type: "text", value: ", " },
-                               { type: "ingredient", value: "milk", name: "milk" },
-                               { type: "text", value: " and " },
-                               { type: "ingredient", value: "sea salt", name: "sea salt" },
-                               { type: "text", value: "." }
-                             ]),
-          Cooklang::Step.new(segments: [
-                               { type: "text", value: "Pour into a bowl and leave to stand for " },
-                               { type: "timer", value: "15 minutes", name: nil },
-                               { type: "text", value: "." }
-                             ]),
-          Cooklang::Step.new(segments: [
-                               { type: "text", value: "Melt the " },
-                               { type: "ingredient", value: "butter", name: "butter" },
-                               { type: "text", value: " in a large non-stick " },
-                               { type: "cookware", value: "frying pan", name: "frying pan" },
-                               { type: "text", value: "." }
-                             ])
-        ]
-      end
-
-      it "formats complete recipe" do
-        expected = <<~OUTPUT.strip
-          Ingredients:
-              butter      some
-              eggs        3
-              flour       125 g
-              milk        250 ml
-              sea salt    1 pinch
-
-          Steps:
-              1. Crack the eggs into a blender, then add the flour, milk and sea salt.
-              2. Pour into a bowl and leave to stand for 15 minutes.
-              3. Melt the butter in a large non-stick frying pan.
-        OUTPUT
-
-        expect(formatter.to_s).to eq(expected)
-      end
+    it "formats ingredients with quantities and units" do
+      expect(output).to match(/shallots\s+2/)
+      expect(output).to match(/garlic\s+4 cloves/)
+      expect(output).to match(/msg\s+0\.5 tsp/)
+      expect(output).to match(/white pepper\s+some/)
     end
 
-    context "with empty recipe" do
-      let(:ingredients) { [] }
-      let(:steps) { [] }
-
-      it "returns empty string" do
-        expect(formatter.to_s).to eq("")
-      end
-    end
-
-    context "with various ingredient formats" do
-      let(:ingredients) do
-        [
-          Cooklang::Ingredient.new(name: "onion", quantity: 1),
-          Cooklang::Ingredient.new(name: "olive oil", unit: "drizzle"),
-          Cooklang::Ingredient.new(name: "salt"),
-          Cooklang::Ingredient.new(name: "pepper", quantity: "some", unit: "grinds")
-        ]
-      end
-      let(:steps) { [] }
-
-      it "handles missing quantities and units gracefully" do
-        expected = <<~OUTPUT.strip
-          Ingredients:
-              onion        1
-              olive oil    drizzle
-              salt         some
-              pepper       some grinds
-        OUTPUT
-
-        expect(formatter.to_s).to eq(expected)
-      end
-    end
-  end
-
-  describe "#format_quantity_unit" do
-    let(:formatter) { described_class.new(recipe) }
-    let(:recipe) { double("recipe") }
+    it "formats steps with sequential numbering" do
+      lines = output.split("\n")
+      step_lines = lines.select { |line| line.match(/^\s*\d+\./) }
 
-    it "formats quantity with unit" do
-      ingredient = Cooklang::Ingredient.new(name: "flour", quantity: 125, unit: "g")
-      expect(formatter.send(:format_quantity_unit, ingredient)).to eq("125 g")
+      expect(step_lines.size).to be >= 10
+      expect(step_lines.first).to match(/1\..*/)
+      expect(step_lines.last).to match(/\d+\..*/)
     end
 
-    it "formats quantity without unit" do
-      ingredient = Cooklang::Ingredient.new(name: "eggs", quantity: 3)
-      expect(formatter.send(:format_quantity_unit, ingredient)).to eq("3")
+    it "includes ingredient names in step text" do
+      expect(output).to include("shallots")
+      expect(output).to include("garlic")
+      expect(output).to include("day-old rice")
     end
 
-    it "formats unit without quantity" do
-      ingredient = Cooklang::Ingredient.new(name: "olive oil", unit: "drizzle")
-      expect(formatter.send(:format_quantity_unit, ingredient)).to eq("drizzle")
+    it "includes timer references in steps" do
+      expect(output).to include("2 minutes")
+      expect(output).to include("30 seconds")
+      expect(output).to include("quick scramble")
     end
 
-    it "handles missing quantity and unit" do
-      ingredient = Cooklang::Ingredient.new(name: "salt")
-      expect(formatter.send(:format_quantity_unit, ingredient)).to eq("some")
+    it "includes cookware references" do
+      expect(output).to include("wok")
+      expect(output).to include("mixing bowl")
     end
   end
 end

data/spec/integration/metadata_canonical_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Canonical Metadata Support" do
+  let(:parser) { Cooklang::Parser.new }
+
+  describe "Complex YAML frontmatter" do
+    it "supports arrays in metadata" do
+      recipe_text = <<~COOK
+        ---
+        title: Pasta Dish
+        tags: [italian, pasta, quick]
+        diet:
+          - vegetarian
+          - gluten-free
+        ---
+        @pasta{200%g}
+      COOK
+
+      recipe = parser.parse(recipe_text)
+
+      expect(recipe.metadata["tags"]).to eq(["italian", "pasta", "quick"])
+      expect(recipe.metadata["diet"]).to eq(["vegetarian", "gluten-free"])
+    end
+
+    it "supports nested hash structures" do
+      recipe_text = <<~COOK
+        ---
+        title: Recipe
+        source:
+          name: My Cookbook
+          url: https://example.com/recipe
+          author: Jane Doe
+        time:
+          prep: 15 minutes
+          cook: 30 minutes
+        ---
+        @flour{100%g}
+      COOK
+
+      recipe = parser.parse(recipe_text)
+
+      expect(recipe.metadata["source"]).to be_a(Hash)
+      expect(recipe.metadata["source"]["name"]).to eq("My Cookbook")
+      expect(recipe.metadata["source"]["url"]).to eq("https://example.com/recipe")
+      expect(recipe.metadata["source"]["author"]).to eq("Jane Doe")
+
+      expect(recipe.metadata["time"]).to be_a(Hash)
+      expect(recipe.metadata["time"]["prep"]).to eq("15 minutes")
+      expect(recipe.metadata["time"]["cook"]).to eq("30 minutes")
+    end
+
+    it "supports mixed data types" do
+      recipe_text = <<~COOK
+        ---
+        title: Test Recipe
+        servings: 4
+        rating: 4.5
+        published: true
+        custom_field: Some value
+        numbers: [1, 2, 3]
+        ---
+        @salt
+      COOK
+
+      recipe = parser.parse(recipe_text)
+
+      expect(recipe.metadata["title"]).to eq("Test Recipe")
+      expect(recipe.metadata["servings"]).to eq(4)
+      expect(recipe.metadata["rating"]).to eq(4.5)
+      expect(recipe.metadata["published"]).to eq(true)
+      expect(recipe.metadata["custom_field"]).to eq("Some value")
+      expect(recipe.metadata["numbers"]).to eq([1, 2, 3])
+    end
+
+    it "raises error on invalid YAML" do
+      recipe_text = <<~COOK
+        ---
+        title: Test
+        tags: [invalid
+          not closed
+        ---
+        @salt
+      COOK
+
+      expect { parser.parse(recipe_text) }.to raise_error(Psych::SyntaxError)
+    end
+  end
+
+  describe "Canonical fields work as plain Hash values" do
+    let(:metadata) { Cooklang::Metadata.new }
+
+    it "stores servings as number or string" do
+      metadata["servings"] = 4
+      expect(metadata["servings"]).to eq(4)
+
+      metadata["servings"] = "6 cups worth"
+      expect(metadata["servings"]).to eq("6 cups worth")
+    end
+
+    it "stores time fields as nested or flat" do
+      metadata["time"] = { "prep" => "10 min", "cook" => "20 min" }
+      expect(metadata["time"]["prep"]).to eq("10 min")
+      expect(metadata["time"]["cook"]).to eq("20 min")
+
+      metadata.clear
+      metadata["prep_time"] = "15 minutes"
+      metadata["cook_time"] = "25 minutes"
+      expect(metadata["prep_time"]).to eq("15 minutes")
+      expect(metadata["cook_time"]).to eq("25 minutes")
+    end
+
+    it "stores source as string or nested hash" do
+      metadata["source"] = {
+        "name" => "The Cookbook",
+        "url" => "https://example.com",
+        "author" => "Chef Name"
+      }
+      expect(metadata["source"]["name"]).to eq("The Cookbook")
+      expect(metadata["source"]["url"]).to eq("https://example.com")
+      expect(metadata["source"]["author"]).to eq("Chef Name")
+
+      metadata.clear
+      metadata["source"] = "Grandma's recipe box"
+      expect(metadata["source"]).to eq("Grandma's recipe box")
+    end
+
+    it "stores tags and diet as arrays" do
+      metadata["tags"] = ["pasta", "italian"]
+      expect(metadata["tags"]).to eq(["pasta", "italian"])
+
+      metadata["diet"] = ["vegan", "gluten-free"]
+      expect(metadata["diet"]).to eq(["vegan", "gluten-free"])
+    end
+
+    it "stores other canonical fields" do
+      metadata["category"] = "dessert"
+      metadata["description"] = "A delicious recipe"
+      metadata["difficulty"] = "easy"
+      metadata["cuisine"] = "Italian"
+      metadata["locale"] = "en_US"
+      metadata["images"] = ["url1", "url2"]
+
+      expect(metadata["category"]).to eq("dessert")
+      expect(metadata["description"]).to eq("A delicious recipe")
+      expect(metadata["difficulty"]).to eq("easy")
+      expect(metadata["cuisine"]).to eq("Italian")
+      expect(metadata["locale"]).to eq("en_US")
+      expect(metadata["images"]).to eq(["url1", "url2"])
+    end
+  end
+
+  describe "Custom metadata fields" do
+    it "allows any custom fields" do
+      metadata = Cooklang::Metadata.new(
+        "wine_pairing" => "Pinot Noir",
+        "my_rating" => 5,
+        "special_equipment" => ["thermometer", "stand mixer"],
+        "notes_to_self" => "Double the garlic next time"
+      )
+
+      expect(metadata["wine_pairing"]).to eq("Pinot Noir")
+      expect(metadata["my_rating"]).to eq(5)
+      expect(metadata["special_equipment"]).to eq(["thermometer", "stand mixer"])
+      expect(metadata["notes_to_self"]).to eq("Double the garlic next time")
+    end
+  end
+end

data/spec/lexer_spec.rb

@@ -146,12 +146,12 @@ RSpec.describe Cooklang::Lexer do
       end
     end
 
-    context "with section markers" do
+    context "with equals (section markers)" do
       it "tokenizes single equals" do
         lexer = described_class.new("= Dough")
         tokens = lexer.tokenize
 
-        expect(tokens.map(&:type)).to eq(%i[section_marker text])
+        expect(tokens.map(&:type)).to eq(%i[equals text])
         expect(tokens.map(&:value)).to eq(["=", " Dough"])
       end
 
@@ -159,7 +159,7 @@ RSpec.describe Cooklang::Lexer do
         lexer = described_class.new("== Filling ==")
         tokens = lexer.tokenize
 
-        expect(tokens.map(&:type)).to eq(%i[section_marker text section_marker])
+        expect(tokens.map(&:type)).to eq(%i[equals text equals])
         expect(tokens.map(&:value)).to eq(["==", " Filling ", "=="])
       end
 
@@ -167,7 +167,7 @@ RSpec.describe Cooklang::Lexer do
         lexer = described_class.new("=== Section ===")
         tokens = lexer.tokenize
 
-        expect(tokens.map(&:type)).to eq(%i[section_marker text section_marker])
+        expect(tokens.map(&:type)).to eq(%i[equals text equals])
         expect(tokens.map(&:value)).to eq(["===", " Section ", "==="])
       end
     end

data/spec/models/ingredient_spec.rb

@@ -47,6 +47,20 @@ RSpec.describe Cooklang::Ingredient do
       expect(ingredient.notes).to eq("sifted")
       expect(ingredient.notes).to be_frozen
     end
+
+    it "defaults fixed to false" do
+      ingredient = described_class.new(name: "salt")
+
+      expect(ingredient.fixed).to be false
+      expect(ingredient.fixed?).to be false
+    end
+
+    it "accepts fixed parameter" do
+      ingredient = described_class.new(name: "salt", quantity: 1, unit: "tsp", fixed: true)
+
+      expect(ingredient.fixed).to be true
+      expect(ingredient.fixed?).to be true
+    end
   end
 
   describe "#to_s" do
@@ -94,16 +108,34 @@ RSpec.describe Cooklang::Ingredient do
         name: "flour",
         quantity: 125,
         unit: "g",
-        notes: "sifted"
+        notes: "sifted",
+        fixed: false
       }
 
       expect(ingredient.to_h).to eq(expected)
     end
 
-    it "omits nil attributes" do
+    it "omits nil attributes but includes fixed" do
       ingredient = described_class.new(name: "salt")
 
-      expect(ingredient.to_h).to eq({ name: "salt" })
+      expect(ingredient.to_h).to eq({ name: "salt", fixed: false })
+    end
+
+    it "includes fixed when true" do
+      ingredient = described_class.new(name: "salt", quantity: 1, unit: "tsp", fixed: true)
+
+      expect(ingredient.to_h).to eq({
+        name: "salt",
+        quantity: 1,
+        unit: "tsp",
+        fixed: true
+      })
+    end
+
+    it "includes fixed as false when not fixed" do
+      ingredient = described_class.new(name: "salt", quantity: 1, unit: "tsp", fixed: false)
+
+      expect(ingredient.to_h[:fixed]).to be false
     end
   end
 
@@ -129,6 +161,13 @@ RSpec.describe Cooklang::Ingredient do
       expect(ingredient1).not_to eq(ingredient2)
     end
 
+    it "returns false for ingredients with different fixed values" do
+      ingredient1 = described_class.new(name: "salt", quantity: 1, fixed: true)
+      ingredient2 = described_class.new(name: "salt", quantity: 1, fixed: false)
+
+      expect(ingredient1).not_to eq(ingredient2)
+    end
+
     it "returns false for non-Ingredient objects" do
       ingredient = described_class.new(name: "flour")
 
@@ -172,6 +211,23 @@ RSpec.describe Cooklang::Ingredient do
         expect(ingredient).not_to have_notes
       end
     end
+
+    describe "#fixed?" do
+      it "returns true when fixed is true" do
+        ingredient = described_class.new(name: "salt", quantity: 1, fixed: true)
+        expect(ingredient).to be_fixed
+      end
+
+      it "returns false when fixed is false" do
+        ingredient = described_class.new(name: "salt", quantity: 1, fixed: false)
+        expect(ingredient).not_to be_fixed
+      end
+
+      it "returns false by default" do
+        ingredient = described_class.new(name: "salt")
+        expect(ingredient).not_to be_fixed
+      end
+    end
   end
 
   describe "#hash" do