cooklang 1.0.0 → 1.0.1

data/spec/parser_spec.rb

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Parser do
+  let(:parser) { described_class.new }
+
+  describe "#parse" do
+    context "with simple ingredients" do
+      it "parses single word ingredients" do
+        recipe = parser.parse("Add @salt to taste.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("salt")
+        expect(ingredient.quantity).to eq("some") # Default quantity per canonical tests
+        expect(ingredient.unit).to be_nil
+        expect(ingredient.notes).to be_nil
+      end
+
+      it "parses multi-word ingredients with braces" do
+        recipe = parser.parse("Add @ground pepper{} to taste.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("ground pepper")
+      end
+
+      it "parses multi-word ingredients without braces (first word only)" do
+        recipe = parser.parse("Add @ground pepper to taste.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("ground")
+      end
+
+      it "parses ingredients with quantities" do
+        recipe = parser.parse("Use @flour{125%g} for the batter.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("flour")
+        expect(ingredient.quantity).to eq(125)
+        expect(ingredient.unit).to eq("g")
+      end
+
+      it "parses ingredients with quantities but no unit" do
+        recipe = parser.parse("Crack @eggs{3} into bowl.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("eggs")
+        expect(ingredient.quantity).to eq(3)
+        expect(ingredient.unit).to be_nil
+      end
+
+      it "parses ingredients with notes" do
+        recipe = parser.parse("Dice @onion{1}(large) finely.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("onion")
+        expect(ingredient.quantity).to eq(1)
+        expect(ingredient.unit).to be_nil
+        expect(ingredient.notes).to eq("large")
+      end
+
+      it "parses ingredients with quantity, unit, and notes" do
+        recipe = parser.parse("Add @butter{2%tbsp}(melted) to pan.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("butter")
+        expect(ingredient.quantity).to eq(2)
+        expect(ingredient.unit).to eq("tbsp")
+        expect(ingredient.notes).to eq("melted")
+      end
+
+      it "parses ingredients with string quantities" do
+        recipe = parser.parse("Add @salt{some} to taste.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("salt")
+        expect(ingredient.quantity).to eq("some")
+      end
+
+      it "parses ingredients with decimal quantities" do
+        recipe = parser.parse("Use @flour{1.5%cups} for batter.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.name).to eq("flour")
+        expect(ingredient.quantity).to eq(1.5)
+        expect(ingredient.unit).to eq("cups")
+      end
+    end
+
+    context "with cookware" do
+      it "parses simple cookware" do
+        recipe = parser.parse("Heat the #pan over medium heat.")
+
+        expect(recipe.cookware.size).to eq(1)
+        cookware = recipe.cookware.first
+        expect(cookware.name).to eq("pan")
+        expect(cookware.quantity).to eq(1) # Default quantity per canonical tests
+      end
+
+      it "parses multi-word cookware with braces" do
+        recipe = parser.parse("Use a #large skillet{} for cooking.")
+
+        expect(recipe.cookware.size).to eq(1)
+        cookware = recipe.cookware.first
+        expect(cookware.name).to eq("large skillet")
+      end
+
+      it "parses multi-word cookware without braces (first word only)" do
+        recipe = parser.parse("Use a #large skillet for cooking.")
+
+        expect(recipe.cookware.size).to eq(1)
+        cookware = recipe.cookware.first
+        expect(cookware.name).to eq("large")
+      end
+
+      it "parses cookware with quantities" do
+        recipe = parser.parse("Prepare #baking sheet{2} with parchment.")
+
+        expect(recipe.cookware.size).to eq(1)
+        cookware = recipe.cookware.first
+        expect(cookware.name).to eq("baking sheet")
+        expect(cookware.quantity).to eq(2)
+      end
+
+      it "parses cookware with string quantities" do
+        recipe = parser.parse("Use #bowls{several} for prep.")
+
+        expect(recipe.cookware.size).to eq(1)
+        cookware = recipe.cookware.first
+        expect(cookware.name).to eq("bowls")
+        expect(cookware.quantity).to eq("several")
+      end
+    end
+
+    context "with timers" do
+      it "parses anonymous timers" do
+        recipe = parser.parse("Cook for ~{10%minutes}.")
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.name).to be_nil
+        expect(timer.duration).to eq(10)
+        expect(timer.unit).to eq("minutes")
+      end
+
+      it "parses named timers" do
+        recipe = parser.parse("Bake ~oven{25%minutes} until golden.")
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.name).to eq("oven")
+        expect(timer.duration).to eq(25)
+        expect(timer.unit).to eq("minutes")
+      end
+
+      it "parses timers with decimal durations" do
+        recipe = parser.parse("Heat for ~{1.5%hours}.")
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.duration).to eq(1.5)
+        expect(timer.unit).to eq("hours")
+      end
+    end
+
+    context "with comments" do
+      it "strips line comments" do
+        recipe = parser.parse("Add @salt -- this is a comment\nto taste.")
+
+        expect(recipe.steps.size).to eq(1)
+        step_text = recipe.steps.first.to_text
+        # Comments preserve newlines for canonical compatibility
+        expect(step_text).to eq("Add salt \nto taste.")
+      end
+
+      it "strips block comments" do
+        recipe = parser.parse("Add @salt [- this is a block comment -] to taste.")
+
+        expect(recipe.steps.size).to eq(1)
+        step_text = recipe.steps.first.to_text
+        expect(step_text).to eq("Add salt  to taste.")
+      end
+    end
+
+    context "with metadata" do
+      it "parses YAML front matter" do
+        input = <<~RECIPE
+          ---
+          title: Pancakes
+          servings: 4
+          prep_time: 10
+          ---
+
+          Mix @flour{1%cup} with @milk{1%cup}.
+        RECIPE
+
+        recipe = parser.parse(input)
+
+        expect(recipe.metadata["title"]).to eq("Pancakes")
+        expect(recipe.metadata["servings"]).to eq(4)
+        expect(recipe.metadata["prep_time"]).to eq(10)
+      end
+
+      it "parses inline metadata" do
+        input = <<~RECIPE
+          >> title: Quick Eggs
+          >> servings: 2
+
+          Crack @eggs{2} into #pan.
+        RECIPE
+
+        recipe = parser.parse(input)
+
+        expect(recipe.metadata["title"]).to eq("Quick Eggs")
+        expect(recipe.metadata["servings"]).to eq(2)
+      end
+    end
+
+    context "with multiple steps" do
+      it "splits steps by blank lines" do
+        input = <<~RECIPE
+          Mix @flour{1%cup} with @milk{1%cup}.
+
+          Heat #pan over medium heat.
+
+          Pour batter into #pan and cook ~{3%minutes}.
+        RECIPE
+
+        recipe = parser.parse(input)
+
+        expect(recipe.steps.size).to eq(3)
+        expect(recipe.steps[0].to_text).to eq("Mix flour with milk.")
+        expect(recipe.steps[1].to_text).to eq("Heat pan over medium heat.")
+        expect(recipe.steps[2].to_text).to eq("Pour batter into pan and cook for 3 minutes.")
+      end
+    end
+
+    context "with mixed elements" do
+      it "parses a complex recipe" do
+        input = <<~RECIPE
+          ---
+          title: Scrambled Eggs
+          servings: 2
+          ---
+
+          Heat #pan{1} over medium heat.
+
+          Crack @eggs{3} into #bowl and whisk.
+
+          Add @butter{1%tbsp}(melted) to #pan.
+
+          Pour eggs into #pan and cook ~{2-3%minutes}, stirring constantly.
+        RECIPE
+
+        recipe = parser.parse(input)
+
+        # Check metadata
+        expect(recipe.metadata["title"]).to eq("Scrambled Eggs")
+        expect(recipe.metadata["servings"]).to eq(2)
+
+        # Check ingredients
+        expect(recipe.ingredients.size).to eq(2)
+        eggs = recipe.ingredients.find { |i| i.name == "eggs" }
+        expect(eggs.quantity).to eq(3)
+
+        butter = recipe.ingredients.find { |i| i.name == "butter" }
+        expect(butter.quantity).to eq(1)
+        expect(butter.unit).to eq("tbsp")
+        expect(butter.notes).to eq("melted")
+
+        # Check cookware
+        expect(recipe.cookware.size).to eq(2)
+        pan = recipe.cookware.find { |c| c.name == "pan" }
+        expect(pan.quantity).to eq(1)
+
+        bowl = recipe.cookware.find { |c| c.name == "bowl" }
+        expect(bowl).not_to be_nil
+
+        # Check timers
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.duration).to eq("2-3")
+        expect(timer.unit).to eq("minutes")
+
+        # Check steps
+        expect(recipe.steps.size).to eq(4)
+      end
+    end
+
+    context "with edge cases" do
+      it "handles empty input" do
+        recipe = parser.parse("")
+
+        expect(recipe.ingredients).to be_empty
+        expect(recipe.cookware).to be_empty
+        expect(recipe.timers).to be_empty
+        expect(recipe.steps).to be_empty
+        expect(recipe.metadata).to be_empty
+      end
+
+      it "handles whitespace-only input" do
+        recipe = parser.parse("   \n\n  \n  ")
+
+        expect(recipe.ingredients).to be_empty
+        expect(recipe.cookware).to be_empty
+        expect(recipe.timers).to be_empty
+        expect(recipe.steps).to be_empty
+      end
+
+      it "deduplicates identical ingredients" do
+        recipe = parser.parse("Add @salt. Then add more @salt.")
+
+        expect(recipe.ingredients.size).to eq(1)
+        expect(recipe.ingredients.first.name).to eq("salt")
+      end
+
+      it "keeps different quantities as separate ingredients" do
+        recipe = parser.parse("Add @salt{1%tsp}. Then add @salt{2%tsp}.")
+
+        expect(recipe.ingredients.size).to eq(2)
+        expect(recipe.ingredients.map(&:quantity)).to contain_exactly(1, 2)
+      end
+    end
+
+    context "with step segments" do
+      it "preserves text and ingredient references in steps" do
+        recipe = parser.parse("Mix @flour{1%cup} with @milk.")
+
+        step = recipe.steps.first
+        expect(step.segments.size).to eq(5)
+        expect(step.segments[0]).to eq("Mix ")
+        expect(step.segments[1]).to be_a(Cooklang::Ingredient)
+        expect(step.segments[2]).to eq(" with ")
+        expect(step.segments[3]).to be_a(Cooklang::Ingredient)
+        expect(step.segments[4]).to eq(".")
+      end
+
+      it "includes cookware and timers in step segments" do
+        recipe = parser.parse("Cook in #pan for ~{5%minutes}.")
+
+        step = recipe.steps.first
+        expect(step.segments).to include(an_instance_of(Cooklang::Cookware))
+        expect(step.segments).to include(an_instance_of(Cooklang::Timer))
+      end
+    end
+
+    context "with edge cases" do
+      it "handles timer with invalid duration format" do
+        input = "Cook ~{invalid_duration}"
+        recipe = parser.parse(input)
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.duration).to eq("invalid_duration")
+        expect(timer.unit).to be_nil
+      end
+
+      it "handles timer with number-only duration" do
+        input = "Cook ~{30}"
+        recipe = parser.parse(input)
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.duration).to eq(30)
+        expect(timer.unit).to be_nil
+      end
+
+      it "handles timer with decimal duration" do
+        input = "Cook ~{2.5}"
+        recipe = parser.parse(input)
+
+        expect(recipe.timers.size).to eq(1)
+        timer = recipe.timers.first
+        expect(timer.duration).to eq(2.5)
+        expect(timer.unit).to be_nil
+      end
+
+      it "handles ingredient with invalid quantity format" do
+        input = "Add @salt{invalid_amount}"
+        recipe = parser.parse(input)
+
+        expect(recipe.ingredients.size).to eq(1)
+        ingredient = recipe.ingredients.first
+        expect(ingredient.quantity).to eq("invalid_amount")
+        expect(ingredient.unit).to be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "simplecov"
+require "simplecov_json_formatter"
+
+SimpleCov.start do
+  formatter SimpleCov::Formatter::JSONFormatter
+  add_filter "/spec/"
+end
+
+require "cooklang"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/token_stream_spec.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "cooklang/token_stream"
+require "cooklang/lexer"
+
+RSpec.describe Cooklang::TokenStream do
+  let(:tokens) do
+    [
+      Cooklang::Token.new(:text, "hello", 0, 0, 0),
+      Cooklang::Token.new(:ingredient_marker, "@", 0, 5, 5),
+      Cooklang::Token.new(:text, "salt", 0, 6, 6),
+      Cooklang::Token.new(:open_brace, "{", 0, 10, 10),
+      Cooklang::Token.new(:text, "2%g", 0, 11, 11),
+      Cooklang::Token.new(:close_brace, "}", 0, 14, 14),
+      Cooklang::Token.new(:newline, "\n", 0, 15, 15)
+    ]
+  end
+
+  let(:stream) { described_class.new(tokens) }
+
+  describe "#initialize" do
+    it "sets up the token array and position" do
+      expect(stream.position).to eq(0)
+      expect(stream.size).to eq(7)
+      expect(stream.length).to eq(7)
+    end
+  end
+
+  describe "#current" do
+    it "returns the current token" do
+      expect(stream.current.type).to eq(:text)
+      expect(stream.current.value).to eq("hello")
+    end
+
+    it "returns nil when at EOF" do
+      empty_stream = described_class.new([])
+      expect(empty_stream.current).to be_nil
+    end
+  end
+
+  describe "#peek" do
+    it "returns the next token without advancing" do
+      expect(stream.peek.type).to eq(:ingredient_marker)
+      expect(stream.position).to eq(0)
+    end
+
+    it "accepts an offset parameter" do
+      expect(stream.peek(2).type).to eq(:text)
+      expect(stream.peek(2).value).to eq("salt")
+    end
+
+    it "returns nil when peeking beyond EOF" do
+      expect(stream.peek(10)).to be_nil
+    end
+  end
+
+  describe "#consume" do
+    it "returns current token and advances position" do
+      token = stream.consume
+      expect(token.type).to eq(:text)
+      expect(token.value).to eq("hello")
+      expect(stream.position).to eq(1)
+    end
+
+    it "accepts expected type parameter" do
+      token = stream.consume(:text)
+      expect(token.type).to eq(:text)
+      expect(stream.position).to eq(1)
+    end
+
+    it "returns nil when expected type does not match" do
+      token = stream.consume(:ingredient_marker)
+      expect(token).to be_nil
+      expect(stream.position).to eq(0)
+    end
+
+    it "returns nil at EOF" do
+      empty_stream = described_class.new([])
+      expect(empty_stream.consume).to be_nil
+    end
+  end
+
+  describe "#eof?" do
+    it "returns false when tokens remain" do
+      expect(stream.eof?).to be_falsey
+    end
+
+    it "returns true when at end" do
+      stream.advance_to(7)
+      expect(stream.eof?).to be_truthy
+    end
+  end
+
+  describe "#scan" do
+    it "consumes token when type matches" do
+      token = stream.scan(:text)
+      expect(token.value).to eq("hello")
+      expect(stream.position).to eq(1)
+    end
+
+    it "returns nil when type does not match" do
+      token = stream.scan(:ingredient_marker)
+      expect(token).to be_nil
+      expect(stream.position).to eq(0)
+    end
+  end
+
+  describe "#check" do
+    it "returns true when current token type matches" do
+      expect(stream.check(:text)).to be_truthy
+    end
+
+    it "returns false when current token type does not match" do
+      expect(stream.check(:ingredient_marker)).to be_falsey
+    end
+  end
+
+  describe "#skip" do
+    it "advances position when type matches" do
+      stream.skip(:text)
+      expect(stream.position).to eq(1)
+    end
+
+    it "does not advance when type does not match" do
+      stream.skip(:ingredient_marker)
+      expect(stream.position).to eq(0)
+    end
+  end
+
+  describe "#consume_while" do
+    it "consumes tokens while condition is true" do
+      stream.consume # Move to ingredient marker
+      tokens_consumed = stream.consume_while { |token| token.type != :open_brace }
+
+      expect(tokens_consumed.length).to eq(2)
+      expect(tokens_consumed[0].type).to eq(:ingredient_marker)
+      expect(tokens_consumed[1].type).to eq(:text)
+      expect(stream.current.type).to eq(:open_brace)
+    end
+  end
+
+  describe "#consume_until" do
+    it "consumes tokens until condition is true" do
+      tokens_consumed = stream.consume_until { |token| token.type == :open_brace }
+
+      expect(tokens_consumed.length).to eq(3)
+      expect(stream.current.type).to eq(:open_brace)
+    end
+  end
+
+  describe "#find_next" do
+    it "finds the index of the next matching token type" do
+      index = stream.find_next(:open_brace)
+      expect(index).to eq(3)
+    end
+
+    it "returns nil when token type not found" do
+      index = stream.find_next(:hyphen)
+      expect(index).to be_nil
+    end
+  end
+
+  describe "#find_next_matching" do
+    it "finds the index of the next token matching a block condition" do
+      index = stream.find_next_matching { |token| token.value.include?("g") }
+      expect(index).to eq(4)
+    end
+  end
+
+  describe "#rest" do
+    it "returns remaining tokens from current position" do
+      stream.consume # Move to ingredient marker
+      remaining = stream.rest
+      expect(remaining.length).to eq(6)
+      expect(remaining[0].type).to eq(:ingredient_marker)
+    end
+  end
+
+  describe "#reset" do
+    it "resets position to beginning" do
+      stream.consume
+      stream.consume
+      stream.reset
+      expect(stream.position).to eq(0)
+      expect(stream.current.type).to eq(:text)
+    end
+  end
+
+  describe "#rewind" do
+    it "moves position back by specified steps" do
+      stream.consume
+      stream.consume
+      stream.consume
+      expect(stream.position).to eq(3)
+
+      stream.rewind(2)
+      expect(stream.position).to eq(1)
+    end
+
+    it "does not go below 0" do
+      stream.consume
+      stream.rewind(5)
+      expect(stream.position).to eq(0)
+    end
+  end
+
+  describe "Enumerable methods" do
+    it "supports map" do
+      types = stream.map(&:type)
+      expect(types).to eq([:text, :ingredient_marker, :text, :open_brace, :text, :close_brace, :newline])
+    end
+
+    it "supports find" do
+      ingredient_token = stream.find { |token| token.type == :ingredient_marker }
+      expect(ingredient_token.type).to eq(:ingredient_marker)
+    end
+
+    it "supports any?" do
+      expect(stream.any? { |token| token.type == :open_brace }).to be_truthy
+    end
+
+    it "supports select" do
+      text_tokens = stream.select { |token| token.type == :text }
+      expect(text_tokens.length).to eq(3)
+    end
+  end
+
+  describe "#each_with_lookahead" do
+    it "yields current and next token pairs" do
+      pairs = []
+      stream.each_with_lookahead { |current, next_token| pairs << [current.type, next_token.type] }
+
+      expect(pairs).to eq([
+        [:text, :ingredient_marker],
+        [:ingredient_marker, :text],
+        [:text, :open_brace],
+        [:open_brace, :text],
+        [:text, :close_brace],
+        [:close_brace, :newline]
+      ])
+    end
+  end
+
+  describe "#slice_from_current" do
+    it "creates a new stream from current position" do
+      stream.consume
+      stream.consume
+      new_stream = stream.slice_from_current
+
+      expect(new_stream.current.type).to eq(:text)
+      expect(new_stream.current.value).to eq("salt")
+      expect(new_stream.size).to eq(5)
+    end
+  end
+
+  describe "#skip_whitespace" do
+    let(:tokens_with_whitespace) do
+      [
+        Cooklang::Token.new(:text, "start", 0, 1, 1),
+        Cooklang::Token.new(:whitespace, " ", 1, 1, 2),
+        Cooklang::Token.new(:whitespace, "\t", 2, 1, 3),
+        Cooklang::Token.new(:text, "end", 3, 1, 4)
+      ]
+    end
+
+    it "consumes whitespace tokens" do
+      stream = described_class.new(tokens_with_whitespace)
+      stream.consume # Move past "start"
+
+      expect(stream.current.type).to eq(:whitespace)
+      stream.skip_whitespace
+
+      expect(stream.current.type).to eq(:text)
+      expect(stream.current.value).to eq("end")
+    end
+  end
+end