prawn-html 0.1.4 → 0.4.0

data/lib/prawn_html/callbacks/highlight.rb

@@ -11,10 +11,8 @@ module PrawnHtml
       end
 
       def render_behind(fragment)
-        original_color = @pdf.fill_color
-        @pdf.fill_color = @color
-        @pdf.fill_rectangle(fragment.top_left, fragment.width, fragment.height)
-        @pdf.fill_color = original_color
+        top, left = fragment.top_left
+        @pdf.draw_rectangle(x: left, y: top, width: fragment.width, height: fragment.height, color: @color)
       end
     end
   end

data/lib/prawn_html/callbacks/strike_through.rb

@@ -8,10 +8,10 @@ module PrawnHtml
       end
 
       def render_in_front(fragment)
-        y = (fragment.top_left[1] + fragment.bottom_left[1]) / 2
-        @pdf.stroke do
-          @pdf.line [fragment.top_left[0], y], [fragment.top_right[0], y]
-        end
+        x1 = fragment.left
+        x2 = fragment.right
+        y = (fragment.top + fragment.bottom) / 2
+        @pdf.underline(x1: x1, x2: x2, y: y)
       end
     end
   end

data/lib/prawn_html/context.rb

@@ -10,34 +10,50 @@ module PrawnHtml
     def initialize(*_args)
       super
       @last_margin = 0
+      @last_text_node = false
     end
 
-    def before_content
-      return '' if empty?
+    # Add an element to the context
+    #
+    # Set the parent for the previous element in the chain.
+    # Run `on_context_add` callback method on the added element.
+    #
+    # @param element [Tag] the element to add
+    #
+    # @return [Context] the context updated
+    def add(element)
+      element.parent = last
+      push(element)
+      element.on_context_add(self) if element.respond_to?(:on_context_add)
+      self
+    end
 
-      last.options[:before_content].to_s
+    # Evaluate before content
+    #
+    # @return [String] before content string
+    def before_content
+      (last.respond_to?(:before_content) && last.before_content) || ''
     end
 
-    # Merges the context options
+    # Merges the context block styles
     #
-    # @return [Hash] the hash of merged options
-    def merge_options
+    # @return [Hash] the hash of merged styles
+    def block_styles
       each_with_object({}) do |element, res|
-        element.options.each do |key, value|
+        element.block_styles.each do |key, value|
           Attributes.merge_attr!(res, key, value)
         end
       end
     end
 
-    # Merge the context styles
+    # Merge the context styles for text nodes
     #
     # @return [Hash] the hash of merged styles
-    def merge_styles
-      context_styles = each_with_object({}) do |element, res|
+    def text_node_styles
+      each_with_object(base_styles) do |element, res|
         evaluate_element_styles(element, res)
         element.update_styles(res) if element.respond_to?(:update_styles)
       end
-      base_styles.merge(context_styles)
     end
 
     private
@@ -49,7 +65,8 @@ module PrawnHtml
     end
 
     def evaluate_element_styles(element, res)
-      element.styles.each do |key, val|
+      styles = element.styles.slice(*Attributes::STYLES_APPLY[:text_node])
+      styles.each do |key, val|
         if res.include?(key) && res[key].is_a?(Array)
           res[key] += val
         else

data/lib/prawn_html/document_renderer.rb

@@ -4,48 +4,38 @@ module PrawnHtml
   class DocumentRenderer
     NEW_LINE = { text: "\n" }.freeze
     SPACE = { text: ' ' }.freeze
-    TAG_CLASSES = [Tags::A, Tags::B, Tags::Body, Tags::Br, Tags::Del, Tags::Div, Tags::H, Tags::Hr, Tags::I, Tags::Img, Tags::Li, Tags::Mark, Tags::P, Tags::Small, Tags::Span, Tags::U, Tags::Ul].freeze
 
     # Init the DocumentRenderer
     #
