poml 0.0.1 → 0.0.2

data/lib/poml/parser.rb

@@ -32,6 +32,9 @@ module Poml
       # Handle escape characters
       content = unescape_poml(content)
       
+      # Pre-process to handle JSON in attributes (convert \" to " inside attribute values)
+      content = preprocess_json_attributes(content)
+      
       # Remove XML comments but preserve surrounding whitespace
       content = content.gsub(/(\s*)<!--.*?-->(\s*)/m) do |match|
         before_space = $1
@@ -44,6 +47,9 @@ module Poml
         end
       end
       
+      # Convert HTML-style void elements to XML self-closing format
+      content = preprocess_void_elements(content)
+      
       # Apply template substitutions
       content = @template_engine.substitute(content)
 
@@ -86,17 +92,15 @@ module Poml
           text_content = child.to_s
           next if text_content.strip.empty?  # Only skip if completely empty when stripped
           
-          # Check if the content (after removing newlines) ends with a space
-          content_no_newlines = text_content.gsub(/\n/, ' ')
-          preserves_trailing_space = content_no_newlines.rstrip != content_no_newlines
-          
-          # Normalize the text: strip leading/trailing whitespace 
-          normalized = text_content.strip
+          # For inline content, preserve spaces but normalize newlines
+          # Convert newlines to single spaces to avoid formatting issues
+          normalized = text_content.gsub(/\s*\n\s*/, ' ')
           
-          # Add back trailing space if it was significant (i.e., there was a space before newlines)
-          normalized += ' ' if preserves_trailing_space
+          # Trim only if the content is just whitespace, otherwise preserve leading/trailing spaces
+          if normalized.strip.empty?
+            next
+          end
           
-          next if normalized.empty?
           elements << Element.new(tag_name: :text, content: normalized)
         when REXML::Element
           # Convert REXML attributes to string hash
@@ -105,12 +109,27 @@ module Poml
             attrs[name.downcase] = value.to_s
           end
           
-          elements << Element.new(
-            tag_name: child.name.downcase.to_sym,
-            attributes: attrs,
-            content: extract_text_content(child),
-            children: parse_element(child)
-          )
+          # Check for conditional and loop attributes before creating element
+          if_condition = attrs['if']
+          for_attribute = attrs['for']
+          
+          # Handle conditional rendering
+          if if_condition && !evaluate_if_condition(if_condition)
+            next # Skip this element
+          end
+          
+          # Handle for loop rendering
+          if for_attribute
+            loop_elements = render_for_loop(child, attrs, for_attribute)
+            elements.concat(loop_elements)
+          else
+            elements << Element.new(
+              tag_name: child.name.downcase.to_sym,
+              attributes: attrs,
+              content: extract_text_content(child),
+              children: parse_element(child)
+            )
+          end
         end
       end
 
@@ -149,5 +168,99 @@ module Poml
         end
       end
     end
