cooklang 0.1.0 → 1.0.1

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Recipe
+    attr_reader :ingredients, :cookware, :timers, :steps, :metadata, :sections, :notes
+
+    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] = {
+          quantity: ingredient.quantity,
+          unit: ingredient.unit
+        }.compact
+      end
+    end
+
+    def steps_text
+      @steps.map(&:to_text)
+    end
+
+    def to_h
+      {
+        ingredients: @ingredients.map(&:to_h),
+        cookware: @cookware.map(&:to_h),
+        timers: @timers.map(&:to_h),
+        steps: @steps.map(&:to_h),
+        metadata: @metadata.to_h,
+        sections: @sections.map(&:to_h),
+        notes: @notes.map(&:to_h)
+      }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Recipe)
+
+      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
+
+    def hash
+      [ingredients, cookware, timers, steps, metadata].hash
+    end
+  end
+end

data/lib/cooklang/section.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Section
+    attr_reader :name, :steps
+
+    def initialize(name:, steps: [])
+      @name = name&.to_s&.freeze
+      @steps = steps.freeze
+    end
+
+    def to_s
+      name || "Section"
+    end
+
+    def to_h
+      {
+        name: name,
+        steps: steps.map(&:to_h)
+      }.compact
+    end
+
+    def ==(other)
+      other.is_a?(Section) &&
+        name == other.name &&
+        steps == other.steps
+    end
+
+    def hash
+      [name, steps].hash
+    end
+  end
+end

data/lib/cooklang/step.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Step
+    attr_reader :segments
+
+    def initialize(segments:)
+      @segments = segments.freeze
+    end
+
+    def to_text
+      text_parts = @segments.map do |segment|
+        case segment
+        when Hash
+          case segment[:type]
+          when :ingredient
+            segment[:name]
+          when :cookware
+            segment[:name]
+          when :timer
+            segment[:name] || "timer"
+          else
+            segment[:value] || ""
+          end
+        when String
+          segment
+        when Ingredient
+          segment.name
+        when Cookware
+          segment.name
+        when Timer
+          if segment.name
+            "#{segment.name} for #{segment.duration} #{segment.unit}"
+          elsif segment.duration && segment.unit
+            "for #{segment.duration} #{segment.unit}"
+          else
+            "timer"
+          end
+        else
+          segment.to_s
+        end
+      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
+      {
+        segments: @segments
+      }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Step)
+
+      segments == other.segments
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      segments.hash
+    end
+
+    def ingredients_used
+      @segments.filter_map { |segment| segment[:name] if segment.is_a?(Hash) && segment[:type] == :ingredient }
+    end
+
+    def cookware_used
+      @segments.filter_map { |segment| segment[:name] if segment.is_a?(Hash) && segment[:type] == :cookware }
+    end
+
+    def timers_used
+      @segments.select { |segment| segment.is_a?(Hash) && segment[:type] == :timer }
+    end
+
+    def has_ingredients?
+      ingredients_used.any?
+    end
+
+    def has_cookware?
+      cookware_used.any?
+    end
+
+    def has_timers?
+      timers_used.any?
+    end
+  end
+end

data/lib/cooklang/timer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Timer
+    attr_reader :name, :duration, :unit
+
+    def initialize(duration:, unit:, name: nil)
+      @name = name&.to_s&.freeze
+      @duration = duration
+      @unit = unit&.to_s&.freeze
+    end
+
+    def to_s
+      result = ""
+      result += "#{@name}: " if @name
+      result += "#{@duration} #{@unit}"
+      result
+    end
+
+    def to_h
+      {
+        name: @name,
+        duration: @duration,
+        unit: @unit
+      }.compact
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Timer)
+
+      name == other.name &&
+        duration == other.duration &&
+        unit == other.unit
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      [name, duration, unit].hash
+    end
+
+    def total_seconds
+      return @duration unless @unit
+
+      case @unit.downcase
+      when "second", "seconds", "sec", "s"
+        @duration
+      when "minute", "minutes", "min", "m"
+        @duration * 60
+      when "hour", "hours", "hr", "h"
+        @duration * 3600
+      when "day", "days", "d"
+        @duration * 86_400
+      else
+        @duration
+      end
+    end
+
+    def has_name?
+      !@name.nil?
+    end
+  end
+end

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 = "0.1.0"
+  VERSION = "1.0.1"
 end

data/lib/cooklang.rb

@@ -1,8 +1,29 @@
 # frozen_string_literal: true
 
 require_relative "cooklang/version"
+require_relative "cooklang/lexer"
+require_relative "cooklang/parser"
+require_relative "cooklang/recipe"
+require_relative "cooklang/ingredient"
+require_relative "cooklang/cookware"
+require_relative "cooklang/timer"
+require_relative "cooklang/step"
+require_relative "cooklang/metadata"
+require_relative "cooklang/section"
+require_relative "cooklang/note"
+require_relative "cooklang/formatter"
+require_relative "cooklang/formatters/text"
 
 module Cooklang
   class Error < StandardError; end
-  # Your code goes here...
+  class ParseError < Error; end
+
+  def self.parse(input)
+    parser = Parser.new
+    parser.parse(input)
+  end
+
+  def self.parse_file(file_path)
+    parse(File.read(file_path))
+  end
 end