poml 0.0.6 → 0.0.8

data/lib/poml/components/data.rb

@@ -9,6 +9,7 @@ module Poml
       
       src = get_attribute('src')
       records_attr = get_attribute('records')
+      data_attr = get_attribute('data')  # Support 'data' attribute as alias for 'records'
       _columns_attr = get_attribute('columns')  # Not used but may be needed for future features
       parser = get_attribute('parser', 'auto')
       syntax = get_attribute('syntax')
@@ -22,9 +23,43 @@ module Poml
         load_table_data(src, parser)
       elsif records_attr
         parse_records_attribute(records_attr)
-      elsif @element.children.any? { |child| child.tag_name == :tr }
+      elsif data_attr
+        parse_records_attribute(data_attr)
+      elsif @element.children.any? { |child| child.tag_name == :tr || child.tag_name == :thead || child.tag_name == :tbody || child.tag_name == :tfoot }
         # Handle HTML-style table markup
-        parse_html_table_children
+        
+        # Check if any children contain for loops - if so, use normal rendering
+        has_for_loops = @element.children.any? { |child| contains_for_loops?(child) }
+        
+        if has_for_loops
+          # When for loops are present, use normal child rendering instead of table parsing
+          # This allows for loops to be processed normally
+          # Set output format to HTML temporarily so tr/td elements render as HTML
+          original_format = @context.output_format
+          @context.output_format = 'html'
+          
+          children_content = render_children
+          
+          # Restore original format
+          @context.output_format = original_format
+          
+          # For raw format, convert HTML table to markdown table
+          if original_format == 'raw'
+            return convert_html_table_to_markdown(children_content)
+          else
+            return children_content
+          end
+        elsif @context.output_format == 'html' || xml_mode?
+          # In HTML or XML mode, render children directly to preserve nested components
+          children_content = render_children
+          if xml_mode?
+            return "<table>\n#{children_content}</table>\n"
+          else
+            return children_content
+          end
+        else
+          parse_html_table_children
+        end
       else
         { records: [], columns: [] }
       end
@@ -32,14 +67,23 @@ module Poml
       # 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'
+      # Check syntax preference and output format
+      result = if syntax == 'tsv' || syntax == 'csv'
         render_table_raw(data, syntax)
       elsif xml_mode?
         render_table_xml(data)
+      elsif @context.output_format == 'html'
+        render_table_html(data)
       else
         render_table_markdown(data)
       end
+      
+      # Apply inline rendering if requested
+      if inline? && !xml_mode?
+        result.strip
+      else
+        result
+      end
     end
     
     private
@@ -104,7 +148,7 @@ module Poml
     end
     
     def parse_json_file(file_path)
-      content = File.read(file_path)
+      content = read_file_with_encoding(file_path)
       records = JSON.parse(content)
       
       # Extract columns from first record if it's an array of objects
@@ -119,7 +163,7 @@ module Poml
     
     def parse_jsonl_file(file_path)
       records = []
-      File.readlines(file_path).each do |line|
+      read_file_lines_with_encoding(file_path).each do |line|
         records << JSON.parse(line.strip) unless line.strip.empty?
       end
       
@@ -191,12 +235,10 @@ module Poml
       records = []
       columns = []
       
-      # Extract rows from tr children
-      @element.children.each do |child|
-        next unless child.tag_name == :tr
-        
+      # Extract rows from tr children (including nested in thead/tbody)
+      find_tr_elements(@element).each do |tr_element|
         row_data = {}
-        child.children.each_with_index do |cell, index|
+        tr_element.children.each_with_index do |cell, index|
           next unless cell.tag_name == :td || cell.tag_name == :th
           
           # Get cell content (render children to get text)
@@ -220,6 +262,68 @@ module Poml
       { records: records, columns: columns }
     end
     
