prawn-markup 0.1.0

data/lib/prawn/markup.rb

@@ -0,0 +1,23 @@
+require 'prawn'
+require 'prawn/measurement_extensions'
+require 'prawn/table'
+require 'nokogiri'
+require 'prawn/markup/support/hash_merger'
+require 'prawn/markup/support/size_converter'
+require 'prawn/markup/support/normalizer'
+require 'prawn/markup/elements/item'
+require 'prawn/markup/elements/cell'
+require 'prawn/markup/elements/list'
+require 'prawn/markup/builders/nestable_builder'
+require 'prawn/markup/builders/list_builder'
+require 'prawn/markup/builders/table_builder'
+require 'prawn/markup/processor'
+require 'prawn/markup/interface'
+require 'prawn/markup/version'
+
+module Prawn
+  module Markup
+  end
+end
+
+Prawn::Document.extensions << Prawn::Markup::Interface

data/lib/prawn/markup/builders/list_builder.rb

@@ -0,0 +1,165 @@
+module Prawn
+  module Markup
+    module Builders
+      class ListBuilder < NestableBuilder
+        BULLET_CHAR = '•'.freeze
+        BULLET_MARGIN = 10
+        CONTENT_MARGIN = 10
+        VERTICAL_MARGIN = 5
+
+        def initialize(pdf, list, total_width, options = {})
+          super(pdf, total_width, options)
+          @list = list
+          @column_widths = compute_column_widths
+        end
+
+        def make(main = false)
+          pdf.make_table(convert_list, list_table_options) do |t|
+            t.columns(0).style(column_cell_style(:bullet))
+            t.columns(1).style(column_cell_style(:content))
+            set_paddings(t, main)
+          end
+        end
+
+        def draw
+          make(true).draw
+        end
+
+        private
+
+        attr_reader :list, :column_widths
+
+        def list_table_options
+          {
+            column_widths: column_widths,
+            cell_style: { border_width: 0, inline_format: true }
+          }
+        end
+
+        def set_paddings(table, main)
+          set_row_padding(table, [0, 0, padding_bottom])
+          if main
+            set_row_padding(table.rows(0), [vertical_margin, 0, padding_bottom])
+            set_row_padding(table.rows(-1), [0, 0, padding_bottom + vertical_margin])
+          else
+            set_row_padding(table.rows(-1), [0, 0, 0])
+          end
+        end
+
+        def set_row_padding(row, padding)
+          row.columns(0).padding = [*padding, bullet_margin]
+          row.columns(1).padding = [*padding, content_margin]
+        end
+
+        def convert_list
+          list.items.map.with_index do |item, i|
+            if item.single?
+              [bullet(i + 1), normalize_list_item_node(item.nodes.first)]
+            else
+              [bullet(i + 1), list_item_table(item)]
+            end
+          end
+        end
+
+        def list_item_table(item)
+          data = item.nodes.map { |n| [normalize_list_item_node(n)] }
+          style = column_cell_style(:content)
+                  .merge(borders: [], padding: [0, 0, padding_bottom, 0])
+          pdf.make_table(data, cell_style: style) do
+            rows(-1).padding = [0, 0, 0, 0]
+          end
+        end
+
+        def normalize_list_item_node(node)
+          normalizer = "item_node_for_#{type_key(node)}"
+          if respond_to?(normalizer, true)
+            send(normalizer, node)
+          else
+            ''
+          end
+        end
+
+        def item_node_for_list(node)
+          # sublist
+          ListBuilder.new(pdf, node, content_width, options).make
+        end
+
+        def item_node_for_hash(node)
+          normalize_cell_hash(node, content_width)
+        end
+
+        def item_node_for_string(node)
+          node
+        end
+
+        def content_width
+          column_widths.last && column_widths.last - content_margin
+        end
+
+        def compute_column_widths
+          return [] if list.items.empty?
+
+          bullet_width = bullet_text_width + bullet_margin
+          text_width = total_width && (total_width - bullet_width)
+          [bullet_width, text_width]
+        end
+
+        def bullet_text_width
+          font = bullet_font
+          font_size = column_cell_style(:bullet)[:size] || pdf.font_size
+          encoded = font.normalize_encoding(bullet(list.items.size))
+          font.compute_width_of(encoded, size: font_size)
+        end
+
+        def bullet_font
+          style = column_cell_style(:bullet)
+          font_name = style[:font] || pdf.font.family
+          pdf.find_font(font_name, style: style[:font_style])
+        end
+
+        # option accessors
+
+        def bullet(index)
+          list.ordered ? "#{index}." : (column_cell_style(:bullet)[:char] || BULLET_CHAR)
+        end
+
+        # margin before bullet
+        def bullet_margin
+          column_cell_style(:bullet)[:margin] || BULLET_MARGIN
+        end
+
+        # margin between bullet and content
+        def content_margin
+          column_cell_style(:content)[:margin] || CONTENT_MARGIN
+        end
+
+        # margin at the top and the bottom of the list
+        def vertical_margin
+          list_options[:vertical_margin] || VERTICAL_MARGIN
+        end
+
+        # vertical padding between list items
+        def padding_bottom
+          column_cell_style(:content)[:leading] || 0
+        end
+
+        def column_cell_style(key)
+          @column_cell_styles ||= {}
+          @column_cell_styles[key] ||=
+            extract_text_cell_style(options[:text] || {}).merge(list_options[key])
+        end
+
+        def list_options
+          @list_options ||= HashMerger.deep(default_list_options, options[:list] || {})
+        end
+
+        def default_list_options
+          {
+            content: {},
+            bullet: { align: :right }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/prawn/markup/builders/nestable_builder.rb

@@ -0,0 +1,68 @@
+module Prawn
+  module Markup
+    module Builders
+      class NestableBuilder
+        TEXT_STYLE_OPTIONS = %i[font size style font_style color text_color
+                                kerning leading align min_font_size overflow rotate
+                                rotate_around single_line valign].freeze
+
+        def initialize(pdf, total_width, options = {})
+          @pdf = pdf
+          @total_width = total_width
+          @options = options
+        end
+
+        private
+
+        attr_reader :pdf, :total_width, :options
+
+        def normalize_cell_hash(hash, cell_width, style_options = {})
+          if hash.key?(:image)
+            compute_image_width(hash, cell_width)
+          else
+            style_options.merge(hash)
+          end
+        end
+
+        def text_options
+          (options[:text] || {})
+        end
+
+        def compute_image_width(hash, max_width)
+          hash.dup.tap do |image_hash|
+            image_hash.delete(:width)
+            image_hash[:image_width] = SizeConverter.new(max_width).parse(hash[:width])
+            if max_width
+              natural_width, _height = natural_image_dimensions(image_hash)
+              image_hash[:fit] = [max_width, 999_999] if max_width < natural_width
+            end
+          end
+        end
+
+        def natural_image_dimensions(hash)
+          _obj, info = pdf.build_image_object(hash[:image])
+          info.calc_image_dimensions(width: hash[:image_width])
+        end
+
+        def extract_text_cell_style(hash)
+          TEXT_STYLE_OPTIONS
+            .each_with_object({}) { |key, h| h[key] = hash[key] }
+            .tap do |options|
+            options[:font_style] ||= options.delete(:style)
+            options[:text_color] ||= options.delete(:color)
+          end
+        end
+
+        def type_key(object)
+          path = object.class.name.to_s
+          i = path.rindex('::')
+          if i
+            path[(i + 2)..-1].downcase
+          else
+            path.downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prawn/markup/builders/table_builder.rb

@@ -0,0 +1,253 @@
+module Prawn
+  module Markup
+    module Builders
+      class TableBuilder < NestableBuilder
+        FAILOVER_STRATEGIES = %i[equal_widths subtable_placeholders].freeze
+
+        DEFAULT_CELL_PADDING = 5
+
+        MIN_COL_WIDTH = 1.cm
+
+        def initialize(pdf, cells, total_width, options = {})
+          super(pdf, total_width, options)
+          @cells = cells
+          @column_widths = []
+        end
+
+        def make
+          compute_column_widths
+          pdf.make_table(convert_cells, prawn_table_options)
+        end
+
+        def draw
+          make.draw
+        rescue Prawn::Errors::CannotFit => e
+          if failover_on_error
+            draw
+          else
+            raise e
+          end
+        end
+
+        private
+
+        attr_reader :cells, :column_widths, :failover_strategy
+
+        def prawn_table_options
+          static_prawn_table_options.tap do |options|
+            options[:width] = total_width
+            options[:header] = cells.first && cells.first.all?(&:header)
+            options[:column_widths] = column_widths
+          end
+        end
+
+        def static_prawn_table_options
+          table_options.dup.tap do |options|
+            options.delete(:placeholder)
+            options.delete(:header)
+            TEXT_STYLE_OPTIONS.each { |key| options[:cell].delete(key) }
+            options[:cell_style] = options.delete(:cell)
+          end
+        end
+
+        def convert_cells
+          cells.map do |row|
+            row.map.with_index do |cell, col|
+              convert_cell(cell, col)
+            end
+          end
+        end
+
+        def convert_cell(cell, col)
+          style_options = table_options[cell.header ? :header : :cell]
+          if cell.single?
+            normalize_cell_node(cell.nodes.first, column_content_width(col), style_options)
+          else
+            cell_table(cell, column_content_width(col), style_options)
+          end
+        end
+
+        def column_content_width(col)
+          width = column_widths[col]
+          width -= horizontal_padding if width
+          width
+        end
+
+        # cell with multiple nodes is represented as single-column table
+        def cell_table(cell, width, style_options)
+          data = cell.nodes.map { |n| [normalize_cell_node(n, width, style_options)] }
+          pdf.make_table(data,
+                         width: width,
+                         cell_style: {
+                           padding: [0, 0, 0, 0],
+                           borders: [],
+                           border_width: 0,
+                           inline_format: true
+                         })
+        end
+
+        def normalize_cell_node(node, width, style_options = {})
+          normalizer = "cell_node_for_#{type_key(node)}"
+          if respond_to?(normalizer, true)
+            send(normalizer, node, width, style_options)
+          else
+            ''
+          end
+        end
+
+        def cell_node_for_list(node, width, _style_options = {})
+          opts = options.merge(text: extract_text_cell_style(table_options[:cell]))
+          subtable(width) do
+            ListBuilder.new(pdf, node, width, opts).make(true)
+          end
+        end
+
+        def cell_node_for_array(node, width, _style_options = {})
+          subtable(width) do
+            TableBuilder.new(pdf, node, width, options).make
+          end
+        end
+
+        def cell_node_for_hash(node, width, style_options = {})
+          normalize_cell_hash(node, width, style_options)
+        end
+
+        def cell_node_for_string(node, _width, style_options = {})
+          style_options.merge(content: node)
+        end
+
+        def subtable(width)
+          if width.nil? && failover_strategy == :subtable_placeholders
+            { content: table_options[:placeholder][:subtable_too_large] }
+          else
+            yield
+          end
+        end
+
+        def normalize_cell_hash(node, width, style_options)
+          if width.nil? && total_width
+            width = total_width - column_width_sum - (columns_without_width - 1) * MIN_COL_WIDTH
+          end
+          super(node, width, style_options)
+        end
+
+        def compute_column_widths
+          parse_given_widths
+          if total_width
+            add_missing_widths
+            stretch_to_total_width
+          end
+        end
+
+        def parse_given_widths
+          return if cells.empty?
+
+          @column_widths = Array.new(cells.first.size)
+          converter = SizeConverter.new(total_width)
+          cells.each do |row|
+            row.each_with_index do |cell, col|
+              @column_widths[col] ||= converter.parse(cell.width)
+            end
+          end
+        end
+
+        def add_missing_widths
+          missing_count = columns_without_width
+          if missing_count == 1 ||
+             (missing_count > 1 && failover_strategy == :equal_widths)
+            distribute_remaing_width(missing_count)
+          end
+        end
+
+        def columns_without_width
+          column_widths.count(&:nil?)
+        end
+
+        def column_width_sum
+          column_widths.compact.inject(:+) || 0
+        end
+
+        def distribute_remaing_width(count)
+          equal_width = (total_width - column_width_sum) / count.to_f
+          return if equal_width < 0
+          column_widths.map! { |width| width || equal_width }
+        end
+
+        def stretch_to_total_width
+          sum = column_width_sum
+          if columns_without_width.zero? && sum < total_width
+            increase_widths(sum)
+          elsif sum > total_width
+            decrease_widths(sum)
+          end
+        end
+
+        def increase_widths(sum)
+          diff = total_width - sum
+          column_widths.map! { |w| w + w / sum * diff }
+        end
+
+        def decrease_widths(sum)
+          sum += columns_without_width * MIN_COL_WIDTH
+          diff = sum - total_width
+          column_widths.map! { |w| w ? [w - w / sum * diff, 0].max : nil }
+        end
+
+        def failover_on_error
+          if failover_strategy == FAILOVER_STRATEGIES.last
+            @failover_strategy = nil
+          else
+            index = FAILOVER_STRATEGIES.index(failover_strategy) || -1
+            @failover_strategy = FAILOVER_STRATEGIES[index + 1]
+          end
+        end
+
+        def horizontal_padding
+          @horizontal_padding ||= begin
+            padding = table_options[:cell][:padding] || [DEFAULT_CELL_PADDING] * 4
+            padding.is_a?(Array) ? padding[1] + padding[3] : padding
+          end
+        end
+
+        def table_options
+          @table_options ||= build_table_options
+        end
+
+        def build_table_options
+          HashMerger.deep(default_table_options, options[:table] || {}).tap do |opts|
+            build_cell_options(opts)
+            build_header_options(opts)
+          end
+        end
+
+        def build_cell_options(opts)
+          HashMerger.enhance(opts, :cell, extract_text_cell_style(options[:text] || {}))
+          convert_style_options(opts[:cell])
+        end
+
+        def build_header_options(opts)
+          HashMerger.enhance(opts, :header, opts[:cell])
+          convert_style_options(opts[:header])
+        end
+
+        def convert_style_options(hash)
+          hash[:font_style] ||= hash.delete(:style)
+          hash[:text_color] ||= hash.delete(:color)
+        end
+
+        def default_table_options
+          {
+            cell: {
+              inline_format: true,
+              padding: [DEFAULT_CELL_PADDING] * 4
+            },
+            header: {},
+            placeholder: {
+              subtable_too_large: '[nested tables with automatic width are not supported]'
+            }
+          }
+        end
+      end
+    end
+  end
+end