cooklang 1.0.0 → 1.0.2

data/lib/cooklang/parsers/cookware_parser.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Parsers
+    class CookwareParser
+      def initialize(stream)
+        @stream = stream
+      end
+
+      def parse
+        return nil unless @stream.current&.type == :cookware_marker
+        @stream.consume(:cookware_marker) # Skip the # marker
+
+        return nil if invalid_syntax?
+
+        brace_index = find_next_brace
+        has_valid_brace = brace_index && !brace_belongs_to_other_marker?(brace_index)
+
+        if has_valid_brace
+          parse_braced_cookware(brace_index)
+        else
+          parse_simple_cookware
+        end
+      end
+
+      private
+        def invalid_syntax?
+          @stream.current&.type == :text && @stream.current.value.start_with?(" ")
+        end
+
+        def find_next_brace
+          @stream.find_next(:open_brace)
+        end
+
+        def brace_belongs_to_other_marker?(brace_index)
+          current_pos = @stream.position
+
+          while @stream.position < brace_index && !@stream.eof?
+            if %i[ingredient_marker cookware_marker timer_marker].include?(@stream.current.type)
+              @stream.advance_to(current_pos)
+              return true
+            end
+            @stream.consume
+          end
+
+          @stream.advance_to(current_pos)
+          false
+        end
+
+        def parse_braced_cookware(brace_index)
+          name = extract_name_until_brace(brace_index)
+          @stream.consume(:open_brace) # Skip open brace
+
+          quantity = extract_quantity
+          @stream.consume(:close_brace) # Skip close brace
+
+          quantity = 1 if quantity.nil? || quantity == ""
+
+          Cookware.new(name: name, quantity: quantity)
+        end
+
+        def parse_simple_cookware
+          remaining_text = nil
+
+          if @stream.current&.type == :text
+            text = @stream.current.value
+            if text.match(/^([a-zA-Z0-9_]+)(.*)$/)
+              name = ::Regexp.last_match(1)
+              remaining_text = ::Regexp.last_match(2)
+            else
+              name = text.strip
+            end
+            @stream.consume
+          else
+            name = ""
+          end
+
+          cookware_item = Cookware.new(name: name, quantity: 1)
+          [cookware_item, remaining_text]
+        end
+
+        def extract_name_until_brace(brace_index)
+          name_parts = []
+
+          while @stream.position < brace_index && !@stream.eof?
+            case @stream.current.type
+            when :text, :hyphen
+              name_parts << @stream.current.value
+            end
+            @stream.consume
+          end
+
+          name_parts.join.strip
+        end
+
+        def extract_quantity
+          text_parts = []
+
+          while !@stream.eof? && @stream.current.type != :close_brace
+            case @stream.current.type
+            when :percent
+              # Skip percent in cookware - quantity comes after
+              @stream.consume
+            when :text
+              text_parts << @stream.current.value
+              @stream.consume
+            else
+              @stream.consume
+            end
+          end
+
+          return nil if text_parts.empty?
+
+          combined_text = text_parts.join.strip
+          parse_quantity_value(combined_text)
+        end
+
+        def parse_quantity_value(text)
+          case text
+          when /^\d+$/
+            text.to_i
+          when /^\d+\.\d+$/
+            text.to_f
+          else
+            text
+          end
+        end
+    end
+  end
+end

