asciidoctor-pdf 1.5.0.beta.8 → 1.5.0.rc.1

data/lib/asciidoctor/pdf/ext/prawn/font/afm.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Prawn::Font::AFM
   if defined? ::Asciidoctor::Logging
     include ::Asciidoctor::Logging
@@ -11,7 +12,7 @@ class Prawn::Font::AFM
     ?\u202f => ?\u00a0,
     ?\u2009 => ' ',
     ?\u25e6 => '-',
-    ?\u25aa => ?\u00b7
+    ?\u25aa => ?\u00b7,
   }
 
   remove_method :normalize_encoding
@@ -29,7 +30,7 @@ class Prawn::Font::AFM
     text.encode 'windows-1252', undef: :replace, replace: ?\u00ac
   rescue ::Encoding::InvalidByteSequenceError
     raise Prawn::Errors::IncompatibleStringEncoding,
-          %(Your document includes text which is not compatible with the Windows-1252 character set.
-If you need full UTF-8 support, use TTF fonts instead of the built-in PDF (AFM) fonts.)
+        'Your document includes text which is not compatible with the Windows-1252 character set.
+If you need full UTF-8 support, use TTF fonts instead of the built-in PDF (AFM) fonts.'
   end
 end

data/lib/asciidoctor/pdf/ext/prawn/formatted_text/box.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 Prawn::Text::Formatted::Box.prepend (Module.new do
   def draw_fragment_overlay_styles fragment
     if (underline = (styles = fragment.styles).include? :underline) || (styles.include? :strikethrough)
       (doc = fragment.document).save_graphics_state do
-        if (text_decoration_width = (fs = fragment.format_state)[:text_decoration_width])
+        if (text_decoration_width = (fs = fragment.format_state)[:text_decoration_width] || doc.text_decoration_width)
           doc.line_width = text_decoration_width
         end
         if (text_decoration_color = fs[:text_decoration_color])

data/lib/asciidoctor/pdf/ext/prawn/formatted_text/fragment.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 Prawn::Text::Formatted::Fragment.prepend (Module.new do
   attr_reader :document
 
@@ -27,9 +28,13 @@ Prawn::Text::Formatted::Fragment.prepend (Module.new do
 
   def width
     if (val = format_state[:width])
-      (val.end_with? 'em') ? val.to_f * @document.font_size : val
+      val = (val.end_with? 'em') ? val.to_f * @document.font_size : (@document.str_to_pt val) if ::String === val
     else
-      super
+      val = super
+    end
+    if (border_offset = format_state[:border_offset])
+      val += border_offset * 2
     end
+    val
   end
 end)

data/lib/asciidoctor/pdf/ext/prawn/images.rb

@@ -1,53 +1,54 @@
 # frozen_string_literal: true
+
 module Asciidoctor
-module Prawn
-module Images
-  class << self
-    def extended base
-      base.class.__send__ :alias_method, :_initial_image, :image
-    end
-  end
+  module Prawn
+    module Images
+      class << self
+        def extended base
+          base.class.__send__ :alias_method, :_initial_image, :image
+        end
+      end
 
-  # Dispatch to suitable image method in Prawn based on file extension.
-  def image file, opts = {}
-    # FIXME handle case when SVG is an IO object
-    if ::String === file && (((opts = opts.dup).delete :format) == 'svg' || (file.downcase.end_with? '.svg'))
-      #opts[:enable_file_requests_with_root] = (::File.dirname file) unless opts.key? :enable_file_requests_with_root
-      #opts[:enable_web_requests] = allow_uri_read if !(opts.key? :enable_web_requests) && (respond_to? :allow_uri_read)
-      #opts[:cache_images] = cache_uri if !(opts.key? :cache_images) && (respond_to? :cache_uri)
-      #opts[:fallback_font_name] = fallback_svg_font_name if !(opts.key? :fallback_font_name) && (respond_to? :fallback_svg_font_name)
-      if (opts.key? :fit) && (fit = opts.delete :fit) && !opts[:width] && !opts[:height]
-        svg (::File.read file, mode: 'r:UTF-8'), opts do |svg_doc|
-          max_width, max_height = fit
-          svg_doc.calculate_sizing requested_width: max_width if max_width && svg_doc.sizing.output_width != max_width
-          svg_doc.calculate_sizing requested_height: max_height if max_height && svg_doc.sizing.output_height > max_height
+      # Dispatch to suitable image method in Prawn based on file extension.
+      def image file, opts = {}
+        # FIXME: handle case when SVG is an IO object
+        if ::String === file && (((opts = opts.dup).delete :format) == 'svg' || (file.downcase.end_with? '.svg'))
+          #opts[:enable_file_requests_with_root] = (::File.dirname file) unless opts.key? :enable_file_requests_with_root
+          #opts[:enable_web_requests] = allow_uri_read if !(opts.key? :enable_web_requests) && (respond_to? :allow_uri_read)
+          #opts[:cache_images] = cache_uri if !(opts.key? :cache_images) && (respond_to? :cache_uri)
+          #opts[:fallback_font_name] = fallback_svg_font_name if !(opts.key? :fallback_font_name) && (respond_to? :fallback_svg_font_name)
+          if (opts.key? :fit) && (fit = opts.delete :fit) && !opts[:width] && !opts[:height]
+            svg (::File.read file, mode: 'r:UTF-8'), opts do |svg_doc|
+              max_width, max_height = fit
+              svg_doc.calculate_sizing requested_width: max_width if max_width && svg_doc.sizing.output_width != max_width
+              svg_doc.calculate_sizing requested_height: max_height if max_height && svg_doc.sizing.output_height > max_height
+            end
+          else
+            svg (::File.read file, mode: 'r:UTF-8'), opts
+          end
+        else
+          _initial_image file, opts
         end
-      else
-        svg (::File.read file, mode: 'r:UTF-8'), opts
       end
-    else
-      _initial_image file, opts
-    end
-  end
 
-  # Retrieve the intrinsic image dimensions for the specified path.
-  #
-  # Returns a Hash containing :width and :height keys that map to the image's
-  # intrinsic width and height values (in pixels)
-  def intrinsic_image_dimensions path, format
-    if format == 'svg'
-      img_obj = ::Prawn::SVG::Interface.new (::File.read path, mode: 'r:UTF-8'), self, {}
-      img_size = img_obj.document.sizing
-      { width: img_size.output_width, height: img_size.output_height }
-    else
-      # NOTE build_image_object caches image data previously loaded
-      _, img_size = ::File.open(path, 'rb') {|fd| build_image_object fd }
-      { width: img_size.width, height: img_size.height }
+      # Retrieve the intrinsic image dimensions for the specified path.
+      #
+      # Returns a Hash containing :width and :height keys that map to the image's
+      # intrinsic width and height values (in pixels)
+      def intrinsic_image_dimensions path, format
+        if format == 'svg'
+          img_obj = ::Prawn::SVG::Interface.new (::File.read path, mode: 'r:UTF-8'), self, {}
+          img_size = img_obj.document.sizing
+          { width: img_size.output_width, height: img_size.output_height }
+        else
+          # NOTE build_image_object caches image data previously loaded
+          _, img_size = ::File.open(path, 'rb') {|fd| build_image_object fd }
+          { width: img_size.width, height: img_size.height }
+        end
+      rescue
+      end
     end
-  rescue
-  end
-end
 
-::Prawn::Document.extensions << Images
-end
+    ::Prawn::Document.extensions << Images
+  end
 end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'pygments.rb'
+
+module Pygments
+  module Ext
+    module BlockStyles
+      BlockSelectorRx = /^\.highlight *\{([^}]+?)\}/
+      HighlightBackgroundColorRx = /^\.highlight +\.hll +{ *background(?:-color)?: *#([a-fA-F0-9]{6})/
+      HexColorRx = /^#[a-fA-F0-9]{6}$/
+
+      @cache = ::Hash.new do |cache, key|
+        styles = {}
+        if BlockSelectorRx =~ (css = ::Pygments.css '.highlight', style: key)
+          ($1.strip.split ';').each do |style|
+            pname, pval = (style.split ':', 2).map(&:strip)
+            if pname == 'background' || pname == 'background-color'
+              styles[:background_color] = pval.slice 1, pval.length if HexColorRx.match? pval
+            elsif pname == 'color'
+              styles[:font_color] = pval.slice 1, pval.length if HexColorRx.match? pval
+            end
+          end
+        end
+        styles[:highlight_background_color] = $1 if HighlightBackgroundColorRx =~ css
+        @cache = cache.merge key => styles
+        styles
+      end
+
+      def self.for style
+        @cache[style]
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
+
 require 'rouge'
 require_relative 'rouge/formatters/prawn'
 require_relative 'rouge/themes/asciidoctor_pdf_default'
-require_relative 'rouge/themes/bw' unless Rouge::Theme.find 'bw'

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

@@ -1,176 +1,208 @@
 # frozen_string_literal: true
+
 module Rouge
-module Formatters
-# Transforms a token stream into an array of
-# formatted text fragments for use with Prawn.
-class Prawn < Formatter
-  tag 'prawn'
+  module Formatters
+    # Transforms a token stream into an array of
+    # formatted text fragments for use with Prawn.
+    class Prawn < Formatter
+      tag 'prawn'
 
-  Tokens = ::Rouge::Token::Tokens
-  LineOrientedTokens = [
-    ::Rouge::Token::Tokens::Generic::Inserted,
-    ::Rouge::Token::Tokens::Generic::Deleted,
-    ::Rouge::Token::Tokens::Generic::Heading,
-    ::Rouge::Token::Tokens::Generic::Subheading
-  ]
+      Tokens = ::Rouge::Token::Tokens
+      LineOrientedTokens = [
+        ::Rouge::Token::Tokens::Generic::Inserted,
+        ::Rouge::Token::Tokens::Generic::Deleted,
+        ::Rouge::Token::Tokens::Generic::Heading,
+        ::Rouge::Token::Tokens::Generic::Subheading,
+      ]
 
-  LF = ?\n
-  NoBreakSpace = ?\u00a0
-  InnerIndent = %(#{LF} )
-  GuardedIndent = NoBreakSpace
-  GuardedInnerIndent = %(#{LF}#{NoBreakSpace})
-  BoldStyle = [:bold].to_set
-  ItalicStyle = [:italic].to_set
-  BoldItalicStyle = [:bold, :italic].to_set
-  UnderlineStyle = [:underline].to_set
+      LF = ?\n
+      DummyText = ?\u0000
+      NoBreakSpace = ?\u00a0
+      InnerIndent = %(#{LF} )
+      GuardedIndent = NoBreakSpace
+      GuardedInnerIndent = %(#{LF}#{NoBreakSpace})
+      BoldStyle = [:bold].to_set
+      ItalicStyle = [:italic].to_set
+      BoldItalicStyle = [:bold, :italic].to_set
+      UnderlineStyle = [:underline].to_set
 
-  def initialize opts = {}
-    unless ::Rouge::Theme === (theme = opts[:theme])
-      unless theme && (theme = ::Rouge::Theme.find theme)
-        theme = ::Rouge::Themes::AsciidoctorPDFDefault
+      def initialize opts = {}
+        unless ::Rouge::Theme === (theme = opts[:theme])
+          unless theme && (theme = ::Rouge::Theme.find theme)
+            theme = ::Rouge::Themes::AsciidoctorPDFDefault
+          end
+          theme = theme.new
+        end
+        @theme = theme
+        @normalized_colors = {}
+        @background_colorizer = BackgroundColorizer.new line_gap: opts[:line_gap]
+        @linenum_fragment_base = create_fragment Tokens::Generic::Lineno
+        @highlight_line_fragment = create_highlight_line_fragment opts[:highlight_background_color]
       end
-      theme = theme.new
-    end
-    @theme = theme
-    @normalized_colors = {}
-    @background_colorizer = BackgroundColorizer.new line_gap: opts[:line_gap]
-    @linenum_fragment_base = (create_fragment Tokens::Generic::Lineno).merge linenum: true
-  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
-  end
+      def background_color
+        @background_color ||= (normalize_color (@theme.style_for Tokens::Text).bg)
+      end
 
-  def stream tokens, opts = {}
-    if opts[:line_numbers]
-      if (linenum = opts[:start_line]) > 0
-        linenum -= 1
-      else
-        linenum = 0
+      # 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
       end
-      fragments = []
-      fragments << (create_linenum_fragment linenum += 1)
-      tokens.each do |tok, val|
-        if val == LF
-          fragments << { text: LF }
-          fragments << (create_linenum_fragment linenum += 1)
-        elsif val.include? LF
-          # 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|
-            fragments << (line_oriented ? (base_fragment.merge text: line, line_oriented: true) : (base_fragment.merge text: line))
-            # NOTE append linenum fragment if there's a next line; only works if source doesn't have trailing endline
-            fragments << (create_linenum_fragment linenum += 1) if line.end_with? LF
+
+      def stream tokens, opts = {}
+        line_numbers = opts[:line_numbers]
+        highlight_lines = opts[:highlight_lines]
+        if line_numbers || highlight_lines
+          linenum = (linenum = opts[:start_line] || 1) > 0 ? linenum : 1
+          fragments = []
+          line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
+          fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
+          tokens.each do |tok, val|
+            if val == LF
+              fragments << { text: LF }
+              linenum += 1
+              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
+              line_oriented = val.end_with? LF
+              base_fragment = create_fragment tok, val
+              val.each_line do |line|
+                if start_of_line
+                  line[0] = GuardedIndent if line.start_with? ' '
+                  start_of_line = nil
+                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
+                linenum += 1
+                line_numbers ? (fragments << (create_linenum_fragment linenum)) : (start_of_line = true)
+                fragments << @highlight_line_fragment.dup if highlight_lines && highlight_lines[linenum]
+              end
+            else
+              if start_of_line
+                val[0] = GuardedIndent if val.start_with? ' '
+                start_of_line = nil
+              end
+              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
+          if line_numbers && (linenum_w = linenum.to_s.length) > 1
+            # 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]
+            end
           end
+          fragments
         else
-          fragments << (create_fragment tok, val)
-        end
-      end
-      # NOTE drop orphaned linenum fragment (due to trailing endline in source)
-      fragments.pop if (last_fragment = fragments[-1]) && last_fragment[:linenum]
-      # NOTE pad numbers that have less digits than the largest line number
-      if (linenum_w = linenum.to_s.length) > 1
-        # 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}) if fragment[:linenum]
-        end
-      end
-      fragments
-    else
-      start_of_line = true
-      tokens.map do |tok, val|
-        # match one or more consecutive endlines
-        if val == LF || (val == (LF * val.length))
           start_of_line = true
-          { text: val }
-        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
-          #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
-          fragment[:line_oriented] = true if (start_of_line = val.end_with? LF)
-          fragment
+          tokens.map do |tok, val|
+            # match one or more consecutive endlines
+            if val == LF || (val == (LF * val.length))
+              start_of_line = true
+              { text: val }
+            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
+              #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
+              fragment[:inline_block] = true if (start_of_line = val.end_with? LF)
+              fragment
+            end
+          end
         end
       end
-      # QUESTION should we strip trailing newline?
-    end
-  end
 
-  # 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 } : {}
-    if (style_rules = @theme.style_for tok)
-      if (bg = normalize_color style_rules.bg) && bg != background_color
-        fragment[:background_color] = bg
-        fragment[:callback] = @background_colorizer
-        if LineOrientedTokens.include? tok
-          fragment[:inline_block] = true unless style_rules[:inline_block] == false
-          fragment[:extend] = true unless style_rules[:extend] == false
-        else
-          fragment[:inline_block] = true if style_rules[:inline_block]
-          fragment[:extend] = true if style_rules[:extend]
+      # 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 } : {}
+        if (style_rules = @theme.style_for tok)
+          if (bg = normalize_color style_rules.bg) && bg != background_color
+            fragment[:background_color] = bg
+            fragment[:callback] = @background_colorizer
+            if LineOrientedTokens.include? tok
+              fragment[:inline_block] = true unless style_rules[:inline_block] == false
+              fragment[:extend] = true unless style_rules[:extend] == false
+            else
+              fragment[:inline_block] = true if style_rules[:inline_block]
+              fragment[:extend] = true if style_rules[:extend]
+            end
+          end
+          if (fg = normalize_color style_rules.fg)
+            fragment[:color] = fg
+          end
+          if style_rules[:bold]
+            fragment[:styles] = style_rules[:italic] ? BoldItalicStyle.dup : BoldStyle.dup
+          elsif style_rules[:italic]
+            fragment[:styles] = ItalicStyle.dup
+          end
+          if style_rules[:underline]
+            if fragment.key? :styles
+              fragment[:styles] << UnderlineStyle[0]
+            else
+              fragment[:styles] = UnderlineStyle.dup
+            end
+          end
         end
+        fragment
       end
-      if (fg = normalize_color style_rules.fg)
-        fragment[:color] = fg
+
+      def create_linenum_fragment linenum
+        @linenum_fragment_base.merge text: %(#{linenum} ), linenum: linenum
       end
-      if style_rules[:bold]
-        fragment[:styles] = style_rules[:italic] ? BoldItalicStyle.dup : BoldStyle.dup
-      elsif style_rules[:italic]
-        fragment[:styles] = ItalicStyle.dup
+
+      def create_highlight_line_fragment bg_color
+        {
+          background_color: (bg_color || 'FFFFCC'),
+          callback: @background_colorizer,
+          extend: true,
+          highlight: true,
+          inline_block: true,
+          text: DummyText,
+          width: 0,
+        }
       end
-      if style_rules[:underline]
-        if fragment.key? :styles
-          fragment[:styles] << UnderlineStyle[0]
+
+      def normalize_color raw
+        return unless raw
+        if (normalized = @normalized_colors[raw])
+          normalized
         else
-          fragment[:styles] = UnderlineStyle.dup
+          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
         end
       end
-    end
-    fragment
-  end
 
-  def create_linenum_fragment linenum
-    @linenum_fragment_base.merge text: %(#{linenum} )
-  end
+      class BackgroundColorizer
+        def initialize opts = {}
+          @line_gap = opts[:line_gap] || 0
+        end
 
-  def normalize_color raw
-    return unless raw
-    if (normalized = @normalized_colors[raw])
-      normalized
-    else
-      normalized = (raw.start_with? '#') ? raw[1..-1] : raw
-      normalized = normalized.each_char.map {|c| c * 2 }.join if normalized.length == 3
-      @normalized_colors[raw] = normalized
+        def render_behind fragment
+          pdf = fragment.document
+          data = fragment.format_state
+          prev_fill_color = pdf.fill_color
+          pdf.fill_color data[:background_color]
+          if data[:inline_block]
+            fragment_width = data[:extend] ? pdf.bounds.width - fragment.left : fragment.width
+            v_gap = @line_gap
+          else
+            fragment_width = fragment.width
+            v_gap = 0
+          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
+          nil
+        end
+      end
     end
   end
 end
-
-class BackgroundColorizer
-  def initialize opts = {}
-    @line_gap = opts[:line_gap] || 0
-  end
-
-  def render_behind fragment
-    pdf = fragment.document
-    data = fragment.format_state
-    prev_fill_color = pdf.fill_color
-    pdf.fill_color data[:background_color]
-    v_gap = data[:inline_block] ? @line_gap : 0
-    fragment_width = data[:line_oriented] && data[:extend] ? (pdf.bounds.width - fragment.left) : fragment.width
-    pdf.fill_rectangle [fragment.left, fragment.top + v_gap * 0.5], fragment_width, (fragment.height + v_gap)
-    pdf.fill_color prev_fill_color
-  end
-end
-end
-end