poml 0.0.1

data/lib/poml/components/content.rb

@@ -0,0 +1,156 @@
+module Poml
+  # Document component (reads and includes external files)
+  class DocumentComponent < Component
+    def initialize(element, context)
+      super
+      @src = element.attributes['src']
+      @selected_pages = element.attributes['selectedpages'] || element.attributes['selectedPages']
+      @syntax = element.attributes['syntax'] || 'text'
+    end
+
+    def render(context = nil)
+      return "[Document: no src specified]" unless @src
+
+      begin
+        # Resolve file path - try relative to current working directory first
+        file_path = @src
+        unless File.exist?(file_path)
+          # Try relative to examples directory
+          examples_dir = File.expand_path('examples')
+          file_path = File.join(examples_dir, @src)
+        end
+        
+        unless File.exist?(file_path)
+          # Try relative to project root examples directory  
+          project_root = File.expand_path('..', File.dirname(__dir__))
+          examples_dir = File.join(project_root, 'examples')
+          file_path = File.join(examples_dir, @src)
+        end
+        
+        # Check if file exists
+        unless File.exist?(file_path)
+          return "[Document: #{@src} (not found)]"
+        end
+
+        # Check file type and extract content
+        if file_path.downcase.end_with?('.pdf')
+          read_pdf_content(file_path)
+        elsif file_path.downcase.end_with?('.docx')
+          read_docx_content(file_path)
+        else
+          File.read(file_path)
+        end
+      rescue => e
+        "[Document: #{@src} (error reading: #{e.message})]"
+      end
+    end
+
+    private
+
+    def read_pdf_content(file_path)
+      if @selected_pages
+        # Parse Python-style slice notation
+        start_page, end_page = parse_python_style_slice(@selected_pages, get_pdf_page_count(file_path))
+        
+        # Convert 0-indexed to 1-indexed for pdftotext (-f and -l are 1-indexed)
+        start_page_1indexed = start_page + 1
+        # For Python slice "1:3" -> start=1, end=3 (0-indexed, end exclusive)
+        # This means we want pages 1,2 (0-indexed) = pages 2,3 (1-indexed)
+        # So pdftotext should use -f 2 -l 3
+        last_page_1indexed = start_page_1indexed + (end_page - start_page) - 1
+        
+        if end_page > start_page + 1
+          # Extract range of pages
+          command = "pdftotext -f #{start_page_1indexed} -l #{last_page_1indexed} \"#{file_path}\" -"
+          result = `#{command}`
+        else
+          # Single page
+          command = "pdftotext -f #{start_page_1indexed} -l #{start_page_1indexed} \"#{file_path}\" -"
+          result = `#{command}`
+        end
+      else
+        # Extract all pages
+        result = `pdftotext "#{file_path}" -`
+      end
+      
+      if $?.success?
+        result
+      else
+        "[Document: #{@src} (error extracting PDF)]"
+      end
+    end
+
+    def parse_python_style_slice(slice, total_length)
+      # Handle different slice formats: "1:3", ":3", "3:", "3", ":"
+      if slice == ':'
+        [0, total_length]
+      elsif slice.end_with?(':')
+        [slice[0..-2].to_i, total_length]
+      elsif slice.start_with?(':')
+        [0, slice[1..-1].to_i]
+      elsif slice.include?(':')
+        parts = slice.split(':')
+        [parts[0].to_i, parts[1].to_i]
+      else
+        index = slice.to_i
+        [index, index + 1]
+      end
+    end
+
+    def get_pdf_page_count(file_path)
+      # Get page count using pdfinfo (if available) or default to large number
+      result = `pdfinfo "#{file_path}" 2>/dev/null | grep "Pages:" | awk '{print $2}'`
+      if $?.success? && !result.strip.empty?
+        result.strip.to_i
+      else
+        # Fallback: try to extract and count pages
+        100  # Default fallback
+      end
+    end
+
+    def read_docx_content(file_path)
+      # Try to extract text from .docx file using antiword or textutil (macOS)
+      # First try textutil (available on macOS)
+      result = `textutil -convert txt -stdout "#{file_path}" 2>/dev/null`
+      if $?.success? && !result.strip.empty?
+        return result
+      end
+
+      # Try pandoc if available
+      result = `pandoc "#{file_path}" -t plain 2>/dev/null`
+      if $?.success? && !result.strip.empty?
+        return result
+      end
+
+      # Try unzip to extract document.xml and parse it
+      begin
+        require 'zip'
+        content = ""
+        Zip::File.open(file_path) do |zip_file|
+          entry = zip_file.find_entry("word/document.xml")
+          if entry
+            xml_content = entry.get_input_stream.read
+            # Simple XML text extraction (not perfect but better than binary)
+            content = xml_content.gsub(/<[^>]*>/, ' ').gsub(/\s+/, ' ').strip
+          end
+        end
+        return content unless content.empty?
+      rescue => e
+        # Zip gem not available or error occurred
+      end
+
+      # Fallback: indicate that document could not be processed
+      "[Document: #{File.basename(file_path)} (Word document text extraction not available)]"
+    end
+  end
+
+  # Paragraph component for basic text content
+  class ParagraphComponent < Component
+    def render
+      apply_stylesheet
+      
+      content = @element.content.empty? ? render_children : @element.content
+      "#{content}\n\n"
+    end
+  end
+end

