asciidoctor-pdf 1.5.0.alpha.1

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

@@ -0,0 +1,5 @@
+class Array
+  def to_h
+    Hash[to_a]
+  end unless respond_to? :to_h
+end

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

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

data/lib/asciidoctor-pdf/implicit_header_processor.rb

@@ -0,0 +1,59 @@
+require 'asciidoctor/extensions'
+
+module Asciidoctor
+module Pdf
+# An include processor that skips the implicit author line below
+# the document title within include documents.
+class ImplicitHeaderProcessor < ::Asciidoctor::Extensions::IncludeProcessor
+  def process doc, reader, target, attributes
+    return reader unless File.exist? target
+    ::File.open target, 'r' do |fd|
+      # FIXME handle case where doc id is specified above title
+      if (first_line = fd.readline) && (first_line.start_with? '= ')
+        # HACK reset counters for each article for Editions
+        if doc.attr? 'env', 'editions'
+          doc.counters.each do |(counter_key, counter_val)|
+            doc.attributes.delete counter_key
+          end
+          doc.counters.clear
+        end
+        if (second_line = fd.readline)
+          if AuthorInfoLineRx =~ second_line
+            # FIXME temporary hack to set author and e-mail attributes; this should handle all attributes in header!
+            author = [$1, $2, $3].compact * ' '
+            email = $4
+            reader.push_include fd.readlines, target, target, 3, attributes unless fd.eof?
+            reader.push_include first_line, target, target, 1, attributes
+            lines = [%(:author: #{author})]
+            lines << %(:email: #{email}) if email
+            reader.push_include lines, target, target, 2, attributes
+          else
+            lines = [second_line]
+            lines += fd.readlines unless fd.eof?
+            reader.push_include lines, target, target, 2, attributes
+            reader.push_include first_line, target, target, 1, attributes
+          end
+        else
+          reader.push_include first_line, target, target, 1, attributes
+        end
+      else
+        lines = [first_line]
+        lines += fd.readlines unless fd.eof?
+        reader.push_include lines, target, target, 1, attributes
+      end
+    end
+    reader
+  end
+
+  def handles? target
+    # FIXME should not require this hack to skip processing bio
+    !(target.end_with? 'bio.adoc') && ((target.end_with? '.adoc') || (target.end_with? '.asciidoc'))
+  end
+
+  # FIXME this method shouldn't be required
+  def update_config config
+    (@config ||= {}).update config
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/pdfmarks.rb

@@ -0,0 +1,30 @@
+module Asciidoctor
+module Pdf
+class Pdfmarks
+  def initialize doc
+    @doc = doc
+  end
+
+  def generate
+    current_datetime = ::DateTime.now.strftime '%Y%m%d%H%M%S'
+    doc = @doc
+    content = <<-EOS
+[ /Title (#{doc.doctitle sanitize: true, use_fallback: true})
+  /Author (#{doc.attr 'authors'})
+  /Subject (#{doc.attr 'subject'})
+  /Keywords (#{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'})
+  /DOCINFO pdfmark
+    EOS
+    content
+  end
+
+  def generate_file pdf_file
+    ::IO.write %(#{pdf_file}marks), generate
+  end
+end
+end
+end

data/lib/asciidoctor-pdf/prawn_ext.rb

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

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

@@ -0,0 +1,94 @@
+######################################################################
+#
+# This file was copied from Prawn (manual/syntax_highlight.rb) and
+# modified for use with Asciidoctor PDF.
+# 
+# Prawn is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# Prawn is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with Prawn. If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright (C) Felipe Doria
+# Copyright (C) 2014 OpenDevise Inc. and the Asciidoctor Project
+#
+######################################################################
+
+require 'coderay'
+
+# Registers a to_prawn method with CodeRay. The method returns an array of hashes to be
+# used with Prawn::Text.formatted_text(array).
+#
+# Usage:
+#
+# CodeRay.scan(string, :ruby).to_prawn
+#
+module Asciidoctor
+module Prawn
+class CodeRayEncoder < ::CodeRay::Encoders::Encoder
+  register_for :to_prawn
+
+  # Manni theme from Pygments
+  COLORS = {
+    default:           '333333',
+
+    annotation:        '9999FF',
+    attribute_name:    '4F9FCF',
+    attribute_value:   'D44950',
+    class:             '00AA88',
+    class_variable:    '003333',
+    color:             'FF6600',
+    comment:           '999999',
+    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',
+    key:               '006699',
+    keyword:           '006699',
+    method:            'CC00FF',
+    namespace:         '00CCFF',
+    predefined_type:   '007788',
+    regexp:            '33AAAA',
+    string:            'CC3300',
+    symbol:            'FFCC33',
+    tag:               '2F6F9F',
+    type:              '007788',
+    value:             '336600'
+  }
+
+  def setup(options)
+    super
+    @out  = []
+    @open = []
+  end
+
+  def text_token(text, kind)
+    color = COLORS[kind] || COLORS[@open.last] || COLORS[:default]
+    
+    @out << {:text => text, :color => color}
+  end
+
+  def begin_group(kind)
+    @open << kind
+  end
+
+  def end_group(kind)
+    @open.pop
+  end
+end
+end
+end

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

@@ -0,0 +1,529 @@
+module Asciidoctor
+module Prawn
+module Extensions
+  include ::Prawn::Measurements
+
+  # - :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
+  # - :padding_bottom is half line spacing
+  # - :final_gap determines whether a gap is added below the last line
+  LineMetrics = ::Struct.new :height, :leading, :padding_top, :padding_bottom, :final_gap
+
+  # Core
+
+  # Retrieves the catalog reference data for the PDF.
+  #
+  def catalog
+    state.store.root
+  end
+
+  # Measurements
+
+  # Returns the width of the current page from edge-to-edge
+  #
+  def page_width
+    page.dimensions[2]
+  end
+
+  # Returns the height of the current page from edge-to-edge
+  #
+  def page_height
+    page.dimensions[3]
+  end
+
+  # Returns the width of the left margin for the current page
+  #
+  def left_margin
+    page.margins[:left]
+  end
+
+  # Returns the width of the right margin for the current page
+  #
+  def right_margin
+    page.margins[:right]
+  end
+
+  # Returns whether the cursor is at the top of the page (i.e., margin box)
+  #
+  def at_page_top?
+    @y == @margin_box.absolute_top
+  end
+
+  # Destinations
+
+  # Generates a destination object that resolves to the top of the page
+  # specified by the page_num parameter or the current page if no page number
+  # is provided. The destination preserves the user's zoom level unlike
+  # the destinations generated by the outline builder.
+  #
+  def dest_top page_num = nil
+    dest_xyz 0, page_height, nil, (page_num ? state.pages[page_num - 1] : page)
+  end
+
+  # Text
+
+=begin
+  # Draws a disc bullet as float text
+  def draw_bullet
+    float { text '•' }
+  end
+=end
+
+  # Fonts
+
+  # Registers a new custom font described in the data parameter
+  # after converting the font name to a String.
+  #
+  # Example:
+  #
+  #  register_font GillSans: {
+  #    normal: 'assets/fonts/GillSans.ttf',
+  #    bold: 'assets/fonts/GillSans-Bold.ttf',
+  #    italic: 'assets/fonts/GillSans-Italic.ttf',
+  #  }
+  #  
+  def register_font data
+    font_families.update data.inject({}) {|accum, (key, val)| accum[key.to_s] = val; accum }
+  end
+
+  # Enhances the built-in font method to allow the font
+  # size to be specified as the second option.
+  #
+  def font name = nil, options = {}
+    if !name.nil? && ((size = options).is_a? ::Numeric)
+      options = { size: size }
+    end
+    super name, options
+  end
+
+  # Retrieves the current font name (i.e., family).
+  #
+  def font_family
+    font.options[:family]
+  end
+
+  alias :font_name :font_family
+
+  # 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 }
+  end
+
+  # Sets the font style for the scope of the block to which this method
+  # yields. If the style is nil and no block is given, return the current 
+  # font style.
+  #
+  def font_style style = nil
+    if block_given?
+      font font.options[:family], style: style do
+        yield
+      end
+    elsif style.nil?
+      font.options[:style] || :normal
+    else
+      font font.options[:family], style: style
+    end
+  end
+
+  # Applies points as a scale factor of the current font if the value provided
+  # is less than or equal to 1 or it's a string (e.g., 1.1em), then delegates to the super
+  # implementation to carry out the built-in functionality.
+  #
+  #--
+  # 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)
+    end
+    super points
+  end
+
+  def calc_line_metrics line_height = 1, font = self.font, font_size = self.font_size
+    line_height_length = line_height * font_size
+    leading = line_height_length - font_size
+    half_leading = leading / 2
+    padding_top = half_leading + font.line_gap
+    padding_bottom = half_leading
+    LineMetrics.new line_height_length, leading, padding_top, padding_bottom, false
+  end
+
+=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
+  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
+    correction = font.height - font_size
+    leading = line_gap - correction
+    shift = (font.line_gap + correction + line_gap) / 2
+    final_gap = font.line_gap != 0
+    LineMetrics.new line_height_length, leading, shift, shift, final_gap
+  end
+=end
+
+  # Parse the text into an array of fragments using the text formatter.
+  def parse_text string, options = {}
+    return [] if string.nil?
+
+    options = options.dup
+    if (format_option = options.delete :inline_format)
+      format_option = [] unless format_option.is_a? ::Array
+      fragments = self.text_formatter.format string, *format_option 
+    else
+      fragments = [{text: string}]
+    end
+
+    if (color = options.delete :color)
+      fragments.map do |fragment|
+        fragment[:color] ? fragment : fragment.merge(color: color)
+      end
+    else
+      fragments
+    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
+    fragments = parse_text string, opts
+    opts = opts.merge document: self
+    box = ::Prawn::Text::Formatted::Box.new fragments, (opts.merge single_line: true)
+    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 }
+    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
+      # 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
+      draw_remaining_formatted_text_on_new_pages remaining_fragments, opts
+    end
+  end
+
+  # Cursor
+
+  # Short-circuits the call to the built-in move_up operation
+  # when n is 0.
+  #
+  def move_up n
+    super unless n == 0
+  end
+
+  # Short-circuits the call to the built-in move_down operation
+  # when n is 0.
+  #
+  def move_down n
+    super unless n == 0
+  end
+
+  # Bounds
+
+  # Overrides the built-in pad operation to allow for asymmetric paddings.
+  #
+  # Example:
+  #
+  #  pad 20, 10 do
+  #    text 'A paragraph with twice as much top padding as bottom padding.'
+  #  end
+  #
+  def pad top, bottom = nil
+    move_down top
+    yield
+    move_down(bottom || top)
+  end
+
+  # Combines the built-in pad and indent operations into a single method.
+  #
+  # Padding may be specified as an array of four values, or as a single value.
+  # The single value is used as the padding around all four sides of the box.
+  #
+  # If padding is nil, this method simply yields to the block and returns.
+  #
+  # Example:
+  #
+  #  pad_box 20 do
+  #    text 'A paragraph inside a blox with even padding on all sides.'
+  #  end
+  #
+  #  pad_box [10, 10, 10, 20] do
+  #    text 'An indented paragraph inside a box with equal padding on all sides.'
+  #  end
+  #
+  def pad_box padding
+    if padding
+      # TODO implement shorthand combinations like in CSS
+      p_top, p_right, p_bottom, p_left = (padding.is_a? ::Array) ? padding : ([padding] * 4)
+      begin
+        # inlined logic
+        move_down p_top
+        bounds.add_left_padding p_left
+        bounds.add_right_padding p_right
+        yield
+        move_down p_bottom
+      ensure
+        bounds.subtract_left_padding p_left
+        bounds.subtract_right_padding p_right
+      end
+    else
+      yield
+    end
+
+    # alternate, delegated logic
+    #pad padding[0], padding[2] do
+    #  indent padding[1], padding[3] do
+    #    yield
+    #  end
+    #end
+  end
+
+  # Stretch the current bounds to the left and right edges of the current page.
+  #
+  def use_page_width_if verdict
+    if verdict
+      indent(-bounds.absolute_left, bounds.absolute_right - page_width) do
+        yield
+      end
+    else
+      yield
+    end
+  end
+
+  # Graphics
+
+  # 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
+      fill_color f_color
+      fill_rectangle bounds.top_left, bounds.width, bounds.height
+      fill_color original_fill_color
+    end
+  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')
+    return if no_fill && no_stroke
+    save_graphics_state do
+      radius = options[:radius] || 0
+
+      # fill
+      unless no_fill
+        fill_color f_color
+        fill_rounded_rectangle bounds.top_left, bounds.width, bounds.height, radius
+      end
+
+      # stroke
+      unless no_stroke
+        stroke_color s_color
+        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
+        #end
+        stroke_rounded_rectangle bounds.top_left, bounds.width, bounds.height, radius
+        #undash if options.has_key? :dash_width
+      end
+    end
+  end
+
+  # Fills and, optionally, strokes the current bounds using the fill and
+  # stroke color specified, then yields to the block. The only_if option can
+  # be used to conditionally disable this behavior.
+  #
+  def shade_box color, line_color = nil, options = {}
+    if (!options.has_key? :only_if) || options[:only_if]
+      # FIXME could use save_graphics_state here
+      previous_fill_color = current_fill_color
+      fill_color color
+      fill_rectangle [bounds.left, bounds.top], bounds.right, bounds.top - bounds.bottom
+      fill_color previous_fill_color
+      if line_color
+        line_width 0.5
+        previous_stroke_color = current_stroke_color
+        stroke_color line_color
+        stroke_bounds
+        stroke_color previous_stroke_color
+      end
+    end
+    yield
+  end
+
+  # A compliment to the stroke_horizontal_rule method, strokes a
+  # vertical line using the current bounds. The width of the line
+  # can be specified using the line_width option. The horizontal (x)
+  # position can be specified using the at option.
+  #
+  def stroke_vertical_rule s_color = stroke_color, options = {}
+    save_graphics_state do
+      line_width options[:line_width] || 0.5
+      stroke_color s_color
+      stroke_vertical_line bounds.bottom, bounds.top, at: (options[:at] || 0)
+    end
+  end
+
+  # Strokes a horizontal line using the current bounds. The width of the line
+  # can be specified using the line_width option.
+  #
+  def stroke_horizontal_rule s_color = stroke_color, options = {}
+    save_graphics_state do
+      line_width options[:line_width] || 0.5
+      stroke_color s_color
+      stroke_horizontal_line bounds.left, bounds.right
+    end
+  end
+
+  # Pages
+
+  # Import the specified page into the current document.
+  #
+  def import_page file
+    prev_page_number = page_number
+    state.compress = false if state.compress # can't use compression if using template
+    start_new_page_discretely template: file
+    go_to_page prev_page_number + 1
+  end
+
+  # Create a new page for the specified image. If the
+  # canvas option is true, the image is stretched to the
+  # edges of the page (full coverage).
+  def image_page file, options = {}
+    start_new_page_discretely
+    if options[:canvas]
+      canvas do
+        image file, width: bounds.width, height: bounds.height
+      end
+    else
+      image file, fit: [bounds.width, bounds.height]
+    end
+    go_to_page page_count
+  end
+
+  # Perform an operation (such as creating a new page) without triggering the on_page_create callback
+  #
+  def perform_discretely
+    if (saved_callback = state.on_page_create_callback)
+      state.on_page_create_callback = nil
+      yield
+      state.on_page_create_callback = saved_callback
+    else
+      yield
+    end
+  end
+
+  # Start a new page without triggering the on_page_create callback
+  #
+  def start_new_page_discretely options = {}
+    perform_discretely do
+      start_new_page options
+    end
+  end
+
+  # Grouping
+
+  # Conditional group operation
+  #
+  def group_if verdict
+    if verdict
+      state.optimize_objects = false # optimize objects breaks group
+      group { yield }
+    else
+      yield
+    end
+  end
+
+  def get_scratch_document
+    # marshal if not using transaction feature
+    #Marshal.load Marshal.dump @prototype
+
+    # use cached instance, tests show it's faster
+    #@prototype ||= ::Prawn::Document.new
+    @scratch ||= if defined? @prototype
+      scratch = Marshal.load Marshal.dump @prototype
+      scratch.instance_variable_set(:@prototype, @prototype)
+      # TODO set scratch number on scratch document
+      scratch
+    else
+      warn 'asciidoctor: WARNING: no scratch prototype available; instantiating fresh scratch document'
+      ::Prawn::Document.new
+    end
+  end
+
+  def is_scratch?
+    !!state.store.info.data[:Scratch]
+  end
+  alias :scratch? :is_scratch?
+
+  # TODO document me
+  def dry_run &block
+    scratch = get_scratch_document
+    scratch.start_new_page
+    start_y = scratch.y
+    scratch.font font_family, style: font_style, size: font_size do
+      scratch.instance_exec(&block)
+    end
+    start_y - scratch.y
+    #height_of_content = start_y - scratch.y
+    #scratch.render_file 'scratch.pdf'
+    #height_of_content
+  end
+
+  # Attempt to keep the objects generated in the block on the same page
+  #
+  # TODO short-circuit nested usage
+  def keep_together &block
+    available_space = cursor
+    if (height_of_content = dry_run(&block)) > available_space
+      started_new_page = true
+      start_new_page
+    else
+      started_new_page = false
+    end
+    yield height_of_content, started_new_page
+  end
+
+  # Attempt to keep the objects generated in the block on the same page
+  # if the verdict parameter is true.
+  #
+  def keep_together_if verdict, &block
+    if verdict
+      keep_together(&block)
+    else
+      yield
+    end
+  end
+
+  def run_with_trial &block
+    available_space = cursor
+    if (height_of_content = dry_run(&block)) > available_space
+      started_new_page = true
+    else
+      started_new_page = false
+    end
+    yield height_of_content, started_new_page
+  end
+end
+end
+end