cooklang 1.0.0 → 1.0.2

data/spec/models/metadata_spec.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Metadata do
+  describe "#initialize" do
+    it "creates empty metadata" do
+      metadata = described_class.new
+
+      expect(metadata).to be_empty
+    end
+
+    it "creates metadata from hash" do
+      data = { "title" => "Test Recipe", "servings" => 4 }
+      metadata = described_class.new(data)
+
+      expect(metadata["title"]).to eq("Test Recipe")
+      expect(metadata["servings"]).to eq(4)
+    end
+
+    it "converts symbol keys to strings" do
+      data = { title: "Test Recipe", servings: 4 }
+      metadata = described_class.new(data)
+
+      expect(metadata["title"]).to eq("Test Recipe")
+      expect(metadata["servings"]).to eq(4)
+    end
+  end
+
+  describe "hash access methods" do
+    let(:metadata) { described_class.new(title: "Test Recipe", servings: 4) }
+
+    describe "#[]=" do
+      it "converts keys to strings" do
+        metadata[:prep_time] = "10 minutes"
+
+        expect(metadata["prep_time"]).to eq("10 minutes")
+      end
+    end
+
+    describe "#[]" do
+      it "converts keys to strings" do
+        expect(metadata[:title]).to eq("Test Recipe")
+        expect(metadata["title"]).to eq("Test Recipe")
+      end
+    end
+
+    describe "#key?" do
+      it "converts keys to strings" do
+        expect(metadata.key?(:title)).to be true
+        expect(metadata.key?("title")).to be true
+        expect(metadata.key?(:nonexistent)).to be false
+      end
+    end
+
+    describe "#delete" do
+      it "converts keys to strings" do
+        metadata.delete(:title)
+
+        expect(metadata).not_to have_key("title")
+      end
+    end
+
+    describe "#fetch" do
+      it "converts keys to strings" do
+        expect(metadata.fetch(:title)).to eq("Test Recipe")
+        expect(metadata.fetch(:nonexistent, "default")).to eq("default")
+      end
+    end
+  end
+
+  describe "#to_h" do
+    it "returns plain hash" do
+      metadata = described_class.new(title: "Test Recipe", servings: 4)
+
+      hash = metadata.to_h
+
+      expect(hash).to be_a(Hash)
+      expect(hash).not_to be_a(described_class)
+      expect(hash).to eq({ "title" => "Test Recipe", "servings" => 4 })
+    end
+  end
+
+  describe "recipe-specific accessors" do
+    let(:metadata) { described_class.new }
+
+    describe "#servings" do
+      it "returns integer servings" do
+        metadata["servings"] = "4"
+
+        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
+    end
+
+    describe "#tags=" do
+      it "sets tags" do
+        metadata.tags = ["breakfast", "quick"]
+
+        expect(metadata["tags"]).to eq(["breakfast", "quick"])
+      end
+    end
+  end
+end

data/spec/models/note_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Note do
+  describe "#initialize" do
+    it "creates note with content" do
+      note = described_class.new(content: "This is a note")
+      expect(note.content).to eq("This is a note")
+    end
+
+    it "converts content to string and freezes it" do
+      note = described_class.new(content: 123)
+      expect(note.content).to eq("123")
+      expect(note.content).to be_frozen
+    end
+  end
+
+  describe "#to_s" do
+    it "returns content" do
+      note = described_class.new(content: "Test note")
+      expect(note.to_s).to eq("Test note")
+    end
+  end
+
+  describe "#to_h" do
+    it "returns hash representation" do
+      note = described_class.new(content: "Test note")
+      expect(note.to_h).to eq({ content: "Test note" })
+    end
+  end
+
+  describe "#==" do
+    it "returns true for notes with same content" do
+      note1 = described_class.new(content: "Same content")
+      note2 = described_class.new(content: "Same content")
+      expect(note1 == note2).to be_truthy
+    end
+
+    it "returns false for notes with different content" do
+      note1 = described_class.new(content: "Content 1")
+      note2 = described_class.new(content: "Content 2")
+      expect(note1 == note2).to be_falsey
+    end
+
+    it "returns false for non-Note objects" do
+      note = described_class.new(content: "Test")
+      expect(note == "Test").to be_falsey
+    end
+  end
+
+  describe "#hash" do
+    it "generates same hash for equal notes" do
+      note1 = described_class.new(content: "Test")
+      note2 = described_class.new(content: "Test")
+      expect(note1.hash).to eq(note2.hash)
+    end
+
+    it "generates different hash for different notes" do
+      note1 = described_class.new(content: "Test 1")
+      note2 = described_class.new(content: "Test 2")
+      expect(note1.hash).not_to eq(note2.hash)
+    end
+  end
+end

