cooklang 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a13e5e798824a4c9fa2d7405a7466f03b59ef20a0a80ed16f1de789cf40df0db
-  data.tar.gz: ade82856860ca28430e38f325e64b15a8f2a0694ebaba9a56cfd058af1f658e5
+  metadata.gz: fa4eed0618449146de288cbfa4b51b05d7ac994fca5e3aca0161c6cfe90d2551
+  data.tar.gz: 45c683a6a2daea2da5d48116cf91181532370df0b1b2e5de0d1b72a749f2e245
 SHA512:
-  metadata.gz: 8ff63ccbc36d06328546b6508429a93d94d5d97a98fdec2d506854d39661d4015f18630269f2e61a838dcb9083b9850e70b0d2db1503f7a7631d6a246a2bd42f
-  data.tar.gz: 010e6b452e3d7102b7c347f6875d132f137b5b55cba594d0b29a3d28ad1cf19dfebbe6b700441f65b763db9c021675e8b7405f90615925fc1ca1baf9191f5e2e
+  metadata.gz: b4cfc4bad69e170f6fff3b5aef1d35b31ba72232b1c9579129f1b3ec1e5f1174af9501a3455be440da077a7138c3af1b822a6f11f232cc6c420621cea8d06552
+  data.tar.gz: 6d84e7c23687b56076c2b9aef18e1f801dbf471ce2fd3e5f216f62016c33656152c7634d3d6d0fa95c9b15181d6f1b05196c225301da0c5ec184a1e136375e73

data/.github/workflows/test.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.2', '3.3', '3.4', '3.5']
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', '3.3', '3.4', '3.5']
 
     steps:
     - uses: actions/checkout@v4
@@ -29,7 +29,7 @@ jobs:
       run: bundle exec rubocop
 
     - uses: qltysh/qlty-action/coverage@v2
-      if: matrix.ruby-version == '3.5'
+      if: matrix.ruby-version == '3.4'
       with:
         token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
         files: coverage/.resultset.json

data/.gitignore

@@ -10,3 +10,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/README.md