data/lib/cooklang/parsers/ingredient_parser.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Parsers
+    class IngredientParser
+      def initialize(stream)
+        @stream = stream
+      end
+
+      def parse
+        return nil unless @stream.current&.type == :ingredient_marker
+        @stream.consume(:ingredient_marker) # Skip the @ marker
+
+        return nil if invalid_syntax?
+
+        brace_index = find_next_brace
+
+        if brace_index
+          parse_braced_ingredient(brace_index)
+        else
+          parse_simple_ingredient
+        end
+      end
+
+      private
+        def invalid_syntax?
+          @stream.current&.type == :text && @stream.current.value.start_with?(" ")
+        end
+
+        def find_next_brace
+          @stream.find_next(:open_brace)
+        end
+
+        def parse_braced_ingredient(brace_index)
+          name = extract_name_until_brace(brace_index)
+          @stream.consume(:open_brace) # Skip open brace
+
+          quantity, unit = extract_quantity_and_unit
+          @stream.consume(:close_brace) # Skip close brace
+
+          notes = extract_notes
+
+          # Default values according to original logic
+          quantity = "some" if (quantity.nil? || quantity == "") && (unit.nil? || unit == "")
+          unit = nil if unit == ""
+
+          Ingredient.new(name: name, quantity: quantity, unit: unit, notes: notes)
+        end
+
+        def parse_simple_ingredient
+          remaining_text = nil
+
+          if @stream.current&.type == :text
+            text = @stream.current.value
+            if text.match(/^([a-zA-Z0-9_]+)(.*)$/)
+              name = ::Regexp.last_match(1)
+              remaining_text = ::Regexp.last_match(2)
+            else
+              name = text.strip
+            end
+            @stream.consume
+          else
+            name = ""
+          end
+
+          ingredient = Ingredient.new(name: name, quantity: "some", unit: nil, notes: nil)
+          [ingredient, remaining_text]
+        end
+
+        def extract_name_until_brace(brace_index)
+          name_parts = []
+          @stream.position
+
+          while @stream.position < brace_index && !@stream.eof?
+            case @stream.current.type
+            when :text, :hyphen
+              name_parts << @stream.current.value
+            end
+            @stream.consume
+          end
+
+          name_parts.join.strip
+        end
+
+        def extract_quantity_and_unit
+          quantity = nil
+          unit = nil
+          text_parts = []
+
+          while !@stream.eof? && @stream.current.type != :close_brace
+            case @stream.current.type
+            when :percent
+              if !text_parts.empty?
+                quantity_text = text_parts.join.strip
+                quantity = parse_quantity_value(quantity_text)
+              end
+              text_parts = []
+              @stream.consume
+            when :text
+              text_parts << @stream.current.value
+              @stream.consume
+            else
+              @stream.consume
+            end
+          end
+
+          if !text_parts.empty?
+            combined_text = text_parts.join.strip
+            if quantity.nil?
+              # Try to parse as numeric quantity first, fallback to string if not purely numeric
+              if combined_text.match?(/^\d+$/)
+                quantity = combined_text.to_i
+                unit = ""
+              elsif combined_text.match?(/^\d+\.\d+$/)
+                quantity = combined_text.to_f
+                unit = ""
+              else
+                # Non-numeric content, keep as string quantity
+                quantity = combined_text
+                unit = ""
+              end
+            else
+              unit = combined_text
+            end
+          end
+
+          [quantity, unit]
+        end
+
+        def parse_quantity_value(text)
+          case text
+          when /^\d+$/
+            text.to_i
+          when /^\d+\.\d+$/
+            text.to_f
+          else
+            text
+          end
+        end
+
+        def extract_quantity_from_text(text)
+          # Simple quantity extraction - this could use QuantityExtractor if needed
+          if text.match(/^(\d+(?:\.\d+)?)\s*(.*)$/)
+            quantity_val = ::Regexp.last_match(1)
+            rest = ::Regexp.last_match(2)
+
+            quantity = quantity_val.include?(".") ? quantity_val.to_f : quantity_val.to_i
+            unit = rest.empty? ? nil : rest
+
+            [quantity, unit]
+          else
+            [text, nil]
+          end
+        end
+
+        def extract_notes
+          return nil unless @stream.current&.type == :open_paren
+
+          @stream.consume(:open_paren) # Skip open paren
+          notes_parts = []
+
+          while !@stream.eof? && @stream.current.type != :close_paren
+            if @stream.current.type == :text
+              notes_parts << @stream.current.value
+            end
+            @stream.consume
+          end
+
+          @stream.consume(:close_paren) if @stream.current&.type == :close_paren
+
+          notes = notes_parts.join.strip
+          notes.empty? ? nil : notes
+        end
+    end
+  end
+end

data/lib/cooklang/parsers/timer_parser.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Parsers
+    class TimerParser
+      def initialize(stream)
+        @stream = stream
+      end
+
+      def parse
+        return nil unless @stream.current&.type == :timer_marker
+        @stream.consume(:timer_marker) # Skip the ~ marker
+
+        return nil if invalid_syntax?
+
+        brace_index = find_next_brace
+
+        if brace_index
+          parse_named_timer(brace_index)
+        else
+          parse_simple_timer
+        end
+      end
+
+      private
+        def invalid_syntax?
+          @stream.current&.type == :text && @stream.current.value.start_with?(" ")
+        end
+
+        def find_next_brace
+          @stream.find_next(:open_brace)
+        end
+
+        def parse_named_timer(brace_index)
+          name = nil
+
+          # Extract name if there's text before the brace
+          if @stream.position < brace_index && @stream.current&.type == :text
+            name = @stream.current.value.strip
+            @stream.advance_to(brace_index)
+          end
+
+          @stream.consume(:open_brace) # Skip open brace
+
+          duration, unit = extract_duration
+          @stream.consume(:close_brace) # Skip close brace
+
+          Timer.new(name: name, duration: duration, unit: unit)
+        end
+
+        def parse_simple_timer
+          remaining_text = nil
+          name = nil
+
+          if @stream.current&.type == :text
+            text = @stream.current.value
+            if text.match(/^([a-zA-Z0-9_]+)(.*)$/)
+              name = ::Regexp.last_match(1)
+              remaining_text = ::Regexp.last_match(2)
+            else
+              name = text.strip
+            end
+            @stream.consume
+          end
+
+          timer = Timer.new(name: name, duration: nil, unit: nil)
+          [timer, remaining_text]
+        end
+
+        def extract_duration
+          duration_parts = []
+          unit = nil
+
+          while !@stream.eof? && @stream.current.type != :close_brace
+            case @stream.current.type
+            when :text, :hyphen
+              duration_parts << @stream.current.value
+              @stream.consume
+            when :percent
+              @stream.consume
+              # Unit comes after percent
+              if @stream.current&.type == :text
+                unit = @stream.current.value
+                @stream.consume
+              end
+            else
+              @stream.consume
+            end
+          end
+
+          return [nil, nil] if duration_parts.empty?
+
+          duration_text = duration_parts.join
+
+          if unit
+            duration = parse_duration_value(duration_text)
+            [duration, unit]
+          else
+            parse_duration_with_unit(duration_text)
+          end
+        end
+
+        def parse_duration_value(text)
+          case text
+          when /^\d+$/
+            text.to_i
+          when /^\d+\.\d+$/
+            text.to_f
+          else
+            text # Keep ranges like "2-3"
+          end
+        end
+
+        def parse_duration_with_unit(text)
+          # Simple duration parsing - could be enhanced with DurationExtractor
+          # First check if it's just a number (integer or decimal)
+          if text.match?(/^(\d+(?:\.\d+)?)$/)
+            parsed_duration = text.include?(".") ? text.to_f : text.to_i
+            [parsed_duration, nil]
+          elsif text.match(/^(\d+(?:\.\d+)?)\s*([a-zA-Z]+)$/)
+            duration = ::Regexp.last_match(1)
+            unit = ::Regexp.last_match(2)
+
+            parsed_duration = duration.include?(".") ? duration.to_f : duration.to_i
+            [parsed_duration, unit]
+          else
+            [text, nil]
+          end
+        end
+    end
+  end
+end

