cooklang 1.0.0 → 1.0.1

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

data/lib/cooklang/processors/token_processor.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../lexer"
+require_relative "../note"
+
+module Cooklang
+  module Processors
+    class TokenProcessor
+      class << self
+        def strip_comments(tokens)
+          result = []
+          i = 0
+
+          while i < tokens.length
+            token = tokens[i]
+
+            case token.type
+            when :comment_line
+              i = handle_comment_line(tokens, i, result)
+            when :comment_block_start
+              i = skip_comment_block(tokens, i)
+            else
+              result << token
+              i += 1
+            end
+          end
+
+          result
+        end
+
+        def extract_notes(tokens)
+          notes = []
+          content_tokens = []
+          i = 0
+
+          while i < tokens.length
+            if tokens[i].type == :note_marker
+              note_content, i = extract_single_note(tokens, i)
+              notes << Note.new(content: note_content) unless note_content.empty?
+            else
+              content_tokens << tokens[i]
+              i += 1
+            end
+          end
+
+          [notes, content_tokens]
+        end
+
+        private
+          def extract_single_note(tokens, start_index)
+            note_text = ""
+            i = start_index + 1 # Skip >
+
+            while i < tokens.length && tokens[i].type != :newline
+              note_text += tokens[i].value if tokens[i].type == :text
+              i += 1
+            end
+
+            [note_text.strip, i]
+          end
+
+          def handle_comment_line(tokens, index, result)
+            index += 1
+            return skip_to_newline(tokens, index) unless index < tokens.length && tokens[index].type == :text
+
+            text_token = tokens[index]
+            newline_pos = text_token.value.index("\n")
+
+            if newline_pos
+              handle_text_with_newline(text_token, newline_pos, result)
+              index + 1
+            else
+              skip_to_newline(tokens, index + 1)
+            end
+          end
+
+          def handle_text_with_newline(text_token, newline_pos, result)
+            remaining_text = text_token.value[(newline_pos + 1)..]
+            return unless remaining_text && !remaining_text.empty?
+
+            result << Token.new(
+              :text,
+              remaining_text,
+              text_token.position,
+              text_token.line,
+              text_token.column
+            )
+          end
+
+          def skip_to_newline(tokens, index)
+            index += 1 while index < tokens.length && tokens[index].type != :newline
+            index
+          end
+
+          def skip_comment_block(tokens, index)
+            index += 1
+            index += 1 while index < tokens.length && tokens[index].type != :comment_block_end
+            index += 1 if index < tokens.length && tokens[index].type == :comment_block_end
+            index
+          end
+      end
+    end
+  end
+end

data/lib/cooklang/recipe.rb

@@ -4,16 +4,23 @@ module Cooklang
   class Recipe
     attr_reader :ingredients, :cookware, :timers, :steps, :metadata, :sections, :notes
 
-    def initialize(ingredients:, cookware:, timers:, steps:, metadata:, sections: [], notes: [])
-      @ingredients = ingredients.freeze
-      @cookware = cookware.freeze
-      @timers = timers.freeze
-      @steps = steps.freeze
-      @metadata = metadata
-      @sections = sections.freeze
-      @notes = notes.freeze
+    def initialize(**components)
+      @ingredients = freeze_component(components[:ingredients])
+      @cookware = freeze_component(components[:cookware])
+      @timers = freeze_component(components[:timers])
+      @steps = freeze_component(components[:steps])
+      @metadata = components[:metadata] || Metadata.new
+      @sections = freeze_component(components[:sections])
+      @notes = freeze_component(components[:notes])
     end
 
