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

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

@@ -2,4 +2,4 @@ class Array
   def to_h
     Hash[to_a]
   end unless respond_to? :to_h
-end
+end if RUBY_VERSION < '2.1.0'

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

@@ -1,9 +1,9 @@
 class OpenStruct
   def [] key
     send key
-  end
+  end unless respond_to? :[]
 
   def []= key, val
     send %(#{key}=), val
-  end
+  end unless respond_to? :[]=
 end if RUBY_VERSION < '2.0.0'

data/lib/asciidoctor-pdf/pdf_core_ext.rb

@@ -0,0 +1,2 @@
+# the following modules / classes are organized under the Asciidoctor::PdfCore namespace
+require_relative 'pdf_core_ext/pdf_object'

data/lib/asciidoctor-pdf/pdf_core_ext/pdf_object.rb

@@ -0,0 +1,25 @@
+module Asciidoctor
+module PdfCore
+module PdfObject
+  # Convert the string to a PDF literal string if it can be encoded as ASCII-8BIT.
+  # Otherwise, return the specified string.
+  #--
+  # QUESTION mixin to String and NilClass as to_pdf_value?
+  def str2pdfval string
+    if string && string.ascii_only?
+      ::PDF::Core::LiteralString.new(string.encode ::Encoding::ASCII_8BIT)
+    else
+      string
+    end
+  end
+
+  # Convert the string to a PDF object, first attempting to
+  # convert it to a PDF literal string.
+  #--
+  # QUESTION mixin to String and NilClass as to_pdf_object?
+  def str2pdfobj string
+    ::PDF::Core::PdfObject(str2pdfval string)
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/pdfmarks.rb

@@ -1,6 +1,9 @@
 module Asciidoctor
 module Pdf
 class Pdfmarks
+  include ::Asciidoctor::Pdf::Sanitizer
+  include ::Asciidoctor::PdfCore::PdfObject
+
   def initialize doc
     @doc = doc
   end
@@ -8,15 +11,16 @@ class Pdfmarks
   def generate
     current_datetime = ::DateTime.now.strftime '%Y%m%d%H%M%S'
     doc = @doc
+    # FIXME use sanitize: :plain_text once available
     content = <<-EOS
-[ /Title (#{doc.doctitle sanitize: true, use_fallback: true})
-  /Author (#{doc.attr 'authors'})
-  /Subject (#{doc.attr 'subject'})
-  /Keywords (#{doc.attr 'keywords'})
+[ /Title #{str2pdfobj sanitize(doc.doctitle use_fallback: true)}
+  /Author #{str2pdfobj(doc.attr 'authors')}
+  /Subject #{str2pdfobj(doc.attr 'subject')}
+  /Keywords #{str2pdfobj(doc.attr 'keywords')}
   /ModDate (D:#{current_datetime})
   /CreationDate (D:#{current_datetime})
   /Creator (Asciidoctor PDF #{::Asciidoctor::Pdf::VERSION}, based on Prawn #{::Prawn::VERSION})
-  /Producer (#{doc.attr 'publisher'})
+  /Producer #{str2pdfobj(doc.attr 'publisher')}
   /DOCINFO pdfmark
     EOS
     content

data/lib/asciidoctor-pdf/prawn_ext.rb

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

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

@@ -38,7 +38,6 @@ class CodeRayEncoder < ::CodeRay::Encoders::Encoder
   # Manni theme from Pygments
   COLORS = {
     default:           '333333',
-
     annotation:        '9999FF',
     attribute_name:    '4F9FCF',
     attribute_value:   'D44950',
@@ -49,14 +48,13 @@ class CodeRayEncoder < ::CodeRay::Encoders::Encoder
     constant:          '336600',
     directive:         '006699',
     doctype:           '009999',
-    instance_variable: '003333',
-    integer:           'FF6600',
     entity:            '999999',
     float:             'FF6600',
     function:          'CC00FF',
     important:         '9999FF',
     inline_delimiter:  'EF804F',
     instance_variable: '003333',
+    integer:           'FF6600',
     key:               '006699',
     keyword:           '006699',
     method:            'CC00FF',
@@ -70,23 +68,25 @@ class CodeRayEncoder < ::CodeRay::Encoders::Encoder
     value:             '336600'
   }
 
-  def setup(options)
+  EOL = "\n"
+
+  def setup options
     super
     @out  = []
     @open = []
   end
 
-  def text_token(text, kind)
+  def text_token text, kind
     color = COLORS[kind] || COLORS[@open.last] || COLORS[:default]
     
-    @out << {:text => text, :color => color}
+    @out << (text == EOL ? { :text => text } : { :text => text, :color => color })
   end
 
-  def begin_group(kind)
+  def begin_group kind
     @open << kind
   end
 
-  def end_group(kind)
+  def end_group kind
     @open.pop
   end
 end

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

@@ -2,6 +2,8 @@ module Asciidoctor
 module Prawn
 module Extensions
   include ::Prawn::Measurements
+  include ::Asciidoctor::Pdf::Sanitizer
+  include ::Asciidoctor::PdfCore::PdfObject
 
   # - :height is the height of a line
   # - :leading is spacing between adjacent lines
@@ -34,15 +36,31 @@ module Extensions
 
   # Returns the width of the left margin for the current page
   #
-  def left_margin
+  def page_margin_left
     page.margins[:left]
   end
+  # deprecated
+  alias :left_margin :page_margin_left
 
   # Returns the width of the right margin for the current page
   #
-  def right_margin
+  def page_margin_right
     page.margins[:right]
   end
+  # deprecated
+  alias :right_margin :page_margin_right
+
+  # Returns the width of the top margin for the current page
+  #
+  def page_margin_top
+    page.margins[:top]
+  end
+
+  # Returns the width of the bottom margin for the current page
+  #
+  def page_margin_bottom
+    page.margins[:bottom]
+  end
 
   # Returns whether the cursor is at the top of the page (i.e., margin box)
   #
@@ -91,8 +109,8 @@ module Extensions
   # size to be specified as the second option.
   #
   def font name = nil, options = {}
-    if !name.nil? && ((size = options).is_a? ::Numeric)
-      options = { size: size }
+    if name && ::Numeric === options
+      options = { size: options }
     end
     super name, options
   end
@@ -120,10 +138,10 @@ module Extensions
       font font.options[:family], style: style do
         yield
       end
-    elsif style.nil?
-      font.options[:style] || :normal
-    else
+    elsif style
       font font.options[:family], style: style
+    else
+      font.options[:style] || :normal
     end
   end
 
@@ -214,6 +232,22 @@ module Extensions
     end
   end
 
+  # Apply the text transform to the specified text.
+  #
+  # Supported transform values are "uppercase" or "lowercase" (passed as either
+  # a String or a Symbol). When the uppercase transform is applied to the text,
+  # it correctly uppercases visible text while leaving markup and named
+  # character entities unchanged.
+  #
+  def transform_text text, transform
+    case transform
+    when :uppercase, 'uppercase'
+      upcase_pcdata text
+    when :lowercase, 'lowercase'
+      text.downcase
+    end
+  end
+
   # Cursor
 
   # Short-circuits the call to the built-in move_up operation
@@ -307,24 +341,30 @@ module Extensions
   # Fills the current bounding box with the specified fill color. Before
   # returning from this method, the original fill color on the document is
   # restored.
-  #
   def fill_bounds f_color = fill_color
-    unless f_color.nil? || f_color.to_s == 'transparent'
-      original_fill_color = fill_color
+    if f_color && f_color != 'transparent'
+      prev_fill_color = fill_color
       fill_color f_color
       fill_rectangle bounds.top_left, bounds.width, bounds.height
-      fill_color original_fill_color
+      fill_color prev_fill_color
     end
   end
 
+  # Fills the absolute bounding box with the specified fill color. Before
+  # returning from this method, the original fill color on the document is
+  # restored.
+  def fill_absolute_bounds f_color = fill_color
+    canvas { fill_bounds f_color }
+  end
+
   # Fills the current bounds using the specified fill color and strokes the
   # bounds using the specified stroke color. Sets the line with if specified
   # in the options. Before returning from this method, the original fill
   # color, stroke color and line width on the document are restored.
   #
   def fill_and_stroke_bounds f_color = fill_color, s_color = stroke_color, options = {}
-    no_fill = (f_color.nil? || f_color.to_s == 'transparent')
-    no_stroke = (s_color.nil? || s_color.to_s == 'transparent')
+    no_fill = !f_color || f_color == 'transparent'
+    no_stroke = !s_color || s_color == 'transparent'
     return if no_fill && no_stroke
     save_graphics_state do
       radius = options[:radius] || 0
@@ -495,7 +535,9 @@ module Extensions
   def keep_together &block
     available_space = cursor
     total_height, _whole_pages, _remainder = dry_run(&block)
-    if total_height > available_space
+    # 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?
       start_new_page
       started_new_page = true
     else

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

@@ -1,6 +1,8 @@
 module Asciidoctor
 module Prawn
 class FormattedTextTransform
+  #ZeroWidthSpace = [0x200b].pack 'U*'
+
   def initialize(options = {})
     @merge_adjacent_text_nodes = options.fetch(:merge_adjacent_text_nodes, false)
     if (theme = options[:theme])
@@ -34,15 +36,22 @@ class FormattedTextTransform
           end
           previous_fragment_is_text = true
         else
-          pcdata = node[:pcdata] || []
-          attributes = node[:attributes]
-          fragments << apply(pcdata).map {|fragment|
-            # decorate child fragments with styles from this element
-            build_fragment(fragment, tag_name, attributes)
-          } unless pcdata.size == 0
+          if (pcdata = node[:pcdata]) && pcdata.size > 0
+            attributes = node[:attributes]
+            fragments << apply(pcdata).map {|fragment|
+              # decorate child fragments with styles from this element
+              build_fragment(fragment, tag_name, attributes)
+            }
+          #else
+          #  # NOTE special case, handle an empty <a> element
+          #  if tag_name == :a
+          #    fragments << build_fragment({ text: ZeroWidthSpace }, tag_name, node[:attributes])
+          #  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
@@ -103,12 +112,25 @@ class FormattedTextTransform
     when :color
       if !fragment[:color]
         if (rgb = attrs[:rgb])
-          if rgb[0] == '#'
-            rgb = rgb[1..-1]
+          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
-          fragment[:color] = rgb
+        # QUESTION should we even support r,g,b and c,m,y,k as individual values?
         elsif (r = attrs[:r]) && (g = attrs[:g]) && (b = attrs[:b])
-          fragment[:color] = [r, g, b].map {|e| '%02x' % e.to_i }.join
+          fragment[:color] = [r, g, b].map {|e| '%02X' % e.to_i }.join
         elsif (c = attrs[:c]) && (m = attrs[:m]) && (y = attrs[:y]) && (k = attrs[:k])
           fragment[:color] = [c.to_i, m.to_i, y.to_i, k.to_i]
         end
@@ -133,6 +155,10 @@ class FormattedTextTransform
       if !fragment[:local] && (value = attrs[:local])
         fragment[:local] = value
       end
+      if !fragment[:name] && (value = attrs[:name])
+        fragment[:name] = value
+        fragment[:callback] = InlineDestinationMarker
+      end
       fragment[:color] ||= @link_font_color
     when :sub
       styles << :subscript
@@ -170,9 +196,25 @@ class FormattedTextTransform
       #  fragment[:color] = value[6..-1].tr(' #', '')
       #end
     end
+    # QUESTION should we remove styles if empty? Need test
     #fragment.delete(:styles) if styles.empty?
     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/images.rb

@@ -0,0 +1,22 @@
+module Asciidoctor
+module Prawn
+module Images
+  # Dispatch to suitable image method in Prawn based on file extension.
+  def image file, opts = {}
+    if (::File.extname file).downcase == '.svg'
+      opts[:at] ||= bounds.top_left
+      svg ::IO.read(file), opts
+    else
+      _builtin_image file, opts
+    end
+  end
+end
+end
+end
+
+module Prawn
+class Document
+  alias :_builtin_image :image
+  include ::Asciidoctor::Prawn::Images
+end
+end

data/lib/asciidoctor-pdf/sanitizer.rb

@@ -0,0 +1,37 @@
+module Asciidoctor
+module Pdf
+module Sanitizer
+  BuiltInEntityChars = {
+    '&lt;' => '<',
+    '&gt;' => '>',
+    '&amp;' => '&'
+  }
+  BuiltInEntityCharRx = /(?:#{BuiltInEntityChars.keys * '|'})/
+  BuiltInEntityCharOrTagRx = /(?:#{BuiltInEntityChars.keys * '|'}|<)/
+  NumericCharRefRx = /&#(\d{2,4});/
+  XmlSanitizeRx = /<[^>]+>/
+  SegmentPcdataRx = /(?:(&[a-z]+;|<[^>]+>)|([^&<]+))/
+
+  # Strip leading, trailing and repeating whitespace, remove XML tags and
+  # resolve all entities in the specified string.
+  #
+  # FIXME move to a module so we can mix it in elsewhere
+  # FIXME add option to control escaping entities, or a filter mechanism in general
+  def sanitize string
+    string.strip
+        .gsub(XmlSanitizeRx, '')
+        .tr_s(' ', ' ')
+        .gsub(NumericCharRefRx) { [$1.to_i].pack('U*') }
+        .gsub(BuiltInEntityCharRx, BuiltInEntityChars)
+  end
+
+  def upcase_pcdata string
+    if BuiltInEntityCharOrTagRx =~ string
+      string.gsub(SegmentPcdataRx) { $2 ? $2.upcase : $1 }
+    else
+      string.upcase
+    end
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/theme_loader.rb

@@ -1,64 +1,90 @@
-require 'yaml'
+require 'safe_yaml/load'
 require 'ostruct'
 require_relative 'core_ext/ostruct'
 
 module Asciidoctor
 module Pdf
 class ThemeLoader
-  DataDir = ::File.expand_path ::File.join(::File.dirname(__FILE__), '..', '..', 'data')
-  ThemesDir = ::File.join DataDir, 'themes'
-  FontsDir = ::File.join DataDir, 'fonts'
+  DataDir = ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', '..', 'data'))
+  ThemesDir = ::File.join(DataDir, 'themes')
+  FontsDir = ::File.join(DataDir, 'fonts')
+  HexColorValueRx = /_color: (?<quote>"|'|)#?(?<value>[A-Za-z0-9]{3,6})\k<quote>$/
+
+  module ColorValue; end
+
+  class HexColorValue < String
+    include ColorValue
+  end
+
+  # A marker module for a normalized CMYK array
+  # Prevents normalizing CMYK value more than once
+  module CmykColorValue
+    include ColorValue
+    def to_s
+      %([#{join ', '}])
+    end
+  end
 
   def self.resolve_theme_file theme_name = nil, theme_path = nil
     theme_name ||= 'default'
     # if .yml extension is given, assume it's a full file name
-    if theme_name.end_with? '.yml'
+    if theme_name.end_with?('.yml')
       # FIXME restrict to jail!
-      theme_path ? (::File.join theme_path, theme_name) : theme_name
+      # QUESTION why are we not using expand_path in this case?
+      theme_path ? ::File.join(theme_path, theme_name) : theme_name
     else
       # QUESTION should we append '-theme.yml' or just '.yml'?
-      ::File.expand_path %(#{theme_name}-theme.yml), (theme_path || ThemesDir)
+      ::File.expand_path(%(#{theme_name}-theme.yml), (theme_path || ThemesDir))
     end
   end
 
+  def self.resolve_theme_asset asset_path, theme_path = nil
+    ::File.expand_path(asset_path, (theme_path || ThemesDir))
+  end
+
   def self.load_theme theme_name = nil, theme_path = nil
-    load_file (resolve_theme_file theme_name, theme_path)
+    load_file(resolve_theme_file(theme_name, theme_path))
   end
 
   def self.load_file filename
-    theme_hash = YAML.load_file filename
-    self.new.load theme_hash
+    data = ::IO.read(filename).each_line.map {|l| l.sub(HexColorValueRx, '_color: \'\k<value>\'') }.join
+    self.new.load(::SafeYAML.load(data))
   end
 
   def load hash
-    hash.inject(OpenStruct.new) do |s, (k, v)|
-      if v.kind_of? Hash
-        v.each do |k2, v2|
-          s[%(#{k}_#{k2})] = (k2.end_with? '_color') ? evaluate(v2, s).to_s : evaluate(v2, s)
-        end
-      else
-        s[k] = (k.end_with? '_color') ? evaluate(v, s).to_s : evaluate(v, s)
-      end
-      s
+    hash.inject(::OpenStruct.new) do |data, (key, val)|
+      process_entry(key, val, data)
     end
   end
 
   private
 
+  def process_entry key, val, data
+    if key != 'font_catalog' && ::Hash === val
+      val.each do |key2, val2|
+        process_entry(%(#{key}_#{key2}), val2, data)
+      end
+    else
+      data[key] = key.end_with?('_color') ? to_color(evaluate(val, data)) : evaluate(val, data)
+    end
+    data
+  end
+
   def evaluate expr, vars
     case expr
-    when String
+    when ::String
       evaluate_math(expand_vars(expr, vars))
-    when Array
+    when ::Array
       expr.map {|e| evaluate(e, vars) }
     else
       expr
     end
   end
   
+  # NOTE we assume expr is a String
   def expand_vars expr, vars
-    if expr.include? '$'
-      if (expr.start_with? '$') && (expr.match /^\$([a-z0-9_]+)$/)
+    if (idx = expr.index('$'))
+      if idx == 0 && expr.match(/^\$([a-z0-9_]+)$/)
         vars[$1]
       else
         expr.gsub(/\$([a-z0-9_]+)/) { vars[$1] }
@@ -69,34 +95,108 @@ class ThemeLoader
   end
   
   def evaluate_math expr
-    return expr unless expr.kind_of? String
+    return expr if !(::String === expr) || ColorValue === expr
     original = expr
+    # FIXME quick HACK to turn a single negative number into an expression
+    expr = %(1 - #{expr[1..-1]}) if expr.start_with?('-')
+    # expand measurement values (e.g., 0.5in)
+    expr = expr.gsub(/(?<=^| |\()(\d+(?:\.\d+)?)(in|mm|cm|pt)(?=$| |\))/) {
+      val = $1.to_f
+      case $2
+      when 'in'
+        val = val * 72
+      when 'mm'
+        val = val * (72 / 25.4)
+      when 'cm'
+        val = val * (720 / 25.4)
+      #when '%'
+      #  val = val / 100.0
+      # default is pt
+      end
+      # QUESTION should we round the value?
+      val
+    }
     while true
+      # TODO move this regular expression to a constant
       result = expr.gsub(/(-?\d+(?:\.\d+)?) *([*\/]) *(-?\d+(?:\.\d+)?)/) { $1.to_f.send($2.to_sym, $3.to_f) }
       unchanged = (result == expr)
       expr = result
       break if unchanged
     end
     while true
+      # TODO move this regular expression to a constant
       result = expr.gsub(/(-?\d+(?:\.\d+)?) *([+\-]) *(-?\d+(?:\.\d+)?)/) { $1.to_f.send($2.to_sym, $3.to_f) }
       unchanged = (result == expr)
       expr = result
       break if unchanged
     end
-    if (expr.end_with? ')') && (expr.match /^(round|floor|ceil)\(/)
+    if expr.end_with?(')') && expr.match(/^(round|floor|ceil)\(/)
       op = $1
       offset = op.length + 1
       expr = expr[offset...-1].to_f.send(op.to_sym)
     end
-    if original == expr
-      expr
+    if expr == original
+      original
     else
-      if ((int_val = expr.to_i) == (float_val = expr.to_f))
-        int_val
+      (int_val = expr.to_i) == (flt_val = expr.to_f) ? int_val : flt_val
+    end
+  end
+
+  def to_color value
+    case value
+    when ColorValue
+      # already converted
+      return value
+    when ::String
+      if value == 'transparent'
+        # FIXME should we have a TransparentColorValue class?
+        return HexColorValue.new(value)
+      elsif value.size == 6
+        return HexColorValue.new(value.upcase)
+      end
+    when ::Array
+      case value.size
+      # CMYK value
+      when 4
+        value = value.map {|e|
+          if ::Numeric === e
+            e = e * 100.0 unless e > 1
+          else
+            e = e.to_s.chomp('%').to_f
+          end
+          (e == (int_e = e.to_i)) ? int_e : e
+        }
+        case value
+        when [0, 0, 0, 0]
+          return HexColorValue.new('FFFFFF')
+        when [100, 100, 100, 100]
+          return HexColorValue.new('000000')
+        else
+          value.extend CmykColorValue
+          return value
+        end
+      # RGB value
+      when 3
+        return HexColorValue.new(value.map {|e| '%02X' % e}.join)
+      # Nonsense array value; flatten to string
       else
-        float_val
+        value = value.join
       end
+    else
+      # Unknown type; coerce to a string
+      value = %(#{value})
+    end
+    value = case value.size
+    when 6
+      value
+    when 3
+      # expand hex shorthand (e.g., f00 -> ff0000)
+      value.each_char.map {|c| c * 2 }.join
+    else
+      # truncate or pad with leading zeros (e.g., ff -> 0000ff)
+      value[0..5].rjust(6, '0')
     end
+    HexColorValue.new(value.upcase)
   end
 end
 end