asciidoctor-pdf 1.6.2 → 2.0.0.alpha.1

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

@@ -6,9 +6,9 @@ module Asciidoctor
       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}$/
+        CharEntityTable = { amp: '&', apos: ?', gt: '>', lt: '<', nbsp: ?\u00a0, quot: '"' }
+        CharRefRx = /&(?:(#{CharEntityTable.keys.join '|'})|#(?:(\d\d\d{0,4})|x(\h\h\h{0,3})));/
+        HexColorRx = /^#\h\h\h\h{0,3}$/
         TextDecorationTable = { 'underline' => :underline, 'line-through' => :strikethrough }
         ThemeKeyToFragmentProperty = {
           'background_color' => :background_color,
@@ -43,30 +43,30 @@ module Asciidoctor
                 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,
+                color: theme.codespan_font_color,
+                font: theme.codespan_font_family,
+                size: theme.codespan_font_size,
+                styles: (to_styles theme.codespan_font_style),
+                background_color: (mono_bg_color = theme.codespan_background_color),
+                border_width: (mono_border_width = theme.codespan_border_width),
+                border_color: mono_border_width && (theme.codespan_border_color || theme.base_border_color),
+                border_offset: (mono_border_offset = (mono_bg_or_border = mono_bg_color || mono_border_width) && theme.codespan_border_offset),
+                border_radius: mono_bg_or_border && theme.codespan_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],
+              kbd: {
+                color: theme.kbd_font_color,
+                font: theme.kbd_font_family || theme.codespan_font_family,
+                size: theme.kbd_font_size,
+                styles: (to_styles theme.kbd_font_style),
+                background_color: (kbd_bg_color = theme.kbd_background_color),
+                border_width: (kbd_border_width = theme.kbd_border_width),
+                border_color: kbd_border_width && (theme.kbd_border_color || theme.base_border_color),
+                border_offset: (kbd_border_offset = (kbd_bg_or_border = kbd_bg_color || kbd_border_width) && theme.kbd_border_offset),
+                border_radius: kbd_bg_or_border && theme.kbd_border_radius,
+                align: kbd_border_offset && :center,
+                callback: kbd_bg_or_border && [TextBackgroundAndBorderRenderer],
               }.compact,
               link: {
                 color: theme.link_font_color,
@@ -75,6 +75,10 @@ module Asciidoctor
                 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,
+                background_color: (link_bg_color = theme.link_background_color),
+                border_offset: (link_border_offset = link_bg_color && theme.link_border_offset),
+                align: link_border_offset && :center,
+                callback: link_bg_color && [TextBackgroundAndBorderRenderer],
               }.compact,
               mark: {
                 color: theme.mark_font_color,
@@ -84,6 +88,12 @@ module Asciidoctor
                 align: mark_border_offset && :center,
                 callback: mark_bg_color && [TextBackgroundAndBorderRenderer],
               }.compact,
+              menu: {
+                color: theme.menu_font_color,
+                font: theme.menu_font_family,
+                size: theme.menu_font_size,
+                styles: (to_styles theme.menu_font_style),
+              }.compact,
             }
             revise_roles = [].to_set
             theme.each_pair.each_with_object @theme_settings do |(key, val), accum|
@@ -106,14 +116,14 @@ module Asciidoctor
             @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) }
