prawn-table-html 0.0.1

data/lib/prawn_html/context.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  class Context < Array
+    DEFAULT_STYLES = {
+      size: 16 * PX
+    }.freeze
+
+    attr_reader :previous_tag
+    attr_accessor :last_text_node
+
+    # Init the Context
+    def initialize(*_args)
+      super
+      @last_text_node = false
+      @merged_styles = nil
+      @previous_tag = nil
+    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)
+      @merged_styles = nil
+      self
+    end
+
+    # Evaluate before content
+    #
+    # @return [String] before content string
+    def before_content
+      (last.respond_to?(:before_content) && last.before_content) || ''
+    end
+
+    # Merges the context block styles
+    #
+    # @return [Hash] the hash of merged styles
+    def block_styles
+      each_with_object({}) do |element, res|
+        element.block_styles.each do |key, value|
+          Attributes.merge_attr!(res, key, value)
+        end
+      end
+    end
+
+    # Merge the context styles for text nodes
+    #
+    # @return [Hash] the hash of merged styles
+    def merged_styles
+      @merged_styles ||=
+        each_with_object(DEFAULT_STYLES.dup) do |element, res|
+          evaluate_element_styles(element, res)
+          element.update_styles(res)
+        end
+    end
+
+    # :nocov:
+    def inspect
+      map(&:class).map(&:to_s).join(', ')
+    end
+    # :nocov:
+
+    # Remove the last element from the context
+    def remove_last
+      last.on_context_remove(self) if last.respond_to?(:on_context_remove)
+      @merged_styles = nil
+      @last_text_node = false
+      @previous_tag = last
+      pop
+    end
+
+    # White space is equal to 'pre'?
+    #
+    # @return [boolean] white space property of the last element is equal to 'pre'
+    def white_space_pre?
+      last && last.styles[:white_space] == :pre
+    end
+
+    private
+
+    def evaluate_element_styles(element, res)
+      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
+          res[key] = val
+        end
+      end
+    end
+  end
+end