+    def find_tr_elements(element)
+      tr_elements = []
+      
+      element.children.each do |child|
+        if child.tag_name == :tr
+          tr_elements << child
+        elsif child.tag_name == :thead || child.tag_name == :tbody || child.tag_name == :tfoot
+          # Recursively find tr elements in table sections
+          tr_elements.concat(find_tr_elements(child))
+        end
+      end
+      
+      tr_elements
+    end
+    
+    def contains_for_loops?(element)
+      # Check if this element or any of its children contain for loops
+      return true if element.tag_name == :for
+      
+      element.children.any? { |child| contains_for_loops?(child) }
+    end
+    
+    def convert_html_table_to_markdown(html_content)
+      # Simple HTML table to markdown conversion
+      # This is a basic implementation - can be enhanced as needed
+      
+      # Extract table rows from HTML
+      rows = []
+      html_content.scan(/<tr[^>]*>(.*?)<\/tr>/m) do |row_match|
+        row_content = row_match[0]
+        cells = []
+        row_content.scan(/<t[hd][^>]*>(.*?)<\/t[hd]>/m) do |cell_match|
+          cell_text = cell_match[0].strip
+          # Remove HTML tags from cell content
+          cell_text = cell_text.gsub(/<[^>]+>/, '')
+          cells << cell_text
+        end
+        rows << cells unless cells.empty?
+      end
+      
+      return '' if rows.empty?
+      
+      # Convert to markdown table
+      if rows.length == 1
+        # Only data rows, create a simple header
+        header_row = rows[0].map.with_index { |_, i| "Column #{i + 1}" }
+        rows.unshift(header_row)
+      end
+      
+      # Build markdown table
+      result = []
+      rows.each_with_index do |row, index|
+        result << "| #{row.join(' | ')} |"
+        if index == 0
+          # Add separator row after header
+          result << "| #{row.map { '---' }.join(' | ')} |"
+        end
+      end
+      
+      result.join("\n")
+    end
+    
     def apply_selection(data, selected_columns, selected_records, max_records, max_columns)
       records = data[:records]
       columns = data[:columns]
@@ -400,6 +504,50 @@ module Poml
     def escape_xml(text)
       text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
     end