data/lib/poml/components/data.rb

@@ -0,0 +1,346 @@
+module Poml
+  # Table component for displaying tabular data
+  class TableComponent < Component
+    require 'csv'
+    require 'json'
+    
+    def render
+      apply_stylesheet
+      
+      src = get_attribute('src')
+      records_attr = get_attribute('records')
+      columns_attr = get_attribute('columns') 
+      parser = get_attribute('parser', 'auto')
+      syntax = get_attribute('syntax')
+      selected_columns = get_attribute('selectedColumns')
+      selected_records = get_attribute('selectedRecords')
+      max_records = get_attribute('maxRecords')
+      max_columns = get_attribute('maxColumns')
+      
+      # Load data from source or use provided records
+      data = if src
+        load_table_data(src, parser)
+      elsif records_attr
+        parse_records_attribute(records_attr)
+      else
+        { records: [], columns: [] }
+      end
+      
+      # Apply column and record selection
+      data = apply_selection(data, selected_columns, selected_records, max_records, max_columns)
+      
+      # Check syntax preference
+      if syntax == 'tsv' || syntax == 'csv'
+        render_table_raw(data, syntax)
+      elsif xml_mode?
+        render_table_xml(data)
+      else
+        render_table_markdown(data)
+      end
+    end
+    
+    private
+    
+    def load_table_data(src, parser)
+      # Resolve relative paths
+      file_path = if src.start_with?('/')
+        src
+      else
+        base_path = if @context.source_path
+          File.dirname(@context.source_path)
+        else
+          Dir.pwd
+        end
+        File.join(base_path, src)
+      end
+      
+      unless File.exist?(file_path)
+        return { records: [], columns: [] }
+      end
+      
+      # Determine parser from file extension if auto
+      if parser == 'auto'
+        ext = File.extname(file_path).downcase
+        parser = case ext
+        when '.csv' then 'csv'
+        when '.tsv' then 'tsv'
+        when '.json' then 'json'
+        when '.jsonl' then 'jsonl'
+        else 'csv'
+        end
+      end
+      
+      case parser
+      when 'csv'
+        parse_csv_file(file_path)
+      when 'tsv'
+        parse_tsv_file(file_path)
+      when 'json'
+        parse_json_file(file_path)
+      when 'jsonl'
+        parse_jsonl_file(file_path)
+      else
+        { records: [], columns: [] }
+      end
+    rescue => e
+      { records: [], columns: [] }
+    end
+    
+    def parse_csv_file(file_path)
+      data = CSV.read(file_path, headers: true)
+      columns = data.headers.map { |header| { field: header, header: header } }
+      records = data.map(&:to_h)
+      { records: records, columns: columns }
+    end
+    
+    def parse_tsv_file(file_path)
+      data = CSV.read(file_path, headers: true, col_sep: "\t")
+      columns = data.headers.map { |header| { field: header, header: header } }
+      records = data.map(&:to_h)
+      { records: records, columns: columns }
+    end
+    
+    def parse_json_file(file_path)
+      content = File.read(file_path)
+      records = JSON.parse(content)
+      
+      # Extract columns from first record if it's an array of objects
+      columns = if records.is_a?(Array) && !records.empty? && records.first.is_a?(Hash)
+        records.first.keys.map { |key| { field: key, header: key } }
+      else
+        []
+      end
+      
+      { records: records.is_a?(Array) ? records : [records], columns: columns }
+    end
+    
+    def parse_jsonl_file(file_path)
+      records = []
+      File.readlines(file_path).each do |line|
+        records << JSON.parse(line.strip) unless line.strip.empty?
+      end
+      
+      # Extract columns from first record
+      columns = if !records.empty? && records.first.is_a?(Hash)
+        records.first.keys.map { |key| { field: key, header: key } }
+      else
+        []
+      end
+      
+      { records: records, columns: columns }
+    end
+    
+    def parse_records_attribute(records_attr)
+      # Handle string records (JSON) or already parsed arrays
+      records = if records_attr.is_a?(String)
+        JSON.parse(records_attr)
+      else
+        records_attr
+      end
+      
+      columns = if records.is_a?(Array) && !records.empty? && records.first.is_a?(Hash)
+        records.first.keys.map { |key| { field: key, header: key } }
+      else
+        []
+      end
+      
+      { records: records.is_a?(Array) ? records : [records], columns: columns }
+    end
+    
+    def apply_selection(data, selected_columns, selected_records, max_records, max_columns)
+      records = data[:records]
+      columns = data[:columns]
+      
+      # Apply column selection
+      if selected_columns && columns
+        if selected_columns.is_a?(Array)
+          # Array of column names
+          new_columns = selected_columns.map do |col_name|
+            columns.find { |col| col[:field] == col_name } || { field: col_name, header: col_name }
+          end
+          columns = new_columns
+          records = records.map do |record|
+            selected_columns.each_with_object({}) { |col, new_record| new_record[col] = record[col] }
+          end
+        elsif selected_columns.is_a?(String) && selected_columns.include?(':')
+          # Python-style slice
+          start_idx, end_idx = parse_slice(selected_columns, columns.length)
+          columns = columns[start_idx...end_idx]
+          column_fields = columns.map { |col| col[:field] }
+          records = records.map do |record|
+            column_fields.each_with_object({}) { |field, new_record| new_record[field] = record[field] }
+          end
+        end
+      end
+      
+      # Apply record selection
+      if selected_records
+        if selected_records.is_a?(Array)
+          records = selected_records.map { |idx| records[idx] }.compact
+        elsif selected_records.is_a?(String) && selected_records.include?(':')
+          start_idx, end_idx = parse_slice(selected_records, records.length)
+          records = records[start_idx...end_idx]
+        end
+      end
+      
+      # Apply max records
+      if max_records && records.length > max_records
+        # Show top half and bottom half with ellipsis
+        top_rows = (max_records / 2.0).ceil
+        bottom_rows = max_records - top_rows
+        ellipsis_record = columns.each_with_object({}) { |col, record| record[col[:field]] = '...' }
+        records = records[0...top_rows] + [ellipsis_record] + records[-bottom_rows..-1]
+      end
+      
+      # Apply max columns
+      if max_columns && columns && columns.length > max_columns
+        columns = columns[0...max_columns]
+        column_fields = columns.map { |col| col[:field] }
+        records = records.map do |record|
+          column_fields.each_with_object({}) { |field, new_record| new_record[field] = record[field] }
+        end
+      end
+      
+      { records: records, columns: columns }
+    end
+    
+    def parse_slice(slice_str, total_length)
+      # Parse Python-style slice notation like "1:3"
+      parts = slice_str.split(':')
+      start_idx = parts[0].to_i
+      end_idx = parts[1] ? parts[1].to_i : total_length
+      [start_idx, end_idx]
+    end
+    
+    def render_table_markdown(data)
+      records = data[:records]
+      columns = data[:columns]
+      
+      return '' if records.empty?
+      
+      # If no columns specified, infer from first record
+      if columns.empty? && records.first.is_a?(Hash)
+        columns = records.first.keys.map { |key| { field: key, header: key } }
+      end
+      
+      return '' if columns.empty?
+      
+      # Build markdown table
+      result = []
+      
+      # Header row
+      headers = columns.map { |col| col[:header] || col[:field] }
+      result << "| #{headers.join(' | ')} |"
+      
+      # Separator row
+      result << "| #{headers.map { '---' }.join(' | ')} |"
+      
+      # Data rows
+      records.each do |record|
+        row_values = columns.map do |col|
+          value = record[col[:field]]
+          value.nil? ? '' : value.to_s
+        end
+        result << "| #{row_values.join(' | ')} |"
+      end
+      
+      result.join("\n")
+    end
+    
+    def render_table_raw(data, syntax)
+      records = data[:records]
+      columns = data[:columns]
+      
+      return '' if records.empty?
+      
+      # If no columns specified, infer from first record
+      if columns.empty? && records.first.is_a?(Hash)
+        columns = records.first.keys.map { |key| { field: key, header: key } }
+      end
+      
+      return '' if columns.empty?
+      
+      # Determine separator
+      separator = syntax == 'tsv' ? "\t" : ","
+      
+      # Build raw table
+      result = []
+      
+      # Header row
+      headers = columns.map { |col| col[:header] || col[:field] }
+      result << headers.join(separator)
+      
+      # Data rows
+      records.each do |record|
+        row_values = columns.map do |col|
+          value = record[col[:field]]
+          value.nil? ? '' : value.to_s
+        end
+        result << row_values.join(separator)
+      end
+      
+      result.join("\n")
+    end
+    
+    def render_table_xml(data)
+      records = data[:records]
+      columns = data[:columns]
+      
+      return '' if records.empty?
+      
+      # If no columns specified, infer from first record
+      if columns.empty? && records.first.is_a?(Hash)
+        columns = records.first.keys.map { |key| { field: key, header: key } }
+      end
+      
+      return '' if columns.empty?
+      
+      # Build XML table structure
+      result = []
+      result << '<table>'
+      result << '  <thead>'
+      result << '    <trow>'
+      columns.each do |col|
+        result << "      <tcell>#{escape_xml(col[:header] || col[:field])}</tcell>"
+      end
+      result << '    </trow>'
+      result << '  </thead>'
+      result << '  <tbody>'
+      
+      records.each do |record|
+        result << '    <trow>'
+        columns.each do |col|
+          value = record[col[:field]]
+          result << "      <tcell>#{escape_xml(value.nil? ? '' : value.to_s)}</tcell>"
+        end
+        result << '    </trow>'
+      end
+      
+      result << '  </tbody>'
+      result << '</table>'
+      
+      result.join("\n")
+    end
+    
+    def escape_xml(text)
+      text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+    end
+  end
+
+  # Image component
+  class ImageComponent < Component
+    def render
+      apply_stylesheet
+      
+      src = get_attribute('src')
+      alt = get_attribute('alt', '')
+      syntax = get_attribute('syntax', 'text')
+
+      if syntax == 'multimedia'
+        "[Image: #{src}]#{alt.empty? ? '' : " (#{alt})"}"
+      else
+        alt.empty? ? "[Image: #{src}]" : alt
+      end
+    end
+  end
+end

data/lib/poml/components/examples.rb

@@ -0,0 +1,55 @@
+module Poml
+  # Example component
+  class ExampleComponent < Component
+    def render
+      apply_stylesheet
+      
+      content = @element.content.empty? ? render_children : @element.content
+      "#{content}\n\n"
+    end
+  end
+
+  # Input component (for examples)
+  class InputComponent < Component
+    def render
+      apply_stylesheet
+      
+      content = @element.content.empty? ? render_children : @element.content
+      "#{content}\n\n"
+    end
+  end
+
+  # Output component (for examples)
+  class OutputComponent < Component
+    def render
+      apply_stylesheet
+      
+      content = @element.content.empty? ? render_children : @element.content
+      "#{content}\n\n"
+    end
+  end
+
+  # Output format component
+  class OutputFormatComponent < Component
+    def render
+      apply_stylesheet
+      
+      caption = get_attribute('caption', 'Output Format')
+      caption_style = get_attribute('captionStyle', 'header')
+      content = @element.content.empty? ? render_children : @element.content
+
+      case caption_style
+      when 'header'
+        "# #{caption}\n\n#{content}\n\n"
+      when 'bold'
+        "**#{caption}:** #{content}\n\n"
+      when 'plain'
+        "#{caption}: #{content}\n\n"
+      when 'hidden'
+        "#{content}\n\n"
+      else
+        "# #{caption}\n\n#{content}\n\n"
+      end
+    end
+  end
+end

data/lib/poml/components/instructions.rb

@@ -0,0 +1,93 @@
+module Poml
+  # Role component
+  class RoleComponent < Component
+    def render
+      apply_stylesheet
+      
+      content = @element.content.empty? ? render_children : @element.content
+
+      if xml_mode?
+        render_as_xml('role', content)
+      else
+        caption = apply_text_transform(get_attribute('caption', 'Role'))
+        caption_style = get_attribute('captionStyle', 'header')
+
+        case caption_style
+        when 'header'
+          "# #{caption}\n\n#{content}\n\n"
+        when 'bold'
+          "**#{caption}:** #{content}\n\n"
+        when 'plain'
+          "#{caption}: #{content}\n\n"
+        when 'hidden'
+          "#{content}\n\n"
+        else
+          "# #{caption}\n\n#{content}\n\n"
+        end
+      end
+    end
+  end
+
+  # Task component
+  class TaskComponent < Component
+    def render
+      apply_stylesheet
+      
+      # For mixed content (text + elements), preserve spacing
+      content = if @element.children.empty?
+        @element.content.strip
+      else
+        # Don't strip when there are children to preserve spacing between text and elements
+        render_children
+      end
+
+      if xml_mode?
+        render_as_xml('task', content)
+      else
+        caption = apply_text_transform(get_attribute('caption', 'Task'))
+        caption_style = get_attribute('captionStyle', 'header')
+
+        case caption_style
+        when 'header'
+          # Don't add extra newlines if content already ends with newlines
+          content_ending = content.end_with?("\n\n") ? "" : "\n\n"
+          "# #{caption}\n\n#{content}#{content_ending}"
+        when 'bold'
+          "**#{caption}:** #{content}\n\n"
+        when 'plain'
+          "#{caption}: #{content}\n\n"
+        when 'hidden'
+          content_ending = content.end_with?("\n\n") ? "" : "\n\n"
+          "#{content}#{content_ending}"
+        else
+          content_ending = content.end_with?("\n\n") ? "" : "\n\n"
+          "# #{caption}\n\n#{content}#{content_ending}"
+        end
+      end
+    end
+  end
+
+  # Hint component
+  class HintComponent < Component
+    def render
+      apply_stylesheet
+      
+      caption = get_attribute('caption', 'Hint')
+      caption_style = get_attribute('captionStyle', 'header')
+      content = @element.content.empty? ? render_children : @element.content
+
+      case caption_style
+      when 'header'
+        "# #{caption}\n\n#{content}\n\n"
+      when 'bold'
+        "**#{caption}:** #{content}\n\n"
+      when 'plain'
+        "#{caption}: #{content}\n\n"
+      when 'hidden'
+        "#{content}\n\n"
+      else
+        "# #{caption}\n\n#{content}\n\n"
+      end
+    end
+  end
+end

data/lib/poml/components/layout.rb

@@ -0,0 +1,50 @@
+module Poml
+  # CP component (custom component with caption)
+  class CPComponent < Component
+    def render
+      apply_stylesheet
+      
+      caption = get_attribute('caption', '')
+      caption_serialized = get_attribute('captionSerialized', caption)
+      
+      # Render children with increased header level for nested CPs
+      content = if @element.content.empty?
+        @context.with_increased_header_level { render_children }
+      else
+        @element.content
+      end
+
+      if xml_mode?
+        # Use captionSerialized for XML tag name, fallback to caption
+        tag_name = caption_serialized.empty? ? caption : caption_serialized
+        return render_as_xml(tag_name, content) unless tag_name.empty?
+        # If no caption, just return content
+        return "#{content}\n\n"
+      else
+        caption_style = get_attribute('captionStyle', 'header')
+        # Use captionSerialized for the actual header if provided
+        display_caption = caption_serialized.empty? ? caption : caption_serialized
+        
+        # Apply stylesheet text transformation
+        display_caption = apply_text_transform(display_caption)
+        
+        return content + "\n\n" if display_caption.empty?
+
+        case caption_style
+        when 'header'
+          header_prefix = '#' * @context.header_level
+          "#{header_prefix} #{display_caption}\n\n#{content}\n\n"
+        when 'bold'
+          "**#{display_caption}:** #{content}\n\n"
+        when 'plain'
+          "#{display_caption}: #{content}\n\n"
+        when 'hidden'
+          "#{content}\n\n"
+        else
+          header_prefix = '#' * @context.header_level
+          "#{header_prefix} #{display_caption}\n\n#{content}\n\n"
+        end
+      end
+    end
+  end
+end