data/lib/cooklang/processors/element_parser.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Processors
+    class ElementParser
+      class << self
+        def parse_ingredient(tokens, start_index)
+          parse_with_parser(tokens, start_index, Parsers::IngredientParser)
+        end
+
+        def parse_cookware(tokens, start_index)
+          parse_with_parser(tokens, start_index, Parsers::CookwareParser)
+        end
+
+        def parse_timer(tokens, start_index)
+          parse_with_parser(tokens, start_index, Parsers::TimerParser)
+        end
+
+        private
+          def parse_with_parser(tokens, start_index, parser_class)
+            stream = TokenStream.new(tokens)
+            stream.advance_to(start_index)
+
+            parser = parser_class.new(stream)
+            result = parser.parse
+            consumed = stream.position - start_index
+
+            # Handle the return format
+            if result.is_a?(Array)
+              [result[0], consumed, result[1]]
+            elsif result
+              [result, consumed, nil]
+            else
+              [nil, 1, nil]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/cooklang/processors/metadata_processor.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Processors
+    class MetadataProcessor
+      class << self
+        def extract_metadata(tokens)
+          metadata = Metadata.new
+          content_tokens = []
+          0
+
+          # Check for YAML front matter
+          if tokens.first&.type == :yaml_delimiter
+            metadata, content_tokens, _ = extract_yaml_frontmatter(tokens)
+          else
+            content_tokens = tokens.dup
+          end
+
+          # Extract inline metadata
+          extract_inline_metadata(content_tokens, metadata)
+
+          [metadata, content_tokens]
+        end
+
+        private
+          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
+              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..]
+
+            [metadata, remaining_tokens, i]
+          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
+
+                # Remove quotes if present
+                value = value.gsub(/^["']|["']$/, "") if value.match?(/^["'].*["']$/)
+
+                # Parse numeric values
+                parsed_value = parse_metadata_value(value)
+                metadata[key] = parsed_value unless value.empty?
+              end
+            end
+          end
+
+          def extract_inline_metadata(tokens, metadata)
+            tokens_to_remove = []
+
+            tokens.each_with_index do |token, index|
+              next unless token.type == :metadata_marker
+
+              # Look for metadata pattern: >> key: value
+              if index + 1 < tokens.length && tokens[index + 1].type == :text
+                text = tokens[index + 1].value.strip
+
+                if text.match(/^([^:]+):\s*(.+)$/)
+                  key = ::Regexp.last_match(1).strip
+                  value = ::Regexp.last_match(2).strip
+
+                  # Remove quotes if present
+                  value = value.gsub(/^["']|["']$/, "") if value.match?(/^["'].*["']$/)
+
+                  # Parse numeric values
+                  parsed_value = parse_metadata_value(value)
+                  metadata[key] = parsed_value
+
+                  # Mark both marker and text tokens for removal
+                  tokens_to_remove << index << (index + 1)
+                end
+              end
+            end
+
+            # Remove only the specific metadata tokens that were processed
+            tokens.reject!.with_index { |token, index| tokens_to_remove.include?(index) }
+          end
+
+          def parse_metadata_value(value)
+            return value if value.empty?
+
+            # Try to parse as integer
+            return value.to_i if value.match?(/^\d+$/)
+
+            # Try to parse as float
+            return value.to_f if value.match?(/^\d+\.\d+$/)
+
+            # Return as string
+            value
+          end
+      end
+    end
+  end
+end