@@ -7,6 +7,10 @@
 
 A Ruby parser for the [Cooklang](https://cooklang.org) recipe markup language.
 
+## Requirements
+
+- Ruby 2.7 or higher
+
 ## Installation
 
 Add to your Gemfile:
@@ -56,7 +60,7 @@ 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:
+The gem provides three built-in formatters for different output needs. Here's an example using this fried rice recipe:
 
 ```ruby
 >> title: Uncle Roger's Fried Rice
@@ -253,6 +257,12 @@ recipe.timers           # Array of Timer objects
 recipe.steps            # Array of Step objects
 recipe.steps_text       # Array of plain text steps
 
+# Metadata (Hash with string keys)
+recipe.metadata["title"]           # "Recipe Name"
+recipe.metadata["servings"]        # 4
+recipe.metadata["tags"]            # ["pasta", "italian"]
+recipe.metadata["custom_field"]    # Any value you set
+
 # Ingredient
 ingredient.name         # "flour"
 ingredient.quantity     # 125
@@ -269,13 +279,22 @@ timer.duration        # 10
 timer.unit            # "minutes"
 ```
 
-## Cooklang Syntax
+## Supported Cooklang Features
+
+- **Ingredients** (`@`): Single/multi-word names, quantities, units, preparation notes
+- **Cookware** (`#`): Single/multi-word names, quantities
+- **Timers** (`~`): Anonymous and named timers
+- **Comments**: Line (`--`) and block (`[- -]`) comments
+- **Metadata**: YAML front matter and inline metadata (`>>`)
+- **Steps**: Paragraph-based with blank line separation
+- **Notes** (`>`): Standalone notes
+- **Sections** (`=`): Recipe sections with optional names
+
+### Not Yet Implemented
 
-- **Ingredients**: `@salt`, `@flour{125%g}`, `@onion{1}(diced)`
-- **Cookware**: `#pan`, `#mixing bowl{}`
-- **Timers**: `~{5%minutes}`, `~pasta{10%minutes}`
-- **Comments**: `-- line comment`, `[- block comment -]`
-- **Metadata**: `>> key: value` or YAML front matter
+- **Recipe References**: `@./path/to/recipe{}`
+- **Shopping Lists**: `aisle.txt` configuration files
+- **Images**: Convention-based image loading
 
 ## Development
 

data/cooklang.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.description = "Cooklang is a markup language for recipes that allows you to define ingredients, cookware, timers, and metadata in a structured way. This gem provides a Ruby parser for Cooklang files."
   spec.homepage = "https://github.com/jamesbrooks/cooklang"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/jamesbrooks/cooklang"
@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 2.7"
+  spec.add_development_dependency "bundler", ">= 2.1"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.13"
   spec.add_development_dependency "rubocop", "~> 1.80"

data/lib/cooklang/formatter.rb

@@ -15,51 +15,5 @@ module Cooklang
     def to_s(*args)
       generate(*args).to_s
     end
-
-    private
-      def ingredients_section
-        return "" if recipe.ingredients.empty?
-
-        ingredient_lines = recipe.ingredients.map do |ingredient|
-          format_ingredient(ingredient)
-        end
-
-        "Ingredients:\n#{ingredient_lines.join("\n")}\n"
-      end
-
-      def steps_section
-        return "" if recipe.steps.empty?
-
-        step_lines = recipe.steps.each_with_index.map do |step, index|
-          "    #{index + 1}. #{step.to_text}"
-        end
-
-        "Steps:\n#{step_lines.join("\n")}\n"
-      end
-
-      def format_ingredient(ingredient)
-        name = ingredient.name
-        quantity_unit = format_quantity_unit(ingredient)
-
-        # Add 4 spaces after the longest ingredient name for alignment
-        name_width = max_ingredient_name_length + 4
-        "    #{name.ljust(name_width)}#{quantity_unit}"
-      end
-
-      def format_quantity_unit(ingredient)
-        if ingredient.quantity && ingredient.unit
-          "#{ingredient.quantity} #{ingredient.unit}"
-        elsif ingredient.quantity
-          ingredient.quantity.to_s
-        elsif ingredient.unit
-          ingredient.unit
-        else
-          "some"
-        end
-      end
-
-      def max_ingredient_name_length
-        @max_ingredient_name_length ||= recipe.ingredients.map(&:name).map(&:length).max || 0
-      end
   end
 end

data/lib/cooklang/formatters/hash.rb

@@ -18,7 +18,7 @@ module Cooklang
     private
       def format_metadata
         {
-          map: recipe.metadata.to_h.transform_values(&:to_s)
+          map: recipe.metadata.to_h
         }
       end
 

data/lib/cooklang/formatters/text.rb

@@ -11,6 +11,52 @@ module Cooklang
 
         sections.join("\n").strip
       end
+
+    private
+      def ingredients_section
+        return "" if recipe.ingredients.empty?
+
+        ingredient_lines = recipe.ingredients.map do |ingredient|
+          format_ingredient(ingredient)
+        end
+
+        "Ingredients:\n#{ingredient_lines.join("\n")}\n"
+      end
+
+      def steps_section
+        return "" if recipe.steps.empty?
+
+        step_lines = recipe.steps.each_with_index.map do |step, index|
+          "    #{index + 1}. #{step.to_text}"
+        end
+
+        "Steps:\n#{step_lines.join("\n")}\n"
+      end
+
+      def format_ingredient(ingredient)
+        name = ingredient.name
+        quantity_unit = format_quantity_unit(ingredient)
+
+        # Add 4 spaces after the longest ingredient name for alignment
+        name_width = max_ingredient_name_length + 4
+        "    #{name.ljust(name_width)}#{quantity_unit}"
+      end
+
+      def format_quantity_unit(ingredient)
+        if ingredient.quantity && ingredient.unit
+          "#{ingredient.quantity} #{ingredient.unit}"
+        elsif ingredient.quantity
+          ingredient.quantity.to_s
+        elsif ingredient.unit
+          ingredient.unit
+        else
+          "some"
+        end
+      end
+
+      def max_ingredient_name_length
+        @max_ingredient_name_length ||= recipe.ingredients.map(&:name).map(&:length).max || 0
+      end
     end
   end
 end

data/lib/cooklang/lexer.rb

@@ -40,6 +40,11 @@ module Cooklang
     def tokenize
       @tokens = []
 
+      # Check for YAML frontmatter at the beginning
+      if @scanner.check(/^---/)
+        handle_yaml_frontmatter
+      end
+
       until @scanner.eos?
         if match_yaml_delimiter
         elsif match_comment_block
@@ -61,6 +66,50 @@ module Cooklang
     end
 
     private
+      def handle_yaml_frontmatter
+        # Emit the opening ---
+        position = current_position
+        line = current_line
+        column = current_column
+        value = @scanner.scan("---")
+        @tokens << Token.new(:yaml_delimiter, value, position, line, column)
+        advance_position(value)
+
+        # Scan until we find the closing --- or EOF
+        yaml_content = ""
+        until @scanner.eos?
+          if @scanner.check(/\n---\s*(\n|$)/)
+            # Found closing delimiter
+            # Add the newline before it
+            if @scanner.check(/\n/)
+              char = @scanner.getch
+              yaml_content += char
+              advance_position(char)
+            end
+            break
+          else
+            char = @scanner.getch
+            yaml_content += char
+            advance_position(char)
+          end
+        end
+
+        # Emit the YAML content as a single token if we have any
+        if !yaml_content.empty?
+          @tokens << Token.new(:yaml_content, yaml_content.rstrip, current_position, current_line, current_column)
+        end
+
+        # Emit the closing --- if present
+        if @scanner.check(/---/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan("---")
+          @tokens << Token.new(:yaml_delimiter, value, position, line, column)
+          advance_position(value)
+        end
+      end
+
       def current_position
         @scanner.pos
       end

data/lib/cooklang/metadata.rb

@@ -23,76 +23,12 @@ module Cooklang
       super(key.to_s)
     end
 
-    def fetch(key, *)
-      super(key.to_s, *)
+    def fetch(key, *args)
+      super(key.to_s, *args)
     end
 
     def to_h
       super
     end
-
-    def servings
-      self["servings"]&.to_i
-    end
-
-    def servings=(value)
-      self["servings"] = value
-    end
-
-    def prep_time
-      self["prep_time"] || self["prep-time"]
-    end
-
-    def prep_time=(value)
-      self["prep_time"] = value
-    end
-
-    def cook_time
-      self["cook_time"] || self["cook-time"]
-    end
-
-    def cook_time=(value)
-      self["cook_time"] = value
-    end
-
-    def total_time
-      self["total_time"] || self["total-time"]
-    end
-
-    def total_time=(value)
-      self["total_time"] = value
-    end
-
-    def title
-      self["title"]
-    end
-
-    def title=(value)
-      self["title"] = value
-    end
-
-    def source
-      self["source"]
-    end
-
-    def source=(value)
-      self["source"] = value
-    end
-
-    def tags
-      value = self["tags"]
-      case value
-      when Array
-        value
-      when String
-        value.split(",").map(&:strip)
-      else
-        []
-      end
-    end
-
-    def tags=(value)
-      self["tags"] = value
-    end
   end
 end

data/lib/cooklang/processors/metadata_processor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "yaml"
+
 module Cooklang
   module Processors
     class MetadataProcessor
@@ -7,7 +9,6 @@ module Cooklang
         def extract_metadata(tokens)
           metadata = Metadata.new
           content_tokens = []
-          0
 
           # Check for YAML front matter
           if tokens.first&.type == :yaml_delimiter
@@ -26,32 +27,17 @@ module Cooklang
           def extract_yaml_frontmatter(tokens)
             metadata = Metadata.new
             i = 1 # Skip the first ---
-            yaml_content = []
-
-            # Find the closing --- delimiter
-            while i < tokens.length
-              if tokens[i].type == :yaml_delimiter
-                # Found closing delimiter
-                break
-              elsif tokens[i].type == :text
-                yaml_content << tokens[i].value
-              elsif tokens[i].type == :newline
-                yaml_content << "\n"
-              elsif tokens[i].type == :metadata_marker
-                yaml_content << ">>"
-              end
+
+            # Look for yaml_content token
+            if i < tokens.length && tokens[i].type == :yaml_content
+              yaml_text = tokens[i].value
+              parse_yaml_content(yaml_text, metadata) unless yaml_text.empty?
               i += 1
             end
 
             # Skip the closing --- if we found it
             i += 1 if i < tokens.length && tokens[i].type == :yaml_delimiter
 
-            # Parse YAML content if we have any
-            if yaml_content.any?
-              yaml_text = yaml_content.join.strip
-              parse_yaml_content(yaml_text, metadata) unless yaml_text.empty?
-            end
-
             # Return remaining tokens
             remaining_tokens = tokens[i..]
 
@@ -59,21 +45,15 @@ module Cooklang
           end
 
           def parse_yaml_content(yaml_text, metadata)
-            # Simple YAML parsing - split by lines and parse key-value pairs
-            yaml_text.split("\n").each do |line|
-              line = line.strip
-              next if line.empty? || line.start_with?("#")
-
-              if line.match(/^([^:]+):\s*(.*)$/)
-                key = ::Regexp.last_match(1).strip
-                value = ::Regexp.last_match(2).strip
+            # Fix malformed YAML with spaces before colon (non-standard YAML but permits the canonical test testMetadataMultiwordKeyWithSpaces to pass)
+            fixed_yaml = yaml_text.gsub(/^(\s*)([^:\n]+?)\s+:(\S)/, '\1\2: \3')
 
-                # Remove quotes if present
-                value = value.gsub(/^["']|["']$/, "") if value.match?(/^["'].*["']$/)
+            parsed = YAML.safe_load(fixed_yaml, permitted_classes: [Date, Time, DateTime])
 
-                # Parse numeric values
-                parsed_value = parse_metadata_value(value)
-                metadata[key] = parsed_value unless value.empty?
+            # Merge parsed YAML into metadata if it's a Hash
+            if parsed.is_a?(Hash)
+              parsed.each do |key, value|
+                metadata[key.to_s] = value
               end
             end
           end
@@ -88,7 +68,7 @@ module Cooklang
               if index + 1 < tokens.length && tokens[index + 1].type == :text
                 text = tokens[index + 1].value.strip
 
-                if text.match(/^([^:]+):\s*(.+)$/)
+                if text.match(/^([^:]+):\s*(.+?)[\n\\n]*$/)
                   key = ::Regexp.last_match(1).strip
                   value = ::Regexp.last_match(2).strip
 

data/lib/cooklang/version.rb

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

data/spec/fixtures/comprehensive_recipe.cook

@@ -0,0 +1,51 @@
+---
+title: Uncle Roger's Ultimate Fried Rice & Dumplings
+servings: 4
+prep_time: 15 minutes
+cook_time: 12 minutes
+difficulty: intermediate
+cuisine: Chinese
+dietary_restrictions: 
+  - can be made vegetarian
+  - gluten-free option available
+---
+
+[- This is a comprehensive recipe that tests all Cooklang features including
+   complex ingredients, cookware, timers, metadata, and various edge cases -]
+
+= Prep Work
+
+First, prepare all ingredients. Dice @shallots{2}(finely chopped) and mince @garlic{4%cloves}(crushed). 
+
+Beat @eggs{3}(room temperature) in a #mixing bowl{large}.
+
+= Main Cooking
+
+Heat @peanut oil{2%tbsp} and @sesame oil{1%tsp} in #wok{} over high heat for ~{2%minutes} until smoking.
+
+Add the diced shallots and garlic, stir-fry for ~{30%seconds}. -- This is critical timing!
+
+Pour in the beaten eggs and scramble for ~quick scramble{45%seconds} until just set.
+
+Add @day-old rice{3%cups}(broken up by hand) and stir-fry, breaking up any clumps for ~{2.5%minutes}.
+
+Season with @soy sauce{2%tbsp}, @fish sauce{1%tsp}, @msg{0.5%tsp}, and @white pepper{some}(to taste).
+
+Add @frozen peas{0.5%cup} and @spring onions{3%stalks}(chopped), cook for ~final timer{1%minute}.
+
+= Dumplings (Optional Side)
+
+For dumplings, prepare @dumpling wrappers{20} and @ground pork{300%g}(seasoned).
+
+Mix pork with @ginger{1%tbsp}(minced), @soy sauce{1%tbsp}, and @cornstarch{1%tsp}.
+
+Steam in #bamboo steamer{} for ~{15%minutes}.
+
+= Final Assembly 
+
+Serve immediately while hot! Garnish with @crispy shallots{some} and @cilantro{handful}(chopped).
+
+[- Note: The "some" quantities and decimal timers test edge cases in parsing -]
+
+-- Cooking tips: Use day-old rice for best texture
+-- Serving suggestion: Pair with jasmine tea

data/spec/formatters/formatter_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Formatter do
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:formatter) { described_class.new(recipe) }
+
+    it "raises NotImplementedError for base class" do
+      expect { formatter.generate }.to raise_error(NotImplementedError, "Subclasses must implement #generate")
+    end
+  end
+
+  describe "#to_s" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:formatter) { described_class.new(recipe) }
+
+    it "calls generate.to_s but fails because generate raises" do
+      expect { formatter.to_s }.to raise_error(NotImplementedError, "Subclasses must implement #generate")
+    end
+  end
+end

data/spec/formatters/hash_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Formatters::Hash do
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:result) { described_class.new(recipe).generate }
+
+    it "generates hash with all required top-level keys" do
+      expect(result).to have_key(:metadata)
+      expect(result).to have_key(:sections)
+      expect(result).to have_key(:ingredients)
+      expect(result).to have_key(:cookware)
+      expect(result).to have_key(:timers)
+      expect(result).to have_key(:data)
+    end
+
+    it "includes expected metadata" do
+      metadata = result[:metadata][:map]
+      expect(metadata["title"]).to eq("Uncle Roger's Ultimate Fried Rice & Dumplings")
+      expect(metadata["servings"]).to eq(4)
+      expect(metadata["difficulty"]).to eq("intermediate")
+    end
+
+    it "parses ingredients with decimal quantities and nil quantities" do
+      ingredients = result[:ingredients]
+
+      # Find MSG with decimal quantity
+      msg = ingredients.find { |i| i[:name] == "msg" }
+      expect(msg[:quantity][:value][:value][:value]).to eq(0.5)
+
+      # Find ingredient with nil quantity (like "some")
+      white_pepper = ingredients.find { |i| i[:name] == "white pepper" }
+      expect(white_pepper[:quantity]).to be_nil
+    end
+
+    it "includes timers with named and decimal durations" do
+      timers = result[:timers]
+      expect(timers.size).to be >= 5
+
+      # Find named timer
+      named_timer = timers.find { |t| t[:name] == "quick scramble" }
+      expect(named_timer).not_to be_nil
+
+      # Find decimal duration timer
+      decimal_timer = timers.find { |t| t[:quantity][:value][:value][:value] == 2.5 }
+      expect(decimal_timer).not_to be_nil
+    end
+
+    it "generates steps with proper indexing" do
+      steps = result[:sections].first[:content]
+      expect(steps.size).to be >= 10
+
+      # Check step numbers are sequential
+      step_numbers = steps.map { |s| s[:value][:number] }
+      expect(step_numbers).to eq((1..step_numbers.size).to_a)
+    end
+  end
+end

data/spec/formatters/json_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Cooklang::Formatters::Json do
+  describe "#generate" do
+    let(:recipe) do
+      recipe_text = File.read(File.join(__dir__, "..", "fixtures", "comprehensive_recipe.cook"))
+      Cooklang.parse(recipe_text)
+    end
+    let(:json_output) { described_class.new(recipe).generate }
+    let(:parsed) { JSON.parse(json_output) }
+
+    it "generates valid JSON" do
+      expect { JSON.parse(json_output) }.not_to raise_error
+    end
+
+    it "includes metadata with proper JSON types" do
+      expect(parsed["metadata"]["map"]["title"]).to eq("Uncle Roger's Ultimate Fried Rice & Dumplings")
+      expect(parsed["metadata"]["map"]["servings"]).to eq(4)
+    end
+
+    it "converts decimal quantities correctly" do
+      ingredients = parsed["ingredients"]
+
+      # MSG with decimal quantity
+      msg = ingredients.find { |i| i["name"] == "msg" }
+      expect(msg["quantity"]["value"]["value"]["value"]).to eq(0.5)
+
+      # White pepper with null quantity
+      white_pepper = ingredients.find { |i| i["name"] == "white pepper" }
+      expect(white_pepper["quantity"]).to be_nil
+    end
+
+    it "handles named timers and decimal durations" do
+      timers = parsed["timers"]
+
+      # Named timer
+      named_timer = timers.find { |t| t["name"] == "quick scramble" }
+      expect(named_timer["quantity"]["value"]["value"]["value"]).to eq(45.0)
+
+      # Decimal duration
+      decimal_timer = timers.find { |t| t["quantity"]["value"]["value"]["value"] == 2.5 }
+      expect(decimal_timer).not_to be_nil
+    end
+
+    it "formats with indentation when requested" do
+      formatted = described_class.new(recipe).generate(indent: "  ")
+      expect(formatted).to include("  \"metadata\"")
+      # Just check that it's longer than compact format (indentation adds space)
+      compact = described_class.new(recipe).generate
+      expect(formatted.length).to be > compact.length
+    end
+  end
+end