asciidoctor-pdf 1.5.0.alpha.16 → 1.5.0

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

@@ -0,0 +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})));/
+        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_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
+
+        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[: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
+          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
+          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
+              end
+            end
+            # 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
+
+        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
+
+        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
+  end
+end

data/lib/{asciidoctor-pdf → asciidoctor/pdf}/formatted_text.rb

@@ -1,8 +1,14 @@
+# 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'
+require_relative 'formatted_text/fragment_position_renderer'
 require_relative 'formatted_text/inline_destination_marker'
 require_relative 'formatted_text/inline_image_arranger'
 require_relative 'formatted_text/inline_image_renderer'
+require_relative 'formatted_text/inline_text_aligner'
+require_relative 'formatted_text/source_wrap'
+require_relative 'formatted_text/text_background_and_border_renderer'

data/lib/asciidoctor/pdf/index_catalog.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    class IndexCatalog
+      include ::Asciidoctor::PDF::TextTransformer
+
+      LeadingAlphaRx = /^\p{Alpha}/
+
+      attr_accessor :start_page_number
+
+      def initialize
+        @categories = {}
+        @start_page_number = 1
+        @dests = {}
+        @sequence = 0
+      end
+
+      def next_anchor_name
+        %(__indexterm-#{@sequence += 1})
+      end
+
+      def store_term names, dest = nil
+        if (num_terms = names.size) > 2
+          store_tertiary_term names[0], names[1], names[2], dest
+        elsif num_terms == 2
+          store_secondary_term names[0], names[1], dest
+        elsif num_terms == 1
+          store_primary_term names[0], dest
+        end
+      end
+
+      def store_primary_term name, dest = nil
+        store_dest dest if dest
+        (init_category uppercase_mb name.chr).store_term name, dest
+      end
+
+      def store_secondary_term primary_name, secondary_name, dest = nil
+        store_dest dest if dest
+        (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
+        (store_secondary_term primary_name, secondary_name).store_term tertiary_name, dest
+      end
+
+      def init_category name
+        name = '@' unless LeadingAlphaRx.match? name
+        @categories[name] ||= IndexTermCategory.new name
+      end
+
+      def find_category name
+        @categories[name]
+      end
+
+      def store_dest dest
+        @dests[dest[:anchor]] = dest
+      end
+
+      def link_dest_to_page anchor, physical_page_number
+        if (dest = @dests[anchor])
+          virtual_page_number = 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
+
+      def empty?
+        @categories.empty?
+      end
+
+      def categories
+        @categories.empty? ? [] : @categories.values.sort
+      end
+    end
+
+    class IndexTermGroup
+      include Comparable
+      attr_reader :name
+
+      def initialize name
+        @name = name
+        @terms = {}
+      end
+
+      def store_term name, dest = nil
+        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
+
+      def <=> other
+        (val = @name.casecmp other.name) == 0 ? @name <=> other.name : val
+      end
+    end
+
+    class IndexTermCategory < IndexTermGroup; end
+
+    class IndexTerm < IndexTermGroup
+      def initialize name
+        super
+        @dests = ::Set.new
+      end
+
+      alias subterms terms
+
+      def add_dest dest
+        @dests << dest
+        self
+      end
+
+      def dests
+        @dests.select {|d| d.key? :page }.sort {|a, b| a[:page] <=> b[:page] }
+      end
+
+      def container?
+        @dests.empty? || @dests.none? {|d| d.key? :page }
+      end
+
+      def leaf?
+        @terms.empty?
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/measurements.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    module Measurements
+      MeasurementValueRx = /(\d+|\d*\.\d+)(in|mm|cm|p[txc])?$/
+      InsetMeasurementValueRx = /(?<=^| |\()(-?\d+(?:\.\d+)?)(in|mm|cm|p[txc])(?=$| |\))/
+      MeasurementValueHintRx = /\d(in|mm|cm|p[txc])/
+
+      # Convert the specified string value to a pt value from the
+      # specified unit of measurement (e.g., in, cm, mm, etc).
+      # If the unit of measurement is not recognized, assume pt.
+      #
+      # Examples:
+      #
+      #  0.5in => 36.0
+      #  100px => 75.0
+      #  72blah => 72.0
+      #
+      def str_to_pt val
+        MeasurementValueRx =~ val ? (to_pt $1.to_f, $2) : val.to_f
+      end
+
+      # Converts the specified float value to a pt value from the
+      # specified unit of measurement (e.g., in, cm, mm, etc).
+      # Raises an argument error if the unit of measurement is not recognized.
+      def to_pt num, units
+        units = units.to_s if ::Symbol === units
+        if units.nil_or_empty?
+          num
+        else
+          case units
+          when 'pt'
+            num
+          when 'in'
+            num * 72
+          when 'mm'
+            num * (72 / 25.4)
+          when 'cm'
+            num * (720 / 25.4)
+          when 'px'
+            # assuming canvas of 96 dpi
+            num * 0.75
+          when 'pc'
+            num * 12
+          else
+            raise ::ArgumentError, %(unknown unit of measurement: #{units})
+          end
+        end
+      end
+
+      # Resolve measurement values in the string to PDF points.
+      def resolve_measurement_values str
+        if MeasurementValueHintRx.match? str
+          str.gsub(InsetMeasurementValueRx) { to_pt $1.to_f, $2 }
+        else
+          str
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/optimizer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'rghost'
+require 'tmpdir'
+
+module Asciidoctor
+  module PDF
+    class Optimizer
+      (QUALITY_NAMES = {
+        'default' => :default,
+        'screen' => :screen,
+        'ebook' => :ebook,
+        'printer' => :printer,
+        'prepress' => :prepress,
+      }).default = :default
+
+      def initialize quality = 'default', compatibility_level = '1.4'
+        @quality = QUALITY_NAMES[quality]
+        @compatibility_level = compatibility_level
+      end
+
+      def generate_file target
+        ::Dir::Tmpname.create ['asciidoctor-pdf-', '.pdf'] do |tmpfile|
+          filename = Pathname.new target
+          filename_o = Pathname.new tmpfile
+          pdfmark = filename.sub_ext '.pdfmark'
+          inputs = pdfmark.file? ? [target, pdfmark.to_s] : target
+          (::RGhost::Convert.new inputs).to :pdf,
+              filename: filename_o.to_s,
+              quality: @quality,
+              d: { Printed: false, CannotEmbedFontPolicy: '/Warning', CompatibilityLevel: @compatibility_level }
+          begin
+            filename_o.rename target
+          rescue ::Errno::EXDEV
+            filename.binwrite filename_o.binread
+            filename_o.unlink
+          end
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/asciidoctor/pdf/pdfmark.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    class Pdfmark
+      include ::Asciidoctor::PDF::Sanitizer
+
+      def initialize doc
+        @doc = doc
+      end
+
+      def generate
+        doc = @doc
+        if doc.attr? 'reproducible'
+          mod_date = creation_date = (::Time.at 0).utc
+        else
+          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
+        content = <<~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}
+          /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}
+          /DOCINFO pdfmark
+        EOS
+        content
+      end
+
+      def generate_file pdf_file
+        # QUESTION should we use the extension pdfmeta to be more clear?
+        ::File.write %(#{pdf_file}mark), generate
+      end
+    end
+  end
+end