asciidoctor-pdf 1.5.0.alpha.16 → 1.5.0

data/lib/{asciidoctor-pdf/prawn_ext → asciidoctor/pdf/ext/prawn}/font/afm.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 class Prawn::Font::AFM
+  include ::Asciidoctor::Logging
+
   FALLBACK_CHARS = {
-    %(\u200b) => '',
-    %(\u202f) => %(\u00a0),
-    %(\u2009) => ' ',
-    %(\u25e6) => '-',
-    %(\u25aa) => %(\u00b7)
+    ?\u200b => '',
+    ?\u202f => ?\u00a0,
+    ?\u2009 => ' ',
+    ?\u25e6 => '-',
+    ?\u25aa => ?\u00b7,
   }
 
   remove_method :normalize_encoding
@@ -17,12 +21,12 @@ class Prawn::Font::AFM
   def normalize_encoding text
     text.encode 'windows-1252', fallback: FALLBACK_CHARS
   rescue ::Encoding::UndefinedConversionError
-    warn 'The following text could not be fully converted to the Windows-1252 character set:'
-    warn %(#{text.gsub(/^/, '| ').rstrip})
-    text.encode 'windows-1252', undef: :replace, replace: %(\u00ac)
+    logger.warn %(The following text could not be fully converted to the Windows-1252 character set:
+#{text.gsub(/^/, '| ').rstrip}) if logger.info? && !@document.scratch?
+    text.encode 'windows-1252', undef: :replace, replace: ?\u00ac
   rescue ::Encoding::InvalidByteSequenceError
     raise Prawn::Errors::IncompatibleStringEncoding,
-          %(Your document includes text which is not compatible with the Windows-1252 character set.
-If you need full UTF-8 support, use TTF fonts instead of the built-in PDF (AFM) fonts.)
+        'Your document includes text which is not compatible with the Windows-1252 character set.
+If you need full UTF-8 support, use TTF fonts instead of the built-in PDF (AFM) fonts.'
   end
 end

data/lib/asciidoctor/pdf/ext/prawn/font_metric_cache.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Prawn::FontMetricCache::CacheEntry
+  # workaround for https://github.com/prawnpdf/prawn/issues/1140
+  def initialize font, options, size
+    font = font.hash
+    super
+  end
+end

data/lib/asciidoctor/pdf/ext/prawn/formatted_text/box.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+Prawn::Text::Formatted::Box.prepend (Module.new do
+  include ::Asciidoctor::Logging
+
+  def draw_fragment_overlay_styles fragment
+    if (underline = (styles = fragment.styles).include? :underline) || (styles.include? :strikethrough)
+      (doc = fragment.document).save_graphics_state do
+        if (text_decoration_width = (fs = fragment.format_state)[:text_decoration_width] || doc.text_decoration_width)
+          doc.line_width = text_decoration_width
+        end
+        if (text_decoration_color = fs[:text_decoration_color])
+          doc.stroke_color = text_decoration_color
+        end
+        underline ? (doc.stroke_line fragment.underline_points) : (doc.stroke_line fragment.strikethrough_points)
+      end
+    end
+  end
+
+  def find_font_for_this_glyph char, current_font, fallback_fonts_to_check, original_font = current_font
+    (doc = @document).font current_font
+    if fallback_fonts_to_check.empty?
+      if logger.info? && !doc.scratch?
+        fonts_checked = @fallback_fonts.dup.unshift original_font
+        missing_chars = (doc.instance_variable_defined? :@missing_chars) ?
+            (doc.instance_variable_get :@missing_chars) : (doc.instance_variable_set :@missing_chars, {})
+        previous_fonts_checked = (missing_chars[char] ||= [])
+        if previous_fonts_checked.empty? && !(previous_fonts_checked.include? fonts_checked)
+          logger.warn %(Could not locate the character `#{char}' in the following fonts: #{fonts_checked.join ', '})
+          previous_fonts_checked << fonts_checked
+        end
+      end
+      current_font
+    elsif doc.font.glyph_present? char
+      current_font
+    else
+      find_font_for_this_glyph char, fallback_fonts_to_check.shift, fallback_fonts_to_check, original_font
+    end
+  end
+
+  def process_vertical_alignment text
+    return super if ::Symbol === (valign = @vertical_align)
+
+    return if defined? @vertical_alignment_processed
+    @vertical_alignment_processed = true
+
+    valign, offset = valign
+
+    if valign == :top
+      @at[1] -= offset
+      return
+    end
+
+    wrap text
+    h = height
+
+    case valign
+    when :center
+      @at[1] -= (@height - h + @descender) * 0.5 + offset
+    when :bottom
+      @at[1] -= (@height - h) + offset
+    end
+
+    @height = h
+  end
+end)

data/lib/{asciidoctor-pdf/prawn_ext → asciidoctor/pdf/ext/prawn}/formatted_text/fragment.rb

@@ -1,14 +1,19 @@
-module Asciidoctor
-module Prawn
-module FormattedText
-module Fragment
+# frozen_string_literal: true
+
+Prawn::Text::Formatted::Fragment.prepend (Module.new do
   attr_reader :document
-  
+
   # Prevent fragment from being written by discarding the text.
   def conceal
     @text = ''
   end
 
+  # Don't strip soft hyphens when repacking unretrieved fragments
+  def include_trailing_white_space!
+    @format_state.delete :normalized_soft_hyphen
+    super
+  end
+
   # Modify the built-in ascender write method to allow an override value to be
   # specified using the format_state hash.
   def ascender= val
@@ -20,18 +25,16 @@ module Fragment
   def descender= val
     @descender = (format_state.key? :descender) ? format_state[:descender] : val
   end
-end
 
-class ::Prawn::Text::Formatted::Fragment
-  if respond_to? :prepend
-    prepend Fragment
-  else
-    # NOTE it's necessary to remove the accessor methods or else they won't get replaced
-    remove_method :ascender=
-    remove_method :descender=
-    include Fragment
+  def width
+    if (val = format_state[:width])
+      val = (val.end_with? 'em') ? val.to_f * @document.font_size : (@document.str_to_pt val) if ::String === val
+    else
+      val = super
+    end
+    if (border_offset = format_state[:border_offset])
+      val += border_offset * 2
+    end
+    val
   end
-end
-end
-end
-end
+end)

data/lib/asciidoctor/pdf/ext/prawn/images.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module Prawn
+    module Images
+      class << self
+        def extended base
+          base.class.__send__ :alias_method, :_initial_image, :image
+        end
+      end
+
+      # Dispatch to suitable image method in Prawn based on file extension.
+      def image file, opts = {}
+        # FIXME: handle case when SVG is an IO object
+        if ::String === file && (((opts = opts.dup).delete :format) == 'svg' || (file.downcase.end_with? '.svg'))
+          #opts[:enable_file_requests_with_root] = (::File.dirname file) unless opts.key? :enable_file_requests_with_root
+          #opts[:enable_web_requests] = allow_uri_read if !(opts.key? :enable_web_requests) && (respond_to? :allow_uri_read)
+          #opts[:cache_images] = cache_uri if !(opts.key? :cache_images) && (respond_to? :cache_uri)
+          #opts[:fallback_font_name] = fallback_svg_font_name if !(opts.key? :fallback_font_name) && (respond_to? :fallback_svg_font_name)
+          if (opts.key? :fit) && (fit = opts.delete :fit) && !opts[:width] && !opts[:height]
+            svg (::File.read file, mode: 'r:UTF-8'), opts do |svg_doc|
+              max_width, max_height = fit
+              svg_doc.calculate_sizing requested_width: max_width if max_width && svg_doc.sizing.output_width != max_width
+              svg_doc.calculate_sizing requested_height: max_height if max_height && svg_doc.sizing.output_height > max_height
+            end
+          else
+            svg (::File.read file, mode: 'r:UTF-8'), opts
+          end
+        else
+          _initial_image file, opts
+        end
+      end
+
+      # Retrieve the intrinsic image dimensions for the specified path.
+      #
+      # Returns a Hash containing :width and :height keys that map to the image's
+      # intrinsic width and height values (in pixels)
+      def intrinsic_image_dimensions path, format
+        if format == 'svg'
+          img_obj = ::Prawn::SVG::Interface.new (::File.read path, mode: 'r:UTF-8'), self, {}
+          img_size = img_obj.document.sizing
+          { width: img_size.output_width, height: img_size.output_height }
+        else
+          # NOTE build_image_object caches image data previously loaded
+          _, img_size = ::File.open(path, 'rb') {|fd| build_image_object fd }
+          { width: img_size.width, height: img_size.height }
+        end
+      rescue
+      end
+    end
+
+    ::Prawn::Document.extensions << Images
+  end
+end

data/lib/asciidoctor/pdf/ext/prawn-svg/interface.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Prawn
+  module SVG
+    class Interface
+      def resize opts = {}
+        sizing = document.sizing
+        sizing.requested_width = opts[:width]
+        sizing.requested_height = opts[:height]
+        sizing.calculate
+      end
+    end
+  end
+end unless Prawn::SVG::Interface.method_defined? :resize

data/lib/asciidoctor/pdf/ext/prawn-svg.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'prawn-svg' unless defined? Prawn::SVG::Interface
+require_relative 'prawn-svg/interface'
+# NOTE disable system fonts since they're non-portable
+Prawn::SVG::Interface.font_path.clear

data/lib/asciidoctor/pdf/ext/prawn-table/cell/asciidoc.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Table
+    class Cell
+      class AsciiDoc < Cell
+        attr_accessor :align
+        attr_accessor :valign
+
+        def initialize pdf, opts = {}
+          @font_options = {}
+          super pdf, [], opts
+        end
+
+        def font_style= val
+          @font_options[:style] = val
+        end
+
+        def text_color= val
+          @font_options[:color] = val
+        end
+
+        def size= val
+          @font_options[:size] = val
+        end
+
+        def font= val
+          @font_options[:family] = val
+        end
+
+        # NOTE: automatic image sizing only works if cell has fixed width
+        def dry_run
+          cell = self
+          max_height = nil
+          height, = @pdf.dry_run do
+            max_height = bounds.height
+            # NOTE: we should be able to use cell.max_width, but returns 0 in some conditions (like when colspan > 1)
+            indent cell.padding_left, bounds.width - cell.width + cell.padding_right do
+              # HACK: force margin_top to be applied
+              move_down 0.0001
+              # TODO: truncate margin bottom of last block
+              traverse cell.content
+            end
+          end
+          # FIXME: prawn-table doesn't support cell taller than a single page
+          [max_height, height - 0.0001].min
+        end
+
+        def natural_content_width
+          # QUESTION can we get a better estimate of the natural width?
+          @natural_content_width ||= (@pdf.bounds.width - padding_left - padding_right)
+        end
+
+        def natural_content_height
+          # NOTE when natural_content_height is called, we already know max width
+          @natural_content_height ||= dry_run
+        end
+
+        def draw_content
+          pdf = @pdf
+          # NOTE draw_bounded_content automatically adds FPTolerance to width and height
+          pdf.bounds.instance_variable_set :@width, spanned_content_width
+          # NOTE we've already reserved the space, so just let the box stretch to the bottom of the page to avoid overflow
+          pdf.bounds.instance_variable_set :@height, pdf.y
+          if @valign != :top && (excess_y = spanned_content_height - natural_content_height) > 0
+            pdf.move_down(@valign == :center ? (excess_y.fdiv 2) : excess_y)
+          end
+          # TODO: apply horizontal alignment (right now must use alignment on content block)
+          # QUESTION inherit table cell font properties?
+          pdf.traverse content
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/{asciidoctor-pdf/prawn-table_ext → asciidoctor/pdf/ext/prawn-table}/cell/text.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 class Prawn::Table::Cell::Text
   # Override draw_content method to drop cursor advancement
   remove_method :draw_content
   def draw_content
     with_font do
       with_text_color do
-        (text_box :width => spanned_content_width + FPTolerance,
-            :height => spanned_content_height + FPTolerance,
-            :at => [0, @pdf.cursor]).render
+        (text_box \
+          width: spanned_content_width + FPTolerance,
+          height: spanned_content_height + FPTolerance,
+          at: [0, @pdf.cursor]).render
       end
     end
   end

data/lib/asciidoctor/pdf/ext/prawn-table/cell.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Prawn::Table::Cell
+  remove_method :draw_borders
+  # Draws borders around the cell. Borders are centered on the bounds of
+  # the cell outside of any padding, so the caller is responsible for
+  # setting appropriate padding to ensure the border does not overlap with
+  # cell content.
+  #
+  def draw_borders pt
+    x, y = pt
+
+    @pdf.mask :line_width, :stroke_color do
+      @borders.each do |border|
+        idx = { top: 0, right: 1, bottom: 2, left: 3 }[border]
+        border_color = @border_colors[idx]
+        border_width = @border_widths[idx]
+        border_line  = @border_lines[idx]
+
+        next unless border_width > 0
+
+        # Left and right borders are drawn one-half border beyond the center
+        # of the corner, so that the corners end up square.
+        from, to = case border
+                   when :top
+                     [[x, y], [x + width, y]]
+                   when :bottom
+                     [[x, y - height], [x + width, y - height]]
+                   when :left
+                     [[x, y + (border_top_width / 2.0)], [x, y - height - (border_bottom_width / 2.0)]]
+                   when :right
+                     [[x + width, y + (border_top_width / 2.0)], [x + width, y - height - (border_bottom_width / 2.0)]]
+                   end
+
+        case border_line
+        when :dashed
+          @pdf.dash border_width * 4
+        when :dotted
+          @pdf.dash border_width, space: border_width * 2
+        when :solid
+          # normal line style
+        else
+          raise ::ArgumentError, 'border_line must be :solid, :dotted or :dashed'
+        end
+
+        @pdf.line_width = border_width
+        if border_color == 'transparent'
+          @pdf.stroke_color = '000000'
+          @pdf.transparent 0 do
+            @pdf.stroke_line from, to
+          end
+        else
+          @pdf.stroke_color = border_color
+          @pdf.stroke_line from, to
+        end
+        @pdf.undash
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/ext/prawn-table.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require ENV['PRAWN_TABLE_REQUIRE_PATH'] || 'prawn/table' unless defined? Prawn::Table::VERSION
+require_relative 'prawn-table/cell'
+require_relative 'prawn-table/cell/asciidoc'
+require_relative 'prawn-table/cell/text'

data/lib/{asciidoctor-pdf/prawn-templates_ext.rb → asciidoctor/pdf/ext/prawn-templates.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Prawn::Document
   # NOTE allows prawn-templates 0.0.4 to be used with prawn >= 2.2.0
   const_set :VALID_OPTIONS, (send :remove_const, :VALID_OPTIONS).dup if VALID_OPTIONS.frozen?

data/lib/asciidoctor/pdf/ext/prawn.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# the following are organized under the Asciidoctor::Prawn namespace
+require_relative 'prawn/font_metric_cache'
+require_relative 'prawn/font/afm'
+require_relative 'prawn/images'
+require_relative 'prawn/formatted_text/box'
+require_relative 'prawn/formatted_text/fragment'
+require_relative 'prawn/extensions'

data/lib/asciidoctor/pdf/ext/pygments.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'pygments.rb'
+
+module Pygments
+  module Ext
+    module BlockStyles
+      BlockSelectorRx = /^\.highlight *\{([^}]+?)\}/
+      HighlightBackgroundColorRx = /^\.highlight +\.hll +{ *background(?:-color)?: *#([a-fA-F0-9]{6})/
+      HexColorRx = /^#[a-fA-F0-9]{6}$/
+
+      @cache = ::Hash.new do |cache, key|
+        styles = {}
+        if BlockSelectorRx =~ (css = ::Pygments.css '.highlight', style: key)
+          ($1.strip.split ';').each do |style|
+            pname, pval = (style.split ':', 2).map(&:strip)
+            if pname == 'background' || pname == 'background-color'
+              styles[:background_color] = pval.slice 1, pval.length if HexColorRx.match? pval
+            elsif pname == 'color'
+              styles[:font_color] = pval.slice 1, pval.length if HexColorRx.match? pval
+            end
+          end
+        end
+        styles[:highlight_background_color] = $1 if HighlightBackgroundColorRx =~ css
+        @cache = cache.merge key => styles
+        styles
+      end
+
+      def self.for style
+        @cache[style]
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/ext/rouge/formatters/prawn.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Rouge
+  module Formatters
+    # Transforms a token stream into an array of
+    # formatted text fragments for use with Prawn.
+    class Prawn < Formatter
+      tag 'prawn'
+
+      Tokens = ::Rouge::Token::Tokens
+      LineOrientedTokens = [
+        ::Rouge::Token::Tokens::Generic::Inserted,
+        ::Rouge::Token::Tokens::Generic::Deleted,
+        ::Rouge::Token::Tokens::Generic::Heading,
+        ::Rouge::Token::Tokens::Generic::Subheading,
+      ]
+
+      LF = ?\n
+      DummyText = ?\u0000
+      NoBreakSpace = ?\u00a0
+      InnerIndent = %(#{LF} )
+      GuardedIndent = NoBreakSpace
+      GuardedInnerIndent = %(#{LF}#{NoBreakSpace})
+      BoldStyle = [:bold].to_set
+      ItalicStyle = [:italic].to_set
+      BoldItalicStyle = [:bold, :italic].to_set
+      UnderlineStyle = [:underline].to_set
+
+      def initialize opts = {}
+        unless ::Rouge::Theme === (theme = opts[:theme])
+          unless theme && (theme = ::Rouge::Theme.find theme)
+            theme = ::Rouge::Themes::AsciidoctorPDFDefault
+          end
+          theme = theme.new
+        end
+        @theme = theme
+        @normalized_colors = {}
+        @background_colorizer = BackgroundColorizer.new line_gap: opts[:line_gap]
+        @linenum_fragment_base = create_fragment Tokens::Generic::Lineno
+        @highlight_line_fragment = create_highlight_line_fragment opts[:highlight_background_color]
+      end
+
+      def background_color
+        @background_color ||= (normalize_color (@theme.style_for Tokens::Text).bg)
+      end
+
+      # Override format method so fragments don't get flatted to a string
+      # and to add an options Hash.
+      def format tokens, opts = {}
+        stream tokens, opts
+      end
+
+      def stream tokens, opts = {}
+        line_numbers = opts[:line_numbers]
+        highlight_lines = opts[:highlight_lines]
+        if line_numbers || highlight_lines
+          linenum = (linenum = opts[:start_line] || 1) > 0 ? linenum : 1
+          fragments = []
+          line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
+          fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
+          tokens.each do |tok, val|
+            if val == LF
+              fragments << { text: LF }
+              linenum += 1
+              line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
+              fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
+            elsif val.include? LF
+              # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
+              line_oriented = val.end_with? LF
+              base_fragment = create_fragment tok, val
+              val.each_line do |line|
+                if start_of_line
+                  line[0] = GuardedIndent if line.start_with? ' '
+                  start_of_line = nil
+                end
+                fragments << (line_oriented ? (base_fragment.merge text: line, inline_block: true) : (base_fragment.merge text: line))
+                next unless line.end_with? LF
+                # NOTE eagerly append linenum fragment or line highlight if there's a next line
+                linenum += 1
+                line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
+                fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
+              end
+            else
+              if start_of_line
+                val[0] = GuardedIndent if val.start_with? ' '
+                start_of_line = nil
+              end
+              fragments << (create_fragment tok, val)
+            end
+          end
+          # NOTE pad numbers that have less digits than the largest line number
+          # FIXME we could store these fragments so we don't have find them again
+          if line_numbers && (linenum_w = linenum.to_s.length) > 1
+            # NOTE extra column is the trailing space after the line number
+            linenum_w += 1
+            fragments.each do |fragment|
+              fragment[:text] = (fragment[:text].rjust linenum_w, NoBreakSpace).to_s if fragment[:linenum]
+            end
+          end
+          fragments
+        else
+          start_of_line = true
+          tokens.map do |tok, val|
+            # match one or more consecutive endlines
+            if val == LF || (val == (LF * val.length))
+              start_of_line = true
+              { text: val }
+            else
+              val[0] = GuardedIndent if start_of_line && (val.start_with? ' ')
+              val.gsub! InnerIndent, GuardedInnerIndent if val.include? InnerIndent
+              # QUESTION do we need the call to create_fragment if val contains only spaces? consider bg
+              #fragment = create_fragment tok, val
+              fragment = val.rstrip.empty? ? { text: val } : (create_fragment tok, val)
+              # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
+              fragment[:inline_block] = true if (start_of_line = val.end_with? LF)
+              fragment
+            end
+          end
+        end
+      end
+
+      # TODO: method could still be optimized (for instance, check if val is LF or empty)
+      def create_fragment tok, val = nil
+        fragment = val ? { text: val } : {}
+        if (style_rules = @theme.style_for tok)
+          if (bg = normalize_color style_rules.bg) && bg != background_color
+            fragment[:background_color] = bg
+            fragment[:callback] = @background_colorizer
+            if LineOrientedTokens.include? tok
+              fragment[:inline_block] = true unless style_rules[:inline_block] == false
+              fragment[:extend] = true unless style_rules[:extend] == false
+            else
+              fragment[:inline_block] = true if style_rules[:inline_block]
+              fragment[:extend] = true if style_rules[:extend]
+            end
+          end
+          if (fg = normalize_color style_rules.fg)
+            fragment[:color] = fg
+          end
+          if style_rules[:bold]
+            fragment[:styles] = style_rules[:italic] ? BoldItalicStyle.dup : BoldStyle.dup
+          elsif style_rules[:italic]
+            fragment[:styles] = ItalicStyle.dup
+          end
+          if style_rules[:underline]
+            if fragment.key? :styles
+              fragment[:styles] << UnderlineStyle[0]
+            else
+              fragment[:styles] = UnderlineStyle.dup
+            end
+          end
+        end
+        fragment
+      end
+
+      def create_linenum_fragment linenum
+        @linenum_fragment_base.merge text: %(#{linenum} ), linenum: linenum
+      end
+
+      def create_highlight_line_fragment bg_color
+        {
+          background_color: (bg_color || 'FFFFCC'),
+          callback: @background_colorizer,
+          extend: true,
+          highlight: true,
+          inline_block: true,
+          text: DummyText,
+          width: 0,
+        }
+      end
+
+      def normalize_color raw
+        return unless raw
+        if (normalized = @normalized_colors[raw])
+          normalized
+        else
+          normalized = (raw.start_with? '#') ? (raw.slice 1, raw.length) : raw
+          normalized = normalized.each_char.map {|c| c * 2 }.join if normalized.length == 3
+          @normalized_colors[raw] = normalized
+        end
+      end
+
+      class BackgroundColorizer
+        def initialize opts = {}
+          @line_gap = opts[:line_gap] || 0
+        end
+
+        def render_behind fragment
+          pdf = fragment.document
+          data = fragment.format_state
+          prev_fill_color = pdf.fill_color
+          pdf.fill_color data[:background_color]
+          if data[:inline_block]
+            fragment_width = data[:extend] ? pdf.bounds.width - fragment.left : fragment.width
+            v_gap = @line_gap
+          else
+            fragment_width = fragment.width
+            v_gap = 0
+          end
+          pdf.fill_rectangle [fragment.left, fragment.top + v_gap * 0.5], fragment_width, (fragment.height + v_gap)
+          pdf.fill_color prev_fill_color
+          fragment.conceal if fragment.text == DummyText
+          nil
+        end
+      end
+    end
+  end
+end