data/lib/prawn_html/document_renderer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  class DocumentRenderer
+    NEW_LINE = { text: "\n" }.freeze
+    SPACE = { text: ' ' }.freeze
+
+    # Init the DocumentRenderer
+    #
+    # @param pdf [PdfWrapper] target PDF wrapper
+    def initialize(pdf)
+      @before_content = []
+      @buffer = []
+      @context = Context.new
+      @last_margin = 0
+      @last_text = ''
+      @last_tag_open = false
+      @pdf = pdf
+    end
+
+    # On tag close callback
+    #
+    # @param element [Tag] closing element wrapper
+    def on_tag_close(element)
+      render_if_needed(element)
+      apply_tag_close_styles(element)
+      context.remove_last
+      @last_tag_open = false
+      @last_text = ''
+    end
+
+    # On tag open callback
+    #
+    # @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:, element_styles: '')
+      tag_class = Tag.class_for(tag_name)
+      return unless tag_class
+
+      options = { width: pdf.page_width, height: pdf.page_height }
+      tag_class.new(tag_name, attributes: attributes, options: options).tap do |element|
+        setup_element(element, element_styles: element_styles)
+        @before_content.push(element.before_content) if element.respond_to?(:before_content)
+        @last_tag_open = true
+      end
+    end
+
+    # On text node callback
+    #
+    # @param content [String] the text node content
+    #
+    # @return [NilClass] nil value (=> no element)
+    def on_text_node(content)
+      if context.last.respond_to?(:on_text_node)
+        # Avoid geting text from table rendered before it.
+        context.last.on_text_node(content)
+        return
+      end
+
+      return if context.previous_tag&.block? && content.match?(/\A\s*\Z/)
+
+      text = prepare_text(content)
+      buffer << context.merged_styles.merge(text: text) unless text.empty?
+      context.last_text_node = true
+      nil
+    end
+
+    # Render the buffer content to the PDF document
+    def render
+      return if buffer.empty?
+
+      output_content(buffer.dup, context.block_styles)
+      buffer.clear
+      @last_margin = 0
+    end
+
+    alias_method :flush, :render
+
+    private
+
+    attr_reader :buffer, :context, :last_margin, :pdf
+
+    def setup_element(element, element_styles:)
+      render_if_needed(element)
+      context.add(element)
+      element.process_styles(element_styles: element_styles)
+      apply_tag_open_styles(element)
+      element.custom_render(pdf, context) if element.respond_to?(:custom_render)
+    end
+
+    def render_if_needed(element)
+      render_needed = element&.block? && buffer.any? && buffer.last != NEW_LINE
+      return false unless render_needed
+
+      render
+      true
+    end
+
+    def apply_tag_close_styles(element)
+      tag_styles = element.tag_close_styles
+      @last_margin = tag_styles[:margin_bottom].to_f
+      puts "apply_tag_close_styles(#{element.tag}), margin_bottom=#{tag_styles[:margin_bottom]}, last_margin=#{@last_margin}"
+      pdf.advance_cursor(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 - last_margin) + tag_styles[:padding_top].to_f
+      puts "apply_tag_open_styles(#{element.tag}), margin_top=#{tag_styles[:margin_top]}, padding_top: #{tag_styles[:padding_top]} last_margin=#{@last_margin}"
+      pdf.advance_cursor(move_down) if move_down > 0
+      pdf.start_new_page if tag_styles[:break_before]
+    end
+
+    def prepare_text(content)
+      text = @before_content.any? ? ::Oga::HTML::Entities.decode(@before_content.join) : ''
+      @before_content.clear
+
+      return (@last_text = text + content) if context.white_space_pre?
+
+      content = content.lstrip if @last_text[-1] == ' ' || @last_tag_open
+      text += content.tr("\n", ' ').squeeze(' ')
+      @last_text = text
+    end
+
+    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, :indent_paragraphs, :leading, :mode, :padding_left)
+      options[:leading] = adjust_leading(buffer, options[:leading])
+      pdf.puts(buffer, options, bounding_box: bounds(buffer, options, block_styles), left_indent: left_indent)
+    end
+
+    def apply_callbacks(buffer)
+      buffer.select { |item| item[:callback] }.each do |item|
+        callback, arg = item[:callback]
+        callback_class = Tag::CALLBACKS[callback]
+        item[:callback] = callback_class.new(pdf, arg)
+      end
+    end
+
+    def adjust_leading(buffer, leading)
+      return leading if leading
+
+      leadings = buffer.map do |item|
+        (item[:size] || Context::DEFAULT_STYLES[:size]) * (ADJUST_LEADING[item[:font]] || ADJUST_LEADING[nil])
+      end
+      leadings.max.round(4)
+    end
+
+    def bounds(buffer, options, block_styles)
+      return unless block_styles[:position] == :absolute
+
+      x = if block_styles.include?(:right)
+            x1 = pdf.calc_buffer_width(buffer) + block_styles[:right]
+            x1 < pdf.page_width ? (pdf.page_width - x1) : 0
+          else
+            block_styles[:left] || 0
+          end
+      y = if block_styles.include?(:bottom)
+            pdf.calc_buffer_height(buffer, options) + block_styles[:bottom]
+          else
+            pdf.page_height - (block_styles[:top] || 0)
+          end
+
+      [[x, y], { width: pdf.page_width - x }]
+    end
+  end
+end

data/lib/prawn_html/html_parser.rb

@@ -0,0 +1,104 @@
+# 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
+      @raw_styles = {}
+    end
+
+    # Processes HTML and renders it
+    #
+    # @param html [String] The HTML content to process
+    def process(html)
+      @styles = {}
+      @processing = !html.include?('<body')
+      @document = Oga.parse_html(html)
+      process_styles # apply previously loaded styles
+      traverse_nodes(document.children)
+      renderer.flush
+    end
+
+    # Parses CSS styles
+    #
+    # @param text_styles [String] The CSS styles to evaluate
+    def parse_styles(text_styles)
+      @raw_styles = text_styles.scan(REGEXP_STYLES).to_h
+    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 = nil)
+      parse_styles(text_styles) if text_styles
+      @raw_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/instance.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  class Instance
+    attr_reader :html_parser, :pdf_wrapper, :renderer
+
+    def initialize(pdf)
+      @pdf_wrapper = PrawnHtml::PdfWrapper.new(pdf)
+      @renderer = PrawnHtml::DocumentRenderer.new(@pdf_wrapper)
+      @html_parser = PrawnHtml::HtmlParser.new(@renderer)
+    end
+
+    def append(css: nil, html: nil)
+      html_parser.parse_styles(css) if css
+      html_parser.process(html) if html
+    end
+  end
+end

