cooklang 0.1.0 → 1.0.1

data/lib/cooklang/lexer.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Cooklang
+  Token = Struct.new(:type, :value, :position, :line, :column) do
+    def initialize(type, value, position = 0, line = 1, column = 1)
+      super
+    end
+  end
+
+  class Lexer
+    TOKENS = {
+      ingredient_marker: "@",
+      cookware_marker: "#",
+      timer_marker: "~",
+      open_brace: "{",
+      close_brace: "}",
+      open_paren: "(",
+      close_paren: ")",
+      percent: "%",
+      comment_line: "--",
+      comment_block_start: "[-",
+      comment_block_end: "-]",
+      metadata_marker: ">>",
+      section_marker: "=",
+      note_marker: ">",
+      newline: "\n",
+      yaml_delimiter: "---"
+    }.freeze
+
+    def initialize(input)
+      @input = input
+      @scanner = StringScanner.new(input)
+      @line = 1
+      @column = 1
+      @tokens = []
+    end
+
+    def tokenize
+      @tokens = []
+
+      until @scanner.eos?
+        if match_yaml_delimiter
+        elsif match_comment_block
+        elsif match_comment_line
+        elsif match_metadata_marker
+        elsif match_section_marker
+        elsif match_note_marker
+        elsif match_special_chars
+        elsif match_newline
+        elsif match_text
+        elsif match_hyphen
+        else
+          # Skip unrecognized character
+          advance_position(@scanner.getch)
+        end
+      end
+
+      @tokens
+    end
+
+    private
+      def current_position
+        @scanner.pos
+      end
+
+      def current_line
+        @line
+      end
+
+      def current_column
+        @column
+      end
+
+      def advance_position(text)
+        text.each_char do |char|
+          if char == "\n"
+            @line += 1
+            @column = 1
+          else
+            @column += 1
+          end
+        end
+      end
+
+      def add_token(type, value)
+        position = current_position
+        line = current_line
+        column = current_column
+        @tokens << Token.new(type, value, position, line, column)
+        advance_position(value)
+      end
+
+      def capture_single_char_token(type)
+        position = current_position
+        line = current_line
+        column = current_column
+        value = @scanner.getch
+        @tokens << Token.new(type, value, position, line, column)
+        advance_position(value)
+        true
+      end
+
+      def match_yaml_delimiter
+        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)
+          true
+        else
+          false
+        end
+      end
+
+      def match_comment_block
+        if @scanner.check(/\[-/)
+          position = current_position
+          line = current_line
+          column = current_column
+          @scanner.scan("[-")
+          @tokens << Token.new(:comment_block_start, "[-", position, line, column)
+          advance_position("[-")
+
+          # Scan until block end or EOF
+          content = ""
+          content += @scanner.getch while !@scanner.eos? && !@scanner.check(/-\]/)
+
+          add_token(:text, content) unless content.empty?
+
+          if @scanner.check(/-\]/)
+            position = current_position
+            line = current_line
+            column = current_column
+            @scanner.scan("-]")
+            @tokens << Token.new(:comment_block_end, "-]", position, line, column)
+            advance_position("-]")
+          end
+
+          true
+        else
+          false
+        end
+      end
+
+      def match_comment_line
+        if @scanner.check(/--/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan("--")
+          @tokens << Token.new(:comment_line, value, position, line, column)
+          advance_position(value)
+
+          # Scan rest of line
+          line_content = @scanner.scan(/[^\n]*/)
+          add_token(:text, line_content) if line_content && !line_content.empty?
+
+          true
+        else
+          false
+        end
+      end
+
+      def match_metadata_marker
+        if @scanner.check(/>>/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan(">>")
+          @tokens << Token.new(:metadata_marker, value, position, line, column)
+          advance_position(value)
+          true
+        else
+          false
+        end
+      end
+
+      def match_section_marker
+        if @scanner.check(/=+/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan(/=+/)
+          @tokens << Token.new(:section_marker, value, position, line, column)
+          advance_position(value)
+          true
+        else
+          false
+        end
+      end
+
+      def match_note_marker
+        # Only match > if it's not part of >>
+        if @scanner.check(/>/) && !@scanner.check(/>>/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan(">")
+          @tokens << Token.new(:note_marker, value, position, line, column)
+          advance_position(value)
+          true
+        else
+          false
+        end
+      end
+
+      def match_special_chars
+        char = @scanner.check(/./)
+
+        case char
+        when "@"
+          capture_single_char_token(:ingredient_marker)
+        when "#"
+          capture_single_char_token(:cookware_marker)
+        when "~"
+          capture_single_char_token(:timer_marker)
+        when "{"
+          capture_single_char_token(:open_brace)
+        when "}"
+          capture_single_char_token(:close_brace)
+        when "("
+          capture_single_char_token(:open_paren)
+        when ")"
+          capture_single_char_token(:close_paren)
+        when "%"
+          capture_single_char_token(:percent)
+        else
+          false
+        end
+      end
+
+      def match_newline
+        if @scanner.check(/\n/)
+          position = current_position
+          line = current_line
+          column = current_column
+          value = @scanner.scan("\n")
+          @tokens << Token.new(:newline, value, position, line, column)
+          advance_position(value)
+          true
+        else
+          false
+        end
+      end
+
+      def match_text
+        # Match any printable text that's not a special character, including spaces and tabs
+        # Exclude [ and ] to allow block comment detection
+        # Exclude = and > to allow section and note markers
+        # Include tabs explicitly along with printable characters
+        if @scanner.check(/[\t[:print:]&&[^@#~{}()%\n\-\[\]=>]]+/)
+          position = current_position
+          line = current_line
+          column = current_column
+          text = @scanner.scan(/[\t[:print:]&&[^@#~{}()%\n\-\[\]=>]]+/)
+          @tokens << Token.new(:text, text, position, line, column)
+          advance_position(text)
+          true
+        else
+          false
+        end
+      end
+
+      def match_hyphen
+        if @scanner.check(/-/) && !@scanner.check(/--/)
+          position = current_position
+          line = current_line
+          column = current_column
+          @scanner.scan("-")
+          @tokens << Token.new(:hyphen, "-", position, line, column)
+          advance_position("-")
+          true
+        else
+          false
+        end
+      end
+  end
+end

data/lib/cooklang/metadata.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Metadata < Hash
+    def initialize(data = {})
+      super()
+      data.each { |key, value| self[key.to_s] = value }
+    end
+
+    def []=(key, value)
+      super(key.to_s, value)
+    end
+
+    def [](key)
+      super(key.to_s)
+    end
+
+    def key?(key)
+      super(key.to_s)
+    end
+
+    def delete(key)
+      super(key.to_s)
+    end
+
+    def fetch(key, *)
+      super(key.to_s, *)
+    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/note.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cooklang
+  class Note
+    attr_reader :content
+
+    def initialize(content:)
+      @content = content.to_s.freeze
+    end
+
+    def to_s
+      content
+    end
+
+    def to_h
+      { content: content }
+    end
+
+    def ==(other)
+      other.is_a?(Note) && content == other.content
+    end
+
+    def hash
+      content.hash
+    end
+  end
+end

data/lib/cooklang/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lexer"
+require_relative "processors/metadata_processor"
+require_relative "processors/token_processor"
+require_relative "processors/step_processor"
+require_relative "builders/recipe_builder"
+
+module Cooklang
+  class Parser
+    def parse(input)
+      # Tokenize input
+      lexer = Lexer.new(input)
+      tokens = lexer.tokenize
+
+      # Extract metadata
+      metadata, content_tokens = Processors::MetadataProcessor.extract_metadata(tokens)
+
+      # Clean up tokens
+      cleaned_tokens = Processors::TokenProcessor.strip_comments(content_tokens)
+      notes, recipe_tokens = Processors::TokenProcessor.extract_notes(cleaned_tokens)
+
+      # Parse steps
+      parsed_steps = Processors::StepProcessor.parse_steps(recipe_tokens)
+
+      # Build final recipe
+      recipe = Builders::RecipeBuilder.build_recipe(parsed_steps, metadata)
+
+      # Add notes to recipe (create new recipe with notes)
+      Recipe.new(
+        ingredients: recipe.ingredients,
+        cookware: recipe.cookware,
+        timers: recipe.timers,
+        steps: recipe.steps,
+        metadata: recipe.metadata,
+        sections: recipe.sections,
+        notes: notes
+      )
+    end
+  end
+end

data/lib/cooklang/parsers/cookware_parser.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "../cookware"
+require_relative "../token_stream"
+
+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