prawn-html 0.1.0 → 0.3.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

@@ -10,34 +10,52 @@ module PrawnHtml
     def initialize(*_args)
       super
       @last_margin = 0
+      @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?
+      return '' if empty? || !last.respond_to?(:tag_styles)
 
-      last.options[:before_content].to_s
+      last.tag_styles[:before_content].to_s
     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 +67,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,49 @@ 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 = {}
+      @document_styles = {}
       @pdf = pdf
     end
 
-    # Assigns the document styles
+    # 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)
-      @doc_styles = styles.transform_values do |style_rules|
-        Attributes.new(style: style_rules).styles
-      end
+      @document_styles.merge!(
+        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
     #
-    # @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)
+      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, document_styles).tap do |element|
         setup_element(element)
       end
     end
@@ -58,8 +59,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 +70,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 +79,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, :document_styles, :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 +100,34 @@ 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?
-
-      margin = (element.pre_styles[:margin_top] - context.last_margin).round(4)
-      pdf.move_down(margin) if margin > 0
+    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
 
-    def output_content(buffer, options)
+    def output_content(buffer, block_styles)
       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)
-      end
+      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 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_handler.rb → html_parser.rb}

@@ -3,16 +3,16 @@
 require 'oga'
 
 module PrawnHtml
-  class HtmlHandler
-    # Init the HtmlHandler
+  class HtmlParser
+    # Init the HtmlParser
     #
-    # @param pdf [Prawn::Document] Target Prawn PDF document
-    def initialize(pdf)
+    # @param renderer [DocumentRenderer] document renderer
+    def initialize(renderer)
       @processing = false
-      @renderer = DocumentRenderer.new(pdf)
+      @renderer = renderer
     end
 
-    # Processes HTML and renders it on the PDF document
+    # Processes HTML and renders it
     #
     # @param html [String] The HTML content to process
     def process(html)
@@ -46,7 +46,7 @@ module PrawnHtml
     def init_element(node)
       node.name.downcase.to_sym.tap do |tag_name|
         @processing = true if tag_name == :body
-        renderer.assign_document_styles(extract_styles(node.text)) if tag_name == :style && !@processing
+        renderer.assign_document_styles(extract_styles(node.text)) if tag_name == :style
       end
     end
 
@@ -65,4 +65,6 @@ module PrawnHtml
       @processing = false if element.tag == :body
     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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  class Tag
+    TAG_CLASSES = %w[A B Body Br Del Div H Hr I Img Li Mark Ol P Small Span 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 = {})
+      @tag = tag
+      element_styles = attributes.delete(:style)
+      @attrs = Attributes.new(attributes)
+      process_styles(document_styles, element_styles)
+    end
+
+    # Is a block tag?
+    #
+    # @return [Boolean] true if the type of the tag is block, false otherwise
+    def block?
+      false
+    end
+
+    # Styles to apply to the block
+    #
+    # @return [Hash] hash of styles to apply
+    def block_styles
+      block_styles = styles.slice(*Attributes::STYLES_APPLY[:block])
+      block_styles[:mode] = attrs.data['mode'].to_sym if attrs.data.include?('mode')
+      block_styles
+    end
+
+    # Styles to apply on tag closing
+    #
+    # @return [Hash] hash of styles to apply
+    def tag_close_styles
+      styles.slice(*Attributes::STYLES_APPLY[:tag_close])
+    end
+
+    # Styles hash
+    #
+    # @return [Hash] hash of styles
+    def styles
+      attrs.styles
+    end
+
+    # Styles to apply on tag opening
+    #
+    # @return [Hash] hash of styles to apply
+    def tag_open_styles
+      styles.slice(*Attributes::STYLES_APPLY[:tag_open])
+    end
+
+    class << self
+      # Evaluate the Tag class from a tag name
+      #
+      # @params tag_name [Symbol] the tag name
+      #
+      # @return [Tag] the class for the tag if available or nil
+      def class_for(tag_name)
+        @tag_classes ||= TAG_CLASSES.each_with_object({}) do |tag_class, res|
+          klass = const_get("PrawnHtml::Tags::#{tag_class}")
+          k = [klass] * klass::ELEMENTS.size
+          res.merge!(klass::ELEMENTS.zip(k).to_h)
+        end
+        @tag_classes[tag_name]
+      end
+    end
+
+    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
+    end
+  end
+end