cooklang 0.1.0 → 1.0.1

data/lib/cooklang/parsers/ingredient_parser.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require_relative "../ingredient"
+require_relative "../token_stream"
+
+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,135 @@
+# frozen_string_literal: true
+
+require_relative "../timer"
+require_relative "../token_stream"
+
+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,45 @@
+# frozen_string_literal: true
+
+require_relative "../token_stream"
+require_relative "../parsers/ingredient_parser"
+require_relative "../parsers/cookware_parser"
+require_relative "../parsers/timer_parser"
+
+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,129 @@
+# frozen_string_literal: true
+
+require_relative "../metadata"
+
+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

data/lib/cooklang/processors/step_processor.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "element_parser"
+require_relative "../token_stream"
+require_relative "../builders/step_builder"
+
+module Cooklang
+  module Processors
+    class StepProcessor
+      class << self
+        def parse_steps(tokens)
+          # Group tokens into steps (separated by blank lines)
+          step_groups = split_into_step_groups(tokens)
+
+          # Parse each step group into step data
+          steps = step_groups.map { |step_tokens| parse_step(step_tokens) }
+
+          # Filter out nil steps (those without content)
+          steps.compact.select { |step_data| step_data.is_a?(Hash) && has_content?(step_data[:segments]) }
+        end
+
+        private
+          def split_into_step_groups(tokens)
+            groups = []
+            current_group = []
+            i = 0
+
+            while i < tokens.length
+              token = tokens[i]
+
+              if token.type == :newline && blank_line_ahead?(tokens, i)
+                groups = finalize_current_group(groups, current_group)
+                current_group = []
+                i = skip_blank_line(tokens, i)
+              else
+                current_group << token
+                i += 1
+              end
+            end
+
+            finalize_current_group(groups, current_group)
+          end
+
+          def blank_line_ahead?(tokens, index)
+            next_index = index + 1
+            return false if next_index >= tokens.length
+
+            # Look for consecutive newlines or newline + whitespace + newline
+            if tokens[next_index].type == :newline
+              true
+            elsif tokens[next_index].type == :text && tokens[next_index].value.strip.empty?
+              # Check if there's a newline after the whitespace
+              next_next_index = next_index + 1
+              next_next_index < tokens.length && tokens[next_next_index].type == :newline
+            else
+              false
+            end
+          end
+
+          def parse_step(tokens)
+            builder = Builders::StepBuilder.new
+            stream = TokenStream.new(tokens)
+
+            while !stream.eof?
+              process_token_with_stream(stream, builder)
+            end
+
+            return nil unless builder.has_content?
+
+            # Return the expected hash format for compatibility
+            {
+              segments: builder.send(:remove_trailing_newlines, builder.segments.dup),
+              ingredients: builder.ingredients,
+              cookware: builder.cookware,
+              timers: builder.timers,
+              section_name: builder.section_name
+            }
+          end
+
+          def process_token_with_stream(stream, builder)
+            token = stream.current
+
+            case token.type
+            when :ingredient_marker
+              process_ingredient_with_stream(stream, builder)
+            when :cookware_marker
+              process_cookware_with_stream(stream, builder)
+            when :timer_marker
+              process_timer_with_stream(stream, builder)
+            when :text
+              builder.add_text(token.value)
+              stream.consume
+            when :newline
+              builder.add_text("\n")
+              stream.consume
+            when :yaml_delimiter
+              # Preserve yaml_delimiter as literal text when not in YAML context
+              builder.add_text(token.value)
+              stream.consume
+            when :open_brace, :close_brace, :open_paren, :close_paren, :percent
+              builder.add_text(token.value)
+              stream.consume
+            when :section_marker
+              process_section_with_stream(stream, builder)
+            else
+              stream.consume
+            end
+          end
+
+
+          def process_ingredient_with_stream(stream, builder)
+            process_element_with_stream(stream, builder, :ingredient)
+          end
+
+          def process_cookware_with_stream(stream, builder)
+            process_element_with_stream(stream, builder, :cookware)
+          end
+
+          def process_timer_with_stream(stream, builder)
+            process_element_with_stream(stream, builder, :timer)
+          end
+
+          def process_element_with_stream(stream, builder, element_type)
+            # Get the current position to pass to ElementParser
+            start_index = stream.position
+            tokens = stream.tokens
+
+            # Parse the element using the appropriate ElementParser method
+            element, consumed, remaining_text = case element_type
+            when :ingredient
+              ElementParser.parse_ingredient(tokens, start_index)
+            when :cookware
+              ElementParser.parse_cookware(tokens, start_index)
+            when :timer
+              ElementParser.parse_timer(tokens, start_index)
+            end
+
+            if element.nil?
+              builder.add_text(stream.current.value)
+              stream.consume
+            else
+              # Add the element using the appropriate builder method
+              case element_type
+              when :ingredient
+                builder.add_ingredient(element)
+              when :cookware
+                builder.add_cookware(element)
+              when :timer
+                builder.add_timer(element)
+              end
+
+              builder.add_remaining_text(remaining_text)
+              # Move stream position forward by consumed tokens
+              stream.advance_to(start_index + consumed)
+            end
+          end
+
+          def process_section_with_stream(stream, builder)
+            stream.consume # Skip section marker
+
+            if stream.current&.type == :text
+              text_content = stream.current.value
+              # Handle both actual newlines and literal \n sequences
+              newline_pos = text_content.index("\n") || text_content.index("\\n")
+
+              if newline_pos
+                # Section name is everything before the newline
+                section_name = text_content[0...newline_pos].strip
+                builder.set_section_name(section_name)
+              else
+                # No newline in this token, take the whole text as section name
+                section_name = text_content.strip
+                builder.set_section_name(section_name)
+              end
+              stream.consume
+            end
+          end
+
+
+
+
+
+
+          def has_content?(segments)
+            segments.any? { |segment| segment != "\n" && !(segment.is_a?(String) && segment.strip.empty?) }
+          end
+
+          def finalize_current_group(groups, current_group)
+            return groups unless group_has_content?(current_group)
+
+            groups << current_group
+            groups
+          end
+
+          def group_has_content?(group)
+            group.any? { |t| t.type != :newline }
+          end
+
+          def skip_blank_line(tokens, start_index)
+            i = start_index + 1
+            i += 1 while i < tokens.length && (tokens[i].type == :newline ||
+                                             (tokens[i].type == :text && tokens[i].value.strip.empty?))
+            i
+          end
+      end
+    end
+  end
+end