-    # @param pdf [Prawn::Document] target Prawn PDF document
+    # @param pdf [PdfWrapper] target PDF wrapper
     def initialize(pdf)
       @buffer = []
       @context = Context.new
-      @doc_styles = {}
       @pdf = pdf
     end
 
-    # Assigns the document styles
-    #
-    # @param styles [Hash] styles hash with CSS selectors as keys and rules as values
-    def assign_document_styles(styles)
-      @doc_styles = styles.transform_values do |style_rules|
-        Attributes.new(style: style_rules).styles
-      end
-    end
-
     # On tag close callback
     #
-    # @param element [Tags::Base] closing element wrapper
+    # @param element [Tag] closing element wrapper
     def on_tag_close(element)
       render_if_needed(element)
-      apply_post_styles(element&.post_styles)
+      apply_tag_close_styles(element)
       context.last_text_node = false
       context.pop
     end
 
     # On tag open callback
     #
-    # @param tag [String] the tag name of the opening element
+    # @param tag_name [String] the tag name of the opening element
     # @param attributes [Hash] an hash of the element attributes
+    # @param element_styles [String] document styles to apply to the element
     #
-    # @return [Tags::Base] the opening element wrapper
-    def on_tag_open(tag, attributes)
-      tag_class = tag_classes[tag]
+    # @return [Tag] the opening element wrapper
+    def on_tag_open(tag_name, attributes:, element_styles: '')
+      tag_class = Tag.class_for(tag_name)
       return unless tag_class
 
-      tag_class.new(tag, attributes).tap do |element|
+      tag_class.new(tag_name, attributes: attributes, element_styles: element_styles).tap do |element|
         setup_element(element)
       end
     end
@@ -58,8 +48,9 @@ module PrawnHtml
     def on_text_node(content)
       return if content.match?(/\A\s*\Z/)
 
-      text = content.gsub(/\A\s*\n\s*|\s*\n\s*\Z/, '').delete("\n").squeeze(' ')
-      buffer << context.merge_styles.merge(text: ::Oga::HTML::Entities.decode(context.before_content) + text)
+      text = ::Oga::HTML::Entities.decode(context.before_content)
+      text += content.gsub(/\A\s*\n\s*|\s*\n\s*\Z/, '').delete("\n").squeeze(' ')
+      buffer << context.text_node_styles.merge(text: text)
       context.last_text_node = true
       nil
     end
@@ -68,8 +59,7 @@ module PrawnHtml
     def render
       return if buffer.empty?
 
-      options = context.merge_options.slice(:align, :leading, :margin_left, :padding_left)
-      output_content(buffer.dup, options)
+      output_content(buffer.dup, context.block_styles)
       buffer.clear
       context.last_margin = 0
     end
@@ -78,19 +68,12 @@ module PrawnHtml
 
     private
 
-    attr_reader :buffer, :context, :doc_styles, :pdf
-
-    def tag_classes
-      @tag_classes ||= TAG_CLASSES.each_with_object({}) do |klass, res|
-        res.merge!(klass.elements)
-      end
-    end
+    attr_reader :buffer, :context, :pdf
 
     def setup_element(element)
       add_space_if_needed unless render_if_needed(element)
-      apply_pre_styles(element)
-      element.apply_doc_styles(doc_styles)
-      context.push(element)
+      apply_tag_open_styles(element)
+      context.add(element)
       element.custom_render(pdf, context) if element.respond_to?(:custom_render)
     end
 
@@ -106,29 +89,41 @@ module PrawnHtml
       true
     end
 
-    def apply_post_styles(styles)
-      context.last_margin = styles[:margin_bottom].to_f
-      return if !styles || styles.empty?
-
-      pdf.move_down(context.last_margin.round(4)) if context.last_margin > 0
-      pdf.move_down(styles[:padding_bottom].round(4)) if styles[:padding_bottom].to_f > 0
+    def apply_tag_close_styles(element)
+      tag_styles = element.tag_close_styles
+      context.last_margin = tag_styles[:margin_bottom].to_f
+      pdf.advance_cursor(context.last_margin + tag_styles[:padding_bottom].to_f)
+      pdf.start_new_page if tag_styles[:break_after]
     end
 
