asciidoctor-pdf 1.6.2 → 2.0.0.alpha.1

data/lib/asciidoctor/pdf/ext/rouge/formatters/prawn.rb

@@ -28,7 +28,7 @@ module Rouge
 
       def initialize opts = {}
         unless ::Rouge::Theme === (theme = opts[:theme])
-          unless theme && (theme = ::Rouge::Theme.find theme)
+          unless theme && ((::Class === theme && theme < ::Rouge::Theme) || (theme = ::Rouge::Theme.find theme))
             theme = ::Rouge::Themes::AsciidoctorPDFDefault
           end
           theme = theme.new
@@ -41,13 +41,7 @@ module Rouge
       end
 
       def background_color
-        @background_color ||= (normalize_color (@theme.style_for Tokens::Text).bg)
-      end
-
-      # Override format method so fragments don't get flatted to a string
-      # and to add an options Hash.
-      def format tokens, opts = {}
-        stream tokens, opts
+        @background_color ||= (normalize_color ((@theme.style_for Tokens::Text) || (::Rouge::Theme::Style.new @theme)).bg)
       end
 
       def stream tokens, opts = {}
@@ -65,7 +59,7 @@ module Rouge
               line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
               fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
             elsif val.include? LF
-              # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
+              # NOTE: we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
               line_oriented = val.end_with? LF
               base_fragment = create_fragment tok, val
               val.each_line do |line|
@@ -75,7 +69,7 @@ module Rouge
                 end
                 fragments << (line_oriented ? (base_fragment.merge text: line, inline_block: true) : (base_fragment.merge text: line))
                 next unless line.end_with? LF
-                # NOTE eagerly append linenum fragment or line highlight if there's a next line
+                # NOTE: eagerly append linenum fragment or line highlight if there's a next line
                 linenum += 1
                 line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
                 fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
@@ -88,10 +82,10 @@ module Rouge
               fragments << (create_fragment tok, val)
             end
           end
-          # NOTE pad numbers that have less digits than the largest line number
-          # FIXME we could store these fragments so we don't have find them again
+          # NOTE: pad numbers that have less digits than the largest line number
+          # FIXME: we could store these fragments so we don't have find them again
           if line_numbers && (linenum_w = linenum.to_s.length) > 1
-            # NOTE extra column is the trailing space after the line number
+            # NOTE: extra column is the trailing space after the line number
             linenum_w += 1
             fragments.each do |fragment|
               fragment[:text] = (fragment[:text].rjust linenum_w, NoBreakSpace).to_s if fragment[:linenum]
@@ -108,10 +102,10 @@ module Rouge
             else
               val[0] = GuardedIndent if start_of_line && (val.start_with? ' ')
               val.gsub! InnerIndent, GuardedInnerIndent if val.include? InnerIndent
-              # QUESTION do we need the call to create_fragment if val contains only spaces? consider bg
+              # QUESTION: do we need the call to create_fragment if val contains only spaces? consider bg
               #fragment = create_fragment tok, val
               fragment = val.rstrip.empty? ? { text: val } : (create_fragment tok, val)
-              # NOTE we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
+              # NOTE: we assume if the fragment ends in a line feed, the intention was to match a line-oriented form
               fragment[:inline_block] = true if (start_of_line = val.end_with? LF)
               fragment
             end
@@ -119,6 +113,10 @@ module Rouge
         end
       end
 
+      # Override format method so fragments don't get flatted to a string
+      # and to add an options Hash.
+      alias format stream
+
       # TODO: method could still be optimized (for instance, check if val is LF or empty)
       def create_fragment tok, val = nil
         fragment = val ? { text: val } : {}
@@ -144,7 +142,7 @@ module Rouge
           end
           if style_rules[:underline]
             if fragment.key? :styles
-              fragment[:styles] << UnderlineStyle[0]
+              fragment[:styles] |= UnderlineStyle
             else
               fragment[:styles] = UnderlineStyle.dup
             end
@@ -174,9 +172,8 @@ module Rouge
         if (normalized = @normalized_colors[raw])
           normalized
         else
-          normalized = (raw.start_with? '#') ? (raw.slice 1, raw.length) : raw
-          normalized = normalized.each_char.map {|c| c * 2 }.join if normalized.length == 3
-          @normalized_colors[raw] = normalized
+          normalized = raw.slice 1, raw.length
+          @normalized_colors[raw] = normalized.length == 3 ? normalized.each_char.map {|c| c * 2 }.join : normalized
         end
       end
 
@@ -199,7 +196,7 @@ module Rouge
           end
           pdf.fill_rectangle [fragment.left, fragment.top + v_gap * 0.5], fragment_width, (fragment.height + v_gap)
           pdf.fill_color prev_fill_color
