cooklang 1.0.2 → 1.0.4

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/models/metadata_spec.rb

@@ -81,161 +81,31 @@ RSpec.describe Cooklang::Metadata do
     end
   end
 
-  describe "recipe-specific accessors" do
+  describe "direct access to metadata" do
     let(:metadata) { described_class.new }
 
-    describe "#servings" do
-      it "returns integer servings" do
-        metadata["servings"] = "4"
+    it "stores any data types" do
+      metadata["servings"] = 4
+      metadata["tags"] = ["pasta", "italian"]
+      metadata["rating"] = 4.5
+      metadata["published"] = true
+      metadata["source"] = { "name" => "Cookbook", "url" => "https://example.com" }
 
-        expect(metadata.servings).to eq(4)
-      end
-
-      it "returns nil when not set" do
-        expect(metadata.servings).to be_nil
-      end
-    end
-
-    describe "#servings=" do
-      it "sets servings" do
-        metadata.servings = 6
-
-        expect(metadata["servings"]).to eq(6)
-      end
-    end
-
-    describe "#prep_time" do
-      it "returns prep_time" do
-        metadata["prep_time"] = "15 minutes"
-
-        expect(metadata.prep_time).to eq("15 minutes")
-      end
-
-      it "returns prep-time as fallback" do
-        metadata["prep-time"] = "15 minutes"
-
-        expect(metadata.prep_time).to eq("15 minutes")
-      end
-
-      it "returns nil when not set" do
-        expect(metadata.prep_time).to be_nil
-      end
-    end
-
-    describe "#prep_time=" do
-      it "sets prep_time" do
-        metadata.prep_time = "20 minutes"
-
-        expect(metadata["prep_time"]).to eq("20 minutes")
-      end
-    end
-
-    describe "#cook_time" do
-      it "returns cook_time" do
-        metadata["cook_time"] = "30 minutes"
-
-        expect(metadata.cook_time).to eq("30 minutes")
-      end
-
-      it "returns cook-time as fallback" do
-        metadata["cook-time"] = "30 minutes"
-
-        expect(metadata.cook_time).to eq("30 minutes")
-      end
-    end
-
-    describe "#cook_time=" do
-      it "sets cook_time" do
-        metadata.cook_time = "25 minutes"
-
-        expect(metadata["cook_time"]).to eq("25 minutes")
-      end
-    end
-
-    describe "#total_time" do
-      it "returns total_time" do
-        metadata["total_time"] = "45 minutes"
-
-        expect(metadata.total_time).to eq("45 minutes")
-      end
-
-      it "returns total-time as fallback" do
-        metadata["total-time"] = "45 minutes"
-
-        expect(metadata.total_time).to eq("45 minutes")
-      end
-    end
-
-    describe "#total_time=" do
-      it "sets total_time" do
-        metadata.total_time = "50 minutes"
-
-        expect(metadata["total_time"]).to eq("50 minutes")
-      end
-    end
-
-    describe "#title" do
-      it "returns title" do
-        metadata["title"] = "Chocolate Cake"
-
-        expect(metadata.title).to eq("Chocolate Cake")
-      end
-    end
-
-    describe "#title=" do
-      it "sets title" do
-        metadata.title = "Vanilla Cake"
-
-        expect(metadata["title"]).to eq("Vanilla Cake")
-      end
-    end
-
-    describe "#source" do
-      it "returns source" do
-        metadata["source"] = "cookbook.com"
-
-        expect(metadata.source).to eq("cookbook.com")
-      end
-    end
-
-    describe "#source=" do
-      it "sets source" do
-        metadata.source = "my-blog.com"
-
-        expect(metadata["source"]).to eq("my-blog.com")
-      end
-    end
-
-    describe "#tags" do
-      it "returns array when tags is array" do
-        metadata["tags"] = ["dessert", "chocolate"]
-
-        expect(metadata.tags).to eq(["dessert", "chocolate"])
-      end
-
-      it "splits string tags on comma" do
-        metadata["tags"] = "dessert, chocolate, sweet"
-
-        expect(metadata.tags).to eq(["dessert", "chocolate", "sweet"])
-      end
-
-      it "returns empty array when not set" do
-        expect(metadata.tags).to eq([])
-      end
-
-      it "returns empty array for non-string, non-array values" do
-        metadata["tags"] = 123
-
-        expect(metadata.tags).to eq([])
-      end
+      expect(metadata["servings"]).to eq(4)
+      expect(metadata["tags"]).to eq(["pasta", "italian"])
+      expect(metadata["rating"]).to eq(4.5)
+      expect(metadata["published"]).to eq(true)
+      expect(metadata["source"]).to eq({ "name" => "Cookbook", "url" => "https://example.com" })
     end
 
-    describe "#tags=" do
-      it "sets tags" do
-        metadata.tags = ["breakfast", "quick"]
+    it "allows any custom fields" do
+      metadata["wine_pairing"] = "Pinot Noir"
+      metadata["my_custom_field"] = { "nested" => "data" }
+      metadata["notes"] = ["note1", "note2"]
 
-        expect(metadata["tags"]).to eq(["breakfast", "quick"])
-      end
+      expect(metadata["wine_pairing"]).to eq("Pinot Noir")
+      expect(metadata["my_custom_field"]).to eq({ "nested" => "data" })
+      expect(metadata["notes"]).to eq(["note1", "note2"])
     end
   end
 end

data/spec/models/recipe_spec.rb

@@ -143,7 +143,7 @@ RSpec.describe Cooklang::Recipe do
 
     let(:expected_hash) do
       {
-        metadata: { map: { "title" => "Test Recipe", "servings" => "4", "prep_time" => "15 minutes" } },
+        metadata: { map: { "title" => "Test Recipe", "servings" => 4, "prep_time" => "15 minutes" } },
         sections: [
           {
             name: nil,
@@ -174,7 +174,7 @@ RSpec.describe Cooklang::Recipe do
 
     let(:expected_json) do
       {
-        "metadata" => { "map" => { "title" => "Test Recipe", "servings" => "4", "prep_time" => "15 minutes" } },
+        "metadata" => { "map" => { "title" => "Test Recipe", "servings" => 4, "prep_time" => "15 minutes" } },
         "sections" => [
           {
             "name" => nil,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cooklang
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - James Brooks
@@ -13,16 +13,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -124,7 +124,6 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -158,8 +157,13 @@ files:
 - spec/comprehensive_spec.rb
 - spec/cooklang_spec.rb
 - spec/fixtures/canonical.yaml
+- spec/fixtures/comprehensive_recipe.cook
+- spec/formatters/formatter_spec.rb
+- spec/formatters/hash_spec.rb
+- spec/formatters/json_spec.rb
 - spec/formatters/text_spec.rb
 - spec/integration/canonical_spec.rb
+- spec/integration/metadata_canonical_spec.rb
 - spec/lexer_spec.rb
 - spec/models/cookware_spec.rb
 - spec/models/ingredient_spec.rb
@@ -186,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -200,8 +204,13 @@ test_files:
 - spec/comprehensive_spec.rb
 - spec/cooklang_spec.rb
 - spec/fixtures/canonical.yaml
+- spec/fixtures/comprehensive_recipe.cook
+- spec/formatters/formatter_spec.rb
+- spec/formatters/hash_spec.rb
+- spec/formatters/json_spec.rb
 - spec/formatters/text_spec.rb
 - spec/integration/canonical_spec.rb
+- spec/integration/metadata_canonical_spec.rb
 - spec/lexer_spec.rb
 - spec/models/cookware_spec.rb
 - spec/models/ingredient_spec.rb