asciidoctor-pdf 1.5.0.beta.1 → 1.5.0

data/lib/asciidoctor/pdf/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'ext/core'
+require_relative 'ext/asciidoctor'
+require_relative 'ext/pdf-core'
+require_relative 'ext/prawn'
+require_relative 'ext/prawn-svg'
+require_relative 'ext/prawn-table'
+require_relative 'ext/prawn-templates'

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Asciidoctor
+  module PDF
+    module FormattedText
+      class Formatter
+        include ::Asciidoctor::Logging
+
+        attr_accessor :scratch
+
+        FormattingSnifferPattern = /[<&]/
+        WHITESPACE = %( \t\n)
+
+        def initialize options = {}
+          @parser = MarkupParser.new
+          @transform = Transform.new merge_adjacent_text_nodes: true, theme: options[:theme]
+          @scratch = false
+        end
+
+        def format string, *args
+          options = args[0] || {}
+          string = string.tr_s WHITESPACE, ' ' if options[:normalize]
+          inherited = options[:inherited]
+          if FormattingSnifferPattern.match? string
+            if (parsed = @parser.parse string)
+              return @transform.apply parsed.content, [], inherited
+            elsif !@scratch
+              logger.error %(failed to parse formatted text: #{string})
+            end
+          end
+          [inherited ? (inherited.merge text: string) : { text: string }]
+        end
+
+        # The original purpose of this method is to split paragraphs, but our formatter only works on paragraphs that have
+        # been presplit. Therefore, we just need to wrap the fragments in a single-element array (representing a single
+        # paragraph) and return them.
+        def array_paragraphs fragments
+          [fragments]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Asciidoctor::PDF::FormattedText
+  class FragmentPositionRenderer
+    attr_reader :top, :right, :bottom, :left, :page_number
+
+    def render_behind fragment
+      @top = fragment.top
+      @right = (@left = fragment.left) + fragment.width
+      @bottom = fragment.bottom
+      @page_number = fragment.document.page_number
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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])
+          (pdf.instance_variable_get :@index).link_dest_to_page name, pdf.page_number if fragment.format_state[:type] == :indexterm
+          # 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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Asciidoctor::PDF::FormattedText
+  module InlineImageArranger
+    include ::Asciidoctor::PDF::Measurements
+    include ::Asciidoctor::Logging
+
+    PlaceholderChar = ::Asciidoctor::Prawn::Extensions::PlaceholderChar
+
+    def wrap fragments
+      arrange_images fragments
+      super
+    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.page.empty? ? doc.cursor : doc.bounds.height
+      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
+
+          max_image_h = fragment[:image_fit] == 'line' ? [available_h, doc.font.height].min : available_h
+
+          # TODO: make helper method to calculate width and height of image
+          if fragment[:image_format] == 'svg'
+            svg_obj = ::Prawn::SVG::Interface.new ::File.read(image_path, mode: 'r:UTF-8'), doc,
+                at: doc.bounds.top_left,
+                width: image_w,
+                fallback_font_name: doc.fallback_svg_font_name,
+                enable_web_requests: doc.allow_uri_read,
+                enable_file_requests_with_root: (::File.dirname image_path),
+                cache_images: doc.cache_uri
+            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) > max_image_h
+              image_w = (svg_obj.resize height: (image_h = max_image_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
+            # NOTE convert intrinsic dimensions to points; constrain to content width
+            elsif (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
+            # NOTE the best we can do is make the image fit within full height of bounds
+            image_w = (image_h = max_image_h) * (image_info.width.fdiv image_info.height) if image_h > max_image_h
+            fragment[:image_obj] = image_obj
+            fragment[:image_info] = image_info
+          end
+
+          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
+          end
+
+          # NOTE we can't rely on the fragment width because the line wrap mechanism ignores it;
+          # it only considers the text (string) and character spacing, rebuilding the string several times
+          fragment[:text] = PlaceholderChar
+          fragment[:actual_character_spacing] = doc.character_spacing
+          fragment[:character_spacing] = image_w
+          fragment[:image_width] = fragment[:width] = image_w
+          fragment[:image_height] = image_h
+        rescue
+          logger.warn %(could not embed image: #{image_path}; #{$!.message}#{::Prawn::Errors::UnsupportedImageType === $! ? '; install prawn-gmagick gem to add support' : ''}) unless scratch
+          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
+          end
+        end
+      end
+    end
+  end
+
+  ::Prawn::Text::Formatted::Box.prepend InlineImageArranger
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Asciidoctor::PDF::FormattedText
+  module InlineImageRenderer
+    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
+      if data.key? :line_height_increased
+        # align image to bottom of line (differs from fragment.top by descender value)
+        image_top = fragment.bottom + data[:image_height]
+      else
+        # center image in line
+        image_top = 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 do
+          pdf.character_spacing(data[:actual_character_spacing]) { image_obj.draw }
+          image_obj.document.warnings.each do |img_warning|
+            # NOTE shim logger can't be imported into a module, so use the one from the PDF document instead
+            pdf.logger.warn %(problem encountered in image: #{data[:image_path]}; #{img_warning})
+          end
+        end
+      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
+    end
+  end
+end

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

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

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

@@ -1,4 +1,4 @@
-# regenerate parser.rb using `tt parser.treetop`
+# frozen_string_literal: true
 # Autogenerated from a Treetop grammar. Edits may be lost.
 
 
@@ -433,11 +433,11 @@ module Markup
                     r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                     r0 = r8
                   else
-                    if (match_len = has_terminal?('sub', false, index))
+                    if (match_len = has_terminal?('key', false, index))
                       r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                       @index += match_len
                     else
-                      terminal_parse_failure('sub')
+                      terminal_parse_failure('key')
                       r9 = nil
                     end
                     if r9
@@ -455,19 +455,43 @@ module Markup
                         r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                         r0 = r10
                       else
-                        if (match_len = has_terminal?('del', false, index))
+                        if (match_len = has_terminal?('sub', false, index))
                           r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                           @index += match_len
                         else
-                          terminal_parse_failure('del')
+                          terminal_parse_failure('sub')
                           r11 = nil
                         end
                         if r11
                           r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                           r0 = r11
                         else
-                          @index = i0
-                          r0 = nil
+                          if (match_len = has_terminal?('mark', false, index))
+                            r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                            @index += match_len
+                          else
+                            terminal_parse_failure('mark')
+                            r12 = nil
+                          end
+                          if r12
+                            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+                            r0 = r12
+                          else
+                            if (match_len = has_terminal?('del', false, index))
+                              r13 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                              @index += match_len
+                            else
+                              terminal_parse_failure('del')
+                              r13 = nil
+                            end
+                            if r13
+                              r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+                              r0 = r13
+                            else
+                              @index = i0
+                              r0 = nil
+                            end
+                          end
                         end
                       end
                     end

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

@@ -1,4 +1,4 @@
-# regenerate parser.rb using `tt parser.treetop`
+# frozen_string_literal: true
 module Asciidoctor
 module PDF
 module FormattedText
@@ -49,9 +49,8 @@ grammar Markup
 
   rule tag_name
     # QUESTION faster to do regex?
-    # 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' / 'strong' / 'em' / 'code' / 'color' / 'font' / 'span' / 'button' / 'sub' / 'sup' / 'del'
+    # QUESTION what about supporting hr?
+    'a' / 'strong' / 'em' / 'code' / 'color' / 'font' / 'span' / 'button' / 'key' / 'sup' / 'sub' / 'mark' / 'del'
   end
 
   rule void_tag_name

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

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

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

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