prawn-html 0.2.0 → 0.4.2

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

@@ -13,13 +13,26 @@ module PrawnHtml
       @last_text_node = false
     end
 
+    # 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
+
     # Evaluate before content
     #
     # @return [String] before content string
     def before_content
-      return '' if empty? || !last.respond_to?(:tag_styles)
-
-      last.tag_styles[:before_content].to_s
+      (last.respond_to?(:before_content) && last.before_content) || ''
     end
 
     # Merges the context block styles

data/lib/prawn_html/document_renderer.rb

@@ -7,23 +7,13 @@ module PrawnHtml
 
     # Init the DocumentRenderer
     #
-    # @param pdf [Prawn::Document] target Prawn PDF document
+    # @param pdf [PdfWrapper] target PDF wrapper
     def initialize(pdf)
       @buffer = []
       @context = Context.new
-      @document_styles = {}
       @pdf = pdf
     end
 
-    # Evaluate the document styles and store the internally
-    #
-    # @param styles [Hash] styles hash with CSS selectors as keys and rules as values
-    def assign_document_styles(styles)
-      @document_styles = styles.transform_values do |style_rules|
-        Attributes.new(style: style_rules).styles
-      end
-    end
-
     # On tag close callback
     #
     # @param element [Tag] closing element wrapper
@@ -38,13 +28,14 @@ module PrawnHtml
     #
     # @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 [Tag] the opening element wrapper
-    def on_tag_open(tag_name, attributes)
+    def on_tag_open(tag_name, attributes:, element_styles: '')
       tag_class = Tag.class_for(tag_name)
       return unless tag_class
 
-      tag_class.new(tag_name, attributes, document_styles).tap do |element|
+      tag_class.new(tag_name, attributes: attributes, element_styles: element_styles).tap do |element|
         setup_element(element)
       end
     end
@@ -57,9 +48,7 @@ module PrawnHtml
     def on_text_node(content)
       return if content.match?(/\A\s*\Z/)
 
-      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)
+      buffer << context.text_node_styles.merge(text: prepare_text(content))
       context.last_text_node = true
       nil
     end
@@ -68,8 +57,7 @@ module PrawnHtml
     def render
       return if buffer.empty?
 
-      options = context.block_styles.slice(:align, :leading, :margin_left, :mode, :padding_left)
-      output_content(buffer.dup, options)
+      output_content(buffer.dup, context.block_styles)
       buffer.clear
       context.last_margin = 0
     end
@@ -78,12 +66,12 @@ module PrawnHtml
 
     private
 
-    attr_reader :buffer, :context, :document_styles, :pdf
+    attr_reader :buffer, :context, :pdf
 
     def setup_element(element)
       add_space_if_needed unless render_if_needed(element)
       apply_tag_open_styles(element)
-      context.push(element)
+      context.add(element)
       element.custom_render(pdf, context) if element.respond_to?(:custom_render)
     end
 
@@ -102,21 +90,45 @@ module PrawnHtml
     def apply_tag_close_styles(element)
       tag_styles = element.tag_close_styles
       context.last_margin = tag_styles[:margin_bottom].to_f
-      move_down = context.last_margin + tag_styles[:padding_bottom].to_f
-      pdf.move_down(move_down) if move_down > 0
+      pdf.advance_cursor(context.last_margin + tag_styles[:padding_bottom].to_f)
+      pdf.start_new_page if tag_styles[:break_after]
     end
 
     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.move_down(move_down) if move_down > 0
+      pdf.advance_cursor(move_down) if move_down > 0
+      pdf.start_new_page if tag_styles[:break_before]
+    end
+
+    def prepare_text(content)
+      white_space_pre = context.last && context.last.styles[:white_space] == :pre
+      text = ::Oga::HTML::Entities.decode(context.before_content)
+      text += white_space_pre ? content : content.gsub(/\A\s*\n\s*|\s*\n\s*\Z/, '').delete("\n").squeeze(' ')
+      text
     end
 
-    def output_content(buffer, options)
-      buffer.each { |item| item[:callback] = item[:callback].new(pdf, item) if item[:callback] }
-      left_indent = options.delete(:margin_left).to_f + options.delete(:padding_left).to_f
+    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.formatted_text(buffer, options)
+      pdf.puts(buffer, options, bounding_box: bounds(block_styles))
+    end
+
+    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

data/lib/prawn_html/tag.rb

@@ -2,20 +2,24 @@
 
 module PrawnHtml
   class Tag
-    TAG_CLASSES = %w[A B Body Br Del Div H Hr I Img Li Mark P Small Span U Ul].freeze
+    CALLBACKS = {
+      'Highlight' => Callbacks::Highlight,
+      'StrikeThrough' => Callbacks::StrikeThrough
+    }.freeze
+    TAG_CLASSES = %w[A B Blockquote Body Br Code Del Div H Hr I Img Li Mark Ol P Pre Small Span Sub Sup U Ul].freeze
 
+    attr_accessor :parent
     attr_reader :attrs, :tag
 
     # Init the Tag
     #
     # @param tag [Symbol] tag name
     # @param attributes [Hash] hash of element attributes
-    # @param document_styles [Hash] hash of document styles
-    def initialize(tag, attributes = {}, document_styles = {})
+    # @param element_styles [String] document styles tp apply to the element
+    def initialize(tag, attributes: {}, element_styles: '')
       @tag = tag
-      element_styles = attributes.delete(:style)
       @attrs = Attributes.new(attributes)
-      process_styles(document_styles, element_styles)
+      process_styles(element_styles, attributes['style'])
     end
 
     # Is a block tag?
@@ -73,23 +77,10 @@ module PrawnHtml
 
     private
 
-    def evaluate_document_styles(document_styles)
-      selectors = [
-        tag.to_s,
-        attrs['class'] ? ".#{attrs['class']}" : nil,
-        attrs['id'] ? "##{attrs['id']}" : nil
-      ].compact!
-      document_styles.each_with_object({}) do |(sel, attributes), res|
-        res.merge!(attributes) if selectors.include?(sel)
-      end
-    end
-
-    def process_styles(document_styles, element_styles)
-      attrs.merge_styles!(attrs.process_styles(tag_styles)) if respond_to?(:tag_styles)
-      doc_styles = evaluate_document_styles(document_styles)
-      attrs.merge_styles!(doc_styles)
-      el_styles = Attributes.parse_styles(element_styles)
-      attrs.merge_styles!(attrs.process_styles(el_styles)) if el_styles
+    def process_styles(element_styles, inline_styles)
+      attrs.merge_text_styles!(tag_styles) if respond_to?(:tag_styles)
+      attrs.merge_text_styles!(element_styles)
+      attrs.merge_text_styles!(inline_styles)
     end
   end
 end

data/lib/prawn_html/tags/a.rb

@@ -6,7 +6,7 @@ module PrawnHtml
       ELEMENTS = [:a].freeze
 
       def tag_styles
-        attrs.href ? { 'href' => attrs.href } : {}
+        "href: #{attrs.href}" if attrs.href
       end
     end
   end