cooklang 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61d7de5e0471ab52eb21411d501fb1b909a5e1c356b2eeb105a37c971847321
-  data.tar.gz: 24fb626c2590541600acf57b317255adbb6fa75abc34ace698c70c8fcf2a5c90
+  metadata.gz: a13e5e798824a4c9fa2d7405a7466f03b59ef20a0a80ed16f1de789cf40df0db
+  data.tar.gz: ade82856860ca28430e38f325e64b15a8f2a0694ebaba9a56cfd058af1f658e5
 SHA512:
-  metadata.gz: 723008d0a4ea83eaec6c376f715f47a74edf29230a2fb8fcc2ec13d47250b65adc6027511343de7a6bd3e4d2b833e592add88373e298bf21e98a1fa217358166
-  data.tar.gz: ff3a2b9eb011b525309a7ac19bda34c51eb9dd68f154958af8b164511b1955a61e786dfd3cb45dd51391682700b9b962e2b3a8f54bade6fc1a5d56ea4053b2b3
+  metadata.gz: 8ff63ccbc36d06328546b6508429a93d94d5d97a98fdec2d506854d39661d4015f18630269f2e61a838dcb9083b9850e70b0d2db1503f7a7631d6a246a2bd42f
+  data.tar.gz: 010e6b452e3d7102b7c347f6875d132f137b5b55cba594d0b29a3d28ad1cf19dfebbe6b700441f65b763db9c021675e8b7405f90615925fc1ca1baf9191f5e2e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cooklang (1.0.0)
+    cooklang (1.0.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -52,19 +52,194 @@ end
 
 # Parse from file
 recipe = Cooklang.parse_file('pancakes.cook')
+```
+
+## Formatters
+
+The gem provides three built-in formatters for different output needs. Here's an example using Uncle Roger's Fried Rice recipe:
+
+```ruby
+>> title: Uncle Roger's Fried Rice
+>> servings: 2
+>> prep_time: 10 minutes
+>> cook_time: 8 minutes
+
+Heat @peanut oil{1%tbsp} in #wok over high heat until smoking.
+
+Add @garlic{3%cloves}(minced) and @shallots{2}(diced), stir-fry for ~{30%seconds}.
+
+Add @eggs{3}(beaten) and scramble until almost set.
+
+Add @day-old rice{3%cups} and stir-fry, breaking up clumps for ~{2%minutes}.
+
+Season with @soy sauce{2%tbsp}, @sesame oil{1%tbsp}, @msg{1%tsp}, and @white pepper{0.5%tsp}.
+
+Add @spring onions{3%stalks}(chopped) and stir for ~{30%seconds} more.
+
+Serve immediately while hot!
+```
+
+### Text Formatter
+Human-readable format with ingredients list and numbered steps:
+
+Usage: `Cooklang::Formatters::Text.new(recipe).generate`
+
+```
+Ingredients:
+    peanut oil       1 tbsp
+    garlic           3 cloves
+    shallots         2
+    eggs             3
+    day-old rice     3 cups
+    soy sauce        2 tbsp
+    sesame oil       1 tbsp
+    msg              1 tsp
+    white pepper     0.5 tsp
+    spring onions    3 stalks
+
+Steps:
+    1. Heat peanut oil in wok over high heat until smoking.
+    2. Add garlic and shallots, stirfry for for 30 seconds.
+    3. Add eggs and scramble until almost set.
+    4. Add day-old rice and stirfry, breaking up clumps for for 2 minutes.
+    5. Season with soy sauce, sesame oil, msg, and white pepper.
+    6. Add spring onions and stir for for 30 seconds more.
+    7. Serve immediately while hot!
+```
+
+### Hash Formatter
+Structured Ruby hash format compatible with Cook CLI:
+
+Usage: `Cooklang::Formatters::Hash.new(recipe).generate`
+
+```ruby
+{:metadata=>
+  {:map=>
+    {"title"=>"Uncle Roger's Fried Rice",
+     "servings"=>"2",
+     "prep_time"=>"10 minutes",
+     "cook_time"=>"8 minutes"}},
+ :sections=>
+  [{:name=>nil,
+    :content=>
+     [{:type=>"step",
+       :value=>
+        {:items=>
+          [{:type=>"text", :value=>"Heat "},
+           {:type=>"ingredient", :index=>0},
+           {:type=>"text", :value=>" in "},
+           {:type=>"cookware", :index=>0},
+           {:type=>"text", :value=>" over high heat until smoking."}],
+         :number=>1}},
+      {:type=>"step",
+       :value=>
+        {:items=>
+          [{:type=>"text", :value=>"Add "},
+           {:type=>"ingredient", :index=>1},
+           {:type=>"text", :value=>" and "},
+           {:type=>"ingredient", :index=>2},
+           {:type=>"text", :value=>" and stir for "},
+           {:type=>"timer", :index=>0}],
+         :number=>2}}]}],
+ :ingredients=>
+  [{:name=>"peanut oil",
+    :quantity=>
+     {:value=>{:type=>"number", :value=>{:type=>"regular", :value=>1.0}},
+      :unit=>"tbsp"}},
+   {:name=>"garlic",
+    :quantity=>
+     {:value=>{:type=>"number", :value=>{:type=>"regular", :value=>3.0}},
+      :unit=>"cloves"},
+    :note=>"minced"},
+   {:name=>"spring onions",
+    :quantity=>
+     {:value=>{:type=>"number", :value=>{:type=>"regular", :value=>3.0}},
+      :unit=>"stalks"},
+    :note=>"chopped"}],
+ :cookware=>[{:name=>"wok"}],
+ :timers=>
+  [{:quantity=>
+     {:value=>{:type=>"number", :value=>{:type=>"regular", :value=>30.0}},
+      :unit=>"seconds"}},
+   {:quantity=>
+     {:value=>{:type=>"number", :value=>{:type=>"regular", :value=>2.0}},
+      :unit=>"minutes"}}]}
+```
 
-# Format as text
-formatter = Cooklang::Formatters::Text.new(recipe)
-puts formatter.to_s
-# Ingredients:
-#     eggs        3
-#     flour       125 g
-#     milk        250 ml
-#
-# Steps:
-#     1. Crack eggs into a bowl, add flour and milk.
-#     2. Heat frying pan over medium heat for 5 minutes.
-#     3. Pour batter and cook until golden.
+### JSON Formatter
+JSON string format for APIs and data interchange:
+
+Usage: `Cooklang::Formatters::Json.new(recipe).generate`
+
+```json
+{
+  "metadata": {
+    "map": {
+      "title": "Uncle Roger's Fried Rice",
+      "servings": "2",
+      "prep_time": "10 minutes",
+      "cook_time": "8 minutes"
+    }
+  },
+  "sections": [
+    {
+      "name": null,
+      "content": [
+        {
+          "type": "step",
+          "value": {
+            "items": [
+              {"type": "text", "value": "Heat "},
+              {"type": "ingredient", "index": 0},
+              {"type": "text", "value": " in "},
+              {"type": "cookware", "index": 0},
+              {"type": "text", "value": " over high heat until smoking."}
+            ],
+            "number": 1
+          }
+        },
+        {
+          "type": "step",
+          "value": {
+            "items": [
+              {"type": "text", "value": "Add "},
+              {"type": "ingredient", "index": 1},
+              {"type": "text", "value": " and stir for "},
+              {"type": "timer", "index": 0}
+            ],
+            "number": 2
+          }
+        }
+      ]
+    }
+  ],
+  "ingredients": [
+    {
+      "name": "peanut oil",
+      "quantity": {
+        "value": {"type": "number", "value": {"type": "regular", "value": 1.0}},
+        "unit": "tbsp"
+      }
+    },
+    {
+      "name": "garlic",
+      "quantity": {
+        "value": {"type": "number", "value": {"type": "regular", "value": 3.0}},
+        "unit": "cloves"
+      },
+      "note": "minced"
+    }
+  ],
+  "cookware": [{"name": "wok"}],
+  "timers": [
+    {
+      "quantity": {
+        "value": {"type": "number", "value": {"type": "regular", "value": 30.0}},
+        "unit": "seconds"
+      }
+    }
+  ]
+}
 ```
 
 ## API

data/lib/cooklang/builders/recipe_builder.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../recipe"
-require_relative "../step"
-require_relative "../section"
-
 module Cooklang
   module Builders
     class RecipeBuilder

data/lib/cooklang/builders/step_builder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../step"
-
 module Cooklang
   module Builders
     class StepBuilder

data/lib/cooklang/formatter.rb

@@ -8,8 +8,12 @@ module Cooklang
       @recipe = recipe
     end
 
-    def to_s
-      raise NotImplementedError, "Subclasses must implement #to_s"
+    def generate(*args)
+      raise NotImplementedError, "Subclasses must implement #generate"
+    end
+
+    def to_s(*args)
+      generate(*args).to_s
     end
 
     private

data/lib/cooklang/formatters/hash.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Formatters
+    class Hash < Formatter
+      def generate(*args)
+        {
+          metadata: format_metadata,
+          sections: format_sections,
+          ingredients: format_ingredients,
+          cookware: format_cookware,
+          timers: format_timers,
+          inline_quantities: [],
+          data: format_data
+        }
+      end
+
+    private
+      def format_metadata
+        {
+          map: recipe.metadata.to_h.transform_values(&:to_s)
+        }
+      end
+
+      def format_sections
+        [
+          {
+            name: nil,
+            content: format_steps_as_content
+          }
+        ]
+      end
+
+      def format_steps_as_content
+        recipe.steps.each_with_index.map do |step, index|
+          {
+            type: "step",
+            value: {
+              items: format_step_items(step),
+              number: index + 1
+            }
+          }
+        end
+      end
+
+      def format_step_items(step)
+        items = []
+
+        step.segments.each do |segment|
+          items << format_segment(segment)
+        end
+
+        items
+      end
+
+      def format_segment(segment)
+        case segment
+        when Hash
+          case segment[:type]
+          when :ingredient
+            {
+              type: "ingredient",
+              index: find_ingredient_index(segment[:name])
+            }
+          when :cookware
+            {
+              type: "cookware",
+              index: find_cookware_index(segment[:name])
+            }
+          when :timer
+            {
+              type: "timer",
+              index: find_timer_index(segment)
+            }
+          else
+            {
+              type: "text",
+              value: segment[:value] || ""
+            }
+          end
+        when String
+          {
+            type: "text",
+            value: segment
+          }
+        when Cooklang::Ingredient
+          {
+            type: "ingredient",
+            index: find_ingredient_index(segment.name)
+          }
+        when Cooklang::Cookware
+          {
+            type: "cookware",
+            index: find_cookware_index(segment.name)
+          }
+        when Cooklang::Timer
+          {
+            type: "timer",
+            index: find_timer_index(segment)
+          }
+        else
+          {
+            type: "text",
+            value: segment.to_s
+          }
+        end
+      end
+
+      def format_ingredients
+        recipe.ingredients.map do |ingredient|
+          {
+            name: ingredient.name,
+            alias: nil,
+            quantity: format_ingredient_quantity(ingredient),
+            note: ingredient.notes,
+            reference: nil,
+            relation: {
+              type: "definition",
+              referenced_from: [],
+              defined_in_step: true,
+              reference_target: nil
+            },
+            modifiers: ""
+          }
+        end
+      end
+
+      def format_ingredient_quantity(ingredient)
+        return nil unless ingredient.quantity && ingredient.quantity != "some"
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: ingredient.quantity.to_f
+            }
+          },
+          unit: ingredient.unit
+        }
+      end
+
+      def format_cookware
+        recipe.cookware.map do |cookware_item|
+          {
+            name: cookware_item.name,
+            alias: nil,
+            quantity: format_cookware_quantity(cookware_item),
+            note: nil,
+            relation: {
+              type: "definition",
+              referenced_from: [],
+              defined_in_step: true
+            },
+            modifiers: ""
+          }
+        end
+      end
+
+      def format_cookware_quantity(cookware_item)
+        return nil unless cookware_item.quantity && cookware_item.quantity != 1
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: cookware_item.quantity.to_f
+            }
+          },
+          unit: nil
+        }
+      end
+
+      def format_timers
+        recipe.timers.map do |timer|
+          {
+            name: (timer.name.nil? || timer.name.empty?) ? nil : timer.name,
+            quantity: format_timer_quantity(timer)
+          }
+        end
+      end
+
+      def format_timer_quantity(timer)
+        return nil unless timer.duration
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: timer.duration.to_f
+            }
+          },
+          unit: timer.unit
+        }
+      end
+
+      def find_ingredient_index(name)
+        recipe.ingredients.find_index { |ingredient| ingredient.name == name } || 0
+      end
+
+      def find_cookware_index(name)
+        recipe.cookware.find_index { |cookware_item| cookware_item.name == name } || 0
+      end
+
+      def find_timer_index(timer_data)
+        # For hash segments, we need to match by duration and unit
+        if timer_data.is_a?(Hash)
+          recipe.timers.find_index do |timer|
+            timer.duration == timer_data[:duration] && timer.unit == timer_data[:unit]
+          end || 0
+        elsif timer_data.is_a?(Cooklang::Timer)
+          recipe.timers.find_index { |timer| timer == timer_data } || 0
+        else
+          0
+        end
+      end
+
+      def format_data
+        {
+          type: "Scaled",
+          target: {
+            factor: 1.0
+          },
+          ingredients: format_ingredient_data,
+          cookware: format_cookware_data,
+          timers: format_timer_data
+        }
+      end
+
+      def format_ingredient_data
+        recipe.ingredients.map do |ingredient|
+          if ingredient.quantity && ingredient.quantity != "some"
+            "scaled"
+          else
+            "noQuantity"
+          end
+        end
+      end
+
+      def format_cookware_data
+        recipe.cookware.map do |cookware_item|
+          if cookware_item.quantity && cookware_item.quantity != 1
+            "scaled"
+          else
+            "noQuantity"
+          end
+        end
+      end
+
+      def format_timer_data
+        recipe.timers.map { "fixed" }
+      end
+    end
+  end
+end

data/lib/cooklang/formatters/json.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cooklang
+  module Formatters
+    class Json < Hash
+      def generate(*args)
+        super().to_json(*args)
+      end
+    end
+  end
+end

data/lib/cooklang/formatters/text.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../formatter"
-
 module Cooklang
   module Formatters
     class Text < Formatter
-      def to_s
+      def generate(*args)
         sections = []
 
         sections << ingredients_section unless recipe.ingredients.empty?

data/lib/cooklang/parser.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "lexer"
-require_relative "processors/metadata_processor"
-require_relative "processors/token_processor"
-require_relative "processors/step_processor"
-require_relative "builders/recipe_builder"
-
 module Cooklang
   class Parser
     def parse(input)

data/lib/cooklang/parsers/cookware_parser.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../cookware"
-require_relative "../token_stream"
-
 module Cooklang
   module Parsers
     class CookwareParser

data/lib/cooklang/parsers/ingredient_parser.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../ingredient"
-require_relative "../token_stream"
-
 module Cooklang
   module Parsers
     class IngredientParser

data/lib/cooklang/parsers/timer_parser.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../timer"
-require_relative "../token_stream"
-
 module Cooklang
   module Parsers
     class TimerParser

data/lib/cooklang/processors/element_parser.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../token_stream"
-require_relative "../parsers/ingredient_parser"
-require_relative "../parsers/cookware_parser"
-require_relative "../parsers/timer_parser"
-
 module Cooklang
   module Processors
     class ElementParser

data/lib/cooklang/processors/metadata_processor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../metadata"
-
 module Cooklang
   module Processors
     class MetadataProcessor

data/lib/cooklang/processors/step_processor.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "element_parser"
-require_relative "../token_stream"
-require_relative "../builders/step_builder"
-
 module Cooklang
   module Processors
     class StepProcessor

data/lib/cooklang/processors/token_processor.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../lexer"
-require_relative "../note"
-
 module Cooklang
   module Processors
     class TokenProcessor

data/lib/cooklang/recipe.rb

@@ -19,6 +19,7 @@ module Cooklang
         (value || []).freeze
       end
 
+
     public
 
     def ingredients_hash
@@ -35,15 +36,11 @@ module Cooklang
     end
 
     def to_h
-      {
-        ingredients: @ingredients.map(&:to_h),
-        cookware: @cookware.map(&:to_h),
-        timers: @timers.map(&:to_h),
-        steps: @steps.map(&:to_h),
-        metadata: @metadata.to_h,
-        sections: @sections.map(&:to_h),
-        notes: @notes.map(&:to_h)
-      }
+      Formatters::Hash.new(self).generate
+    end
+
+    def to_json(*args)
+      Formatters::Json.new(self).generate(*args)
     end
 
     def ==(other)

data/lib/cooklang/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cooklang
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/lib/cooklang.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "cooklang/version"
-require_relative "cooklang/lexer"
-require_relative "cooklang/parser"
-require_relative "cooklang/recipe"
+
+# Core classes
 require_relative "cooklang/ingredient"
 require_relative "cooklang/cookware"
 require_relative "cooklang/timer"
@@ -11,8 +10,37 @@ require_relative "cooklang/step"
 require_relative "cooklang/metadata"
 require_relative "cooklang/section"
 require_relative "cooklang/note"
+
+# Parsing infrastructure
+require_relative "cooklang/token_stream"
+require_relative "cooklang/lexer"
+
+# Parsers (depend on token_stream and core classes)
+require_relative "cooklang/parsers/ingredient_parser"
+require_relative "cooklang/parsers/cookware_parser"
+require_relative "cooklang/parsers/timer_parser"
+
+# Processors (depend on parsers and token_stream)
+require_relative "cooklang/processors/element_parser"
+require_relative "cooklang/processors/metadata_processor"
+require_relative "cooklang/processors/token_processor"
+
+# Builders (depend on core classes)
+require_relative "cooklang/builders/step_builder"
+require_relative "cooklang/builders/recipe_builder"
+
+# Processors that depend on builders
+require_relative "cooklang/processors/step_processor"
+
+# Main parser (depends on processors and builders)
+require_relative "cooklang/parser"
+
+# Recipe (depends on formatters)
 require_relative "cooklang/formatter"
+require_relative "cooklang/formatters/hash"
+require_relative "cooklang/formatters/json"
 require_relative "cooklang/formatters/text"
+require_relative "cooklang/recipe"
 
 module Cooklang
   class Error < StandardError; end

data/spec/models/recipe_spec.rb

@@ -96,7 +96,7 @@ RSpec.describe Cooklang::Recipe do
   end
 
   describe "#to_h" do
-    it "returns complete hash representation" do
+    it "returns complete hash representation in Cook CLI format" do
       recipe = described_class.new(
         ingredients: [ingredient],
         cookware: [cookware],
@@ -107,11 +107,214 @@ RSpec.describe Cooklang::Recipe do
 
       hash = recipe.to_h
 
-      expect(hash[:ingredients]).to eq([ingredient.to_h])
-      expect(hash[:cookware]).to eq([cookware.to_h])
-      expect(hash[:timers]).to eq([timer.to_h])
-      expect(hash[:steps]).to eq([step.to_h])
-      expect(hash[:metadata]).to eq(metadata.to_h)
+      expect(hash).to have_key(:metadata)
+      expect(hash).to have_key(:sections)
+      expect(hash).to have_key(:ingredients)
+      expect(hash).to have_key(:cookware)
+      expect(hash).to have_key(:timers)
+      expect(hash).to have_key(:inline_quantities)
+
+      expect(hash[:metadata]).to have_key(:map)
+      expect(hash[:ingredients]).to be_an(Array)
+      expect(hash[:cookware]).to be_an(Array)
+      expect(hash[:timers]).to be_an(Array)
+      expect(hash[:sections]).to be_an(Array)
+    end
+  end
+
+  describe "comprehensive output tests" do
+    let(:recipe_text) do
+      <<~RECIPE
+        >> title: Test Recipe
+        >> servings: 4
+        >> prep_time: 15 minutes
+
+        Heat #large pot{} over medium heat.
+
+        Add @olive oil{2%tbsp} and @onion{1%medium}(diced).
+        Cook for ~{5%minutes} until soft.
+
+        Add @salt{} and @pepper{} to taste.
+        Season with @garlic{2%cloves}(minced).
+      RECIPE
+    end
+
+    let(:parsed_recipe) { Cooklang.parse(recipe_text) }
+
+    let(:expected_hash) do
+      {
+        metadata: { map: { "title" => "Test Recipe", "servings" => "4", "prep_time" => "15 minutes" } },
+        sections: [
+          {
+            name: nil,
+            content: [
+              { type: "step", value: { items: [{ type: "text", value: "Heat " }, { type: "cookware", index: 0 }, { type: "text", value: " over medium heat." }], number: 1 } },
+              { type: "step", value: { items: [{ type: "text", value: "Add " }, { type: "ingredient", index: 0 }, { type: "text", value: " and " }, { type: "ingredient", index: 1 }, { type: "text", value: "." }, { type: "text", value: "\n" }, { type: "text", value: "Cook for " }, { type: "timer", index: 0 }, { type: "text", value: " until soft." }], number: 2 } },
+              { type: "step", value: { items: [{ type: "text", value: "Add " }, { type: "ingredient", index: 2 }, { type: "text", value: " and " }, { type: "ingredient", index: 3 }, { type: "text", value: " to taste." }, { type: "text", value: "\n" }, { type: "text", value: "Season with " }, { type: "ingredient", index: 4 }, { type: "text", value: "." }], number: 3 } }
+            ]
+          }
+        ],
+        ingredients: [
+          { name: "olive oil", alias: nil, quantity: { value: { type: "number", value: { type: "regular", value: 2.0 } }, unit: "tbsp" }, note: nil, reference: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true, reference_target: nil }, modifiers: "" },
+          { name: "onion", alias: nil, quantity: { value: { type: "number", value: { type: "regular", value: 1.0 } }, unit: "medium" }, note: "diced", reference: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true, reference_target: nil }, modifiers: "" },
+          { name: "salt", alias: nil, quantity: nil, note: nil, reference: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true, reference_target: nil }, modifiers: "" },
+          { name: "pepper", alias: nil, quantity: nil, note: nil, reference: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true, reference_target: nil }, modifiers: "" },
+          { name: "garlic", alias: nil, quantity: { value: { type: "number", value: { type: "regular", value: 2.0 } }, unit: "cloves" }, note: "minced", reference: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true, reference_target: nil }, modifiers: "" }
+        ],
+        cookware: [
+          { name: "large pot", alias: nil, quantity: nil, note: nil, relation: { type: "definition", referenced_from: [], defined_in_step: true }, modifiers: "" }
+        ],
+        timers: [
+          { name: nil, quantity: { value: { type: "number", value: { type: "regular", value: 5.0 } }, unit: "minutes" } }
+        ],
+        inline_quantities: [],
+        data: { type: "Scaled", target: { factor: 1.0 }, ingredients: ["scaled", "scaled", "noQuantity", "noQuantity", "scaled"], cookware: ["noQuantity"], timers: ["fixed"] }
+      }
+    end
+
+    let(:expected_json) do
+      {
+        "metadata" => { "map" => { "title" => "Test Recipe", "servings" => "4", "prep_time" => "15 minutes" } },
+        "sections" => [
+          {
+            "name" => nil,
+            "content" => [
+              { "type" => "step", "value" => { "items" => [{ "type" => "text", "value" => "Heat " }, { "type" => "cookware", "index" => 0 }, { "type" => "text", "value" => " over medium heat." }], "number" => 1 } },
+              { "type" => "step", "value" => { "items" => [{ "type" => "text", "value" => "Add " }, { "type" => "ingredient", "index" => 0 }, { "type" => "text", "value" => " and " }, { "type" => "ingredient", "index" => 1 }, { "type" => "text", "value" => "." }, { "type" => "text", "value" => "\n" }, { "type" => "text", "value" => "Cook for " }, { "type" => "timer", "index" => 0 }, { "type" => "text", "value" => " until soft." }], "number" => 2 } },
+              { "type" => "step", "value" => { "items" => [{ "type" => "text", "value" => "Add " }, { "type" => "ingredient", "index" => 2 }, { "type" => "text", "value" => " and " }, { "type" => "ingredient", "index" => 3 }, { "type" => "text", "value" => " to taste." }, { "type" => "text", "value" => "\n" }, { "type" => "text", "value" => "Season with " }, { "type" => "ingredient", "index" => 4 }, { "type" => "text", "value" => "." }], "number" => 3 } }
+            ]
+          }
+        ],
+        "ingredients" => [
+          { "name" => "olive oil", "alias" => nil, "quantity" => { "value" => { "type" => "number", "value" => { "type" => "regular", "value" => 2.0 } }, "unit" => "tbsp" }, "note" => nil, "reference" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true, "reference_target" => nil }, "modifiers" => "" },
+          { "name" => "onion", "alias" => nil, "quantity" => { "value" => { "type" => "number", "value" => { "type" => "regular", "value" => 1.0 } }, "unit" => "medium" }, "note" => "diced", "reference" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true, "reference_target" => nil }, "modifiers" => "" },
+          { "name" => "salt", "alias" => nil, "quantity" => nil, "note" => nil, "reference" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true, "reference_target" => nil }, "modifiers" => "" },
+          { "name" => "pepper", "alias" => nil, "quantity" => nil, "note" => nil, "reference" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true, "reference_target" => nil }, "modifiers" => "" },
+          { "name" => "garlic", "alias" => nil, "quantity" => { "value" => { "type" => "number", "value" => { "type" => "regular", "value" => 2.0 } }, "unit" => "cloves" }, "note" => "minced", "reference" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true, "reference_target" => nil }, "modifiers" => "" }
+        ],
+        "cookware" => [
+          { "name" => "large pot", "alias" => nil, "quantity" => nil, "note" => nil, "relation" => { "type" => "definition", "referenced_from" => [], "defined_in_step" => true }, "modifiers" => "" }
+        ],
+        "timers" => [
+          { "name" => nil, "quantity" => { "value" => { "type" => "number", "value" => { "type" => "regular", "value" => 5.0 } }, "unit" => "minutes" } }
+        ],
+        "inline_quantities" => [],
+        "data" => { "type" => "Scaled", "target" => { "factor" => 1.0 }, "ingredients" => ["scaled", "scaled", "noQuantity", "noQuantity", "scaled"], "cookware" => ["noQuantity"], "timers" => ["fixed"] }
+      }
+    end
+
+    describe "#to_h" do
+      it "returns complete canonical structure" do
+        expect(parsed_recipe.to_h).to eq(expected_hash)
+      end
+    end
+
+    describe "#to_json" do
+      it "returns JSON with null for canonical defaults" do
+        expect(JSON.parse(parsed_recipe.to_json)).to eq(expected_json)
+      end
+    end
+
+    describe "canonical vs JSON consistency" do
+      it "maintains different representations for same recipe" do
+        # Internal canonical representation keeps defaults
+        expect(parsed_recipe.ingredients.find { |i| i.name == "salt" }.quantity).to eq("some")
+        expect(parsed_recipe.cookware.first.quantity).to eq(1)
+
+        # Both hash and JSON output convert defaults to nil for external use
+        hash = parsed_recipe.to_h
+        json_parsed = JSON.parse(parsed_recipe.to_json)
+
+        salt_hash = hash[:ingredients].find { |i| i[:name] == "salt" }
+        salt_json = json_parsed["ingredients"].find { |i| i["name"] == "salt" }
+        expect(salt_hash[:quantity]).to be_nil
+        expect(salt_json["quantity"]).to be_nil
+
+        expect(hash[:cookware].first[:quantity]).to be_nil
+        expect(json_parsed["cookware"].first["quantity"]).to be_nil
+      end
+    end
+  end
+
+  describe "edge cases" do
+    it "handles empty recipe" do
+      recipe = described_class.new(
+        ingredients: [],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      hash = recipe.to_h
+      expect(hash[:ingredients]).to eq([])
+      expect(hash[:cookware]).to eq([])
+      expect(hash[:timers]).to eq([])
+      expect(hash[:sections].first[:content]).to eq([])
+
+      json = JSON.parse(recipe.to_json)
+      expect(json["ingredients"]).to eq([])
+      expect(json["cookware"]).to eq([])
+      expect(json["timers"]).to eq([])
+    end
+
+    it "handles ingredients with no quantity specified" do
+      ingredient = Cooklang::Ingredient.new(name: "salt")
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      hash = recipe.to_h
+      salt = hash[:ingredients].first
+      expect(salt[:quantity]).to be_nil
+
+      json = JSON.parse(recipe.to_json)
+      salt_json = json["ingredients"].first
+      expect(salt_json["quantity"]).to be_nil
+    end
+
+    it "handles cookware with no quantity specified" do
+      cookware = Cooklang::Cookware.new(name: "pan")
+      recipe = described_class.new(
+        ingredients: [],
+        cookware: [cookware],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      hash = recipe.to_h
+      pan = hash[:cookware].first
+      expect(pan[:quantity]).to be_nil
+
+      json = JSON.parse(recipe.to_json)
+      pan_json = json["cookware"].first
+      expect(pan_json["quantity"]).to be_nil
+    end
+
+    it "handles fractional quantities" do
+      ingredient = Cooklang::Ingredient.new(name: "flour", quantity: 1.5, unit: "cups")
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      hash = recipe.to_h
+      flour = hash[:ingredients].first
+      expect(flour[:quantity][:value][:value][:value]).to eq(1.5)
+      expect(flour[:quantity][:unit]).to eq("cups")
+
+      json = JSON.parse(recipe.to_json)
+      flour_json = json["ingredients"].first
+      expect(flour_json["quantity"]["value"]["value"]["value"]).to eq(1.5)
+      expect(flour_json["quantity"]["unit"]).to eq("cups")
     end
   end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cooklang
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - James Brooks
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -135,6 +134,8 @@ files:
 - lib/cooklang/builders/step_builder.rb
 - lib/cooklang/cookware.rb
 - lib/cooklang/formatter.rb
+- lib/cooklang/formatters/hash.rb
+- lib/cooklang/formatters/json.rb
 - lib/cooklang/formatters/text.rb
 - lib/cooklang/ingredient.rb
 - lib/cooklang/lexer.rb
@@ -178,7 +179,6 @@ metadata:
   homepage_uri: https://github.com/jamesbrooks/cooklang
   source_code_uri: https://github.com/jamesbrooks/cooklang
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -193,8 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.1
 specification_version: 4
 summary: A Ruby parser for the Cooklang recipe markup language.
 test_files: