poml 0.0.6 → 0.0.7

data/lib/poml/components/base.rb

@@ -40,13 +40,44 @@ module Poml
       end
     end
 
+    def inline?
+      # Check if component should render inline
+      get_attribute('inline', false) == true || get_attribute('inline') == 'true'
+    end
+
+    def render_with_inline_support(content)
+      # Render content with inline vs block consideration
+      if inline?
+        render_inline(content)
+      else
+        render_block(content)
+      end
+    end
+
+    def render_inline(content)
+      # Inline rendering - no extra whitespace or newlines
+      content.to_s.strip
+    end
+
+    def render_block(content)
+      # Block rendering - traditional with proper spacing
+      content.to_s.rstrip + "\n\n"
+    end
+
     def render_as_xml(tag_name, content = nil, attributes = {})
       # Render as XML element with proper formatting
       content ||= render_children
       attrs_str = attributes.map { |k, v| " #{k}=\"#{v}\"" }.join('')
       
+      # Check if this is an inline component that shouldn't have trailing newlines
+      is_inline_component = is_inline_component_name?(self.class.name.split('::').last)
+      
       if content.strip.empty?
-        "<#{tag_name}#{attrs_str}/>\n"
+        if is_inline_component
+          "<#{tag_name}#{attrs_str}/>"
+        else
+          "<#{tag_name}#{attrs_str}/>\n"
+        end
       else
         # Add line breaks for nice formatting
         if content.include?('<item>')
@@ -57,11 +88,60 @@ module Poml
           "<#{tag_name}#{attrs_str}>\n  #{indented_content}\n</#{tag_name}>\n"
         else
           # Simple content
-          "<#{tag_name}#{attrs_str}>#{content}</#{tag_name}>\n"
+          if is_inline_component
+            "<#{tag_name}#{attrs_str}>#{content}</#{tag_name}>"
+          else
+            "<#{tag_name}#{attrs_str}>#{content}</#{tag_name}>\n"
+          end
         end
       end
     end
 
+    # Helper method for robust file reading with encoding support
+    def read_file_with_encoding(file_path, encoding: 'utf-8')
+      # Normalize file path for cross-platform compatibility
+      normalized_path = File.expand_path(file_path)
+      
+      # Try primary encoding first (UTF-8)
+      begin
+        return File.read(normalized_path, encoding: encoding)
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
+        # If UTF-8 fails, try with binary mode and force encoding
+        begin
+          content = File.read(normalized_path, mode: 'rb')
+          # Try to detect and convert encoding
+          return content.force_encoding('utf-8').encode('utf-8', invalid: :replace, undef: :replace)
+        rescue => encoding_error
+          # If all else fails, read as binary and provide meaningful error
+          raise "File encoding error for #{file_path}: #{e.message}. Original encoding detection failed: #{encoding_error.message}"
+        end
+      rescue => e
+        # Re-raise other file reading errors with context
+        raise "Error reading file #{file_path}: #{e.message}"
+      end
+    end
+
+    # Helper method for reading file lines with encoding support
+    def read_file_lines_with_encoding(file_path, encoding: 'utf-8')
+      # Normalize file path for cross-platform compatibility
+      normalized_path = File.expand_path(file_path)
+      
+      begin
+        return File.readlines(normalized_path, encoding: encoding)
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
+        # If UTF-8 fails, try with binary mode and force encoding line by line
+        begin
+          content = File.read(normalized_path, mode: 'rb')
+          lines = content.force_encoding('utf-8').encode('utf-8', invalid: :replace, undef: :replace).lines
+          return lines
+        rescue => encoding_error
+          raise "File encoding error for #{file_path}: #{e.message}. Original encoding detection failed: #{encoding_error.message}"
+        end
+      rescue => e
+        raise "Error reading file #{file_path}: #{e.message}"
+      end
+    end
+
     def get_attribute(name, default = nil)
       value = @element.attributes[name.to_s.downcase]
       case value