data/lib/prawn_html/pdf_wrapper.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module PrawnHtml
+  class PdfWrapper
+    extend Forwardable
+
+    def_delegators :@pdf, :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
+
+    # Calculate the height of a buffer of items
+    #
+    # @param buffer [Array] Buffer of items
+    # @param options [Hash] Output options
+    #
+    # @return [Float] calculated height
+    def calc_buffer_height(buffer, options)
+      pdf.height_of_formatted(buffer, options)
+    end
+
+    # Calculate the width of a buffer of items
+    #
+    # @param buffer [Array] Buffer of items
+    #
+    # @return [Float] calculated width
+    def calc_buffer_width(buffer)
+      width = 0
+      buffer.each do |item|
+        font_family = item[:font] || pdf.font.name
+        pdf.font(font_family, size: item[:size] || pdf.font_size) do
+          width += pdf.width_of(item[:text], inline_format: true)
+        end
+      end
+      width
+    end
+
+    # Height of the page
+    #
+    # @return [Float] height
+    def page_height
+      pdf.bounds.height
+    end
+
+    # Width of the page
+    #
+    # @return [Float] width
+    def page_width
+      pdf.bounds.width
+    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, left_indent: 0)
+      return output_buffer(buffer, options, left_indent: left_indent) unless bounding_box
+
+      current_y = pdf.cursor
+      pdf.bounding_box(*bounding_box) do
+        output_buffer(buffer, options, left_indent: left_indent)
+      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
+
+    def table(rows, options = {})
+      pdf.table(rows, options) # uses prawn-table
+    end
+
+    private
+
+    attr_reader :pdf
+
+    def output_buffer(buffer, options, left_indent:)
+      formatted_text = proc { pdf.formatted_text(buffer, options) }
+      return formatted_text.call if left_indent == 0
+
+      pdf.indent(left_indent, 0, &formatted_text)
+    end
+  end
+end

data/lib/prawn_html/tag.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  class Tag
+    extend Forwardable
+
+    CALLBACKS = {
+      'Background' => Callbacks::Background,
+      '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
+      Table Tr Td Th Tbody Colgroup Col
+    ].freeze
+
+    def_delegators :@attrs, :styles, :update_styles
+
+    attr_accessor :parent
+    attr_reader :attrs, :tag
+
+    # Init the Tag
+    #
+    # @param tag [Symbol] tag name
+    # @param attributes [Hash] hash of element attributes
+    # @param options [Hash] options (container width/height/etc.)
+    def initialize(tag, attributes: {}, options: {})
+      @tag = tag
+      @options = options
+      @attrs = Attributes.new(attributes)
+    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
+
+    # Process tag styles
+    #
+    # @param element_styles [String] extra styles to apply to the element
+    def process_styles(element_styles: nil)
+      attrs.merge_text_styles!(tag_styles, options: options) if respond_to?(:tag_styles)
+      attrs.merge_text_styles!(element_styles, options: options) if element_styles
+      attrs.merge_text_styles!(attrs.style, options: options)
+      attrs.merge_text_styles!(extra_styles, options: options) if respond_to?(:extra_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 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
+
+    attr_reader :options
+  end
+end

data/lib/prawn_html/tags/a.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  module Tags
+    class A < Tag
+      ELEMENTS = [:a].freeze
+
+      def extra_styles
+        attrs.href ? "href: #{attrs.href}" : nil
+      end
+
+      def tag_styles
+        <<~STYLES
+          color: #00E;
+          text-decoration: underline;
+        STYLES
+      end
+    end
+  end
+end

data/lib/prawn_html/tags/b.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  module Tags
+    class B < Tag
+      ELEMENTS = [:b, :strong].freeze
+
+      def tag_styles
+        'font-weight: bold'
+      end
+    end
+  end
+end

data/lib/prawn_html/tags/blockquote.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  module Tags
+    class Blockquote < Tag
+      ELEMENTS = [:blockquote].freeze
+
+      MARGIN_BOTTOM = 12.7
+      MARGIN_LEFT = 40.4
+      MARGIN_TOP = 12.7
+
+      def block?
+        true
+      end
+
+      def tag_styles
+        <<~STYLES
+          margin-bottom: #{MARGIN_BOTTOM}px;
+          margin-left: #{MARGIN_LEFT}px;
+          margin-top: #{MARGIN_TOP}px;
+        STYLES
+      end
+    end
+  end
+end

data/lib/prawn_html/tags/body.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module PrawnHtml
+  module Tags
+    class Body < Tag
+      ELEMENTS = [:body].freeze
+
+      def block?
+        true
+      end
+    end
+  end
+end