asciidoctor-pdf 1.5.0.alpha.16 → 1.5.0

data/lib/asciidoctor-pdf/asciidoctor_ext/section.rb

@@ -1,34 +0,0 @@
-class Asciidoctor::Section
-  def numbered_title opts = {}
-    unless (@cached_numbered_title ||= nil)
-      if (slevel = (@level == 0 && @special ? 1 : @level)) == 0
-        @is_numbered = false
-        @cached_numbered_title = @cached_formal_numbered_title = title
-      elsif @numbered && !@caption && slevel <= (@document.attr 'sectnumlevels', 3).to_i
-        @is_numbered = true
-        @cached_numbered_title = %(#{sectnum} #{title})
-        @cached_formal_numbered_title = if slevel == 1 && @document.doctype == 'book'
-          %(#{@document.attr 'chapter-label', 'Chapter'} #{@cached_numbered_title}).lstrip
-        else
-          @cached_numbered_title
-        end
-      else
-        @is_numbered = false
-        @cached_numbered_title = @cached_formal_numbered_title = captioned_title
-      end
-    end
-    opts[:formal] ? @cached_formal_numbered_title : @cached_numbered_title
-  end unless method_defined? :numbered_title
-
-  def part?
-    @document.doctype == 'book' && @level == 0 && !@special
-  end unless method_defined? :part?
-
-  def chapter?
-    @document.doctype == 'book' && (@level == 1 || (@special && @level == 0))
-  end unless method_defined? :chapter?
-
-  def part_or_chapter?
-    @document.doctype == 'book' && @level < 2
-  end unless method_defined? :part_or_chapter?
-end

data/lib/asciidoctor-pdf/asciidoctor_ext.rb

@@ -1,5 +0,0 @@
-# NOTE these are all candidates for inclusion in Asciidoctor core
-require_relative 'asciidoctor_ext/section'
-require_relative 'asciidoctor_ext/list'
-require_relative 'asciidoctor_ext/list_item'
-require_relative 'asciidoctor_ext/image'

data/lib/asciidoctor-pdf/core_ext/numeric.rb

@@ -1,15 +0,0 @@
-class Numeric
-  if (instance_method :truncate).arity == 0
-    def truncate_to_precision precision
-      if (precision = precision.to_i) > 0
-        factor = 10 ** precision
-        (self * factor).truncate.fdiv factor
-      else
-        truncate
-      end
-    end
-  else
-    # use native method in Ruby >= 2.4
-    alias :truncate_to_precision :truncate
-  end unless method_defined? :truncate_to_precision
-end

data/lib/asciidoctor-pdf/core_ext/ostruct.rb

@@ -1,17 +0,0 @@
-class OpenStruct
-  def [] key
-    send key
-  end unless method_defined? :[]
-
-  def []= key, val
-    send %(#{key}=), val
-  end unless method_defined? :[]=
-end if RUBY_ENGINE == 'rbx' || RUBY_VERSION < '2.0.0'
-
-class OpenStruct
-  def delete key
-    begin
-      delete_field key
-    rescue ::NameError; end
-  end
-end

data/lib/asciidoctor-pdf/core_ext.rb

@@ -1,4 +0,0 @@
-require_relative 'core_ext/object'
-require_relative 'core_ext/array'
-require_relative 'core_ext/numeric'
-require_relative 'core_ext/string'

data/lib/asciidoctor-pdf/formatted_text/formatter.rb

@@ -1,27 +0,0 @@
-module Asciidoctor
-module Pdf
-module FormattedText
-class Formatter
-  FormattingSnifferPattern = /[<&]/
-  WHITESPACE = " \t\n"
-
-  def initialize options = {}
-    @parser = MarkupParser.new
-    @transform = Transform.new merge_adjacent_text_nodes: true, theme: options[:theme]
-  end
-
-  def format string, *args
-    options = args[0] || {}
-    string = string.tr_s(WHITESPACE, ' ') if options[:normalize]
-    return [text: string] unless string.match(FormattingSnifferPattern)
-    if (parsed = @parser.parse(string))
-      @transform.apply(parsed.content)
-    else
-      warn %(Failed to parse formatted text: #{string})
-      [text: string]
-    end
-  end
-end
-end
-end
-end

data/lib/asciidoctor-pdf/formatted_text/inline_destination_marker.rb

@@ -1,21 +0,0 @@
-module Asciidoctor::Pdf::FormattedText
-module InlineDestinationMarker
-  module_function
-
-  # render_behind is called before the text is printed
-  def render_behind fragment
-    unless (pdf = fragment.document).scratch?
-      if (name = fragment.format_state[:name])
-        if fragment.format_state[:type] == :indexterm
-          (pdf.instance_variable_get :@index).link_dest_to_page name, pdf.page_number
-        end
-        # get precise position of the reference (x, y)
-        dest_rect = fragment.absolute_bounding_box
-        pdf.add_dest name, (pdf.dest_xyz dest_rect[0], dest_rect[-1])
-        # prevent any text from being written
-        fragment.conceal
-      end
-    end
-  end
-end
-end

data/lib/asciidoctor-pdf/formatted_text/inline_image_arranger.rb

@@ -1,172 +0,0 @@
-module Asciidoctor::Pdf::FormattedText
-module InlineImageArranger
-  include ::Asciidoctor::Pdf::Measurements
-
-  ImagePlaceholderChar = '.'
-  begin
-    require 'thread_safe' unless defined? ::ThreadSafe
-    PlaceholderWidthCache = ::ThreadSafe::Cache.new
-  rescue
-    PlaceholderWidthCache = {}
-  end
-  TemporaryPath = ::Asciidoctor::Pdf::TemporaryPath
-
-  if respond_to? :prepend
-    def wrap fragments
-      arrange_images fragments
-      super
-    end
-  else
-    class << self
-      def extended base
-        base.class.__send__ :alias_method, :_initial_wrap, :wrap
-      end
-    end
-
-    def wrap fragments
-      arrange_images fragments
-      _initial_wrap fragments
-    end
-  end
-
-  # Iterates over the fragments that represent inline images and prepares the
-  # image data to be embedded into the document.
-  #
-  # This method populates the image_width, image_height, image_obj and
-  # image_info (PNG only) keys on the fragment. The text is replaced with
-  # placeholder text that will be used to reserve enough room in the line to
-  # fit the image.
-  #
-  # The image height is scaled down to 75% of the specified width (px to pt
-  # conversion). If the image height is more than 1.5x the height of the
-  # surrounding line of text, the font size and line metrics of the fragment
-  # are modified to fit the image in the line.
-  #
-  # If this is the scratch document, the image renderer callback is removed so
-  # that the image is not embedded.
-  #
-  # When this method is called, the cursor is positioned at start of where this
-  # group of fragments will be written (offset by the leading padding).
-  #
-  # This method is called each time the set of fragments overflow to another
-  # page, so it's necessary to short-circuit if that case is detected.
-  def arrange_images fragments
-    doc = @document
-    return if (raw_image_fragments = fragments.select {|f| (f.key? :image_path) && !(f.key? :image_obj) }).empty?
-    scratch = doc.scratch?
-    available_w = doc.bounds.width
-    #available_h = doc.bounds.height
-    # NOTE try to fit image within bounds if cursor is within 1% of top of page
-    # QUESTION are we considering the right boundaries here?
-    available_h ||= (doc.cursor / (available_h = doc.bounds.height) >= 0.99 ? doc.cursor : available_h)
-    raw_image_fragments.each do |fragment|
-      drop = scratch
-      begin
-        image_path = fragment[:image_path]
-
-        # NOTE only attempt to convert an unresolved (i.e., String) value
-        if ::String === (image_w = fragment[:image_width])
-          image_w = [available_w, (image_w.end_with? '%') ? (image_w.to_f / 100 * available_w) : image_w.to_f].min
-        end
-
-        # TODO make helper method to calculate width and height of image
-        if fragment[:image_format] == 'svg'
-          svg_obj = ::Prawn::Svg::Interface.new ::IO.read(image_path), doc,
-              at: doc.bounds.top_left,
-              width: image_w,
-              fallback_font_name: doc.default_svg_font
-          svg_size = image_w ? svg_obj.document.sizing :
-              # NOTE convert intrinsic dimensions to points; constrain to content width
-              (svg_obj.resize width: [(to_pt svg_obj.document.sizing.output_width, :px), available_w].min)
-          # NOTE the best we can do is make the image fit within full height of bounds
-          if (image_h = svg_size.output_height) > available_h
-            image_w = (svg_size = svg_obj.resize height: (image_h = available_h)).output_width
-          else
-            image_w = svg_size.output_width
-          end
-          fragment[:image_obj] = svg_obj
-        else
-          # TODO cache image info based on path (Prawn caches based on SHA1 of content)
-          # NOTE image_obj is constrained to image_width by renderer
-          image_obj, image_info = ::File.open(image_path, 'rb') {|fd| doc.build_image_object fd }
-          if image_w
-            if image_w == image_info.width
-              image_h = image_info.height.to_f
-            else
-              image_h = image_w * (image_info.height.fdiv image_info.width)
-            end
-          else
-            # NOTE convert intrinsic dimensions to points; constrain to content width
-            if (image_w = to_pt image_info.width, :px) > available_w
-              image_h = (image_w = available_w) * (image_info.height.fdiv image_info.width)
-            else
-              image_h = to_pt image_info.height, :px
-            end
-          end
-          # NOTE the best we can do is make the image fit within full height of bounds
-          image_w = (image_h = available_h) * (image_info.width.fdiv image_info.height) if image_h > available_h
-          fragment[:image_obj] = image_obj
-          fragment[:image_info] = image_info
-        end
-
-        spacer_w = nil
-        doc.fragment_font fragment do
-          # NOTE if image height exceeds line height by more than 1.5x, increase the line height
-          # FIXME we could really use a nicer API from Prawn here; this is an ugly hack
-          if (f_height = image_h) > (line_font = doc.font).height * 1.5
-            # align with descender (equivalent to vertical-align: bottom in CSS)
-            fragment[:ascender] = f_height - (fragment[:descender] = line_font.descender)
-            doc.font_size(fragment[:size] = f_height * (doc.font_size / line_font.height))
-            # align with baseline (roughly equivalent to vertical-align: baseline in CSS)
-            #fragment[:ascender] = f_height
-            #fragment[:descender] = 0
-            #doc.font_size(fragment[:size] = (f_height + line_font.descender) * (doc.font_size / line_font.height))
-            fragment[:line_height_increased] = true
-          end
-
-          unless (spacer_w = PlaceholderWidthCache[f_info = doc.font_info])
-            spacer_w = PlaceholderWidthCache[f_info] = doc.width_of ImagePlaceholderChar
-          end
-        end
-
-        # NOTE make room for image by repeating image placeholder character, using character spacing to fine-tune
-        # NOTE image_width is constrained to available_w, so we don't have to check for overflow
-        spacer_cnt, remainder = image_w.divmod spacer_w
-        if spacer_cnt > 0
-          fragment[:text] = ImagePlaceholderChar * spacer_cnt
-          fragment[:character_spacing] = remainder.fdiv spacer_cnt if remainder > 0
-        else
-          fragment[:text] = ImagePlaceholderChar
-          fragment[:character_spacing] = -(spacer_w - remainder)
-        end
-
-        # FIXME we could use a nicer API from Prawn here that lets us reserve a fragment width without text
-        #fragment[:image_width] = fragment[:width] = image_w
-        fragment[:image_width] = image_w
-        fragment[:image_height] = image_h
-      rescue => e
-        warn %(asciidoctor: WARNING: could not embed image: #{image_path}; #{e.message})
-        drop = true # delegate to cleanup logic in ensure block
-      ensure
-        # NOTE skip rendering image in scratch document or if image can't be loaded
-        if drop
-          fragment.delete :callback
-          fragment.delete :image_info
-          # NOTE retain key to indicate we've visited fragment already
-          fragment[:image_obj] = nil
-          # NOTE in main document, temporary image path is unlinked by renderer
-          ::File.unlink image_path if TemporaryPath === image_path && image_path.exist?
-        end
-      end
-    end
-  end
-end
-
-if respond_to? :prepend
-  class ::Prawn::Text::Formatted::Box
-    prepend InlineImageArranger
-  end
-else
-  ::Prawn::Text::Formatted::Box.extensions << InlineImageArranger
-end
-end

data/lib/asciidoctor-pdf/formatted_text/inline_image_renderer.rb

@@ -1,46 +0,0 @@
-module Asciidoctor::Pdf::FormattedText
-module InlineImageRenderer
-  TemporaryPath = ::Asciidoctor::Pdf::TemporaryPath
-  module_function
-
-  # Embeds the image object in this fragment into the document in place of the
-  # text that was previously used to reserve space for the image in the line.
-  #
-  # If the image height is less than 1.5x the height of the surrounding text,
-  # it is centered vertically in the line. If the image height is greater, then
-  # the image is aligned to the bottom of the text.
-  #
-  # Note that render_behind is called before the text is printed.
-  #
-  # This handler is only used on the main document (not the scratch document).
-  #
-  def render_behind fragment
-    pdf = fragment.document
-    data = fragment.format_state
-    image_top = if data.key? :line_height_increased
-      # align image to bottom of line (differs from fragment.top by descender value)
-      fragment.bottom + data[:image_height]
-    else
-      # center image in line
-      fragment.top - ((fragment.height - data[:image_height]) / 2.0)
-    end
-    image_left = fragment.left + ((fragment.width - data[:image_width]) / 2.0)
-    case data[:image_format]
-    when 'svg'
-      (image_obj = data[:image_obj]).options[:at] = [image_left, image_top]
-      # NOTE prawn-svg messes with the cursor; use float to workaround
-      # NOTE prawn-svg 0.24.0, 0.25.0, & 0.25.1 didn't restore font after call to draw (see mogest/prawn-svg#80)
-      pdf.float { image_obj.draw }
-    else
-      pdf.embed_image data[:image_obj], data[:image_info], at: [image_left, image_top], width: data[:image_width], height: data[:image_height]
-    end
-    # ...or use the public interface, loading the image again
-    #pdf.image data[:image_path], at: [image_left, image_top], width: data[:image_width]
-
-    # prevent any text from being written
-    fragment.conceal
-  ensure
-    ::File.unlink data[:image_path] if TemporaryPath === data[:image_path] && data[:image_path].exist?
-  end
-end
-end

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

@@ -1,261 +0,0 @@
-module Asciidoctor
-module Pdf
-module FormattedText
-class Transform
-  LF = %(\n)
-  CharEntityTable = {
-    lt: '<',
-    gt: '>',
-    amp: '&',
-    quot: '"',
-    apos: '\''
-  }
-  CharRefRx = /&(?:#(\d{2,6})|(#{CharEntityTable.keys * '|'}));/
-  TextDecorationTable = { 'underline' => :underline, 'line-through' => :strikethrough }
-  #DummyText = %(\u0000)
-
-  def initialize(options = {})
-    @merge_adjacent_text_nodes = options[:merge_adjacent_text_nodes]
-    # TODO add support for character spacing
-    if (theme = options[:theme])
-      @link_font_settings = {
-        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)
-      }.select! {|_, val| val }
-      @monospaced_font_settings = {
-        color: theme.literal_font_color,
-        font: theme.literal_font_family,
-        size: theme.literal_font_size,
-        styles: to_styles(theme.literal_font_style)
-      }.select! {|_, val| val }
-    else
-      @link_font_settings = { color: '0000FF' }
-      @monospaced_font_settings = { font: 'Courier', size: 0.9 }
-    end
-  end
-
-  # FIXME pass styles downwards to child elements rather than decorating on way out of hierarchy
-  def apply(parsed)
-    fragments = []
-    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]
-            # NOTE decorate child fragments with styles from this element
-            fragments << apply(pcdata).map {|fragment| build_fragment(fragment, 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
-          #    fragments << build_fragment({ text: DummyText }, tag_name, node[:attributes])
-          #    previous_fragment_is_text = false
-          #  end
-          end
-        # case 2: void element
-        else
-          case node[:name]
-          when :br
-            if @merge_adjacent_text_nodes && previous_fragment_is_text
-              fragments << { 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],
-              text: attributes[:alt],
-              callback: InlineImageRenderer
-            }
-            if (img_w = attributes[:width])
-              fragment[:image_width] = img_w
-            end
-            fragments << fragment
-            previous_fragment_is_text = false
-          end
-        end
-      when :text
-        text = node[:value]
-        # NOTE the remaining logic is shared with :entity
-        if @merge_adjacent_text_nodes && previous_fragment_is_text
-          fragments << { text: %(#{fragments.pop[:text]}#{text}) }
-        else
-          fragments << { text: text }
-        end
-        previous_fragment_is_text = true
-      when :entity
-        if (name = node[:name])
-          text = CharEntityTable[name]
-        else
-          # FIXME AFM fonts do not include a thin space glyph; set fallback_fonts to allow glyph to be resolved
-          text = [node[:number]].pack('U*')
-        end
-        # NOTE the remaining logic is shared with :text
-        if @merge_adjacent_text_nodes && previous_fragment_is_text
-          fragments << { text: %(#{fragments.pop[:text]}#{text}) }
-        else
-          fragments << { text: text }
-        end
-        previous_fragment_is_text = true
-      end
-    end
-    fragments.flatten
-  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 :code
-      # NOTE prefer old value, except for styles, which should be combined
-      fragment.update(@monospaced_font_settings) {|k, old_v, new_v| k == :styles ? old_v.merge(new_v) : old_v }
-    when :color
-      if !fragment[: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
-      end
-    when :font
-      if !fragment[:font] && (value = attrs[:name])
-        fragment[:font] = value
-      end
-      if !fragment[:size] && (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 !fragment[:character_spacing] && (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) {
-            $2 ? CharEntityTable[$2.to_sym] : [$1.to_i].pack('U*')
-          } : 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
-          end
-          fragment[:callback] = InlineDestinationMarker
-          visible = false
-        end
-      end
-      # NOTE prefer old value, except for styles, which should be combined
-      fragment.update(@link_font_settings) {|k, old_v, new_v| k == :styles ? old_v.merge(new_v) : old_v } 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
-          end
-        when 'font-style'
-          if pvalue == 'italic'
-            styles << :italic
-          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|
-      case class_name
-      when 'underline'
-        styles << :underline
-      when 'line-through'
-        styles << :strikethrough
-      end
-    end if attrs.key?(:class)
-    fragment.delete(:styles) if styles.empty?
-    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
-    else
-      styles = nil
-    end
-    if (style = TextDecorationTable[text_decoration])
-      styles ? (styles << style) : [style].to_set
-    else
-      styles
-    end
-  end
-end
-end
-end
-end

data/lib/asciidoctor-pdf/implicit_header_processor.rb

@@ -1,63 +0,0 @@
-require 'asciidoctor/extensions'
-
-module Asciidoctor
-module Pdf
-# An include processor that skips the implicit author line below
-# the document title within include documents.
-class ImplicitHeaderProcessor < ::Asciidoctor::Extensions::IncludeProcessor
-  def process doc, reader, target, attributes
-    return reader unless File.exist? target
-    ::File.open target, 'r' do |fd|
-      # FIXME handle case where doc id is specified above title
-      if (first_line = fd.readline) && (first_line.start_with? '= ')
-        # HACK reset counters for each article for Editions
-        if doc.attr? 'env', 'editions'
-          doc.counters.each do |counter_key, counter_val|
-            doc.attributes.delete counter_key
-          end
-          doc.counters.clear
-        end
-        if (second_line = fd.readline)
-          if AuthorInfoLineRx =~ second_line
-            # FIXME temporary hack to set author and e-mail attributes; this should handle all attributes in header!
-            author = [$1, $2, $3].compact * ' '
-            email = $4
-            reader.push_include fd.readlines, target, target, 3, attributes unless fd.eof?
-            reader.push_include first_line, target, target, 1, attributes
-            lines = [%(:author: #{author})]
-            lines << %(:email: #{email}) if email
-            reader.push_include lines, target, target, 2, attributes
-          else
-            lines = [second_line]
-            lines += fd.readlines unless fd.eof?
-            reader.push_include lines, target, target, 2, attributes
-            reader.push_include first_line, target, target, 1, attributes
-          end
-        else
-          reader.push_include first_line, target, target, 1, attributes
-        end
-      else
-        lines = [first_line]
-        lines += fd.readlines unless fd.eof?
-        reader.push_include lines, target, target, 1, attributes
-      end
-    end
-    reader
-  end
-
-  def handles? target
-    # FIXME should not require this hack to skip processing bio
-    !(target.end_with? 'bio.adoc') && ((target.end_with? '.adoc') || (target.end_with? '.asciidoc'))
-  end
-
-  # FIXME this method shouldn't be required
-  def update_config config
-    (@config ||= {}).update config
-  end
-end
-end
-end
-
-Asciidoctor::Extensions.register :pdf do
-  include_processor Asciidoctor::Pdf::ImplicitHeaderProcessor if @document.backend == 'pdf'
-end