@@ -131,6 +211,15 @@ module Poml
       # Override this in inline components
       false
     end
+
+    def unescape_xml_entities(text)
+      # Unescape XML entities that were escaped during preprocessing
+      text.gsub('&amp;', '&')
+          .gsub('&lt;', '<')
+          .gsub('&gt;', '>')
+          .gsub('&quot;', '"')
+          .gsub('&apos;', "'")
+    end
     
     def self.inline_component_classes
       # List of component classes that should be treated as inline
@@ -154,6 +243,16 @@ module Poml
       component_class_name = component_class.name.split('::').last
       inline_component_names.include?(component_class_name)
     end
+    
+    def is_inline_component_name?(component_class_name)
+      # Check if the component class name is registered as inline
+      inline_component_names = %w[
+        BoldComponent ItalicComponent UnderlineComponent StrikethroughComponent 
+        CodeComponent InlineComponent
+      ]
+      
+      inline_component_names.include?(component_class_name)
+    end
   end
 
   # Component registry and factory
@@ -164,12 +263,55 @@ module Poml
     def self.render_element(element, context)
       # Try to find component using multiple key formats for compatibility
       tag_name = element.tag_name
+      
+      # In HTML output format, preserve HTML elements as-is
+      if context.output_format == 'html' && is_html_element?(element)
+        return render_html_element_as_is(element, context)
+      end
+      
       component_class = COMPONENT_MAPPING[tag_name] || 
                        COMPONENT_MAPPING[tag_name.to_s] || 
-                       COMPONENT_MAPPING[tag_name.to_sym] ||
-                       TextComponent
+                       COMPONENT_MAPPING[tag_name.to_sym]
+      
+      # Use UnknownComponent for unrecognized tags (except :text which should use TextComponent)
+      if component_class.nil?
+        component_class = tag_name == :text ? TextComponent : UnknownComponent
+      end
+      
       component = component_class.new(element, context)
       component.render
     end
+    
+    private
+    
+    def self.is_html_element?(element)
+      # Common HTML elements that should be preserved in HTML format
+      html_elements = [:b, :i, :u, :strong, :em, :span, :div, :p, :h1, :h2, :h3, :h4, :h5, :h6, 
+                      :table, :thead, :tbody, :tfoot, :tr, :th, :td, :ul, :ol, :li, :a, :img, :code]
+      
+      return html_elements.include?(element.tag_name)
+    end
+    
+    def self.render_html_element_as_is(element, context)
+      tag_name = element.tag_name.to_s
+      
+      # Build attributes string
+      attr_string = ""
+      if element.attributes && !element.attributes.empty?
+        attr_string = element.attributes.map { |k, v| %{#{k}="#{v}"} }.join(" ")
+        attr_string = " " + attr_string
+      end
+      
+      # Render children
+      children_content = element.children.map { |child| render_element(child, context) }.join('')
+      content = children_content.empty? ? element.content : children_content
+      
+      # Return as HTML element
+      if content.empty?
+        "<#{tag_name}#{attr_string} />"
+      else
+        "<#{tag_name}#{attr_string}>#{content}</#{tag_name}>"
+      end
+    end
   end
 end

data/lib/poml/components/content.rb

@@ -38,7 +38,7 @@ module Poml
         elsif file_path.downcase.end_with?('.docx')
           read_docx_content(file_path)
         else
-          File.read(file_path)
+          read_file_with_encoding(file_path)
         end
       rescue => e
         "[Document: #{@src} (error reading: #{e.message})]"
@@ -149,8 +149,15 @@ module Poml
     def render
       apply_stylesheet
       
-      content = @element.content.empty? ? render_children : @element.content
-      "#{content}\n\n"
+      # If the element has children, render them (for mixed content like text + formatting)
+      # Otherwise, use the element's direct content
+      content = @element.children.empty? ? @element.content : render_children
+      
+      if xml_mode? || @context.output_format == 'html'
+        "<p>#{content}</p>"
+      else
+        render_with_inline_support(content)
+      end
     end
   end
 end