cooklang 1.0.0 → 1.0.2

data/lib/cooklang/formatters/hash.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Cooklang
+  module Formatters
+    class Hash < Formatter
+      def generate(*args)
+        {
+          metadata: format_metadata,
+          sections: format_sections,
+          ingredients: format_ingredients,
+          cookware: format_cookware,
+          timers: format_timers,
+          inline_quantities: [],
+          data: format_data
+        }
+      end
+
+    private
+      def format_metadata
+        {
+          map: recipe.metadata.to_h.transform_values(&:to_s)
+        }
+      end
+
+      def format_sections
+        [
+          {
+            name: nil,
+            content: format_steps_as_content
+          }
+        ]
+      end
+
+      def format_steps_as_content
+        recipe.steps.each_with_index.map do |step, index|
+          {
+            type: "step",
+            value: {
+              items: format_step_items(step),
+              number: index + 1
+            }
+          }
+        end
+      end
+
+      def format_step_items(step)
+        items = []
+
+        step.segments.each do |segment|
+          items << format_segment(segment)
+        end
+
+        items
+      end
+
+      def format_segment(segment)
+        case segment
+        when Hash
+          case segment[:type]
+          when :ingredient
+            {
+              type: "ingredient",
+              index: find_ingredient_index(segment[:name])
+            }
+          when :cookware
+            {
+              type: "cookware",
+              index: find_cookware_index(segment[:name])
+            }
+          when :timer
+            {
+              type: "timer",
+              index: find_timer_index(segment)
+            }
+          else
+            {
+              type: "text",
+              value: segment[:value] || ""
+            }
+          end
+        when String
+          {
+            type: "text",
+            value: segment
+          }
+        when Cooklang::Ingredient
+          {
+            type: "ingredient",
+            index: find_ingredient_index(segment.name)
+          }
+        when Cooklang::Cookware
+          {
+            type: "cookware",
+            index: find_cookware_index(segment.name)
+          }
+        when Cooklang::Timer
+          {
+            type: "timer",
+            index: find_timer_index(segment)
+          }
+        else
+          {
+            type: "text",
+            value: segment.to_s
+          }
+        end
+      end
+
+      def format_ingredients
+        recipe.ingredients.map do |ingredient|
+          {
+            name: ingredient.name,
+            alias: nil,
+            quantity: format_ingredient_quantity(ingredient),
+            note: ingredient.notes,
+            reference: nil,
+            relation: {
+              type: "definition",
+              referenced_from: [],
+              defined_in_step: true,
+              reference_target: nil
+            },
+            modifiers: ""
+          }
+        end
+      end
+
+      def format_ingredient_quantity(ingredient)
+        return nil unless ingredient.quantity && ingredient.quantity != "some"
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: ingredient.quantity.to_f
+            }
+          },
+          unit: ingredient.unit
+        }
+      end
+
+      def format_cookware
+        recipe.cookware.map do |cookware_item|
+          {
+            name: cookware_item.name,
+            alias: nil,
+            quantity: format_cookware_quantity(cookware_item),
+            note: nil,
+            relation: {
+              type: "definition",
+              referenced_from: [],
+              defined_in_step: true
+            },
+            modifiers: ""
+          }
+        end
+      end
+
+      def format_cookware_quantity(cookware_item)
+        return nil unless cookware_item.quantity && cookware_item.quantity != 1
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: cookware_item.quantity.to_f
+            }
+          },
+          unit: nil
+        }
+      end
+
+      def format_timers
+        recipe.timers.map do |timer|
+          {
+            name: (timer.name.nil? || timer.name.empty?) ? nil : timer.name,
+            quantity: format_timer_quantity(timer)
+          }
+        end
+      end
+
+      def format_timer_quantity(timer)
+        return nil unless timer.duration
+
+        {
+          value: {
+            type: "number",
+            value: {
+              type: "regular",
+              value: timer.duration.to_f
+            }
+          },
+          unit: timer.unit
+        }
+      end
+
+      def find_ingredient_index(name)
+        recipe.ingredients.find_index { |ingredient| ingredient.name == name } || 0
+      end
+
+      def find_cookware_index(name)
+        recipe.cookware.find_index { |cookware_item| cookware_item.name == name } || 0
+      end
+
+      def find_timer_index(timer_data)
+        # For hash segments, we need to match by duration and unit
+        if timer_data.is_a?(Hash)
+          recipe.timers.find_index do |timer|
+            timer.duration == timer_data[:duration] && timer.unit == timer_data[:unit]
+          end || 0
+        elsif timer_data.is_a?(Cooklang::Timer)
+          recipe.timers.find_index { |timer| timer == timer_data } || 0
+        else
+          0
+        end
+      end
+
+      def format_data
+        {
+          type: "Scaled",
+          target: {
+            factor: 1.0
+          },
+          ingredients: format_ingredient_data,
+          cookware: format_cookware_data,
+          timers: format_timer_data
+        }
+      end
+
+      def format_ingredient_data
+        recipe.ingredients.map do |ingredient|
+          if ingredient.quantity && ingredient.quantity != "some"
+            "scaled"
+          else
+            "noQuantity"
+          end
+        end
+      end
+
+      def format_cookware_data
+        recipe.cookware.map do |cookware_item|
+          if cookware_item.quantity && cookware_item.quantity != 1
+            "scaled"
+          else
+            "noQuantity"
+          end
+        end
+      end
+
+      def format_timer_data
+        recipe.timers.map { "fixed" }
+      end
+    end
+  end
+end

data/lib/cooklang/formatters/json.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cooklang
+  module Formatters
+    class Json < Hash
+      def generate(*args)
+        super().to_json(*args)
+      end
+    end
+  end
+end

data/lib/cooklang/formatters/text.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative "../formatter"
-
 module Cooklang
   module Formatters
     class Text < Formatter
-      def to_s
+      def generate(*args)
         sections = []
 
         sections << ingredients_section unless recipe.ingredients.empty?

data/lib/cooklang/lexer.rb

@@ -42,27 +42,17 @@ module Cooklang
 
       until @scanner.eos?
         if match_yaml_delimiter
-          # Handle YAML front matter
         elsif match_comment_block
-          # Handle block comments
         elsif match_comment_line
-          # Handle line comments
         elsif match_metadata_marker
-          # Handle >> metadata
         elsif match_section_marker
-          # Handle = section markers
         elsif match_note_marker
-          # Handle > note markers (only if not part of >>)
         elsif match_special_chars
-          # Handle single character tokens
         elsif match_newline
-          # Handle newlines
         elsif match_text
-          # Handle plain text
         elsif match_hyphen
-          # Handle single hyphens that aren't part of comments
         else
-          # Skip unrecognized characters
+          # Skip unrecognized character
           advance_position(@scanner.getch)
         end
       end
@@ -258,14 +248,15 @@ module Cooklang
       end
 
       def match_text
-        # Match any text that's not a special character, including spaces and tabs
+        # 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
-        if @scanner.check(/[^@#~{}()%\n\-\[\]=>]+/)
+        # 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(/[^@#~{}()%\n\-\[\]=>]+/)
+          text = @scanner.scan(/[\t[:print:]&&[^@#~{}()%\n\-\[\]=>]]+/)
           @tokens << Token.new(:text, text, position, line, column)
           advance_position(text)
           true