-          fragment.conceal if fragment.text == DummyText
+          fragment.conceal true if fragment.text == DummyText
           nil
         end
       end

data/lib/asciidoctor/pdf/ext/rouge/themes/asciidoctor_pdf_default.rb

@@ -10,6 +10,7 @@ module Rouge
       # Deviate from pastie here since our italic is actually a thinner font
       style Comment,                   fg: '#888888' #, italic: true
       style Comment::Preproc,          fg: '#cc0000', bold: true
+      style Comment::PreprocFile,      fg: '#cc0000', bold: true if defined? Comment::PreprocFile
       # Deviate from pastie here by not using a background color
       style Comment::Special,          fg: '#cc0000', bold: true #, bg: '#fff0f0'
 

data/lib/asciidoctor/pdf/ext/rouge.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 
-require 'rouge'
 require_relative 'rouge/formatters/prawn'
 require_relative 'rouge/themes/asciidoctor_pdf_default'

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

@@ -24,9 +24,9 @@ module Asciidoctor
           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
+            reason = @parser.failure_reason.sub %r/ at line \d+, column \d+ \(byte (\d+)\)(.*)/, '\2 at byte \1'
+            logger.error %(failed to parse formatted text: #{string} (reason: #{reason})) unless @scratch
           end
           [inherited ? (inherited.merge text: string) : { text: string }]
         end

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

@@ -6,16 +6,14 @@ module Asciidoctor::PDF::FormattedText
 
     # 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
+      return if (pdf = fragment.document).scratch?
+      name = fragment.format_state[:name]
+      pdf.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 true
     end
   end
 end

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

@@ -37,7 +37,7 @@ module Asciidoctor::PDF::FormattedText
       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_w = available_width
       available_h = doc.page.empty? ? doc.cursor : doc.bounds.height
       last_fragment = {}
       raw_image_fragments.each do |fragment|
@@ -47,92 +47,83 @@ module Asciidoctor::PDF::FormattedText
         else
           drop = scratch
         end
-        begin
-          image_path = fragment[:image_path]
+        image_path = fragment[:image_path]
+        image_w = fragment[:image_width] || '100%'
 
-          # 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
+        # NOTE: intrinsic width is stored behind % symbol
+        if (pctidx = image_w.index '%') && pctidx + 1 < image_w.length
+          pct = (image_w.slice 0, pctidx).to_f / 100
+          intrinsic_w = (image_w.slice pctidx + 1, image_w.length).to_f
+          image_w = [available_w, pct * intrinsic_w].min
+        else
+          image_w = [available_w, pctidx ? (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
+        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
+        # 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 ? (doc.method :load_open_uri).to_proc : false,
+            enable_file_requests_with_root: (::File.dirname image_path),
+            cache_images: doc.cache_uri
+          svg_size = svg_obj.document.sizing
+          # 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
-            # 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
+            image_w = svg_size.output_width
           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
+          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_h = image_w * (image_info.height.fdiv image_info.width)) > max_image_h
+            # 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)
           end
+          fragment[:image_obj] = image_obj
+          fragment[:image_info] = image_info
+        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 === $! && !(defined? ::GMagick::Image) ? '; 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
+        doc.save_font 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
-          last_fragment = fragment
         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 === $! && !(defined? ::GMagick::Image) ? '; 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
+        last_fragment = fragment
       end
     end
   end

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

@@ -2,6 +2,8 @@
 
 module Asciidoctor::PDF::FormattedText
   module InlineImageRenderer
+    include ::Asciidoctor::Logging
+
     module_function
 
     # Embeds the image object in this fragment into the document in place of the
@@ -26,20 +28,15 @@ module Asciidoctor::PDF::FormattedText
         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)
+      if Prawn::SVG::Interface === (image_obj = data[:image_obj])
+        image_obj.options[:at] = [image_left, image_top]
+        # NOTE: prawn-svg messes with the cursor; use float to workaround
         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
+          image_obj.document.warnings.each {|img_warning| logger.warn %(problem encountered in image: #{data[:image_path]}; #{img_warning}) }
         end
       else
-        pdf.embed_image data[:image_obj], data[:image_info], at: [image_left, image_top], width: data[:image_width], height: data[:image_height]
+        pdf.embed_image 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]

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

@@ -10,10 +10,8 @@ module Asciidoctor::PDF::FormattedText
       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
+      if (align == :center || align == :right) && (gap_width = fragment.width - (document.width_of text)) != 0
+        x += gap_width * (align == :center ? 0.5 : 1)
       end
       document.draw_text! text, at: [x, y]
       fragment.conceal