+                @theme_settings['big'] = { size: %(#{(base_font_size_large / theme.base_font_size.to_f).round 5}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) }
+                @theme_settings['small'] = { size: %(#{(base_font_size_small / theme.base_font_size.to_f).round 5}em) }
               else
                 @theme_settings['small'] = { size: '0.8333em' }
               end
@@ -122,9 +132,10 @@ module Asciidoctor
             @theme_settings = {
               button: { font: 'Courier', styles: [:bold].to_set },
               code: { font: 'Courier' },
-              key: { font: 'Courier', styles: [:italic].to_set },
+              kbd: { font: 'Courier', styles: [:italic].to_set },
               link: { color: '0000FF' },
               mark: { background_color: 'FFFF00', callback: [TextBackgroundAndBorderRenderer] },
+              menu: { styles: [:bold].to_set },
               'line-through' => { styles: [:strikethrough].to_set },
               'underline' => { styles: [:underline].to_set },
               'big' => { size: '1.667em' },
@@ -135,48 +146,53 @@ module Asciidoctor
 
         def apply parsed, fragments = [], inherited = nil
           previous_fragment_is_text = false
-          # NOTE we use each since using inject is slower than a manual loop
+          # 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
+                # 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
+                  # QUESTION: should this be handled by the formatter after the transform is complete?
+                  if previous_fragment_is_text && ((previous_fragment_text = fragments[-1][:text]).end_with? ' ')
+                    fragments[-1][:text] = previous_fragment_text.chomp ' '
+                  end
                 else
                   tag_name = node[:name]
                   attributes = node[:attributes]
                   parent = clone_fragment inherited
-                  # NOTE decorate child fragments with inherited properties from this element
+                  # 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[:src],
                     image_format: attributes[:format],
+                    # a zero-width space in the text will cause the image to be duplicated
                     # NOTE: add enclosing square brackets here to avoid errors in parsing
                     text: %([#{attributes[:alt].delete ZeroWidthSpace}]),
-                    callback: [InlineImageRenderer],
                     object_id: node.object_id, # used to deduplicate if fragment gets split up
                   }
+                  if inherited && (callback = inherited[:callback]) && (callback.include? TextBackgroundAndBorderRenderer)
+                    # NOTE: if we keep InlineTextAligner, it needs to skip draw_text! for image fragment
+                    fragment[:callback] = [TextBackgroundAndBorderRenderer, InlineImageRenderer]
+                    fragment.update inherited.slice :border_color, :border_offset, :border_radius, :border_width, :background_color
+                  else
+                    fragment[:callback] = [InlineImageRenderer]
+                  end
+                  attributes[: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]
+                    end
+                  end if attributes.key? :class
                   if inherited && (link = inherited[:link])
                     fragment[:link] = link
                   end
@@ -188,15 +204,15 @@ module Asciidoctor
                   end
                   fragments << fragment
                   previous_fragment_is_text = false
+                else # :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
                 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]]
@@ -213,61 +229,54 @@ module Asciidoctor
                 fragments << (clone_fragment inherited, text: text)
               end
               previous_fragment_is_text = true
+            else # :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
             end
           end
           fragments
         end
 
-        def build_fragment fragment, tag_name, attrs = {}
+        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
+          when :button, :code, :kbd, :mark, :menu
             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
           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).to_s == value || value.to_i.to_s == value
-                fragment[:size] = f_value
-              elsif value != '1em'
-                fragment[:size] = value
+              if value.end_with? 'em'
+                fragment[:size] = value unless value == '1em'
+              else
+                fragment[:size] = value.to_f
               end
             end
-            # NOTE width is used for font-based icons
+            # 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[:color])
+              case value.chr
+              when '#' # hex string (e.g., #FF0000)
+                fragment[:color] = value.length == 7 ? (value.slice 1, 6) : (value.slice 1, 3).each_char.map {|c| c * 2 }.join if HexColorRx.match? value
+              when '[' # CMYK array (e.g., [50, 100, 0, 0])
+                fragment[:color] = ((((value.slice 1, value.length).chomp ']').split ', ', 4).each_with_object ::Array.new 4, 0).with_index do |(it, accum), idx|
+                  accum[idx] = (ival = it.to_i) == (fval = it.to_f) ? ival : fval
+                end
+              else # assume a 6-character hex color (internal only)
+                fragment[:color] = value
+              end
             end
             #if (value = attrs[:character_spacing])
             #  fragment[:character_spacing] = value.to_f
@@ -276,15 +285,15 @@ module Asciidoctor
             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
+              # 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
+              elsif (value = attrs[:id])
+                # 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
@@ -299,39 +308,29 @@ module Asciidoctor
             styles << :superscript
           when :del
             styles << :strikethrough
-          when :span
-            # NOTE spaces in style value are superfluous for our purpose; split drops record after trailing ;
+          else # :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 'color' # color needed to support syntax highlighters
+                fragment[:color] = pvalue.length == 7 ? (pvalue.slice 1, 6) : (pvalue.slice 1, 3).each_char.map {|c| c * 2 }.join if (pvalue.start_with? '#') && (HexColorRx.match? pvalue)
               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
+                # 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] || [])
+                  fragment[:background_color] = pvalue.length == 7 ? (pvalue.slice 1, 6) : (pvalue.slice 1, 3).each_char.map {|c| c * 2 }.join
+                  # Q: is it possible that callback would already be set?
+                  #fragment[:callback] = [TextBackgroundAndBorderRenderer] | (fragment[:callback] || [])
+                  fragment[:callback] = [TextBackgroundAndBorderRenderer]
                 end
               end
             end if attrs.key? :style
@@ -340,6 +339,7 @@ module Asciidoctor
           attrs[:class].split.each do |class_name|
             next unless @theme_settings.key? class_name
             update_fragment fragment, @theme_settings[class_name]
+            # NOTE: defer assignment of callback since we must look at combined styles of element and role
             if fragment[:background_color] || (fragment[:border_color] && fragment[:border_width])
               fragment[:callback] = [TextBackgroundAndBorderRenderer] | (fragment[:callback] || [])
               fragment[:align] = :center if fragment[:border_offset]
@@ -370,6 +370,8 @@ module Asciidoctor
             styles = [:italic].to_set
           when 'bold_italic'
             styles = [:bold, :italic].to_set
+          when 'normal_italic'
+            styles = [:normal, :italic].to_set
           end
           if (style = TextDecorationTable[text_decoration])
             styles ? (styles << style) : [style].to_set
@@ -382,9 +384,14 @@ module Asciidoctor
           fragment.update props do |k, oval, nval|
             case k
             when :styles
-              nval ? (oval.merge nval) : oval.clear
-            when :callback
-              oval | nval
+              if nval
+                oval.subtract [:bold, :italic] if nval.delete? :normal
+                oval.merge nval
+              else
+                oval.clear
+              end
+            #when :callback
+            #  oval | nval
             else
               nval
             end

data/lib/asciidoctor/pdf/formatted_text.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'treetop'
-require 'set' unless defined? Set
 require_relative 'formatted_text/parser'
 require_relative 'formatted_text/transform'
 require_relative 'formatted_text/formatter'

data/lib/asciidoctor/pdf/index_catalog.rb

@@ -20,7 +20,7 @@ module Asciidoctor
         %(__indexterm-#{@sequence += 1})
       end
 
-      def store_term names, dest = nil
+      def store_term names, dest
         if (num_terms = names.size) > 2
           store_tertiary_term names[0], names[1], names[2], dest
         elsif num_terms == 2
@@ -40,8 +40,8 @@ module Asciidoctor
         (store_primary_term primary_name).store_term secondary_name, dest
       end
 
-      def store_tertiary_term primary_name, secondary_name, tertiary_name, dest = nil
-        store_dest dest if dest
+      def store_tertiary_term primary_name, secondary_name, tertiary_name, dest
+        store_dest dest
         (store_secondary_term primary_name, secondary_name).store_term tertiary_name, dest
       end
 
@@ -60,7 +60,7 @@ module Asciidoctor
 
       def link_dest_to_page anchor, physical_page_number
         if (dest = @dests[anchor])
-          virtual_page_number = physical_page_number - (@start_page_number - 1)
+          virtual_page_number = (dest[:page_sortable] = physical_page_number) - (@start_page_number - 1)
           dest[:page] = (virtual_page_number < 1 ? (RomanNumeral.new physical_page_number, :lower) : virtual_page_number).to_s
         end
       end
@@ -70,7 +70,7 @@ module Asciidoctor
       end
 
       def categories
-        @categories.empty? ? [] : @categories.values.sort
+        @categories.values.sort
       end
     end
 
@@ -83,16 +83,12 @@ module Asciidoctor
         @terms = {}
       end
 
-      def store_term name, dest = nil
+      def store_term name, dest
         term = (@terms[name] ||= (IndexTerm.new name))
         term.add_dest dest if dest
         term
       end
 
-      def find_term name
-        @terms[name]
-      end
-
       def terms
         @terms.empty? ? [] : @terms.values.sort
       end
@@ -118,7 +114,7 @@ module Asciidoctor
       end
 
       def dests
-        @dests.select {|d| d.key? :page }.sort {|a, b| a[:page] <=> b[:page] }
+        @dests.select {|d| d.key? :page }.sort_by {|d| d[:page_sortable] }
       end
 
       def container?

data/lib/asciidoctor/pdf/optimizer.rb

@@ -6,8 +6,6 @@ require 'rghost/gs_alone'
 require 'tmpdir'
 
 RGhost::GSAlone.prepend (Module.new do
-  WindowsRx = /win|ming/
-
   def initialize params, debug
     (@params = params.dup).push(*(@params.pop.split File::PATH_SEPARATOR))
     @debug = debug
@@ -60,9 +58,9 @@ module Asciidoctor
             inputs = target
           end
           (::RGhost::Convert.new inputs).to :pdf,
-              filename: filename_tmp.to_s,
-              quality: @quality,
-              d: { Printed: false, CannotEmbedFontPolicy: '/Warning', CompatibilityLevel: @compatibility_level }
+            filename: filename_tmp.to_s,
+            quality: @quality,
+            d: { Printed: false, CannotEmbedFontPolicy: '/Warning', CompatibilityLevel: @compatibility_level }
           filename_o.binwrite filename_tmp.binread
         end
         nil

data/lib/asciidoctor/pdf/pdfmark.rb

@@ -17,23 +17,31 @@ module Asciidoctor
           mod_date = (::Time.parse doc.attr 'docdatetime') rescue (now ||= ::Time.now)
           creation_date = (::Time.parse doc.attr 'localdatetime') rescue (now || ::Time.now)
         end
-        # FIXME: use sanitize: :plain_text once available
+        if (doc.attribute_locked? 'author') && !(doc.attribute_locked? 'authors')
+          author = sanitize doc.attr 'author'
+        elsif doc.attr? 'authors'
+          author = sanitize doc.attr 'authors'
+        elsif doc.attr? 'author' # rubocop:disable Lint/DuplicateBranch
+          author = sanitize doc.attr 'author'
+        end
+        # see https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/pdfmark_reference.pdf
         <<~EOS
-        [ /Title #{(sanitize doc.doctitle use_fallback: true).to_pdf_object}
-          /Author #{(doc.attr 'authors').to_pdf_object}
-          /Subject #{(doc.attr 'subject').to_pdf_object}
-          /Keywords #{(doc.attr 'keywords').to_pdf_object}
+        [ /Title #{(sanitize doc.header? ? doc.doctitle : (doc.attr 'untitled-label')).to_pdf_object}
+          /Author #{author.to_pdf_object}
+          /Subject #{((doc.attr? 'subject') ? (sanitize doc.attr 'subject') : nil).to_pdf_object}
+          /Keywords #{((doc.attr? 'keywords') ? (sanitize doc.attr 'keywords') : nil).to_pdf_object}
           /ModDate #{mod_date.to_pdf_object}
           /CreationDate #{creation_date.to_pdf_object}
           /Creator (Asciidoctor PDF #{::Asciidoctor::PDF::VERSION}, based on Prawn #{::Prawn::VERSION})
-          /Producer #{(doc.attr 'publisher').to_pdf_object}
+          /Producer #{((doc.attr? 'publisher') ? (sanitize doc.attr 'publisher') : nil).to_pdf_object}
           /DOCINFO pdfmark
         EOS
       end
 
       def generate_file pdf_file
-        # QUESTION should we use the extension pdfmeta to be more clear?
-        ::File.write %(#{pdf_file}mark), generate
+        # QUESTION: should we use the extension pdfmeta to be more clear?
+        ::File.write (pdfmark_file = %(#{pdf_file}mark)), generate
+        pdfmark_file
       end
     end
   end

data/lib/asciidoctor/pdf/roman_numeral.rb

@@ -48,15 +48,9 @@ module Asciidoctor
         1000 => 'M',
       }
 
-      def initialize initial_value, letter_case = nil
-        initial_value ||= 1
-        if ::Integer === initial_value
-          @integer_value = initial_value
-        else
-          @integer_value = RomanNumeral.roman_to_int initial_value
-          letter_case = :lower if letter_case.nil? && initial_value.upcase != initial_value
-        end
-        @letter_case = letter_case.nil? ? :upper : letter_case
+      def initialize initial_value, letter_case
+        @integer_value = ::Integer === initial_value ? initial_value : (RomanNumeral.roman_to_int initial_value)
+        @letter_case = letter_case
       end
 
       def to_s
@@ -71,18 +65,6 @@ module Asciidoctor
         @letter_case == :lower ? roman.downcase : roman
       end
 
-      def to_i
-        @integer_value
-      end
-
-      def odd?
-        to_i.odd?
-      end
-
-      def even?
-        to_i.even?
-      end
-
       def next
         RomanNumeral.new @integer_value + 1, @letter_case
       end
@@ -96,7 +78,7 @@ module Asciidoctor
         RomanNumeral.new @integer_value - 1, @letter_case
       end
 
-      def empty?
+      def nil_or_empty?
         false
       end
 

data/lib/asciidoctor/pdf/sanitizer.rb

@@ -4,29 +4,30 @@ module Asciidoctor
   module PDF
     module Sanitizer
       XMLSpecialChars = {
-        '&lt;' => ?<,
-        '&gt;' => ?>,
-        '&amp;' => ?&,
+        '&lt;' => '<',
+        '&gt;' => '>',
+        '&amp;' => '&',
       }
-      XMLSpecialCharsRx = /(?:#{XMLSpecialChars.keys.join ?|})/
+      XMLSpecialCharsRx = /(?:#{XMLSpecialChars.keys.join '|'})/
       InverseXMLSpecialChars = XMLSpecialChars.invert
       InverseXMLSpecialCharsRx = /[#{InverseXMLSpecialChars.keys.join}]/
       (BuiltInNamedEntities = {
-        'amp' => ?&,
+        'amp' => '&',
         'apos' => ?',
-        'gt' => ?>,
-        'lt' => ?<,
+        'gt' => '>',
+        'lt' => '<',
         'nbsp' => ' ',
-        'quot' => ?",
-      }).default = ??
+        'quot' => '"',
+      }).default = '?'
       SanitizeXMLRx = /<[^>]+>/
-      CharRefRx = /&(?:([a-z][a-z]+\d{0,2})|#(?:(\d\d\d{0,4})|x([a-f\d][a-f\d][a-f\d]{0,3})));/
+      CharRefRx = /&(?:amp;)?(?:([a-z][a-z]+\d{0,2})|#(?:(\d\d\d{0,4})|x(\h\h\h{0,3})));/
+      UnescapedAmpersandRx = /&(?!(?:[a-z][a-z]+\d{0,2}|#(?:\d\d\d{0,4}|x\h\h\h{0,3}));)/
 
       # Strip leading, trailing and repeating whitespace, remove XML tags and
       # resolve all entities in the specified string.
       #
-      # FIXME move to a module so we can mix it in elsewhere
-      # FIXME add option to control escaping entities, or a filter mechanism in general
+      # FIXME: move to a module so we can mix it in elsewhere
+      # FIXME: add option to control escaping entities, or a filter mechanism in general
       def sanitize string
         string = string.gsub SanitizeXMLRx, '' if string.include? '<'
         string = string.gsub(CharRefRx) { $1 ? BuiltInNamedEntities[$1] : ([$2 ? $2.to_i : ($3.to_i 16)].pack 'U1') } if string.include? '&'
@@ -37,8 +38,12 @@ module Asciidoctor
         string.gsub InverseXMLSpecialCharsRx, InverseXMLSpecialChars
       end
 
+      def escape_amp string
+        string.gsub UnescapedAmpersandRx, '&amp;'
+      end
+
       def encode_quotes string
-        (string.include? ?") ? (string.gsub ?", '&quot;') : string
+        (string.include? '"') ? (string.gsub '"', '&quot;') : string
       end
     end
   end