prawn-markup 0.1.0

data/lib/prawn/markup/elements/cell.rb

@@ -0,0 +1,15 @@
+module Prawn
+  module Markup
+    module Elements
+      class Cell < Item
+        attr_reader :header, :width
+
+        def initialize(header: false, width: 'auto')
+          super()
+          @header = header
+          @width = width
+        end
+      end
+    end
+  end
+end

data/lib/prawn/markup/elements/item.rb

@@ -0,0 +1,17 @@
+module Prawn
+  module Markup
+    module Elements
+      class Item
+        attr_reader :nodes
+
+        def initialize
+          @nodes = []
+        end
+
+        def single?
+          nodes.size <= 1
+        end
+      end
+    end
+  end
+end

data/lib/prawn/markup/elements/list.rb

@@ -0,0 +1,14 @@
+module Prawn
+  module Markup
+    module Elements
+      class List
+        attr_reader :ordered, :items
+
+        def initialize(ordered)
+          @ordered = ordered
+          @items = []
+        end
+      end
+    end
+  end
+end

data/lib/prawn/markup/interface.rb

@@ -0,0 +1,17 @@
+module Prawn
+  module Markup
+    module Interface
+      attr_writer :markup_options
+
+      def markup(html, options = {})
+        options = HashMerger.deep(markup_options, options)
+        Processor.new(self, options).parse(html)
+      end
+
+      def markup_options
+        @markup_options ||= {}
+      end
+
+    end
+  end
+end

data/lib/prawn/markup/processor.rb