+    private
+      def freeze_component(value)
+        (value || []).freeze
+      end
+
+    public
+
     def ingredients_hash
       @ingredients.each_with_object({}) do |ingredient, hash|
         hash[ingredient.name] = {
@@ -42,15 +49,18 @@ module Cooklang
     def ==(other)
       return false unless other.is_a?(Recipe)
 
-      ingredients == other.ingredients &&
-        cookware == other.cookware &&
-        timers == other.timers &&
-        steps == other.steps &&
-        metadata == other.metadata &&
-        sections == other.sections &&
-        notes == other.notes
+      comparable_attributes.all? do |attr|
+        send(attr) == other.send(attr)
+      end
     end
 
+    private
+      def comparable_attributes
+        %i[ingredients cookware timers steps metadata sections notes]
+      end
+
+    public
+
     def eql?(other)
       self == other
     end

data/lib/cooklang/step.rb

@@ -9,7 +9,7 @@ module Cooklang
     end
 
     def to_text
-      @segments.map do |segment|
+      text_parts = @segments.map do |segment|
         case segment
         when Hash
           case segment[:type]
@@ -39,7 +39,17 @@ module Cooklang
         else
           segment.to_s
         end
-      end.join.rstrip
+      end
+
+      result = text_parts.join
+
+      # Special normalization for metadata break patterns:
+      # Convert sequences like "--- \n text \n ---" to "--- text ---"
+      if result.include?("---")
+        result = result.gsub(/---\s*\n\s*/, "--- ").gsub(/\s*\n\s*---/, " ---")
+      end
+
+      result.rstrip
     end
 
     def to_h

data/lib/cooklang/timer.rb

@@ -7,7 +7,7 @@ module Cooklang
     def initialize(duration:, unit:, name: nil)
       @name = name&.to_s&.freeze
       @duration = duration
-      @unit = unit.to_s.freeze
+      @unit = unit&.to_s&.freeze
     end
 
     def to_s
@@ -42,6 +42,8 @@ module Cooklang
     end
 
     def total_seconds
+      return @duration unless @unit
+
       case @unit.downcase
       when "second", "seconds", "sec", "s"
         @duration

data/lib/cooklang/token_stream.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Cooklang
+  class TokenStream
+    include Enumerable
+    extend Forwardable
+
+    # Delegate array-like methods to @tokens
+    def_delegators :@tokens, :size, :length, :empty?
+
+    attr_reader :position
+
+    def initialize(tokens)
+      @tokens = tokens
+      @position = 0
+    end
+
+    def current
+      @tokens[@position]
+    end
+
+    def peek(offset = 1)
+      @tokens[@position + offset]
+    end
+
+    def consume(expected_type = nil)
+      return nil if eof?
+      return nil if expected_type && current&.type != expected_type
+
+      token = current
+      @position += 1
+      token
+    end
+
+    def eof?
+      @position >= @tokens.length
+    end
+
+    # Ruby Enumerable support
+    def each
+      while !eof?
+        yield consume
+      end
+    end
+
+    # StringScanner-inspired methods
+    def scan(type)
+      consume if check(type)
+    end
+
+    def check(type)
+      current&.type == type
+    end
+
+    def skip(type)
+      @position += 1 if check(type)
+    end
+
+    # Convenience methods for complex parsing
+    def consume_while(&block)
+      result = []
+      while !eof? && block.call(current)
+        result << consume
+      end
+      result
+    end
+
+    def consume_until(&block)
+      result = []
+      until eof? || block.call(current)
+        result << consume
+      end
+      result
+    end
+
+    def skip_whitespace
+      consume_while { |token| token.type == :whitespace }
+    end
+
+    # Advanced iteration with lookahead
+    def each_with_lookahead
+      return enum_for(:each_with_lookahead) unless block_given?
+
+      (0...(@tokens.length - 1)).each do |i|
+        yield @tokens[i], @tokens[i + 1]
+      end
+    end
+
+    # StringScanner-inspired position methods
+    def rest
+      @tokens[@position..]
+    end
+
+    def reset
+      @position = 0
+    end
+
+    def rewind(steps = 1)
+      @position = [@position - steps, 0].max
+    end
+
+    # Utility methods
+    def find_next(type)
+      (@position...@tokens.length).find { |i| @tokens[i].type == type }
+    end
+
+    def find_next_matching(&block)
+      (@position...@tokens.length).find { |i| block.call(@tokens[i]) }
+    end
+
+    # Create a new stream starting from current position
+    def slice_from_current
+      TokenStream.new(@tokens[@position..])
+    end
+
+    # Public interface methods to avoid instance_variable_get/set
+    attr_reader :tokens
+
+    def position=(new_position)
+      @position = [new_position, 0].max
+      @position = [@position, @tokens.length].min
+    end
+
+    def advance_to(new_position)
+      self.position = new_position
+    end
+  end
+end

data/lib/cooklang/version.rb

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