+    
+    def render_table_html(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 HTML table structure
+      result = []
+      result << '<table>'
+      result << '  <thead>'
+      result << '    <tr>'
+      columns.each do |col|
+        result << "      <th>#{escape_html(col[:header] || col[:field])}</th>"
+      end
+      result << '    </tr>'
+      result << '  </thead>'
+      result << '  <tbody>'
+      
+      records.each do |record|
+        result << '    <tr>'
+        columns.each do |col|
+          value = record[col[:field]]
+          result << "      <td>#{escape_html(value.nil? ? '' : value.to_s)}</td>"
+        end
+        result << '    </tr>'
+      end
+      
+      result << '  </tbody>'
+      result << '</table>'
+      
+      result.join("\n")
+    end
+    
+    def escape_html(text)
+      text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+    end
   end
 
   # Object component for displaying structured data
@@ -410,15 +558,27 @@ module Poml
     def render
       apply_stylesheet
       
-      data = get_attribute('data')
+      data_attr = get_attribute('data')
       syntax = get_attribute('syntax', 'json')
       
-      return '' unless data
+      return '' unless data_attr
+      
+      # Parse data if it's a JSON string
+      data = if data_attr.is_a?(String) && data_attr.start_with?('{', '[')
+        begin
+          JSON.parse(data_attr)
+        rescue JSON::ParserError
+          data_attr  # Use as-is if parsing fails
+        end
+      else
+        data_attr
+      end
       
       if xml_mode?
         render_as_xml('obj', serialize_data(data, syntax))
       else
-        serialize_data(data, syntax)
+        result = serialize_data(data, syntax)
+        inline? ? result.strip : result
       end
     end
     
@@ -543,7 +703,7 @@ module Poml
           return "[Webpage: File not found: #{file_path}]"
         end
         
-        html_content = File.read(full_path)
+        html_content = read_file_with_encoding(full_path)
         process_html_content(html_content, selector, extract_text)
       rescue => e
         "[Webpage: Error reading file #{file_path}: #{e.message}]"
@@ -631,13 +791,373 @@ module Poml
       apply_stylesheet
       
       src = get_attribute('src')
+      base64 = get_attribute('base64')
       alt = get_attribute('alt', '')
-      syntax = get_attribute('syntax', 'text')
+      syntax = get_attribute('syntax', 'multimedia')
+      max_width = get_attribute('maxWidth')
+      max_height = get_attribute('maxHeight')
+      resize = get_attribute('resize')
+      image_type = get_attribute('type')
+      position = get_attribute('position', 'here')
+
+      # Handle missing src and base64
+      unless src || base64
+        return handle_error("no src or base64 specified")
+      end
+
+      begin
+        # Process the image
+        if src
+          if url?(src)
+            content = fetch_image_from_url(src, max_width, max_height, resize, image_type)
+          else
+            content = read_local_image(src, max_width, max_height, resize, image_type)
+          end
+        elsif base64
+          content = process_base64_image(base64, max_width, max_height, resize, image_type)
+        end
+
+        # Render based on syntax and XML mode
+        if xml_mode?
+          attributes = {}
+          attributes[:src] = src if src
+          attributes[:base64] = base64 if base64
+          attributes[:alt] = alt unless alt.empty?
+          attributes[:type] = image_type if image_type
+          attributes[:position] = position
+          render_as_xml('img', content || '', attributes)
+        else
+          if syntax == 'multimedia'
+            # Show image reference with content info
+            image_ref = src || '[embedded image]'
+            result = "[Image: #{image_ref}]"
+            result += " (#{alt})" unless alt.empty?
+            result += "\n#{content}" if content && content.is_a?(String) && content.start_with?('data:')
+            result
+          else
+            # Text mode - show alt text or simple reference
+            alt.empty? ? "[Image: #{src || 'embedded'}]" : alt
+          end
+        end
+      rescue => e
+        handle_error("error processing image: #{e.message}")
+      end
+    end
+
+    private
+
+    def url?(src)
+      src && src.match?(/^https?:\/\//i)
+    end
+
+    def fetch_image_from_url(url, max_width = nil, max_height = nil, resize = nil, image_type = nil)
+      require 'net/http'
+      require 'uri'
+      require 'base64'
+
+      uri = URI.parse(url)
+      
+      # Configure HTTP client
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.scheme == 'https'
+      http.read_timeout = 10
+      http.open_timeout = 5
+
+      # Create request with appropriate headers
+      request = Net::HTTP::Get.new(uri.request_uri)
+      request['User-Agent'] = 'POML Ruby/1.0'
+      request['Accept'] = 'image/*'
+
+      # Fetch the image
+      response = http.request(request)
+
+      unless response.code == '200'
+        raise "HTTP #{response.code}: #{response.message}"
+      end
+
+      # Process the image data
+      image_data = response.body
+      content_type = response['content-type'] || detect_image_type(image_data)
+      
+      # Apply processing if requested
+      if max_width || max_height || resize || image_type
+        image_data = process_image_data(image_data, content_type, max_width, max_height, resize, image_type)
+      end
+
+      # Return base64 encoded data URL
+      base64_data = Base64.strict_encode64(image_data)
+      mime_type = image_type ? "image/#{image_type}" : content_type
+      "data:#{mime_type};base64,#{base64_data}"
+    rescue => e
+      raise "Failed to fetch image from URL #{url}: #{e.message}"
+    end
+
+    def read_local_image(file_path, max_width = nil, max_height = nil, resize = nil, image_type = nil)
+      require 'base64'
+
+      # Resolve file path
+      full_path = if file_path.start_with?('/')
+        file_path
+      else
+        base_path = @context.source_path ? File.dirname(@context.source_path) : Dir.pwd
+        File.join(base_path, file_path)
+      end
+
+      unless File.exist?(full_path)
+        raise "File not found: #{file_path}"
+      end
+
+      # Read image data
+      image_data = File.read(full_path, mode: 'rb')
+      content_type = detect_image_type_from_extension(full_path) || detect_image_type(image_data)
+
+      # Apply processing if requested
+      if max_width || max_height || resize || image_type
+        image_data = process_image_data(image_data, content_type, max_width, max_height, resize, image_type)
+      end
+
+      # Return base64 encoded data URL
+      base64_data = Base64.strict_encode64(image_data)
+      mime_type = image_type ? "image/#{image_type}" : content_type
+      "data:#{mime_type};base64,#{base64_data}"
+    rescue => e
+      raise "Failed to read local image #{file_path}: #{e.message}"
+    end
+
+    def process_base64_image(base64_data, max_width = nil, max_height = nil, resize = nil, image_type = nil)
+      require 'base64'
+
+      # Decode base64 data
+      image_data = Base64.decode64(base64_data)
+      content_type = detect_image_type(image_data)
+
+      # Apply processing if requested
+      if max_width || max_height || resize || image_type
+        image_data = process_image_data(image_data, content_type, max_width, max_height, resize, image_type)
+      end
+
+      # Return base64 encoded data URL
+      processed_base64 = Base64.strict_encode64(image_data)
+      mime_type = image_type ? "image/#{image_type}" : content_type
+      "data:#{mime_type};base64,#{processed_base64}"
+    rescue => e
+      raise "Failed to process base64 image: #{e.message}"
+    end
+
+    def detect_image_type_from_extension(file_path)
+      ext = File.extname(file_path).downcase
+      case ext
+      when '.jpg', '.jpeg' then 'image/jpeg'
+      when '.png' then 'image/png'
+      when '.gif' then 'image/gif'
+      when '.webp' then 'image/webp'
+      when '.svg' then 'image/svg+xml'
+      when '.bmp' then 'image/bmp'
+      when '.tiff', '.tif' then 'image/tiff'
+      else nil
+      end
+    end
+
+    def detect_image_type(image_data)
+      # Check magic bytes to detect image type
+      return 'image/jpeg' if image_data[0..1] == "\xFF\xD8".b
+      return 'image/png' if image_data[0..7] == "\x89PNG\r\n\x1A\n".b
+      return 'image/gif' if image_data[0..5] == "GIF87a".b || image_data[0..5] == "GIF89a".b
+      return 'image/webp' if image_data[0..3] == "RIFF".b && image_data[8..11] == "WEBP".b
+      return 'image/bmp' if image_data[0..1] == "BM".b
+      return 'image/svg+xml' if image_data.include?('<svg')
+      
+      # Default fallback
+      'image/octet-stream'
+    end
+
+    def process_image_data(image_data, content_type, max_width, max_height, resize, new_type)
+      begin
+        require 'vips'
+      rescue LoadError
+        # Fallback to basic implementation if vips is not available
+        warn "Warning: ruby-vips gem not found. Image processing features are limited. Install ruby-vips gem for full image processing support."
+        return image_data
+      end
+
+      begin
+        # Load image from memory
+        image = Vips::Image.new_from_buffer(image_data, "")
+        
+        # Apply resizing if requested
+        if max_width || max_height || resize
+          image = resize_image(image, max_width, max_height, resize)
+        end
 
-      if syntax == 'multimedia'
-        "[Image: #{src}]#{alt.empty? ? '' : " (#{alt})"}"
+        # Convert format if requested
+        if new_type && !content_type.include?(new_type)
+          # Map new_type to vips format
+          format_suffix = case new_type.downcase
+                         when 'jpeg', 'jpg' then '.jpg'
+                         when 'png' then '.png'
+                         when 'webp' then '.webp'
+                         when 'tiff', 'tif' then '.tiff'
+                         when 'gif' then '.gif'
+                         else '.jpg' # default fallback
+                         end
+          
+          # Convert image to new format
+          image = convert_image_format(image, format_suffix)
+        end
+
+        # Write image back to buffer
+        image.write_to_buffer(get_vips_format_string(new_type || extract_format_from_content_type(content_type)))
+      rescue => e
+        warn "Warning: Image processing failed (#{e.message}). Returning original image data."
+        image_data
+      end
+    end
+
+    private
+
+    def resize_image(image, max_width, max_height, resize_mode)
+      current_width = image.width
+      current_height = image.height
+
+      # Convert parameters to integers if they are strings
+      max_width = max_width.to_i if max_width && max_width != 0
+      max_height = max_height.to_i if max_height && max_height != 0
+
+      # Determine target dimensions
+      if resize_mode == 'fit'
+        # Fit within bounds while preserving aspect ratio
+        if max_width && max_height
+          scale_x = max_width.to_f / current_width
+          scale_y = max_height.to_f / current_height
+          scale = [scale_x, scale_y].min
+          
+          if scale < 1.0 # Only resize if image is larger than target
+            image = image.resize(scale)
+          end
+        elsif max_width
+          scale = max_width.to_f / current_width
+          if scale < 1.0
+            image = image.resize(scale)
+          end
+        elsif max_height
+          scale = max_height.to_f / current_height
+          if scale < 1.0
+            image = image.resize(scale)
+          end
+        end
+      elsif resize_mode == 'fill'
+        # Fill the entire area, potentially cropping
+        if max_width && max_height
+          scale_x = max_width.to_f / current_width
+          scale_y = max_height.to_f / current_height
+          scale = [scale_x, scale_y].max
+          
+          # Resize to fill
+          image = image.resize(scale)
+          
+          # Crop to exact dimensions if needed
+          if image.width > max_width || image.height > max_height
+            left = [(image.width - max_width) / 2, 0].max
+            top = [(image.height - max_height) / 2, 0].max
+            image = image.crop(left, top, max_width, max_height)
+          end
+        end
+      elsif resize_mode == 'stretch'
+        # Stretch to exact dimensions (may distort aspect ratio)
+        if max_width && max_height
+          scale_x = max_width.to_f / current_width
+          scale_y = max_height.to_f / current_height
+          image = image.resize(scale_x, vscale: scale_y)
+        end
+      else
+        # Default behavior: fit within bounds
+        if max_width && current_width > max_width
+          scale = max_width.to_f / current_width
+          image = image.resize(scale)
+        end
+        if max_height && image.height > max_height
+          scale = max_height.to_f / image.height
+          image = image.resize(scale)
+        end
+      end
+
+      image
+    end
+
+    def convert_image_format(image, format_suffix)
+      case format_suffix.downcase
+      when '.jpg', '.jpeg'
+        # For JPEG, ensure RGB colorspace and add quality setting
+        image = image.colourspace(:srgb) if image.bands >= 3
+        image
+      when '.png'
+        # PNG supports transparency, no special handling needed
+        image
+      when '.webp'
+        # WebP format, good compression
+        image
+      when '.tiff'
+        # TIFF format
+        image
+      when '.gif'
+        # For GIF, we may need to handle transparency and color reduction
+        # Note: libvips has limited GIF write support, might need special handling
+        image
+      else
+        image
+      end
+    end
+
+    def get_vips_format_string(image_type)
+      case image_type&.downcase
+      when 'jpeg', 'jpg'
+        '.jpg[Q=85]' # JPEG with 85% quality
+      when 'png'
+        '.png'
+      when 'webp'
+        '.webp'
+      when 'tiff', 'tif'
+        '.tiff'
+      when 'gif'
+        '.gif'
+      else
+        '.jpg[Q=85]' # Default to JPEG
+      end
+    end
+
+    def extract_format_from_content_type(content_type)
+      return nil unless content_type&.start_with?('image/')
+      
+      format = content_type.split('/').last
+      case format
+      when 'jpeg' then 'jpg'
+      else format
+      end
+    end
+
+    public
+
+    def process_image_data_old(image_data, content_type, max_width, max_height, resize, new_type)
+      # Note: This is a basic implementation that doesn't actually resize images
+      # For full image processing, consider using mini_magick or image_processing gems
+      
+      # If type conversion is requested and it's different from current type
+      if new_type && !content_type.include?(new_type)
+        # For now, we'll just change the MIME type
+        # Real implementation would use an image processing library
+        # Note: Basic image format conversion available. Install mini_magick gem for enhanced image processing support.
+      end
+
+      # Legacy implementation - kept for compatibility
+      # Use process_image_data method above for full image processing with libvips
+      image_data
+    end
+
+    def handle_error(message)
+      if xml_mode?
+        render_as_xml('img', "[Error: #{message}]")
       else
-        alt.empty? ? "[Image: #{src}]" : alt
+        "[Image Error: #{message}]"
       end
     end
   end