asciidoctor-pdf 1.5.0.beta.8 → 1.5.0.rc.1

data/lib/asciidoctor/pdf/formatted_text/inline_text_aligner.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
+
 module Asciidoctor::PDF::FormattedText
-module InlineTextAligner
-  module_function
+  module InlineTextAligner
+    module_function
 
-  def render_behind fragment
-    document = fragment.document
-    text = fragment.text
-    x = fragment.left
-    y = fragment.baseline
-    align = fragment.format_state[:align]
-    if align == :center || align == :right
-      if (gap_width = fragment.width - (document.width_of text)) != 0
-        x += gap_width * (align == :center ? 0.5 : 1)
+    def render_behind fragment
+      document = fragment.document
+      text = fragment.text
+      x = fragment.left
+      y = fragment.baseline
+      align = fragment.format_state[:align]
+      if align == :center || align == :right
+        if (gap_width = fragment.width - (document.width_of text)) != 0
+          x += gap_width * (align == :center ? 0.5 : 1)
+        end
       end
+      document.draw_text! text, at: [x, y]
+      fragment.conceal
     end
-    document.draw_text! text, at: [x, y]
-    fragment.conceal
   end
 end
-end

data/lib/asciidoctor/pdf/formatted_text/source_wrap.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    module FormattedText
+      module SourceWrap
+        NoBreakSpace = ?\u00a0
+
+        def wrap array
+          initialize_wrap array
+          stop = nil
+          highlight_line = nil
+          unconsumed = @arranger.unconsumed
+          if (linenum_fragment = unconsumed[0] || {})[:linenum]
+            linenum_spacer = { text: NoBreakSpace + (' ' * (linenum_fragment[:text].length - 1)) }
+          end
+          until stop
+            if linenum_spacer && (first_fragment = unconsumed[0])
+              if first_fragment[:linenum]
+                highlight_line = (second_fragment = unconsumed[1]) && (second_fragment[:highlight]) ? second_fragment.dup : nil
+              else
+                first_fragment[:text] = first_fragment[:text].lstrip
+                @arranger.unconsumed.unshift highlight_line if highlight_line
+                @arranger.unconsumed.unshift linenum_spacer.dup
+              end
+            end
+            @line_wrap.wrap_line document: @document, kerning: @kerning, width: available_width, arranger: @arranger, disable_wrap_by_char: @disable_wrap_by_char
+            if enough_height_for_this_line?
+              move_baseline_down
+              print_line
+            else
+              stop = true
+            end
+            stop ||= @single_line || @arranger.finished?
+          end
+          @text = @printed_lines.join ?\n
+          @everything_printed = @arranger.finished?
+          @arranger.unconsumed
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/formatted_text/text_background_and_border_renderer.rb

@@ -1,46 +1,55 @@
 # frozen_string_literal: true
+
 module Asciidoctor::Pdf::FormattedText
-module TextBackgroundAndBorderRenderer
-  module_function
+  module TextBackgroundAndBorderRenderer
+    module_function
 
-  # render_behind is called before the text is printed
-  def render_behind fragment
-    return if (pdf = fragment.document).scratch?
-    data = fragment.format_state
-    if (border_offset = data[:border_offset])
-      at = [fragment.left - border_offset, fragment.top + border_offset]
-      width = fragment.width + border_offset * 2
-      height = fragment.height + border_offset * 2
-    else
-      at = fragment.top_left
-      width = fragment.width
-      height = fragment.height
-    end
-    border_radius = data[:border_radius]
-    if (background_color = data[:background_color])
-      prev_fill_color = pdf.fill_color
-      pdf.fill_color background_color
-      if border_radius
-        pdf.fill_rounded_rectangle at, width, height, border_radius
+    DummyText = ?\u0000
+
+    # render_behind is called before the text is printed
+    def render_behind fragment
+      return if (pdf = fragment.document).scratch?
+      data = fragment.format_state
+      if data[:inline_block]
+        padding = (height = fragment.line_height) - fragment.height
+        at = [fragment.left, fragment.top + padding * 0.5]
+        width = data[:extend] ? (pdf.bounds.width - fragment.left) : fragment.width
+        fragment.conceal if fragment.text == DummyText
+      elsif (border_offset = data[:border_offset])
+        at = [fragment.left, fragment.top + border_offset]
+        width = fragment.width
+        height = fragment.height + border_offset * 2
       else
-        pdf.fill_rectangle at, width, height
+        at = fragment.top_left
+        width = fragment.width
+        height = fragment.height
       end