-    def apply_pre_styles(element)
-      pdf.move_down(element.options[:padding_top].round(4)) if element.options.include?(:padding_top)
-      return if !element.pre_styles || element.pre_styles.empty?
+    def apply_tag_open_styles(element)
+      tag_styles = element.tag_open_styles
+      move_down = (tag_styles[:margin_top].to_f - context.last_margin) + tag_styles[:padding_top].to_f
+      pdf.advance_cursor(move_down) if move_down > 0
+      pdf.start_new_page if tag_styles[:break_before]
+    end
 
-      margin = (element.pre_styles[:margin_top] - context.last_margin).round(4)
-      pdf.move_down(margin) if margin > 0
+    def output_content(buffer, block_styles)
+      apply_callbacks(buffer)
+      left_indent = block_styles[:margin_left].to_f + block_styles[:padding_left].to_f
+      options = block_styles.slice(:align, :leading, :mode, :padding_left)
+      options[:indent_paragraphs] = left_indent if left_indent > 0
+      pdf.puts(buffer, options, bounding_box: bounds(block_styles))
     end
 
-    def output_content(buffer, options)
-      buffer.each { |item| item[:callback] = item[:callback].new(pdf, item) if item[:callback] }
-      if (left = options.delete(:margin_left).to_f + options.delete(:padding_left).to_f) > 0
-        pdf.indent(left) { pdf.formatted_text(buffer, options) }
-      else
-        pdf.formatted_text(buffer, options)
+    def apply_callbacks(buffer)
+      buffer.select { |item| item[:callback] }.each do |item|
+        callback = Tag::CALLBACKS[item[:callback]]
+        item[:callback] = callback.new(pdf, item)
       end
     end
+
+    def bounds(block_styles)
+      return unless block_styles[:position] == :absolute
+
+      y = pdf.bounds.height - (block_styles[:top] || 0)
+      w = pdf.bounds.width - (block_styles[:left] || 0)
+      [[block_styles[:left] || 0, y], { width: w }]
+    end
   end
 end

data/lib/prawn_html/html_parser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'oga'
+
+module PrawnHtml
+  class HtmlParser
+    REGEXP_STYLES = /\s*([^{\s]+)\s*{\s*([^}]*?)\s*}/m.freeze
+
+    # Init the HtmlParser
+    #
+    # @param renderer [DocumentRenderer] document renderer
+    # @param ignore_content_tags [Array] array of tags (symbols) to skip their contents while preparing the PDF document
+    def initialize(renderer, ignore_content_tags: %i[script style])
+      @processing = false
+      @ignore = false
+      @ignore_content_tags = ignore_content_tags
+      @renderer = renderer
+      @styles = {}
+    end
+
+    # Processes HTML and renders it
+    #
+    # @param html [String] The HTML content to process
+    def process(html)
+      @processing = !html.include?('<body')
+      @document = Oga.parse_html(html)
+      traverse_nodes(document.children)
+      renderer.flush
+    end
+
+    private
+
+    attr_reader :document, :ignore, :processing, :renderer, :styles
+
+    def traverse_nodes(nodes)
+      nodes.each do |node|
+        next if node.is_a?(Oga::XML::Comment)
+
+        element = node_open(node)
+        traverse_nodes(node.children) if node.children.any?
+        node_close(element) if element
+      end
+    end
+
+    def node_open(node)
+      tag = node.is_a?(Oga::XML::Element) && init_element(node)
+      return unless processing
+      return IgnoredTag.new(tag) if ignore
+      return renderer.on_text_node(node.text) unless tag
+
+      renderer.on_tag_open(tag, attributes: prepare_attributes(node), element_styles: styles[node])
+    end
+
+    def init_element(node)
+      node.name.downcase.to_sym.tap do |tag_name|
+        @processing = true if tag_name == :body
+        @ignore = true if @processing && @ignore_content_tags.include?(tag_name)
+        process_styles(node.text) if tag_name == :style
+      end
+    end
+
+    def process_styles(text_styles)
+      hash_styles = text_styles.scan(REGEXP_STYLES).to_h
+      hash_styles.each do |selector, rule|
+        document.css(selector).each do |node|
+          styles[node] = rule
+        end
+      end
+    end
+
+    def prepare_attributes(node)
+      node.attributes.each_with_object({}) do |attr, res|
+        res[attr.name] = attr.value
+      end
+    end
+
+    def node_close(element)
+      if processing
+        renderer.on_tag_close(element) unless ignore
+        @ignore = false if ignore && @ignore_content_tags.include?(element.tag)
+      end
+      @processing = false if element.tag == :body
+    end
+  end
+
+  class IgnoredTag
+    attr_accessor :tag
+
+    def initialize(tag_name)
+      @tag = tag_name
+    end
+  end
+
+  HtmlHandler = HtmlParser
+end

