cooklang 1.0.0 → 1.0.1

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,171 @@
+# 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" do
+      recipe = described_class.new(
+        ingredients: [ingredient],
+        cookware: [cookware],
+        timers: [timer],
+        steps: [step],
+        metadata: metadata
+      )
+
+      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)
+    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

data/spec/models/section_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Section do
+  describe "#initialize" do
+    it "creates section with name" do
+      section = described_class.new(name: "Preparation")
+      expect(section.name).to eq("Preparation")
+    end
+
+    it "converts name to string and freezes it" do
+      section = described_class.new(name: 123)
+      expect(section.name).to eq("123")
+      expect(section.name).to be_frozen
+    end
+  end
+
+  describe "#to_s" do
+    it "returns name" do
+      section = described_class.new(name: "Cooking")
+      expect(section.to_s).to eq("Cooking")
+    end
+  end
+
+  describe "#to_h" do
+    it "returns hash representation" do
+      section = described_class.new(name: "Preparation")
+      expect(section.to_h).to eq({ name: "Preparation", steps: [] })
+    end
+  end
+
+  describe "#==" do
+    it "returns true for sections with same name" do
+      section1 = described_class.new(name: "Prep")
+      section2 = described_class.new(name: "Prep")
+      expect(section1 == section2).to be_truthy
+    end
+
+    it "returns false for sections with different names" do
+      section1 = described_class.new(name: "Prep")
+      section2 = described_class.new(name: "Cook")
+      expect(section1 == section2).to be_falsey
+    end
+
+    it "returns false for non-Section objects" do
+      section = described_class.new(name: "Prep")
+      expect(section == "Prep").to be_falsey
+    end
+  end
+
+  describe "#hash" do
+    it "generates same hash for equal sections" do
+      section1 = described_class.new(name: "Test")
+      section2 = described_class.new(name: "Test")
+      expect(section1.hash).to eq(section2.hash)
+    end
+
+    it "generates different hash for different sections" do
+      section1 = described_class.new(name: "Test 1")
+      section2 = described_class.new(name: "Test 2")
+      expect(section1.hash).not_to eq(section2.hash)
+    end
+  end
+end