+    
+    def evaluate_if_condition(condition)
+      value = @template_engine.evaluate_attribute_expression(condition)
+      !!value
+    end
+    
+    def render_for_loop(xml_element, attrs, for_attribute)
+      # Parse for attribute like "i in [1,2,3]" or "item in items"
+      if for_attribute =~ /^(\w+)\s+in\s+(.+)$/
+        loop_var = $1
+        list_expr = $2.strip
+        
+        # Evaluate the list expression
+        list = @template_engine.evaluate_attribute_expression(list_expr)
+        return [] unless list.is_a?(Array)
+        
+        # Create elements for each item in the list
+        elements = []
+        list.each_with_index do |item, index|
+          # Create loop context
+          old_loop_var = @context.variables[loop_var]
+          old_loop_context = @context.variables['loop']
+          
+          @context.variables[loop_var] = item
+          @context.variables['loop'] = {
+            'index' => index,
+            'length' => list.length,
+            'first' => index == 0,
+            'last' => index == list.length - 1
+          }
+          
+          # Remove for attribute and process element normally
+          loop_attrs = attrs.dup
+          loop_attrs.delete('for')
+          
+          element = Element.new(
+            tag_name: xml_element.name.downcase.to_sym,
+            attributes: loop_attrs,
+            content: extract_text_content(xml_element),
+            children: parse_element(xml_element)
+          )
+          
+          elements << element
+          
+          # Restore previous context
+          if old_loop_var
+            @context.variables[loop_var] = old_loop_var
+          else
+            @context.variables.delete(loop_var)
+          end
+          
+          if old_loop_context
+            @context.variables['loop'] = old_loop_context
+          else
+            @context.variables.delete('loop')
+          end
+        end
+        
+        elements
+      else
+        # Invalid for syntax, return empty
+        []
+      end
+    end
+    
+    def preprocess_void_elements(content)
+      # List of HTML void elements that should be self-closing in XML
+      void_elements = %w[br hr img input area base col embed link meta param source track wbr]
+      
+      # Convert <element> to <element/> for void elements, but only if not already self-closing
+      void_elements.each do |element|
+        # Match opening tag that's not already self-closing
+        # Use a more specific pattern to avoid matching already self-closing tags
+        pattern = /<(#{element})(\s+[^>\/]*?)?(?<!\/)>/i
+        content = content.gsub(pattern) do |match|
+          element_name = $1
+          attributes = $2 || ''
+          "<#{element_name}#{attributes}/>"
+        end
+      end
+      
+      content
+    end
+    
+    def preprocess_json_attributes(content)
+      # Convert problematic characters in attribute values to make them valid XML
+      content = content.gsub(/\\"/, '&quot;')  # Handle JSON quotes
+      
+      # Handle comparison operators in attribute values
+      content = content.gsub(/(\w+\s*=\s*"[^"]*?)(<)([^"]*?")/m, '\1&lt;\3')
+      content = content.gsub(/(\w+\s*=\s*"[^"]*?)(>)([^"]*?")/m, '\1&gt;\3')
+      
+      content
+    end
   end
 end

data/lib/poml/renderer.rb

@@ -42,19 +42,38 @@ module Poml
     end
 
     def render_dict(elements)
+      # Render content first to allow meta components to modify context
+      content = render_raw(elements)
+      
+      # Gather metadata after rendering
+      metadata = {
+        'chat' => @context.chat,
+        'stylesheet' => @context.stylesheet,
+        'variables' => @context.variables
+      }
+      
+      # Include custom metadata (title, description, etc.)
+      metadata.merge!(@context.custom_metadata) if @context.custom_metadata && !@context.custom_metadata.empty?
+      
+      # Include additional metadata if present
+      metadata['response_schema'] = @context.response_schema if @context.response_schema
+      metadata['tools'] = @context.tools if @context.tools && !@context.tools.empty?
+      metadata['runtime_parameters'] = @context.runtime_parameters if @context.runtime_parameters && !@context.runtime_parameters.empty?
+      
       {
-        'content' => render_raw(elements),
-        'metadata' => {
-          'chat' => @context.chat,
-          'stylesheet' => @context.stylesheet,
-          'variables' => @context.variables
-        }
+        'content' => content,
+        'metadata' => metadata
       }
     end
 
     def render_openai_chat(elements)
+      # First render to collect structured messages
       content = render_raw(elements)
-      if @context.chat
+      
+      # Use structured messages if available
+      if @context.respond_to?(:chat_messages) && !@context.chat_messages.empty?
+        @context.chat_messages
+      elsif @context.chat
         parse_chat_messages(content)
       else
         [{ 'role' => 'user', 'content' => content }]

data/lib/poml/template_engine.rb

@@ -1,5 +1,5 @@
 module Poml
-  # Template engine for handling {{variable}} substitutions
+  # Template engine for handling {{variable}} substitutions and control structures
   class TemplateEngine
     def initialize(context)
       @context = context
@@ -15,6 +15,37 @@ module Poml
       end
     end
 
+    def evaluate_attribute_expression(expression)
+      # Handle attribute expressions that might return non-string values
+      if expression =~ /^(\w+(?:\.\w+)*)\s*\+\s*(\d+)$/
+        variable_path = $1
+        increment = $2.to_i
+        
+        value = get_nested_variable(variable_path)
+        if value.is_a?(Numeric)
+          value + increment
+        else
+          expression
+        end
+      elsif expression =~ /^(\w+(?:\.\w+)*)$/
+        # Simple variable or dot notation lookup
+        variable_path = $1
+        get_nested_variable(variable_path)
+      elsif expression =~ /^(true|false)$/i
+        $1.downcase == 'true'
+      elsif expression =~ /^-?\d+$/
+        $1.to_i
+      elsif expression =~ /^-?\d*\.\d+$/
+        $1.to_f
+      elsif @context.variables.key?(expression)
+        # Direct variable lookup (backward compatibility)
+        @context.variables[expression]
+      else
+        # Try to evaluate as a more complex expression
+        evaluate_complex_expression(expression)
+      end
+    end
+
     private
 
     def evaluate_expression(expression)
@@ -40,15 +71,81 @@ module Poml
         # Direct variable lookup (backward compatibility)
         @context.variables[expression].to_s
       else
-        # Return original expression if not found
-        "{{#{expression}}}"
+        # Try to evaluate as a more complex expression
+        result = evaluate_complex_expression(expression)
+        result ? result.to_s : "{{#{expression}}}"
+      end
+    end
+    
+    def evaluate_complex_expression(expression)
+      # Handle more complex expressions like array literals, object access, etc.
+      
+      # Try to parse as JSON first (for arrays and objects)
+      begin
+        require 'json'
+        return JSON.parse(expression)
+      rescue JSON::ParserError
+        # Not valid JSON, continue with other parsing
+      end
+      
+      # Array literals like ['apple', 'banana', 'cherry']
+      if expression =~ /^\[(.+)\]$/
+        array_content = $1
+        # Simple parsing for string arrays
+        if array_content.match(/^'[^']*'(?:\s*,\s*'[^']*')*$/)
+          return array_content.split(',').map { |item| item.strip.gsub(/^'|'$/, '') }
+        end
+      end
+      
+      # Object literals like { name: 'John', age: 30 }
+      if expression =~ /^\{(.+)\}$/
+        # This would need a proper expression parser for full support
+        # For now, return the expression as-is
+        return expression
+      end
+      
+      # Ternary operator like condition ? valueIfTrue : valueIfFalse
+      if expression =~ /^(.+)\s*\?\s*(.+)\s*:\s*(.+)$/
+        condition = $1.strip
+        true_value = $2.strip
+        false_value = $3.strip
+        
+        condition_result = evaluate_condition(condition)
+        if condition_result
+          evaluate_expression(true_value)
+        else
+          evaluate_expression(false_value)
+        end
+      end
+      
+      nil
+    end
+    
+    def evaluate_condition(condition)
+      # Simple condition evaluation
+      case condition
+      when 'true'
+        true
+      when 'false'
+        false
+      when /^!(.+)$/
+        !evaluate_condition($1.strip)
+      else
+        value = get_nested_variable(condition)
+        !!value
       end
     end
     
     def get_nested_variable(path)
       # Handle dot notation like "loop.index"
       parts = path.split('.')
-      value = @context.variables
+      
+      # Handle both Context objects and raw variable hashes
+      value = if @context.respond_to?(:variables)
+        @context.variables
+      else
+        @context
+      end
       
       parts.each do |part|
         if value.is_a?(Hash) && value.key?(part)

data/lib/poml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Poml
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/poml.rb

@@ -2,10 +2,10 @@
 
 require_relative "poml/version"
 require_relative 'poml/context'
+require_relative 'poml/template_engine'
 require_relative 'poml/parser'
 require_relative 'poml/renderer'
 require_relative 'poml/components'
-require_relative 'poml/template_engine'
 
 module Poml
   class Error < StandardError; end
@@ -50,4 +50,70 @@ module Poml
 
     result
   end
+
+  def self.parse(content, context: nil)
+    context ||= Context.new
+    parser = Parser.new(context)
+    parser.parse(content)
+  end
+
+  def self.render(content, format: 'text', context: nil, **options)
+    context ||= Context.new(**options)
+    elements = parse(content, context: context)
+    renderer = Renderer.new(context)
+    renderer.render(elements, format)
+  end
+
+  # Convenience method for quick text rendering
+  def self.to_text(content, **options)
+    render(content, format: 'raw', **options)
+  end
+
+  # Convenience method for chat format
+  def self.to_chat(content, **options)
+    render(content, format: 'openai_chat', **options)
+  end
+
+  # Convenience method for dict format
+  def self.to_dict(content, **options)
+    render(content, format: 'dict', **options)
+  end
+  
+  # Legacy method for backward compatibility
+  def self.process(markup:, format: 'dict', **options)
+    # Handle file paths
+    content = if File.exist?(markup)
+      File.read(markup)
+    else
+      markup
+    end
+    
+    # Extract output file option
+    output_file = options.delete(:output_file)
+    
+    # Extract context from various parameter formats
+    if options.key?(:context)
+      # If context is provided explicitly, use it as variables
+      context_options = {}
+      context_options[:variables] = options.delete(:context)
+    else
+      # Extract known context options and ignore unknown ones
+      context_options = {}
+      context_options[:variables] = options.delete(:variables) || options.reject { |k, v| [:stylesheet, :chat, :syntax].include?(k) }
+    end
+    
+    context_options[:stylesheet] = options.delete(:stylesheet) if options.key?(:stylesheet)
+    context_options[:chat] = options.delete(:chat) if options.key?(:chat)
+    context_options[:syntax] = options.delete(:syntax) if options.key?(:syntax)
+    
+    result = render(content, format: format, **context_options)
+    
+    # Write to file if output_file is specified
+    if output_file
+      File.write(output_file, result)
+      '' # Return empty string when writing to file
+    else
+      result
+    end
+  end
 end

data/{README.md → readme.md}

@@ -6,17 +6,25 @@ A Ruby implementation of the POML (Prompt Oriented Markup Language) interpreter.
 
 This is a **Ruby port** of the original [POML library](https://github.com/microsoft/poml) developed by Microsoft, which was originally implemented in JavaScript/TypeScript and Python. This Ruby gem is designed to be **fully compatible** with the original POML specification and will **closely follow** the development of the original library to maintain feature parity.
 
+## Demo Video
+
+[![The 5-minute guide to POML](https://i3.ytimg.com/vi/b9WDcFsKixo/maxresdefault.jpg)](https://youtu.be/b9WDcFsKixo)
+
 ### Original Library Resources
 
 For comprehensive documentation, tutorials, and examples, please refer to the **original POML library documentation**:
 
 - 📚 **Main Repository**: <https://github.com/microsoft/poml>
-- 📖 **Documentation**: Complete language reference and guides
+- 📖 **Documentation**: [Complete language reference and guides](https://microsoft.github.io/poml/latest/)
 - 💡 **Examples**: Extensive collection of POML examples
 - 🎯 **Use Cases**: Real-world applications and patterns
 
 The original documentation is an excellent resource for learning POML concepts, syntax, and best practices that apply to this Ruby implementation as well.
 
+## Implementation status
+
+Please refer to [ROADMAP.md](https://github.com/GhennadiiMir/poml/blob/main/ROADMAP.md) for understanding which features are already implemented.
+
 ## Installation
 
 ```bash

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: poml
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ghennadii Mirosnicenco
 bindir: bin
 cert_chain: []
-date: 2025-08-17 00:00:00.000000000 Z
+date: 2025-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rexml
@@ -50,7 +50,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- README.md
 - TUTORIAL.md
 - bin/poml
 - examples/101_explain_character.poml
@@ -64,7 +63,6 @@ files:
 - examples/202_arc_agi.poml
 - examples/301_generate_poml.poml
 - examples/README.md
-- examples/_generate_expects.py
 - examples/assets/101_jerry_mouse.jpg
 - examples/assets/101_tom_and_jerry.docx
 - examples/assets/101_tom_cat.jpg
@@ -104,11 +102,16 @@ files:
 - lib/poml/components/content.rb
 - lib/poml/components/data.rb
 - lib/poml/components/examples.rb
+- lib/poml/components/formatting.rb
 - lib/poml/components/instructions.rb
 - lib/poml/components/layout.rb
 - lib/poml/components/lists.rb
+- lib/poml/components/media.rb
+- lib/poml/components/meta.rb
 - lib/poml/components/styling.rb
+- lib/poml/components/template.rb
 - lib/poml/components/text.rb
+- lib/poml/components/utilities.rb
 - lib/poml/components/workflow.rb
 - lib/poml/components_new.rb
 - lib/poml/components_old.rb
@@ -119,6 +122,7 @@ files:
 - lib/poml/version.rb
 - media/logo-16-purple.png
 - media/logo-64-white.png
+- readme.md
 homepage: https://github.com/GhennadiiMir/poml
 licenses:
 - MIT

data/examples/_generate_expects.py

@@ -1,35 +0,0 @@
-import os
-import poml
-import io
-import sys
-from contextlib import redirect_stdout
-
-
-def process_example(example_content, output_file):
-    """
-    Process the example content and return the expected output.
-    """
-    # Capture stdout
-    poml.poml(example_content, format="raw", output_file=output_file, extra_args=["--prettyPrint", "true"])
-
-
-def generate_expectations():
-    """
-    Generate the expected output files for the examples.
-    """
-    examples_dir = os.path.abspath(os.path.dirname(__file__))
-    expect_dir = os.path.join(examples_dir, "expects")
-    print("Generating expectations in:", expect_dir)
-
-    for example_file in sorted(os.listdir(examples_dir)):
-        if example_file.endswith(".poml"):
-            print(f"Processing example: {example_file}")
-            # Generate the expected output
-            process_example(
-                os.path.join(examples_dir, example_file),
-                os.path.join(expect_dir, example_file.replace(".poml", ".txt")),
-            )
-
-
-if __name__ == "__main__":
-    generate_expectations()