data/lib/prawn_html/pdf_wrapper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module PrawnHtml
+  class PdfWrapper
+    extend Forwardable
+
+    def_delegators :@pdf, :bounds, :start_new_page
+
+    # Wrapper for Prawn PDF Document
+    #
+    # @param pdf_document [Prawn::Document] PDF document to wrap
+    def initialize(pdf_document)
+      @pdf = pdf_document
+    end
+
+    # Advance the cursor
+    #
+    # @param move_down [Float] Quantity to advance (move down)
+    def advance_cursor(move_down)
+      return if !move_down || move_down == 0
+
+      pdf.move_down(move_down)
+    end
+
+    # Draw a rectangle
+    #
+    # @param x [Float] left position of the rectangle
+    # @param y [Float] top position of the rectangle
+    # @param width [Float] width of the rectangle
+    # @param height [Float] height of the rectangle
+    # @param color [String] fill color
+    def draw_rectangle(x:, y:, width:, height:, color:)
+      current_fill_color = pdf.fill_color
+      pdf.fill_color = color
+      pdf.fill_rectangle([y, x], width, height)
+      pdf.fill_color = current_fill_color
+    end
+
+    # Horizontal line
+    #
+    # @param color [String] line color
+    # @param dash [Integer|Array] integer or array of integer with dash options
+    def horizontal_rule(color:, dash:)
+      current_color = pdf.stroke_color
+      pdf.dash(dash) if dash
+      pdf.stroke_color = color if color
+      pdf.stroke_horizontal_rule
+      pdf.stroke_color = current_color if color
+      pdf.undash if dash
+    end
+
+    # Image
+    #
+    # @param src [String] image source path
+    # @param options [Hash] hash of options
+    def image(src, options = {})
+      return unless src
+
+      pdf.image(src, options)
+    end
+
+    # Output to the PDF document
+    #
+    # @param buffer [Array] array of text items
+    # @param options [Hash] hash of options
+    # @param bounding_box [Array] bounding box arguments, if bounded
+    def puts(buffer, options, bounding_box: nil)
+      return pdf.formatted_text(buffer, options) unless bounding_box
+
+      current_y = pdf.cursor
+      pdf.bounding_box(*bounding_box) do
+        pdf.formatted_text(buffer, options)
+      end
+      pdf.move_cursor_to(current_y)
+    end
+
+    # Underline
+    #
+    # @param x1 [Float] left position of the line
+    # @param x2 [Float] right position of the line
+    # @param y [Float] vertical position of the line
+    def underline(x1:, x2:, y:)
+      pdf.stroke do
+        pdf.line [x1, y], [x2, y]
+      end
+    end
+
+    private
+
+    attr_reader :pdf
+  end
+end