-      pdf.fill_color prev_fill_color
-    end
-    if (border_width = data[:border_width])
-      border_color = data[:border_color]
-      prev_stroke_color = pdf.stroke_color
-      prev_line_width = pdf.line_width
-      pdf.stroke_color border_color
-      pdf.line_width border_width
-      if border_radius
-        pdf.stroke_rounded_rectangle at, width, height, border_radius
-      else
-        pdf.stroke_rectangle at, width, height
+      border_radius = data[:border_radius]
+      if (background_color = data[:background_color])
+        prev_fill_color = pdf.fill_color
+        pdf.fill_color background_color
+        if border_radius
+          pdf.fill_rounded_rectangle at, width, height, border_radius
+        else
+          pdf.fill_rectangle at, width, height
+        end
+        pdf.fill_color prev_fill_color
+      end
+      if (border_width = data[:border_width])
+        border_color = data[:border_color]
+        prev_stroke_color = pdf.stroke_color
+        prev_line_width = pdf.line_width
+        pdf.stroke_color border_color
+        pdf.line_width border_width
+        if border_radius
+          pdf.stroke_rounded_rectangle at, width, height, border_radius
+        else
+          pdf.stroke_rectangle at, width, height
+        end
+        pdf.stroke_color prev_stroke_color
+        pdf.line_width prev_line_width
       end
-      pdf.stroke_color prev_stroke_color
-      pdf.line_width prev_line_width
+      nil
     end
   end
 end
-end

data/lib/asciidoctor/pdf/formatted_text/transform.rb

@@ -1,375 +1,394 @@
 # frozen_string_literal: true
+
 module Asciidoctor