data/spec/models/recipe_spec.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Recipe do
+  let(:ingredient) { Cooklang::Ingredient.new(name: "flour", quantity: 125, unit: "g") }
+  let(:cookware) { Cooklang::Cookware.new(name: "pan") }
+  let(:timer) { Cooklang::Timer.new(duration: 5, unit: "minutes") }
+  let(:step) { Cooklang::Step.new(segments: ["Mix the ", { type: :ingredient, name: "flour" }]) }
+  let(:metadata) { Cooklang::Metadata.new(title: "Test Recipe") }
+
+  describe "#initialize" do
+    it "creates a recipe with all components" do
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      expect(recipe.ingredients).to eq([ingredient])
+      expect(recipe.cookware).to eq([cookware])
+      expect(recipe.timers).to eq([timer])
+      expect(recipe.steps).to eq([step])
+      expect(recipe.metadata).to eq(metadata)
+    end
+
+    it "freezes arrays to prevent modification" do
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      expect(recipe.ingredients).to be_frozen
+      expect(recipe.cookware).to be_frozen
+      expect(recipe.timers).to be_frozen
+      expect(recipe.steps).to be_frozen
+    end
+  end
+
+  describe "#ingredients_hash" do
+    it "returns ingredients as a hash with quantity and unit" do
+      ingredient1 = Cooklang::Ingredient.new(name: "flour", quantity: 125, unit: "g")
+      ingredient2 = Cooklang::Ingredient.new(name: "salt", quantity: 1, unit: "pinch")
+
+      recipe = described_class.new(
+        ingredients: [ingredient1, ingredient2],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      expected = {
+        "flour" => { quantity: 125, unit: "g" },
+        "salt" => { quantity: 1, unit: "pinch" }
+      }
+
+      expect(recipe.ingredients_hash).to eq(expected)
+    end
+
+    it "omits nil values" do
+      ingredient = Cooklang::Ingredient.new(name: "salt")
+
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      expect(recipe.ingredients_hash).to eq({ "salt" => {} })
+    end
+  end
+
+  describe "#steps_text" do
+    it "returns text representation of steps" do
+      step1 = Cooklang::Step.new(segments: ["Mix the ingredients"])
+      step2 = Cooklang::Step.new(segments: ["Cook for ", { type: :timer, name: "timer" }])
+
+      recipe = described_class.new(
+        ingredients: [],
+        cookware: [],
+        timers: [],
+        steps: [step1, step2],
+        metadata: Cooklang::Metadata.new
+      )
+
+      expect(recipe.steps_text).to eq(["Mix the ingredients", "Cook for timer"])
+    end
+  end
+
+  describe "#to_h" do
+    it "returns complete hash representation in Cook CLI format" do
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      hash = recipe.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
+
+  describe "#==" do
+    it "returns true for recipes with same content" do
+      recipe1 = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      recipe2 = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      expect(recipe1).to eq(recipe2)
+    end
+
+    it "returns false for recipes with different content" do
+      recipe1 = described_class.new(
+        ingredients: [ingredient],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      recipe2 = described_class.new(
+        ingredients: [],
+        cookware: [cookware],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      expect(recipe1).not_to eq(recipe2)
+    end
+
+    it "returns false for non-Recipe objects" do
+      recipe = described_class.new(
+        ingredients: [],
+        cookware: [],
+        timers: [],
+        steps: [],
+        metadata: Cooklang::Metadata.new
+      )
+
+      expect(recipe).not_to eq("not a recipe")
+    end
+  end
+end