@@ -0,0 +1,145 @@
+module Prawn
+  module Markup
+    # Processes known HTML tags. Unknown tags are ignored.
+    class Processor < Nokogiri::XML::SAX::Document
+      class Error < StandardError; end
+
+      class << self
+        def known_elements
+          @@known_elments ||= []
+        end
+
+        def logger
+          @@logger
+        end
+
+        def logger=(logger)
+          @@logger = logger
+        end
+      end
+
+      self.logger = defined?(Rails) ? Rails.logger : nil
+
+      require 'prawn/markup/processor/text'
+      require 'prawn/markup/processor/headings'
+      require 'prawn/markup/processor/images'
+      require 'prawn/markup/processor/tables'
+      require 'prawn/markup/processor/lists'
+
+      prepend Prawn::Markup::Processor::Text
+      prepend Prawn::Markup::Processor::Headings
+      prepend Prawn::Markup::Processor::Images
+      prepend Prawn::Markup::Processor::Tables
+      prepend Prawn::Markup::Processor::Lists
+
+      def initialize(pdf, options = {})
+        @pdf = pdf
+        @options = options
+      end
+
+      def parse(html)
+        return if html.to_s.strip.empty?
+        reset
+        html = Prawn::Markup::Normalizer.new(html).normalize
+        Nokogiri::HTML::SAX::Parser.new(self).parse(html) { |ctx| ctx.recovery = true }
+      end
+
+      def start_element(name, attrs = [])
+        stack.push(name: name, attrs: Hash[attrs])
+        if self.class.known_elements.include?(name)
+          send("start_#{name}") if respond_to?("start_#{name}", true)
+        end
+      end
+
+      def end_element(name)
+        send("end_#{name}") if respond_to?("end_#{name}", true)
+        stack.pop
+      end
+
+      def characters(string)
+        # entities will be replaced again later by inline_format
+        append_text(string.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;'))
+      end
+
+      def error(string)
+        logger.debug('SAX parsing error: ' + string) if logger
+      end
+
+      def warning(string)
+        logger.warn(string) if logger
+      end
+
+      private
+
+      attr_reader :pdf, :stack, :text_buffer, :bottom_margin, :options
+
+      def reset
+        @stack = []
+        @text_buffer = ''
+      end
+
+      def append_text(string)
+        text_buffer.concat(string)
+      end
+
+      def buffered_text?
+        !text_buffer.strip.empty?
+      end
+
+      def dump_text
+        text = process_text(text_buffer.dup)
+        text_buffer.clear
+        text
+      end
+
+      def put_bottom_margin(value)
+        @bottom_margin = value
+      end
+
+      def inside_container?
+        false
+      end
+
+      def current_attrs
+        stack.last[:attrs]
+      end
+
+      def process_text(text)
+        if options[:text] && options[:text][:preprocessor]
+          options[:text][:preprocessor].call(text)
+        else
+          text
+        end
+      end
+
+      def style_properties
+        style = current_attrs['style']
+        if style
+          tokens = style.split(';').map { |p| p.split(':', 2).map(&:strip) }
+          Hash[tokens]
+        else
+          {}
+        end
+      end
+
+      def placeholder_value(keys, *args)
+        placeholder = dig_options(keys)
+        return if placeholder.nil?
+
+        if placeholder.respond_to?(:call)
+          placeholder.call(*args)
+        else
+          placeholder.to_s
+        end
+      end
+
+      def dig_options(keys)
+        keys.inject(options) { |opts, key| opts ? opts[key] : nil }
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/prawn/markup/processor/headings.rb

@@ -0,0 +1,64 @@
+module Prawn
+  module Markup
+    module Processor::Headings
+      def self.prepended(base)
+        base.known_elements.push('h1', 'h2', 'h3', 'h4', 'h5', 'h6')
+      end
+
+      (1..6).each do |i|
+        define_method("start_h#{i}") do
+          start_heading(i)
+        end
+
+        define_method("end_h#{i}") do
+          end_heading(i)
+        end
+      end
+
+      def start_heading(level)
+        if current_table
+          add_cell_text_node(current_cell)
+        elsif current_list
+          add_cell_text_node(current_list_item)
+        else
+          add_current_text if buffered_text?
+          pdf.move_down(current_heading_margin_top(level))
+        end
+      end
+
+      def end_heading(level)
+        options = heading_options(level)
+        if current_table
+          add_cell_text_node(current_cell, options)
+        elsif current_list
+          add_cell_text_node(current_list_item, options)
+        else
+          add_current_text(options)
+          put_bottom_margin(options[:margin_bottom])
+        end
+      end
+
+      private
+
+      def current_heading_margin_top(level)
+        top_margin = heading_options(level)[:margin_top] || 0
+        margin = [top_margin, @bottom_margin || 0].max
+        put_bottom_margin(nil)
+        margin
+      end
+
+      def heading_options(level)
+        @heading_options ||= {}
+        @heading_options[level] ||= default_options_with_size(level)
+      end
+
+      def default_options_with_size(level)
+        default = text_options.dup
+        default[:size] ||= pdf.font_size
+        default[:size] *= 2.5 - level * 0.25
+        HashMerger.deep(default, options[:"heading#{level}"] || {})
+      end
+
+    end
+  end
+end

data/lib/prawn/markup/processor/images.rb

@@ -0,0 +1,91 @@
+require 'open-uri'
+
+module Prawn
+  module Markup
+    module Processor::Images
+      ALLOWED_IMAGE_TYPES = %w[image/png image/jpeg].freeze
+
+      def self.prepended(base)
+        base.known_elements.push('img', 'iframe')
+      end
+
+      def start_img
+        add_current_text
+        add_image_or_placeholder(current_attrs['src'])
+      end
+
+      def start_iframe
+        placeholder = iframe_placeholder
+        append_text("\n#{placeholder}\n") if placeholder
+      end
+
+      private
+
+      def add_image_or_placeholder(src)
+        img = image_properties(src)
+        if img
+          add_image(img)
+        else
+          append_text("\n#{invalid_image_placeholder}\n")
+        end
+      end
+
+      def add_image(img)
+        # parse width in the current context
+        img[:width] = SizeConverter.new(pdf.bounds.width).parse(style_properties['width'])
+        pdf.image(img.delete(:image), img)
+        put_bottom_margin(text_margin_bottom)
+      rescue Prawn::Errors::UnsupportedImageType
+        append_text("\n#{invalid_image_placeholder}\n")
+      end
+
+      def image_properties(src)
+        img = load_image(src)
+        if img
+          props = style_properties
+          {
+            image: img,
+            width: props['width'],
+            position: convert_float_to_position(props['float'])
+          }
+        end
+      end
+
+      def load_image(src)
+        if options[:image] && options[:image][:loader]
+          options[:image][:loader].call(src)
+        else
+          decode_base64_image(src) || load_remote_image(src)
+        end
+      end
+
+      def decode_base64_image(src)
+        match = src.match(/^data:(.*?);(.*?),(.*)$/)
+        if match && ALLOWED_IMAGE_TYPES.include?(match[1])
+          StringIO.new(Base64.decode64(match[3]))
+        end
+      end
+
+      def load_remote_image(src)
+        if src =~ %r{^https?:/}
+          URI.parse(src).open
+        end
+      end
+
+      def convert_float_to_position(float)
+        { nil => nil,
+          'none' => nil,
+          'left' => :left,
+          'right' => :right }[float]
+      end
+
+      def invalid_image_placeholder
+        placeholder_value(%i[image placeholder]) || '[unsupported image]'
+      end
+
+      def iframe_placeholder
+        placeholder_value(%i[iframe placeholder], current_attrs['src'])
+      end
+    end
+  end
+end

data/lib/prawn/markup/processor/lists.rb

@@ -0,0 +1,95 @@
+module Prawn
+  module Markup
+    module Processor::Lists
+      def self.prepended(base)
+        base.known_elements.push('ol', 'ul', 'li')
+      end
+
+      def start_ol
+        start_list(true)
+      end
+
+      def start_ul
+        start_list(false)
+      end
+
+      def start_list(ordered)
+        if current_list
+          add_cell_text_node(current_list_item)
+        elsif current_table
+          add_cell_text_node(current_cell)
+        else
+          add_current_text
+        end
+        @list_stack.push(Elements::List.new(ordered))
+      end
+
+      def end_list
+        list = list_stack.pop
+        append_list(list) unless list.items.empty?
+      end
+      alias end_ol end_list
+      alias end_ul end_list
+
+      def start_li
+        current_list.items << Elements::Item.new
+      end
+
+      def end_li
+        add_cell_text_node(current_list_item)
+      end
+
+      def start_img
+        if current_list
+          add_cell_image(current_list_item)
+        else
+          super
+        end
+      end
+
+      private
+
+      attr_reader :list_stack
+
+      def reset
+        @list_stack = []
+        super
+      end
+
+      def current_list
+        list_stack.last
+      end
+
+      def current_list_item
+        current_list.items.last
+      end
+
+      def inside_container?
+        super || current_list
+      end
+
+      def append_list(list)
+        if list_stack.empty?
+          if current_table
+            current_cell.nodes << list
+          else
+            add_list(list)
+          end
+        else
+          current_list_item.nodes << list
+        end
+      end
+
+      def add_list(list)
+        Builders::ListBuilder.new(pdf, list, pdf.bounds.width, options).draw
+        put_bottom_margin(text_margin_bottom)
+      rescue Prawn::Errors::CannotFit => e
+        append_text(list_too_large_placeholder(e))
+      end
+
+      def list_too_large_placeholder(error)
+        placeholder_value(%i[list placeholder too_large], error) || '[list content too large]'
+      end
+    end
+  end
+end