-module PDF
-module FormattedText
-class Transform
-  LF = ?\n
-  ZeroWidthSpace = ?\u200b
-  CharEntityTable = {
-    amp: ?&,
-    apos: ?',
-    gt: ?>,
-    lt: ?<,
-    nbsp: ?\u00a0,
-    quot: ?",
-  }
-  CharRefRx = /&(?:(#{CharEntityTable.keys.join ?|})|#(?:(\d\d\d{0,4})|x([a-f\d][a-f\d][a-f\d]{0,3})));/
-  TextDecorationTable = { 'underline' => :underline, 'line-through' => :strikethrough }
-  ThemeKeyToFragmentProperty = {
-    'background_color' => :background_color,
-    'border_color' => :border_color,
-    'border_offset' => :border_offset,
-    'border_radius' => :border_radius,
-    'border_width' => :border_width,
-    'font_color' => :color,
-    'font_family' => :font,
-    'font_size' => :size,
-    'text_decoration_color' => :text_decoration_color,
-    'text_decoration_width' => :text_decoration_width,
-  }
-  #DummyText = ?\u0000
+  module PDF
+    module FormattedText
+      class Transform
+        LF = ?\n
+        ZeroWidthSpace = ?\u200b
+        CharEntityTable = { amp: ?&, apos: ?', gt: ?>, lt: ?<, nbsp: ?\u00a0, quot: ?" }
+        CharRefRx = /&(?:(#{CharEntityTable.keys.join ?|})|#(?:(\d\d\d{0,4})|x([a-f\d][a-f\d][a-f\d]{0,3})));/
+        HexColorRx = /^#[a-fA-F0-9]{6}$/
+        TextDecorationTable = { 'underline' => :underline, 'line-through' => :strikethrough }
+        ThemeKeyToFragmentProperty = {
+          'background_color' => :background_color,
+          'border_color' => :border_color,
+          'border_offset' => :border_offset,
+          'border_radius' => :border_radius,
+          'border_width' => :border_width,
+          'font_color' => :color,
+          'font_family' => :font,
+          'font_size' => :size,
+          'text_decoration_color' => :text_decoration_color,
+          'text_decoration_width' => :text_decoration_width,
+        }
+        #DummyText = ?\u0000
 
-  def initialize(options = {})
-    @merge_adjacent_text_nodes = options[:merge_adjacent_text_nodes]
-    # TODO add support for character spacing
-    if (theme = options[:theme])
-      @theme_settings = {
-        button: {
-          color: theme.button_font_color,
-          font: theme.button_font_family,
-          size: theme.button_font_size,
-          styles: (to_styles theme.button_font_style),
-          background_color: (button_bg_color = theme.button_background_color),
-          border_width: (button_border_width = theme.button_border_width),
-          border_color: button_border_width && (theme.button_border_color || theme.base_border_color),
-          border_offset: (button_bg_or_border = button_bg_color || button_border_width) && theme.button_border_offset,
-          border_radius: button_bg_or_border && theme.button_border_radius,
-          callback: button_bg_or_border && [TextBackgroundAndBorderRenderer],
-        }.compact,
-        code: {
-          color: theme.literal_font_color,
-          font: theme.literal_font_family,
-          size: theme.literal_font_size,
-          styles: (to_styles theme.literal_font_style),
-          background_color: (monospaced_bg_color = theme.literal_background_color),
-          border_width: (monospaced_border_width = theme.literal_border_width),
-          border_color: monospaced_border_width && (theme.literal_border_color || theme.base_border_color),
-          border_offset: (monospaced_bg_or_border = monospaced_bg_color || monospaced_border_width) && theme.literal_border_offset,
-          border_radius: monospaced_bg_or_border && theme.literal_border_radius,
-          callback: monospaced_bg_or_border && [TextBackgroundAndBorderRenderer],
-        }.compact,
-        key: {
-          color: theme.key_font_color,
-          font: theme.key_font_family || theme.literal_font_family,
-          size: theme.key_font_size,
-          styles: (to_styles theme.key_font_style),
-          background_color: (key_bg_color = theme.key_background_color),
-          border_width: (key_border_width = theme.key_border_width),
-          border_color: key_border_width && (theme.key_border_color || theme.base_border_color),
-          border_offset: (key_bg_or_border = key_bg_color || key_border_width) && theme.key_border_offset,
-          border_radius: key_bg_or_border && theme.key_border_radius,
-          callback: key_bg_or_border && [TextBackgroundAndBorderRenderer],
-        }.compact,
-        link: {
-          color: theme.link_font_color,
-          font: theme.link_font_family,
-          size: theme.link_font_size,
-          styles: (to_styles theme.link_font_style, theme.link_text_decoration),
-          text_decoration_color: theme.link_text_decoration_color,
-          text_decoration_width: theme.link_text_decoration_width,
-        }.compact,
-        mark: {
-          color: theme.mark_font_color,
-          styles: (to_styles theme.mark_font_style),
-          background_color: (mark_bg_color = theme.mark_background_color),
-          border_offset: mark_bg_color && theme.mark_border_offset,
-          callback: mark_bg_color && [TextBackgroundAndBorderRenderer],
-        }.compact,
-      }
-      revise_roles = [].to_set
-      theme.each_pair.reduce @theme_settings do |accum, (key, val)|
-        if (key = key.to_s).start_with? 'role_'
-          role, key = (key.slice 5, key.length).split '_', 2
-          if (prop = ThemeKeyToFragmentProperty[key])
-            (accum[role] ||= {})[prop] = val
-          elsif key == 'font_style' || key == 'text_decoration'
-            revise_roles << role
+        def initialize options = {}
+          @merge_adjacent_text_nodes = options[:merge_adjacent_text_nodes]
+          # TODO: add support for character spacing
+          if (theme = options[:theme])
+            @theme_settings = {
+              button: {
+                color: theme.button_font_color,
+                font: theme.button_font_family,
+                size: theme.button_font_size,
+                styles: (to_styles theme.button_font_style),
+                background_color: (button_bg_color = theme.button_background_color),
+                border_width: (button_border_width = theme.button_border_width),
+                border_color: button_border_width && (theme.button_border_color || theme.base_border_color),
+                border_offset: (button_border_offset = (button_bg_or_border = button_bg_color || button_border_width) && theme.button_border_offset),
+                border_radius: button_bg_or_border && theme.button_border_radius,
+                align: button_border_offset && :center,
+                callback: button_bg_or_border && [TextBackgroundAndBorderRenderer],
+              }.compact,
+              code: {
+                color: theme.literal_font_color,
+                font: theme.literal_font_family,
+                size: theme.literal_font_size,
+                styles: (to_styles theme.literal_font_style),
+                background_color: (mono_bg_color = theme.literal_background_color),
+                border_width: (mono_border_width = theme.literal_border_width),
+                border_color: mono_border_width && (theme.literal_border_color || theme.base_border_color),
+                border_offset: (mono_border_offset = (mono_bg_or_border = mono_bg_color || mono_border_width) && theme.literal_border_offset),
+                border_radius: mono_bg_or_border && theme.literal_border_radius,
+                align: mono_border_offset && :center,
+                callback: mono_bg_or_border && [TextBackgroundAndBorderRenderer],
+              }.compact,
+              key: {
+                color: theme.key_font_color,
+                font: theme.key_font_family || theme.literal_font_family,
+                size: theme.key_font_size,
+                styles: (to_styles theme.key_font_style),
+                background_color: (key_bg_color = theme.key_background_color),
+                border_width: (key_border_width = theme.key_border_width),
+                border_color: key_border_width && (theme.key_border_color || theme.base_border_color),
+                border_offset: (key_border_offset = (key_bg_or_border = key_bg_color || key_border_width) && theme.key_border_offset),
+                border_radius: key_bg_or_border && theme.key_border_radius,
+                align: key_border_offset && :center,
+                callback: key_bg_or_border && [TextBackgroundAndBorderRenderer],
+              }.compact,
+              link: {
+                color: theme.link_font_color,
+                font: theme.link_font_family,
+                size: theme.link_font_size,
+                styles: (to_styles theme.link_font_style, theme.link_text_decoration),
+                text_decoration_color: theme.link_text_decoration_color,
+                text_decoration_width: theme.link_text_decoration_width,
+              }.compact,
+              mark: {
+                color: theme.mark_font_color,
+                styles: (to_styles theme.mark_font_style),
+                background_color: (mark_bg_color = theme.mark_background_color),
+                border_offset: (mark_border_offset = mark_bg_color && theme.mark_border_offset),
+                align: mark_border_offset && :center,
+                callback: mark_bg_color && [TextBackgroundAndBorderRenderer],
+              }.compact,
+            }
+            revise_roles = [].to_set
+            theme.each_pair.each_with_object @theme_settings do |(key, val), accum|
+              next unless (key = key.to_s).start_with? 'role_'
+              role, key = (key.slice 5, key.length).split '_', 2
+              if (prop = ThemeKeyToFragmentProperty[key])
+                (accum[role] ||= {})[prop] = val
+              #elsif key == 'font_kerning'
+              #  unless (resolved_val = val == 'none' ? false : (val == 'normal' ? true : nil)).nil?
+              #    (accum[role] ||= {})[:kerning] = resolved_val
+              #  end
+              elsif key == 'font_style' || key == 'text_decoration'
+                revise_roles << role
+              end
+            end
+            revise_roles.each_with_object @theme_settings do |role, accum|
+              (accum[role] ||= {})[:styles] = to_styles theme[%(role_#{role}_font_style)], theme[%(role_#{role}_text_decoration)]
+            end
+            @theme_settings['line-through'] = { styles: [:strikethrough].to_set } unless @theme_settings.key? 'line-through'
+            @theme_settings['underline'] = { styles: [:underline].to_set } unless @theme_settings.key? 'underline'
+            unless @theme_settings.key? 'big'
+              if (base_font_size_large = theme.base_font_size_large)
+                @theme_settings['big'] = { size: %(#{(base_font_size_large / theme.base_font_size.to_f).round 4}em) }
+              else
+                @theme_settings['big'] = { size: '1.1667em' }
+              end
+            end
+            unless @theme_settings.key? 'small'
+              if (base_font_size_small = theme.base_font_size_small)
+                @theme_settings['small'] = { size: %(#{(base_font_size_small / theme.base_font_size.to_f).round 4}em) }
+              else
+                @theme_settings['small'] = { size: '0.8333em' }
+              end
+            end
+          else
+            @theme_settings = {
+              button: { font: 'Courier', styles: [:bold].to_set },
+              code: { font: 'Courier' },
+              key: { font: 'Courier', styles: [:italic].to_set },
+              link: { color: '0000FF' },
+              mark: { background_color: 'FFFF00', callback: [TextBackgroundAndBorderRenderer] },
+              'line-through' => { styles: [:strikethrough].to_set },
+              'underline' => { styles: [:underline].to_set },
+              'big' => { size: '1.667em' },
+              'small' => { size: '0.8333em' },
+            }
           end
         end
-        accum
-      end
-      revise_roles.reduce @theme_settings do |accum, role|
-        (accum[role] ||= {})[:styles] = to_styles theme[%(role_#{role}_font_style)], theme[%(role_#{role}_text_decoration)]
-        accum
-      end
-      @theme_settings['line-through'] = { styles: [:strikethrough].to_set } unless @theme_settings.key? 'line-through'
-      @theme_settings['underline'] = { styles: [:underline].to_set } unless @theme_settings.key? 'underline'
-      unless @theme_settings.key? 'big'
-        if (base_font_size_large = theme.base_font_size_large)
-          @theme_settings['big'] = { size: %(#{(base_font_size_large / theme.base_font_size.to_f).round 4}em) }
-        else
-          @theme_settings['big'] = { size: '1.1667em' }
-        end
-      end
-      unless @theme_settings.key? 'small'
-        if (base_font_size_small = theme.base_font_size_small)
-          @theme_settings['small'] = { size: %(#{(base_font_size_small / theme.base_font_size.to_f).round 4}em) }
-        else
-          @theme_settings['small'] = { size: '0.8333em' }
-        end
-      end
-    else
-      @theme_settings = {
-        button: { font: 'Courier', styles: [:bold].to_set },
-        code: { font: 'Courier' },
-        key: { font: 'Courier', styles: [:italic].to_set },
-        link: { color: '0000FF' },
-        mark: { background_color: 'FFFF00', callback: [TextBackgroundAndBorderRenderer] },
-        'line-through' => { styles: [:strikethrough].to_set },
-        'underline' => { styles: [:underline].to_set },
-        'big' => { size: '1.667em' },
-        'small' => { size: '0.8333em' },
-      }
-    end
-  end
 
-  def apply(parsed, fragments = [], inherited = nil)
-    previous_fragment_is_text = false
-    # NOTE we use each since using inject is slower than a manual loop
-    parsed.each do |node|
-      case node[:type]
-      when :element
-        # case 1: non-void element
-        if node.key?(:pcdata)
-          unless (pcdata = node[:pcdata]).empty?
-            tag_name = node[:name]
-            attributes = node[:attributes]
-            parent = clone_fragment inherited
-            # NOTE decorate child fragments with inherited properties from this element
-            apply(pcdata, fragments, (build_fragment parent, tag_name, attributes))
-            previous_fragment_is_text = false
-          # NOTE skip element if it has no children
-          #else
-          #  # NOTE handle an empty anchor element (i.e., <a ...></a>)
-          #  if (tag_name = node[:name]) == :a
-          #    seed = clone_fragment inherited, text: DummyText
-          #    fragments << build_fragment(seed, tag_name, node[:attributes])
-          #    previous_fragment_is_text = false
-          #  end
+        def apply parsed, fragments = [], inherited = nil
+          previous_fragment_is_text = false
+          # NOTE we use each since using inject is slower than a manual loop
+          parsed.each do |node|
+            case node[:type]
+            when :element
+              # case 1: non-void element
+              if node.key? :pcdata
+                # NOTE skip element if it has no children
+                if (pcdata = node[:pcdata]).empty?
+                  ## NOTE handle an empty anchor element (i.e., <a ...></a>)
+                  #if (tag_name = node[:name]) == :a
+                  #  seed = clone_fragment inherited, text: DummyText
+                  #  fragments << build_fragment(seed, tag_name, node[:attributes])
+                  #  previous_fragment_is_text = false
+                  #end
+                else
+                  tag_name = node[:name]
+                  attributes = node[:attributes]
+                  parent = clone_fragment inherited
+                  # NOTE decorate child fragments with inherited properties from this element
+                  apply pcdata, fragments, (build_fragment parent, tag_name, attributes)
+                  previous_fragment_is_text = false
+                end
+              # case 2: void element
+              else
+                case node[:name]
+                when :br
+                  if @merge_adjacent_text_nodes && previous_fragment_is_text
+                    fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{LF}))
+                  else
+                    fragments << { text: LF }
+                  end
+                  previous_fragment_is_text = true
+                when :img
+                  attributes = node[:attributes]
+                  fragment = {
+                    image_path: attributes[:tmp] == 'true' ? attributes[:src].extend(TemporaryPath) : attributes[:src],
+                    image_format: attributes[:format],
+                    # a zero-width space in the text will cause the image to be duplicated
+                    text: (attributes[:alt].delete ZeroWidthSpace),
+                    callback: [InlineImageRenderer],
+                  }
+                  if inherited && (link = inherited[:link])
+                    fragment[:link] = link
+                  end
+                  if (img_w = attributes[:width])
+                    fragment[:image_width] = img_w
+                  end
+                  if (img_fit = attributes[:fit])
+                    fragment[:image_fit] = img_fit
+                  end
+                  fragments << fragment
+                  previous_fragment_is_text = false
+                end
+              end
+            when :text
+              if @merge_adjacent_text_nodes && previous_fragment_is_text
+                fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{node[:value]}))
+              else
+                fragments << (clone_fragment inherited, text: node[:value])
+              end
+              previous_fragment_is_text = true
+            when :charref
+              if (ref_type = node[:reference_type]) == :name
+                text = CharEntityTable[node[:value]]
+              elsif ref_type == :decimal
+                # FIXME: AFM fonts do not include a thin space glyph; set fallback_fonts to allow glyph to be resolved
+                text = [node[:value]].pack 'U1'
+              else
+                # FIXME: AFM fonts do not include a thin space glyph; set fallback_fonts to allow glyph to be resolved
+                text = [(node[:value].to_i 16)].pack 'U1'
+              end
+              if @merge_adjacent_text_nodes && previous_fragment_is_text
+                fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{text}))
+              else
+                fragments << (clone_fragment inherited, text: text)
+              end
+              previous_fragment_is_text = true
+            end
           end
-        # case 2: void element
-        else
-          case node[:name]
-          when :br
-            if @merge_adjacent_text_nodes && previous_fragment_is_text
-              fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{LF}))
-            else
-              fragments << { text: LF }
+          fragments
+        end
+
+        def build_fragment fragment, tag_name, attrs = {}
+          styles = (fragment[:styles] ||= ::Set.new)
+          case tag_name
+          when :strong
+            styles << :bold
+          when :em
+            styles << :italic
+          when :button, :code, :key, :mark
+            update_fragment fragment, @theme_settings[tag_name]
+          when :color
+            if (rgb = attrs[:rgb])
+              case rgb.chr
+              when '#'
+                fragment[:color] = rgb.slice 1, rgb.length
+              when '['
+                # treat value as CMYK array (e.g., "[50, 100, 0, 0]")
+                fragment[:color] = rgb.slice(1, rgb.length).chomp(']').split(', ').map(&:to_i)
+                # ...or we could honor an rgb array too
+                #case (vals = rgb.slice(1, rgb.length).chomp(']').split(', ')).size
+                #when 4
+                #  fragment[:color] = vals.map(&:to_i)
+                #when 3
+                #  fragment[:color] = vals.map {|e| '%02X' % e.to_i }.join
+                #end
+              else
+                fragment[:color] = rgb
+              end
+            # QUESTION should we even support r,g,b and c,m,y,k as individual values?
+            elsif (r_val = attrs[:r]) && (g_val = attrs[:g]) && (b_val = attrs[:b])
+              fragment[:color] = [r_val, g_val, b_val].map {|e| '%02X' % e.to_i }.join
+            elsif (c_val = attrs[:c]) && (m_val = attrs[:m]) && (y_val = attrs[:y]) && (k_val = attrs[:k])
+              fragment[:color] = [c_val.to_i, m_val.to_i, y_val.to_i, k_val.to_i]
             end
-            previous_fragment_is_text = true
-          when :img
-            attributes = node[:attributes]
-            fragment = {
-              image_path: attributes[:tmp] == 'true' ? attributes[:src].extend(TemporaryPath) : attributes[:src],
-              image_format: attributes[:format],
-              # a zero-width space in the text will cause the image to be duplicated
-              text: (attributes[:alt].delete ZeroWidthSpace),
-              callback: [InlineImageRenderer],
-            }
-            if inherited && (link = inherited[:link])
-              fragment[:link] = link
+          when :font
+            if (value = attrs[:name])
+              fragment[:font] = value
             end
-            if (img_w = attributes[:width])
-              fragment[:image_width] = img_w
+            if (value = attrs[:size])
+              # FIXME: can we make this comparison more robust / accurate?
+              if (f_value = value.to_f).to_s == value || value.to_i.to_s == value
+                fragment[:size] = f_value
+              elsif value != '1em'
+                fragment[:size] = value
+              end
             end
-            fragments << fragment
-            previous_fragment_is_text = false
+            # NOTE width is used for font-based icons
+            if (value = attrs[:width])
+              fragment[:width] = value
+              fragment[:align] = :center
+              fragment[:callback] = (fragment[:callback] || []) | [InlineTextAligner]
+            end
+            #if (value = attrs[:character_spacing])
+            #  fragment[:character_spacing] = value.to_f
+            #end
+          when :a
+            visible = true
+            # a element can have no attributes, so short-circuit if that's the case
+            unless attrs.empty?
+              # NOTE href, anchor, and name are mutually exclusive; nesting is not supported
+              if (value = attrs[:anchor])
+                fragment[:anchor] = value
+              elsif (value = attrs[:href])
+                fragment[:link] = (value.include? ';') ? (value.gsub CharRefRx do
+                  $1 ? CharEntityTable[$1.to_sym] : [$2 ? $2.to_i : ($3.to_i 16)].pack('U1')
+                end) : value
+              elsif (value = attrs[:id] || attrs[:name])
+                # NOTE text is null character, which is used as placeholder text so Prawn doesn't drop fragment
+                fragment = { name: value, callback: [InlineDestinationMarker] }
+                if (type = attrs[:type])
+                  fragment[:type] = type.to_sym
+                end
+                visible = nil
+              end
+            end
+            update_fragment fragment, @theme_settings[:link] if visible
+          when :sub
+            styles << :subscript
+          when :sup
+            styles << :superscript
+          when :del
+            styles << :strikethrough
+          when :span
+            # NOTE spaces in style value are superfluous for our purpose; split drops record after trailing ;
+            attrs[:style].tr(' ', '').split(';').each do |style|
+              pname, pvalue = style.split ':', 2
+              # TODO: text-transform
+              case pname
+              when 'color'
+                # TODO: check whether the value is a valid hex color?
+                case pvalue.length
+                when 6
+                  fragment[:color] = pvalue
+                when 7
+                  fragment[:color] = pvalue.slice 1, 6 if pvalue.start_with? '#'
+                end
+                # QUESTION should we support the 3 character form?
+                #when 3
+                #  fragment[:color] = pvalue.each_char.map {|c| c * 2 }.join
+                #when 4
+                #  fragment[:color] = pvalue.slice(1, 3).each_char.map {|c| c * 2 }.join if pvalue.start_with?('#')
+              when 'font-weight'
+                styles << :bold if pvalue == 'bold'
+              when 'font-style'
+                styles << :italic if pvalue == 'italic'
+              when 'align', 'text-align'
+                fragment[:align] = pvalue.to_sym
+                fragment[:callback] = (fragment[:callback] || []) | [InlineTextAligner]
+              when 'width'
+                # NOTE implicitly activates inline-block behavior
+                fragment[:width] = pvalue
+              when 'background-color' # background-color needed to support syntax highlighters
+                if (pvalue.start_with? '#') && (HexColorRx.match? pvalue)
+                  fragment[:background_color] = pvalue.slice 1, pvalue.length
+                  fragment[:callback] = [TextBackgroundAndBorderRenderer] | (fragment[:callback] || [])
+                end
+              end
+            end if attrs.key? :style
           end
+          # TODO: we could limit to select tags, but doesn't seem to really affect performance
+          attrs[:class].split.each do |class_name|
+            next unless @theme_settings.key? class_name
+            update_fragment fragment, @theme_settings[class_name]
+            if fragment[:background_color] || (fragment[:border_color] && fragment[:border_width])
+              fragment[:callback] = [TextBackgroundAndBorderRenderer] | (fragment[:callback] || [])
+              fragment[:align] = :center if fragment[:border_offset]
+            end
+          end if attrs.key? :class
+          fragment.delete :styles if styles.empty?
+          fragment[:callback] = (fragment[:callback] || []) | [InlineTextAligner] if fragment.key? :align
+          fragment
         end
-      when :text
-        if @merge_adjacent_text_nodes && previous_fragment_is_text
-          fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{node[:value]}))
-        else
-          fragments << (clone_fragment inherited, text: node[:value])
-        end
-        previous_fragment_is_text = true
-      when :charref
-        if (ref_type = node[:reference_type]) == :name
-          text = CharEntityTable[node[:value]]
-        elsif ref_type == :decimal
-          # FIXME AFM fonts do not include a thin space glyph; set fallback_fonts to allow glyph to be resolved
-          text = [node[:value]].pack('U1')
-        else
-          # FIXME AFM fonts do not include a thin space glyph; set fallback_fonts to allow glyph to be resolved
-          text = [(node[:value].to_i 16)].pack('U1')
-        end
-        if @merge_adjacent_text_nodes && previous_fragment_is_text
-          fragments << (clone_fragment inherited, text: %(#{fragments.pop[:text]}#{text}))
-        else
-          fragments << (clone_fragment inherited, text: text)
-        end
-        previous_fragment_is_text = true
-      end
-    end
-    fragments
-  end
 
-  def build_fragment(fragment, tag_name, attrs = {})
-    styles = (fragment[:styles] ||= ::Set.new)
-    case tag_name
-    when :strong
-      styles << :bold
-    when :em
-      styles << :italic
-    when :button, :code, :key, :mark
-      fragment.update(@theme_settings[tag_name]) {|k, oval, nval| k == :styles ? (nval ? oval.merge(nval) : oval.clear) : (k == :callback ? oval.union(nval) : nval) }
-    when :color
-      if (rgb = attrs[:rgb])
-        case rgb.chr
-        when '#'
-          fragment[:color] = rgb[1..-1]
-        when '['
-          # treat value as CMYK array (e.g., "[50, 100, 0, 0]")
-          fragment[:color] = rgb[1..-1].chomp(']').split(', ').map(&:to_i)
-          # ...or we could honor an rgb array too
-          #case (vals = rgb[1..-1].chomp(']').split(', ')).size
-          #when 4
-          #  fragment[:color] = vals.map(&:to_i)
-          #when 3
-          #  fragment[:color] = vals.map {|e| '%02X' % e.to_i }.join
-          #end
-        else
-          fragment[:color] = rgb
-        end
-      # QUESTION should we even support r,g,b and c,m,y,k as individual values?
-      elsif (r_val = attrs[:r]) && (g_val = attrs[:g]) && (b_val = attrs[:b])
-        fragment[:color] = [r_val, g_val, b_val].map {|e| '%02X' % e.to_i }.join
-      elsif (c_val = attrs[:c]) && (m_val = attrs[:m]) && (y_val = attrs[:y]) && (k_val = attrs[:k])
-        fragment[:color] = [c_val.to_i, m_val.to_i, y_val.to_i, k_val.to_i]
-      end
-    when :font
-      if (value = attrs[:name])
-        fragment[:font] = value
-      end
-      if (value = attrs[:size])
-        # FIXME can we make this comparison more robust / accurate?
-        if %(#{f_value = value.to_f}) == value || %(#{value.to_i}) == value
-          fragment[:size] = f_value
-        elsif value != '1em'
-          fragment[:size] = value
-        end
-      end
-      if (value = attrs[:width])
-        fragment[:width] = value
-        if (value = attrs[:align])
-          fragment[:align] = value.to_sym
-          fragment[:callback] = ((fragment[:callback] ||= []) << InlineTextAligner).uniq
-        end
-      end
-      #if (value = attrs[:character_spacing])
-      #  fragment[:character_spacing] = value.to_f
-      #end
-    when :a
-      visible = true
-      # a element can have no attributes, so short-circuit if that's the case
-      unless attrs.empty?
-        # NOTE href, anchor, and name are mutually exclusive; nesting is not supported
-        if (value = attrs[:anchor])
-          fragment[:anchor] = value
-        elsif (value = attrs[:href])
-          fragment[:link] = value.include?(';') ? value.gsub(CharRefRx) {
-            $1 ? CharEntityTable[$1.to_sym] : [$2 ? $2.to_i : ($3.to_i 16)].pack('U1')
-          } : value
-        elsif (value = attrs[:name])
-          # NOTE text is null character, which is used as placeholder text so Prawn doesn't drop fragment
-          fragment[:name] = value
-          if (type = attrs[:type])
-            fragment[:type] = type.to_sym
+        def clone_fragment fragment, append = nil
+          if fragment
+            fragment = fragment.dup
+            fragment[:styles] = fragment[:styles].dup if fragment.key? :styles
+            fragment[:callback] = fragment[:callback].dup if fragment.key? :callback
+          else
+            fragment = {}
           end
-          fragment[:callback] = ((fragment[:callback] ||= []) << InlineDestinationMarker).uniq
-          visible = false
+          fragment.update append if append
+          fragment
         end
-      end
-      fragment.update(@theme_settings[:link]) {|k, oval, nval| k == :styles ? (nval ? oval.merge(nval) : oval.clear) : nval } if visible
-    when :sub
-      styles << :subscript
-    when :sup
-      styles << :superscript
-    when :del
-      styles << :strikethrough
-    when :span
-      # NOTE spaces in style attribute value are superfluous, for our purpose; split drops record after trailing ;
-      attrs[:style].tr(' ', '').split(';').each do |style|
-        pname, pvalue = style.split(':', 2)
-        case pname
-        when 'color'
-          # QUESTION should we check whether the value is a valid hex color?
-          unless fragment[:color]
-            case pvalue.length
-            when 6
-              fragment[:color] = pvalue
-            when 7
-              fragment[:color] = pvalue.slice(1, 6) if pvalue.start_with?('#')
-            # QUESTION should we support the 3 character form?
-            #when 3
-            #  fragment[:color] = pvalue.each_char.map {|c| c * 2 }.join
-            #when 4
-            #  fragment[:color] = pvalue.slice(1, 3).each_char.map {|c| c * 2 }.join if pvalue.start_with?('#')
-            end
-          end
-        when 'font-weight'
-          if pvalue == 'bold'
-            styles << :bold
+
+        def to_styles font_style, text_decoration = nil
+          case font_style
+          when 'bold'
+            styles = [:bold].to_set
+          when 'italic'
+            styles = [:italic].to_set
+          when 'bold_italic'
+            styles = [:bold, :italic].to_set
           end
-        when 'font-style'
-          if pvalue == 'italic'
-            styles << :italic
+          if (style = TextDecorationTable[text_decoration])
+            styles ? (styles << style) : [style].to_set
+          else
+            styles
           end
-        # TODO text-transform
         end
-      end if attrs.key?(:style)
-    end
-    # TODO we could limit to select tags, but doesn't seem to really affect performance
-    attrs[:class].split.each do |class_name|
-      if @theme_settings.key? class_name
-        fragment.update(@theme_settings[class_name]) {|k, oval, nval| k == :styles ? (nval ? oval.merge(nval) : oval.clear) : nval }
-        if fragment[:background_color] || (fragment[:border_color] && fragment[:border_width])
-          fragment[:callback] = ((fragment[:callback] || []) << TextBackgroundAndBorderRenderer).uniq
+
+        def update_fragment fragment, props
+          fragment.update props do |k, oval, nval|
+            if k == :styles
+              nval ? (oval.merge nval) : oval.clear
+            elsif k == :callback
+              oval | nval
+            else
+              nval
+            end
+          end
         end
       end
-    end if attrs.key?(:class)
-    fragment.delete(:styles) if styles.empty?
-    fragment
-  end
-
-  def clone_fragment fragment, append = nil
-    if fragment
-      fragment = fragment.dup
-      fragment[:styles] = fragment[:styles].dup if fragment.key? :styles
-      fragment[:callback] = fragment[:callback].dup if fragment.key? :callback
-    else
-      fragment = {}
     end
-    fragment.update append if append
-    fragment
   end
-
-  def to_styles(font_style, text_decoration = nil)
-    case font_style
-    when 'bold'
-      styles = [:bold].to_set
-    when 'italic'
-      styles = [:italic].to_set
-    when 'bold_italic'
-      styles = [:bold, :italic].to_set
-    end
-    if (style = TextDecorationTable[text_decoration])
-      styles ? (styles << style) : [style].to_set
-    else
-      styles
-    end
-  end
-end
-end
-end
 end