asciidoctor-pdf 1.5.0.alpha.7 → 1.5.0.alpha.8

data/lib/asciidoctor-pdf/{prawn_ext/formatted_text → formatted_text}/parser.treetop

@@ -1,6 +1,8 @@
+# regenerate parser.rb using `tt parser.treetop`
 module Asciidoctor
-module Prawn
-grammar FormattedText
+module Pdf
+module FormattedText
+grammar Markup
   rule text
     complex
   end
@@ -15,20 +17,20 @@ grammar FormattedText
 
   rule element
     # strict tag matching (costs a minor toll)
-    # empty_element / start_tag complex end_tag &{|seq| seq[0].name == seq[2].name } {
+    # void_element / start_tag complex end_tag &{|seq| seq[0].name == seq[2].name } {
 
-    empty_element / start_tag complex end_tag {
-      # NOTE content only applies to non-empty element
+    void_element / start_tag complex end_tag {
+      # NOTE content only applies to non-void elements (second part of rule)
       def content
         { type: :element, name: (tag_element = elements[0]).name.to_sym, attributes: tag_element.attributes, pcdata: elements[1].content }
       end
     }
   end
 
-  rule empty_element
-    '<br' (spaces? '/')? '>' {
+  rule void_element
+    '<' void_tag_name attributes (spaces? '/')? '>' {
       def content
-        { type: :element, name: :br, attributes: {} }
+        { type: :element, name: elements[1].text_value.to_sym, attributes: elements[2].content }
       end
     }
   end
@@ -47,7 +49,13 @@ grammar FormattedText
 
   rule tag_name
     # QUESTION faster to do regex?
-    'a' / 'b' / 'code' / 'color' / 'del' / 'em' / 'font' / 'i' / 'link' / 'span' / 'strikethrough' / 'strong' / 'sub' / 'sup' / 'u'
+    # QUESTION can we cut stuff we aren't using? what about supporting hr?
+    #'a' / 'b' / 'code' / 'color' / 'del' / 'em' / 'font' / 'i' / 'img' / 'link' / 'span' / 'strikethrough' / 'strong' / 'sub' / 'sup' / 'u'
+    'a' / 'code' / 'color' / 'del' / 'em' / 'font' / 'span' / 'strong' / 'sub' / 'sup'
+  end
+
+  rule void_tag_name
+    'br' / 'img'
   end
 
   rule attributes
@@ -113,3 +121,4 @@ grammar FormattedText
 end
 end
 end
+end

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

@@ -1,10 +1,19 @@
 module Asciidoctor
-module Prawn
-class FormattedTextTransform
+module Pdf
+module FormattedText
+class Transform
+  EOL = "\n"
+  NamedEntityTable = {
+    :lt => '<',
+    :gt => '>',
+    :amp => '&',
+    :quot => '"',
+    :apos => '\''
+  }
   #ZeroWidthSpace = [0x200b].pack 'U*'
 
   def initialize(options = {})
-    @merge_adjacent_text_nodes = options.fetch(:merge_adjacent_text_nodes, false)
+    @merge_adjacent_text_nodes = options[:merge_adjacent_text_nodes]
     if (theme = options[:theme])
       @link_font_color = theme.link_font_color
       @monospaced_font_color = theme.literal_font_color
@@ -20,69 +29,79 @@ class FormattedTextTransform
     end
   end
 
-  # FIXME might want to pass styles downwards rather than decorating on way up
+  # 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 using inject is slower than a manual loop
+    # NOTE we use each since using inject is slower than a manual loop
     parsed.each {|node|
-      case (node_type = node[:type])
+      case node[:type]
       when :element
-        if (tag_name = node[:name]) == :br
-          if @merge_adjacent_text_nodes && previous_fragment_is_text
-            fragments << { text: %(#{fragments.pop[:text]}\n) }
-          else
-            fragments << { text: "\n" }
-          end
-          previous_fragment_is_text = true
-        else
-          if (pcdata = node[:pcdata]) && pcdata.size > 0
+        # case 1: non-void element
+        if (pcdata = node[:pcdata])
+          if pcdata.size > 0
+            tag_name = node[:name]
             attributes = node[:attributes]
             fragments << apply(pcdata).map {|fragment|
               # decorate child fragments with styles from this element
               build_fragment(fragment, tag_name, attributes)
             }
+            previous_fragment_is_text = false
+          # NOTE skip element if it has no children
           #else
-          #  # NOTE special case, handle an empty <a> element
-          #  if tag_name == :a
+          #  # NOTE handle an empty anchor element (i.e., <a ...></a>)
+          #  if (tag_name = node[:name]) == :a
           #    fragments << build_fragment({ text: ZeroWidthSpace }, tag_name, node[:attributes])
+          #    previous_fragment_is_text = false
           #  end
           end
-          previous_fragment_is_text = false
-        end
-      when :text, :entity
-        # TODO could avoid this redundant type check by splitting :text and :entity cases
-        node_text = if node_type == :text
-          node[:value]
-        elsif node_type == :entity
-          if (entity_name = node[:name])
-            case entity_name
-            when :lt
-              '<'
-            when :gt
-              '>'
-            when :amp
-              '&'
-            when :quot
-              '"'
-            when :apos
-              '\''
+        # case 2: void element
+        else
+          case node[:name]
+          when :br
+            if @merge_adjacent_text_nodes && previous_fragment_is_text
+              fragments << { text: %(#{fragments.pop[:text]}#{EOL}) }
+            else
+              fragments << { text: EOL }
             end
-          else
-            [node[:number]].pack('U*')
-            # afm fonts do not include a thin space glyph
-            # set fallback_fonts to allow glyph to be resolved
-            #if (node_number = node[:number]) == 8201
-            #  ' '
-            #else
-            #  [node_number].pack('U*')
-            #end
+            previous_fragment_is_text = true
+          when :img
+            attributes = node[:attributes]
+            fragment = {
+              image_path: attributes[:src],
+              image_type: attributes[:type],
+              image_tmp: (attributes[:tmp] == 'true'),
+              text: attributes[:alt],
+              callback: InlineImageRenderer
+            }
+            if (img_w = attributes[:width])
+              fragment[:image_width] = img_w.to_f
+            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 = NamedEntityTable[name]
+        else
+          # NOTE 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]}#{node_text}) }
+          fragments << { text: %(#{fragments.pop[:text]}#{text}) }
         else
-          fragments << { text: node_text }
+          fragments << { text: text }
         end
         previous_fragment_is_text = true
       end
@@ -91,12 +110,13 @@ class FormattedTextTransform
   end
 
   def build_fragment(fragment, tag_name = nil, attrs = {})
-    #return { text: fragment } if tag_name.nil?
+    # QUESTION should we short-circuit if tag_name is nil?
+    #return { text: fragment } unless tag_name
     styles = (fragment[:styles] ||= ::Set.new)
     case tag_name
-    when :b, :strong
+    when :strong
       styles << :bold
-    when :i, :em
+    when :em
       styles << :italic
     when :code
       fragment[:font] ||= @monospaced_font_family
@@ -140,12 +160,17 @@ class FormattedTextTransform
         fragment[:font] = value
       end
       if !fragment[:size] && (value = attrs[:size])
-        fragment[:size] = value.to_f
+        # 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, :link
+    when :a
       if !fragment[:anchor] && (value = attrs[:anchor])
         fragment[:anchor] = value
       end
@@ -164,9 +189,9 @@ class FormattedTextTransform
       styles << :subscript
     when :sup
       styles << :superscript
-    when :u
-      styles << :underline
-    when :del, :strikethrough
+    #when :u
+    #  styles << :underline
+    when :del
       styles << :strikethrough
     when :span
       # span logic with normal style parsing
@@ -201,20 +226,6 @@ class FormattedTextTransform
     fragment
   end
 end
-
-module InlineDestinationMarker
-  module_function
-
-  def render_behind fragment
-    unless (pdf_doc = fragment.instance_variable_get :@document).scratch?
-      if (name = (fragment.instance_variable_get :@format_state)[:name])
-        # get precise position of the reference
-        dest_rect = fragment.absolute_bounding_box
-        # QUESTION should we set precise x value of destination or just 0?
-        pdf_doc.add_dest name, (pdf_doc.dest_xyz dest_rect.first, dest_rect.last)
-      end
-    end
-  end
 end
 end
 end

data/lib/asciidoctor-pdf/prawn_ext.rb

@@ -1,4 +1,4 @@
-# the following modules / classes are organized under the Asciidoctor::Prawn namespace
+# the following are organized under the Asciidoctor::Prawn namespace
 require_relative 'prawn_ext/images'
+require_relative 'prawn_ext/formatted_text/fragment'
 require_relative 'prawn_ext/extensions'
-require_relative 'prawn_ext/formatted_text/formatter'

data/lib/asciidoctor-pdf/prawn_ext/extensions.rb

@@ -5,6 +5,8 @@ module Extensions
   include ::Asciidoctor::Pdf::Sanitizer
   include ::Asciidoctor::PdfCore::PdfObject
 
+  MeasurementValueRx = /(\d+|\d*\.\d+)(in|mm|cm|px|pt)?$/
+
   # - :height is the height of a line
   # - :leading is spacing between adjacent lines
   # - :padding_top is half line spacing, plus any line_gap in the font
@@ -28,12 +30,24 @@ module Extensions
     page.dimensions[2]
   end
 
+  # Returns the effective (writable) width of the page
+  #
+  def effective_page_width
+    reference_bounds.width
+  end
+
   # Returns the height of the current page from edge-to-edge
   #
   def page_height
     page.dimensions[3]
   end
 
+  # Returns the effective (writable) height of the page
+  #
+  def effective_page_height
+    reference_bounds.height
+  end
+
   # Returns the width of the left margin for the current page
   #
   def page_margin_left
@@ -68,6 +82,37 @@ module Extensions
     @y == @margin_box.absolute_top
   end
 
+  # Converts the specified float value to a pt value from the
+  # specified unit of measurement (e.g., in, cm, mm, etc).
+  def to_pt num, units
+    case units
+    when nil, 'pt'
+      num
+    when 'in'
+      num * 72
+    when 'mm'
+      num * (72 / 25.4)
+    when 'cm'
+      num * (720 / 25.4)
+    when 'px'
+      num * 0.75
+    end
+  end
+
+  # Convert the specified string value to a pt value from the
+  # specified unit of measurement (e.g., in, cm, mm, etc).
+  #
+  # Examples:
+  #
+  #  0.5in => 36.0
+  #  100px => 75.0
+  #
+  def str_to_pt val
+    if MeasurementValueRx =~ val
+      to_pt $1.to_f, $2
+    end
+  end
+
   # Destinations
 
   # Generates a destination object that resolves to the top of the page
@@ -95,10 +140,11 @@ module Extensions
   #
   # Example:
   #
-  #  register_font GillSans: {
-  #    normal: 'assets/fonts/GillSans.ttf',
-  #    bold: 'assets/fonts/GillSans-Bold.ttf',
-  #    italic: 'assets/fonts/GillSans-Italic.ttf',
+  #  register_font Roboto: {
+  #    normal: 'fonts/roboto-normal.ttf',
+  #    italic: 'fonts/roboto-italic.ttf',
+  #    bold: 'fonts/roboto-bold.ttf',
+  #    bold_italic: 'fonts/roboto-bold_italic.ttf'
   #  }
   #  
   def register_font data
@@ -126,7 +172,7 @@ module Extensions
   # Retrieves the current font info (family, style, size) as a Hash
   #
   def font_info
-    { family: font.options[:family], style: font.options[:style] || :normal, size: @font_size }
+    { family: font.options[:family], style: (font.options[:style] || :normal), size: @font_size }
   end
 
   # Sets the font style for the scope of the block to which this method
@@ -153,17 +199,62 @@ module Extensions
   # QUESTION should we round the result?
   def font_size points = nil
     return @font_size unless points
-    #if points.is_a? String
-    #  # QUESTION should we round?
-    #  points = (@font_size * (points.chop.to_f / 100.0)).round
-    #  warn points
-    #elsif points <= 1
-    #  points = (@font_size * points)
-    #end
-    if points <= 1
-      points = (@font_size * points)
+    if points == 1
+      super @font_size
+    elsif String === points
+      if points.end_with? 'rem'
+        super (@theme.base_font_size * points.to_f)
+      elsif points.end_with? 'em'
+        super (@font_size * points.to_f)
+      elsif points.end_with? '%'
+        super (@font_size * (points.to_f / 100.0))
+      else
+        super points.to_f
+      end
+    # FIXME HACK assume em value
+    elsif points < 1
+      super (@font_size * points)
+    else
+      super points
+    end
+  end
+
+  def resolve_font_style styles
+    if styles.include? :bold
+      (styles.include? :italic) ? :bold_italic : :bold
+    elsif styles.include? :italic
+      :italic
+    else
+      :normal
+    end
+  end
+
+  # Apply the font settings (family, size, styles and character spacing) from
+  # the fragment to the document, then yield to the block.
+  #
+  # The original font settings are restored before this method returns.
+  #
+  def fragment_font fragment
+    f_info = font_info
+    f_family = fragment[:font] || f_info[:family]
+    f_size = fragment[:size] || f_info[:size]
+    if (f_styles = fragment[:styles])
+      f_style = resolve_font_style f_styles
+    else
+      f_style = :normal
+    end
+
+    if (c_spacing = fragment[:character_spacing])
+      character_spacing c_spacing do
+        font f_family, size: f_size, style: f_style do
+          yield
+        end
+      end
+    else
+      font f_family, size: f_size, style: f_style do
+        yield
+      end
     end
-    super points
   end
 
   def calc_line_metrics line_height = 1, font = self.font, font_size = self.font_size
@@ -177,7 +268,7 @@ module Extensions
 
 =begin
   # these line metrics attempted to figure out a correction based on the reported height and the font_size
-  # however, it only works for some fonts, and breaks down for fonts like NotoSerif
+  # however, it only works for some fonts, and breaks down for fonts like Noto Serif
   def calc_line_metrics line_height = 1, font = self.font, font_size = self.font_size
     line_height_length = font_size * line_height
     line_gap = line_height_length - font_size
@@ -210,21 +301,38 @@ module Extensions
     end
   end
 
-  # Performs the same work as text except that the first_line_options
-  # are applied to the first line of text renderered.
-  def text_with_formatted_first_line string, first_line_options, opts
+  # Performs the same work as text except that the first_line_opts
+  # are applied to the first line of text renderered. It's necessary
+  # to use low-level APIs in this method so that we only style the
+  # first line and not the remaining lines (which is the default
+  # behavior in Prawn).
+  def text_with_formatted_first_line string, first_line_opts, opts
+    color = opts.delete :color
     fragments = parse_text string, opts
+    # NOTE the low-level APIs we're using don't recognize the :styles option, so we must resolve
+    if (styles = opts.delete :styles)
+      opts[:style] = resolve_font_style styles
+    end
+    if (first_line_styles = first_line_opts.delete :styles)
+      first_line_opts[:style] = resolve_font_style first_line_styles
+    end
+    first_line_color = (first_line_opts.delete :color) || color
     opts = opts.merge document: self
-    box = ::Prawn::Text::Formatted::Box.new fragments, (opts.merge single_line: true)
+    # QUESTION should we merge more carefully here? (hand-select keys?)
+    first_line_opts = opts.merge(first_line_opts).merge single_line: true
+    box = ::Prawn::Text::Formatted::Box.new fragments, first_line_opts
+    # NOTE get remaining_fragments before we add color to fragments on first line
     remaining_fragments = box.render dry_run: true
-    # HACK prawn removes the color from remaining_fragments, so we have to explicitly restore
-    if (color = opts[:color])
-      remaining_fragments.each {|fragment| fragment[:color] ||= color }
+    # NOTE color must be applied per-fragment
+    if first_line_color
+      fragments.each {|fragment| fragment[:color] ||= first_line_color}
     end
-    # FIXME merge options more intelligently so as not to clobber other styles in set
-    fragments = fragments.map {|fragment| fragment.merge first_line_options }
-    fill_formatted_text_box fragments, (opts.merge single_line: true)
-    if remaining_fragments.size > 0
+    fill_formatted_text_box fragments, first_line_opts
+    unless remaining_fragments.empty?
+      # NOTE color must be applied per-fragment
+      if color
+        remaining_fragments.each {|fragment| fragment[:color] ||= color }
+      end
       # as of Prawn 1.2.1, we have to handle the line gap after the first line manually
       move_down opts[:leading]
       remaining_fragments = fill_formatted_text_box remaining_fragments, opts
@@ -364,7 +472,7 @@ module Extensions
   #
   def fill_and_stroke_bounds f_color = fill_color, s_color = stroke_color, options = {}
     no_fill = !f_color || f_color == 'transparent'
-    no_stroke = !s_color || s_color == 'transparent'
+    no_stroke = !s_color || s_color == 'transparent' || options[:line_width] == 0
     return if no_fill && no_stroke
     save_graphics_state do
       radius = options[:radius] || 0
@@ -378,7 +486,7 @@ module Extensions
       # stroke
       unless no_stroke
         stroke_color s_color
-        line_width options[:line_width] || 0.5
+        line_width(options[:line_width] || 0.5)
         # FIXME think about best way to indicate dashed borders
         #if options.has_key? :dash_width
         #  dash options[:dash_width], space: options[:dash_space] || 1
@@ -429,9 +537,26 @@ module Extensions
   #
   def stroke_horizontal_rule s_color = stroke_color, options = {}
     save_graphics_state do
-      line_width options[:line_width] || 0.5
+      line_width(l_width = options[:line_width] || 0.5)
       stroke_color s_color
-      stroke_horizontal_line bounds.left, bounds.right
+      case (options[:line_style] || :solid)
+      when :solid
+        stroke_horizontal_line bounds.left, bounds.right
+      when :double
+        move_up l_width * 1.5
+        stroke_horizontal_line bounds.left, bounds.right
+        move_down l_width * 3
+        stroke_horizontal_line bounds.left, bounds.right
+        move_up l_width * 1.5
+      when :dashed
+        dash l_width * 4
+        stroke_horizontal_line bounds.left, bounds.right
+        undash
+      when :dotted
+        dash l_width
+        stroke_horizontal_line bounds.left, bounds.right
+        undash
+      end
     end
   end
 
@@ -511,20 +636,24 @@ module Extensions
     end
   end
 
-  def is_scratch?
-    !!state.store.info.data[:Scratch]
+  def scratch?
+    (@_label ||= (state.store.info.data[:Scratch] ? :scratch : :primary)) == :scratch
   end
-  alias :scratch? :is_scratch?
+  alias :is_scratch? :scratch?
 
   # TODO document me
   def dry_run &block
     scratch = get_scratch_document
     scratch.start_new_page
     start_page_number = scratch.page_number
+    # QUESTION is it enough to just set the padding or do we need to clone the bounds?
+    default_bounds = scratch.bounds
+    scratch.bounds = bounds.deep_copy.tap {|b| b.instance_variable_set :@document, scratch }
     start_y = scratch.y
     scratch.font font_family, style: font_style, size: font_size do
       scratch.instance_exec(&block)
     end
+    scratch.bounds = default_bounds
     whole_pages = scratch.page_number - start_page_number
     [(whole_pages * bounds.height + (start_y - scratch.y)), whole_pages, (start_y - scratch.y)]
   end
@@ -537,7 +666,7 @@ module Extensions
     total_height, _whole_pages, _remainder = dry_run(&block)
     # NOTE technically, if we're at the page top, we don't even need to do the
     # dry run, except several uses of this method rely on the calculated height
-    if total_height > available_space && !at_page_top?
+    if total_height > available_space && !at_page_top? && total_height <= effective_page_height
       start_new_page
       started_new_page = true
     else