' : ' '}#{dd.text}" : ''}+++) list_item = ListItem.new list, list_item_text dd.blocks.each {|it| list_item << it } list << list_item end convert_outline_list list markers.pop when 'horizontal' table_data = [] term_padding = desc_padding = term_line_metrics = term_inline_format = term_kerning = nil max_term_width = 0 theme_font :description_list_term do if (term_font_styles = font_styles).empty? term_inline_format = true else term_inline_format = [inherited: { styles: term_font_styles }] end term_line_metrics = calc_line_metrics @theme.description_list_term_line_height || @theme.base_line_height term_padding = [term_line_metrics.padding_top, 10, (@theme.prose_margin_bottom || 0) * 0.5 + term_line_metrics.padding_bottom, 10] desc_padding = [0, 10, (@theme.prose_margin_bottom || 0) * 0.5, 10] term_kerning = default_kerning? end node.items.each do |terms, desc| term_text = terms.map(&:text).join ?\n if (term_width = width_of term_text, inline_format: term_inline_format, kerning: term_kerning) > max_term_width max_term_width = term_width end row_data = [{ text_color: @font_color, kerning: term_kerning, content: term_text, inline_format: term_inline_format, padding: term_padding, leading: term_line_metrics.leading, # FIXME: prawn-table doesn't have support for final_gap option #final_gap: term_line_metrics.final_gap, valign: :top, }] desc_container = Block.new desc, :open desc_container << (Block.new desc_container, :paragraph, source: (desc.instance_variable_get :@text), subs: :default) if desc.text? desc.blocks.each {|b| desc_container << b } if desc.block? row_data << { content: (::Prawn::Table::Cell::AsciiDoc.new self, content: desc_container, text_color: @font_color, padding: desc_padding, valign: :top), } table_data << row_data end max_term_width += (term_padding[1] + term_padding[3]) term_column_width = [max_term_width, bounds.width * 0.5].min table table_data, position: :left, cell_style: { border_width: 0 }, column_widths: [term_column_width] do @pdf.layout_table_caption node if node.title? end margin_bottom (@theme.prose_margin_bottom || 0) * 0.5 when 'qanda' @list_numerals << '1' convert_outline_list node @list_numerals.pop else # TODO: check if we're within one line of the bottom of the page # and advance to the next page if so (similar to logic for section titles) layout_caption node.title, category: :description_list if node.title? term_line_height = @theme.description_list_term_line_height || @theme.base_line_height line_metrics = theme_font(:description_list_term) { calc_line_metrics term_line_height } node.items.each do |terms, desc| # NOTE: don't orphan the terms (keep together terms and at least one line of content) allocate_space_for_list_item line_metrics, (terms.size + 1), ((@theme.description_list_term_spacing || 0) + 0.05) theme_font :description_list_term do if (term_font_styles = font_styles).empty? term_font_styles = nil end terms.each do |term| # QUESTION should we pass down styles in other calls to layout_prose layout_prose term.text, margin_top: 0, margin_bottom: @theme.description_list_term_spacing, align: :left, line_height: term_line_height, normalize_line_height: true, styles: term_font_styles end end indent(@theme.description_list_description_indent || 0) do traverse_list_item desc, :dlist_desc, normalize_line_height: true end if desc end end end def convert_olist node add_dest_for_block node if node.id # TODO: move list_numeral resolve to a method case node.style when 'arabic' list_numeral = 1 when 'decimal' list_numeral = '01' when 'loweralpha' list_numeral = 'a' when 'upperalpha' list_numeral = 'A' when 'lowerroman' list_numeral = RomanNumeral.new 'i' when 'upperroman' list_numeral = RomanNumeral.new 'I' when 'lowergreek' list_numeral = LowercaseGreekA when 'unstyled', 'unnumbered', 'no-bullet' list_numeral = nil when 'none' list_numeral = '' else list_numeral = 1 end if list_numeral && list_numeral != '' && (start = (node.attr 'start', nil, false) || ((node.option? 'reversed') ? node.items.size : nil)) if (start = start.to_i) > 1 (start - 1).times { list_numeral = list_numeral.next } elsif start < 1 && !(::String === list_numeral) (start - 1).abs.times { list_numeral = list_numeral.pred } end end @list_numerals << list_numeral convert_outline_list node @list_numerals.pop end def convert_ulist node add_dest_for_block node if node.id # TODO: move bullet_type to method on List (or helper method) if node.option? 'checklist' @list_bullets << :checkbox else if (style = node.style) case style when 'bibliography' bullet_type = :square when 'unstyled', 'no-bullet' bullet_type = nil else candidate = style.to_sym if Bullets.key? candidate bullet_type = candidate else logger.warn %(unknown unordered list style: #{candidate}) unless scratch? bullet_type = :disc end end else case node.outline_level when 1 bullet_type = :disc when 2 bullet_type = :circle else bullet_type = :square end end @list_bullets << bullet_type end convert_outline_list node @list_bullets.pop end def convert_outline_list node # TODO: check if we're within one line of the bottom of the page # and advance to the next page if so (similar to logic for section titles) layout_caption node.title, category: :outline_list if node.title? opts = {} if (align = resolve_alignment_from_role node.roles) opts[:align] = align elsif node.style == 'bibliography' opts[:align] = :left elsif (align = @theme.outline_list_text_align) # NOTE: theme setting only affects alignment of list text (not nested blocks) opts[:align] = align.to_sym end line_metrics = calc_line_metrics @theme.base_line_height complex = false # ...or if we want to give all items in the list the same treatment #complex = node.items.find(&:complex?) ? true : false if (node.context == :ulist && !@list_bullets[-1]) || (node.context == :olist && !@list_numerals[-1]) if node.style == 'unstyled' # unstyled takes away all indentation list_indent = 0 elsif (list_indent = @theme.outline_list_indent || 0) > 0 # no-bullet aligns text with left-hand side of bullet position (as though there's no bullet) list_indent = [list_indent - (rendered_width_of_string %(#{node.context == :ulist ? ?\u2022 : '1.'}x)), 0].max end else list_indent = @theme.outline_list_indent || 0 end indent list_indent do node.items.each do |item| allocate_space_for_list_item line_metrics convert_outline_list_item item, node, opts end end # NOTE: Children will provide the necessary bottom margin if last item is complex. # However, don't leave gap at the bottom if list is nested in an outline list unless complex || (node.nested? && node.parent.parent.outline?) # correct bottom margin of last item margin_bottom((@theme.prose_margin_bottom || 0) - (@theme.outline_list_item_spacing || 0)) end end def convert_outline_list_item node, list, opts = {} # TODO: move this to a draw_bullet (or draw_marker) method marker_style = {} marker_style[:font_color] = @theme.outline_list_marker_font_color || @font_color marker_style[:font_family] = font_family marker_style[:font_size] = font_size marker_style[:line_height] = @theme.base_line_height case (list_type = list.context) when :ulist complex = node.complex? if (marker_type = @list_bullets[-1]) if marker_type == :checkbox # QUESTION should we remove marker indent if not a checkbox? if node.attr? 'checkbox', nil, false marker_type = (node.attr? 'checked', nil, false) ? :checked : :unchecked marker = @theme[%(ulist_marker_#{marker_type}_content)] || BallotBox[marker_type] end else marker = @theme[%(ulist_marker_#{marker_type}_content)] || Bullets[marker_type] end [:font_color, :font_family, :font_size, :line_height].each do |prop| marker_style[prop] = @theme[%(ulist_marker_#{marker_type}_#{prop})] || @theme[%(ulist_marker_#{prop})] || marker_style[prop] end if marker end when :olist complex = node.complex? if (index = @list_numerals.pop) if index == '' marker = '' else marker = %(#{index}.) dir = (node.parent.option? 'reversed') ? :pred : :next @list_numerals << (index.public_send dir) end end when :dlist # NOTE: list.style is 'qanda' complex = node[1]&.complex? @list_numerals << (index = @list_numerals.pop).next marker = %(#{index}.) else complex = node.complex? logger.warn %(unknown list type #{list_type.inspect}) unless scratch? marker = @theme.ulist_marker_disc_content || Bullets[:disc] end if marker if marker_style[:font_family] == 'fa' logger.info 'deprecated fa icon set found in theme; use fas, far, or fab instead' unless scratch? marker_style[:font_family] = FontAwesomeIconSets.find {|candidate| (icon_font_data candidate).yaml[candidate].value? marker } || 'fas' end marker_gap = rendered_width_of_char 'x' font marker_style[:font_family], size: marker_style[:font_size] do marker_width = rendered_width_of_string marker marker_height = height_of_typeset_text marker, line_height: marker_style[:line_height], single_line: true start_position = -marker_width + -marker_gap float do start_new_page if @media == 'prepress' && cursor < marker_height flow_bounding_box start_position, width: marker_width do layout_prose marker, align: :right, character_spacing: -0.5, color: marker_style[:font_color], inline_format: false, line_height: marker_style[:line_height], margin: 0, normalize: false, single_line: true end end end end if complex traverse_list_item node, list_type, (opts.merge normalize_line_height: true) else traverse_list_item node, list_type, (opts.merge margin_bottom: @theme.outline_list_item_spacing, normalize_line_height: true) end end def traverse_list_item node, list_type, opts = {} if list_type == :dlist # qanda terms, desc = node terms.each {|term| layout_prose %(#{term.text}), (opts.merge margin_top: 0, margin_bottom: @theme.description_list_term_spacing) } if desc layout_prose desc.text, (opts.merge hyphenate: true) if desc.text? traverse desc end else if (primary_text = node.text).nil_or_empty? layout_prose DummyText, opts unless node.blocks? else layout_prose primary_text, (opts.merge hyphenate: true) end traverse node end end def allocate_space_for_list_item line_metrics, number = 1, additional_gap = 0 advance_page if !at_page_top? && cursor < (line_metrics.height + line_metrics.leading + line_metrics.padding_top + additional_gap) * number end def convert_image node, opts = {} node.extend ::Asciidoctor::Image unless ::Asciidoctor::Image === node target, image_format = node.target_and_format if image_format == 'gif' && !(defined? ::GMagick::Image) logger.warn %(GIF image format not supported. Install the prawn-gmagick gem or convert #{target} to PNG.) unless scratch? image_path = nil elsif ::Base64 === target image_path = target elsif (image_path = resolve_image_path node, target, (opts.fetch :relative_to_imagesdir, true), image_format) if image_format == 'pdf' if ::File.readable? image_path if (id = node.id) add_dest_block = proc do node.set_attr 'pdf-destination', (node_dest = dest_top) add_dest id, node_dest end end # NOTE: import_page automatically advances to next page afterwards # QUESTION should we add destination to top of imported page? if (pgnums = node.attr 'pages', nil, false) (resolve_pagenums pgnums).each_with_index do |pgnum, idx| if idx == 0 import_page image_path, page: pgnum, replace: page.empty?, &add_dest_block else import_page image_path, page: pgnum, replace: true end end else import_page image_path, page: [(node.attr 'page', nil, 1).to_i, 1].max, replace: page.empty?, &add_dest_block end else # QUESTION should we use alt text in this case? logger.warn %(pdf to insert not found or not readable: #{image_path}) unless scratch? end return elsif !(::File.readable? image_path) logger.warn %(image to embed not found or not readable: #{image_path}) unless scratch? image_path = nil end elsif image_format == 'pdf' # QUESTION should we use alt text in this case? return end theme_margin :block, :top unless (pinned = opts[:pinned]) return on_image_error :missing, node, target, opts unless image_path alignment = ((node.attr 'align', nil, false) || @theme.image_align || :left).to_sym # TODO: support cover (aka canvas) image layout using "canvas" (or "cover") role width = resolve_explicit_width node.attributes, (available_w = bounds.width), support_vw: true, use_fallback: true, constrain_to_bounds: true # TODO: add `to_pt page_width` method to ViewportWidth type width = (width.to_f / 100) * page_width if ViewportWidth === width # NOTE: if width is not set explicitly and max-width is fit-content, caption height may not be accurate caption_h = node.title? ? (layout_caption node, category: :image, side: :bottom, block_align: alignment, block_width: width, max_width: @theme.image_caption_max_width, dry_run: true) : 0 align_to_page = node.option? 'align-to-page' begin rendered_w = nil span_page_width_if align_to_page do if image_format == 'svg' if ::Base64 === image_path svg_data = ::Base64.decode64 image_path file_request_root = false else svg_data = ::File.read image_path, mode: 'r:UTF-8' file_request_root = ::File.dirname image_path end svg_obj = ::Prawn::SVG::Interface.new svg_data, self, position: alignment, width: width, fallback_font_name: fallback_svg_font_name, enable_web_requests: allow_uri_read, enable_file_requests_with_root: file_request_root, cache_images: cache_uri rendered_w = (svg_size = svg_obj.document.sizing).output_width if !width && (svg_obj.document.root.attributes.key? 'width') # NOTE: scale native width & height from px to pt and restrict width to available width if (adjusted_w = [available_w, (to_pt rendered_w, :px)].min) != rendered_w svg_size = svg_obj.resize width: (rendered_w = adjusted_w) end end # NOTE: shrink image so it fits within available space; group image & caption if (rendered_h = svg_size.output_height) > (available_h = cursor - caption_h) unless pinned || at_page_top? advance_page available_h = cursor - caption_h end rendered_w = (svg_obj.resize height: (rendered_h = available_h)).output_width if rendered_h > available_h end image_y = y image_cursor = cursor add_dest_for_block node if node.id # NOTE: workaround to fix Prawn not adding fill and stroke commands on page that only has an image; # breakage occurs when running content (stamps) are added to page # seems to be resolved as of Prawn 2.2.2 update_colors if graphic_state.color_space.empty? # 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) # NOTE: cursor advances automatically svg_obj.draw svg_obj.document.warnings.each do |img_warning| logger.warn %(problem encountered in image: #{image_path}; #{img_warning}) end unless scratch? draw_image_border image_cursor, rendered_w, rendered_h, alignment unless node.role? && (node.has_role? 'noborder') if (link = node.attr 'link', nil, false) add_link_to_image link, { width: rendered_w, height: rendered_h }, position: alignment, y: image_y end else # FIXME: this code really needs to be better organized! # NOTE: use low-level API to access intrinsic dimensions; build_image_object caches image data previously loaded image_obj, image_info = ::Base64 === image_path ? ::StringIO.open((::Base64.decode64 image_path), 'rb') {|fd| build_image_object fd } : ::File.open(image_path, 'rb') {|fd| build_image_object fd } # NOTE: if width is not specified, scale native width & height from px to pt and restrict width to available width rendered_w, rendered_h = image_info.calc_image_dimensions width: (width || [available_w, (to_pt image_info.width, :px)].min) # NOTE: shrink image so it fits within available space; group image & caption if rendered_h > (available_h = cursor - caption_h) unless pinned || at_page_top? advance_page available_h = cursor - caption_h end rendered_w, rendered_h = image_info.calc_image_dimensions height: available_h if rendered_h > available_h end image_y = y image_cursor = cursor add_dest_for_block node if node.id # NOTE: workaround to fix Prawn not adding fill and stroke commands on page that only has an image; # breakage occurs when running content (stamps) are added to page # seems to be resolved as of Prawn 2.2.2 update_colors if graphic_state.color_space.empty? # NOTE: specify both width and height to avoid recalculation embed_image image_obj, image_info, width: rendered_w, height: rendered_h, position: alignment draw_image_border image_cursor, rendered_w, rendered_h, alignment unless node.role? && (node.has_role? 'noborder') if (link = node.attr 'link', nil, false) add_link_to_image link, { width: rendered_w, height: rendered_h }, position: alignment, y: image_y end # NOTE: Asciidoctor disables automatic advancement of cursor for raster images, so move cursor manually move_down rendered_h if y == image_y end end layout_caption node, category: :image, side: :bottom, block_align: alignment, block_width: rendered_w, max_width: @theme.image_caption_max_width if node.title? theme_margin :block, :bottom unless pinned rescue on_image_error :exception, node, target, (opts.merge message: %(could not embed image: #{image_path}; #{$!.message}#{::Prawn::Errors::UnsupportedImageType === $! ? '; install prawn-gmagick gem to add support' : ''})) end end def draw_image_border top, w, h, alignment if (@theme.image_border_width || 0) > 0 && @theme.image_border_color if (@theme.image_border_fit || 'content') == 'auto' bb_width = bounds.width elsif alignment == :center bb_x = (bounds.width - w) * 0.5 elsif alignment == :right bb_x = bounds.width - w end bounding_box [(bb_x || 0), top], width: (bb_width || w), height: h, position: alignment do theme_fill_and_stroke_bounds :image, background_color: nil end true end end def on_image_error _reason, node, target, opts = {} logger.warn opts[:message] if (opts.key? :message) && !scratch? alt_text_vars = { alt: (node.attr 'alt'), target: target } alt_text_template = @theme.image_alt_content || '%{link}[%{alt}]%{/link} | %{target}' if (link = node.attr 'link', nil, false) alt_text_vars[:link] = %() alt_text_vars[:'/link'] = '' else alt_text_vars[:link] = '' alt_text_vars[:'/link'] = '' end alt_text = alt_text_template % alt_text_vars theme_font :image_alt do layout_prose alt_text, align: ((node.attr 'align', nil, false) || @theme.image_align).to_sym, margin: 0, normalize: false, single_line: true end layout_caption node, category: :image, side: :bottom if node.title? theme_margin :block, :bottom unless opts[:pinned] nil end def convert_audio node add_dest_for_block node if node.id theme_margin :block, :top audio_path = node.media_uri node.attr 'target' play_symbol = (node.document.attr? 'icons', 'font') ? %(#{(icon_font_data 'fas').unicode 'play'}) : RightPointer layout_prose %(#{play_symbol}#{NoBreakSpace}#{audio_path} (audio)), normalize: false, margin: 0, single_line: true layout_caption node, side: :bottom if node.title? theme_margin :block, :bottom end def convert_video node case (poster = node.attr 'poster', nil, false) when 'youtube' video_path = %(https://www.youtube.com/watch?v=#{video_id = node.attr 'target'}) # see http://stackoverflow.com/questions/2068344/how-do-i-get-a-youtube-video-thumbnail-from-the-youtube-api poster = allow_uri_read ? %(https://img.youtube.com/vi/#{video_id}/maxresdefault.jpg) : nil type = 'YouTube video' when 'vimeo' video_path = %(https://vimeo.com/#{video_id = node.attr 'target'}) if allow_uri_read if cache_uri Helpers.require_library 'open-uri/cached', 'open-uri-cached' unless defined? ::OpenURI::Cache else ::OpenURI end poster = ::OpenURI.open_uri %(http://vimeo.com/api/v2/video/#{video_id}.xml), 'r' do |f| /
) end def convert_inline_button node %() end def convert_inline_callout node if (conum_color = @theme.conum_font_color) # NOTE CMYK value gets flattened here, but is restored by formatted text parser %(
', '', true]
when :superscript
open, close, is_tag = ['', '', true]
when :subscript
open, close, is_tag = ['', '', true]
when :double
open, close, is_tag = ['“', '”', false]
when :single
open, close, is_tag = ['‘', '’', false]
when :mark
open, close, is_tag = ['', '', true]
else
open, close, is_tag = [nil, nil, false]
end
inner_text = node.text
if (role = node.role)
if (text_transform = (load_theme node.document)[%(role_#{role}_text_transform)])
inner_text = transform_text inner_text, text_transform
end
quoted_text = is_tag ? %(#{open.chop} class="#{role}">#{inner_text}#{close}) : %(#{open}#{inner_text}#{close})
else
quoted_text = %(#{open}#{inner_text}#{close})
end
# NOTE destination is created inside callback registered by FormattedTextTransform#build_fragment
node.id ? %(#{DummyText}#{quoted_text}) : quoted_text
end
def layout_title_page doc
return unless doc.header? && !doc.notitle
# NOTE a new page may have already been started at this point, so decide what to do with it
if page.empty?
page.reset_content if (recycle = @ppbook ? recto_page? : true)
elsif @ppbook && page_number > 0 && recto_page?
start_new_page
end
side = recycle ? page_side : (page_side page_number + 1)
prev_bg_image = @page_bg_image[side]
prev_bg_color = @page_bg_color
if (bg_image = resolve_background_image doc, @theme, 'title-page-background-image')
@page_bg_image[side] = bg_image[0] && bg_image
end
if (bg_color = resolve_theme_color :title_page_background_color)
@page_bg_color = bg_color
end
recycle ? (init_page self) : start_new_page
@page_bg_image[side] = prev_bg_image if bg_image
@page_bg_color = prev_bg_color if bg_color
# IMPORTANT this is the first page created, so we need to set the base font
font @theme.base_font_family, size: @root_font_size
# QUESTION allow alignment per element on title page?
title_align = (@theme.title_page_align || @base_align).to_sym
# FIXME: disallow .pdf as image type
if @theme.title_page_logo_display != 'none' && (logo_image_path = (doc.attr 'title-logo-image') || (logo_image_from_theme = @theme.title_page_logo_image))
if (logo_image_path.include? ':') && logo_image_path =~ ImageAttributeValueRx
logo_image_attrs = (AttributeList.new $2).parse %w(alt width height)
if logo_image_from_theme
relative_to_imagesdir = false
logo_image_path = sub_attributes_discretely doc, $1
logo_image_path = ThemeLoader.resolve_theme_asset logo_image_path, @themesdir unless doc.is_uri? logo_image_path
else
relative_to_imagesdir = true
logo_image_path = $1
end
else
logo_image_attrs = {}
relative_to_imagesdir = false
if logo_image_from_theme
logo_image_path = sub_attributes_discretely doc, logo_image_path
logo_image_path = ThemeLoader.resolve_theme_asset logo_image_path, @themesdir unless doc.is_uri? logo_image_path
end
end
logo_image_attrs['target'] = logo_image_path
if (logo_align = [(logo_image_attrs.delete 'align'), @theme.title_page_logo_align, title_align.to_s].find {|val| (BlockAlignmentNames.include? val) })
logo_image_attrs['align'] = logo_align
end
if (logo_image_top = logo_image_attrs['top'] || @theme.title_page_logo_top)
initial_y, @y = @y, (resolve_top logo_image_top)
end
# FIXME: add API to Asciidoctor for creating blocks like this (extract from extensions module?)
image_block = ::Asciidoctor::Block.new doc, :image, content_model: :empty, attributes: logo_image_attrs
# NOTE pinned option keeps image on same page
indent (@theme.title_page_logo_margin_left || 0), (@theme.title_page_logo_margin_right || 0) do
convert_image image_block, relative_to_imagesdir: relative_to_imagesdir, pinned: true
end
@y = initial_y if initial_y
end
# TODO: prevent content from spilling to next page
theme_font :title_page do
if (title_top = @theme.title_page_title_top)
@y = resolve_top title_top
end
unless @theme.title_page_title_display == 'none'
doctitle = doc.doctitle partition: true
move_down(@theme.title_page_title_margin_top || 0)
indent (@theme.title_page_title_margin_left || 0), (@theme.title_page_title_margin_right || 0) do
theme_font :title_page_title do
layout_prose doctitle.main,
align: title_align,
margin: 0,
line_height: @theme.title_page_title_line_height
end
end
move_down(@theme.title_page_title_margin_bottom || 0)
end
if @theme.title_page_subtitle_display != 'none' && (subtitle = (doctitle || (doc.doctitle partition: true)).subtitle)
move_down(@theme.title_page_subtitle_margin_top || 0)
indent (@theme.title_page_subtitle_margin_left || 0), (@theme.title_page_subtitle_margin_right || 0) do
theme_font :title_page_subtitle do
layout_prose subtitle,
align: title_align,
margin: 0,
line_height: @theme.title_page_subtitle_line_height
end
end
move_down(@theme.title_page_subtitle_margin_bottom || 0)
end
if @theme.title_page_authors_display != 'none' && (doc.attr? 'authors')
move_down(@theme.title_page_authors_margin_top || 0)
indent (@theme.title_page_authors_margin_left || 0), (@theme.title_page_authors_margin_right || 0) do
authors_content = @theme.title_page_authors_content
authors_content = {
name_only: @theme.title_page_authors_content_name_only || authors_content,
with_email: @theme.title_page_authors_content_with_email || authors_content,
with_url: @theme.title_page_authors_content_with_url || authors_content,
}
# TODO: provide an API in core to get authors as an array
authors = (1..(doc.attr 'authorcount', 1).to_i).map {|idx|
promote_author doc, idx do
author_content_key = (url = doc.attr 'url') ? ((url.start_with? 'mailto:') ? :with_email : :with_url) : :name_only
if (author_content = authors_content[author_content_key])
apply_subs_discretely doc, author_content
else
doc.attr 'author'
end
end
}.join (@theme.title_page_authors_delimiter || ', ')
theme_font :title_page_authors do
layout_prose authors,
align: title_align,
margin: 0,
normalize: false
end
end
move_down(@theme.title_page_authors_margin_bottom || 0)
end
unless @theme.title_page_revision_display == 'none' || (revision_info = [(doc.attr? 'revnumber') ? %(#{doc.attr 'version-label'} #{doc.attr 'revnumber'}) : nil, (doc.attr 'revdate')].compact).empty?
move_down(@theme.title_page_revision_margin_top || 0)
revision_text = revision_info.join (@theme.title_page_revision_delimiter || ', ')
if (revremark = doc.attr 'revremark')
revision_text = %(#{revision_text}: #{revremark})
end
indent (@theme.title_page_revision_margin_left || 0), (@theme.title_page_revision_margin_right || 0) do
theme_font :title_page_revision do
layout_prose revision_text,
align: title_align,
margin: 0,
normalize: false
end
end
move_down(@theme.title_page_revision_margin_bottom || 0)
end
end
layout_prose DummyText, margin: 0, line_height: 1, normalize: false if page.empty?
end
def layout_cover_page doc, face
# TODO: turn processing of attribute with inline image a utility function in Asciidoctor
if (image_path = (doc.attr %(#{face}-cover-image)))
if image_path.empty?
go_to_page page_count if face == :back
start_new_page_discretely
# NOTE open graphics state to prevent page from being reused
open_graphics_state if face == :front
return
elsif image_path == '~'
image_path = nil
@page_margin_by_side[:cover] = @page_margin_by_side[:recto] if @media == 'prepress'
elsif (image_path.include? ':') && image_path =~ ImageAttributeValueRx
image_attrs = (AttributeList.new $2).parse %w(alt width)
image_path = resolve_image_path doc, $1, true, (image_format = image_attrs['format'])
else
image_path = resolve_image_path doc, image_path, false
end
return unless image_path
unless ::File.readable? image_path
logger.warn %(#{face} cover image not found or readable: #{image_path})
return
end
go_to_page page_count if face == :back
if image_path.downcase.end_with? '.pdf'
import_page image_path, page: [((image_attrs || {})['page']).to_i, 1].max, advance: face != :back
else
image_opts = resolve_image_options image_path, image_attrs, background: true, format: image_format
image_page image_path, (image_opts.merge canvas: true)
end
end
end
def stamp_foreground_image doc, has_front_cover
pages = state.pages
if (first_page = (has_front_cover ? (pages.slice 1, pages.size) : pages).find {|it| !it.imported_page? }) &&
(first_page_num = (pages.index first_page) + 1) &&
(fg_image = resolve_background_image doc, @theme, 'page-foreground-image') && fg_image[0]
go_to_page first_page_num
create_stamp 'foreground-image' do
canvas { image fg_image[0], ({ position: :center, vposition: :center }.merge fg_image[1]) }
end
stamp 'foreground-image'
(first_page_num.next..page_count).each do |num|
go_to_page num
stamp 'foreground-image' unless page.imported_page?
end
end
end
def start_new_chapter chapter
start_new_page unless at_page_top?
# TODO: must call update_colors before advancing to next page if start_new_page is called in layout_chapter_title
start_new_page if @ppbook && verso_page? && !(chapter.option? 'nonfacing')
end
alias start_new_part start_new_chapter
def layout_chapter_title _node, title, opts = {}
layout_heading title, (opts.merge outdent: true)
end
alias layout_part_title layout_chapter_title
# NOTE layout_heading doesn't set the theme font because it's used for various types of headings
# QUESTION why doesn't layout_heading accept a node?
def layout_heading string, opts = {}
hlevel = opts[:level]
unless (top_margin = (margin = (opts.delete :margin)) || (opts.delete :margin_top))
if at_page_top?
if hlevel && (top_margin = @theme[%(heading_h#{hlevel}_margin_page_top)] || @theme.heading_margin_page_top || 0) > 0
move_down top_margin
end
top_margin = 0
else
top_margin = (hlevel ? @theme[%(heading_h#{hlevel}_margin_top)] : nil) || @theme.heading_margin_top
end
end
bot_margin = margin || (opts.delete :margin_bottom) || (hlevel ? @theme[%(heading_h#{hlevel}_margin_bottom)] : nil) || @theme.heading_margin_bottom
if (transform = resolve_text_transform opts)
string = transform_text string, transform
end
outdent_section opts.delete :outdent do
margin_top top_margin
# QUESTION should we move inherited styles to typeset_text?
if (inherited = apply_text_decoration ::Set.new, :heading, hlevel).empty?
inline_format_opts = true
else
inline_format_opts = [{ inherited: inherited }]
end
typeset_text string, calc_line_metrics((opts.delete :line_height) || (hlevel ? @theme[%(heading_h#{hlevel}_line_height)] : nil) || @theme.heading_line_height || @theme.base_line_height), {
color: @font_color,
inline_format: inline_format_opts,
align: @base_align.to_sym,
}.merge(opts)
margin_bottom bot_margin
end
end
# NOTE inline_format is true by default
def layout_prose string, opts = {}
top_margin = (margin = (opts.delete :margin)) || (opts.delete :margin_top) || @theme.prose_margin_top
bot_margin = margin || (opts.delete :margin_bottom) || @theme.prose_margin_bottom
if (transform = resolve_text_transform opts)
string = transform_text string, transform
end
string = hyphenate_text string, @hyphenator if (opts.delete :hyphenate) && (defined? @hyphenator)
# NOTE used by extensions; ensures linked text gets formatted using the link styles
if (anchor = opts.delete :anchor)
string = %(#{string})
end
margin_top top_margin
string = ZeroWidthSpace + string if opts.delete :normalize_line_height
# NOTE normalize makes endlines soft (replaces "\n" with ' ')
inline_format_opts = { normalize: (opts.delete :normalize) != false }
if (styles = opts.delete :styles)
inline_format_opts[:inherited] = { styles: styles }
end
typeset_text string, calc_line_metrics((opts.delete :line_height) || @theme.base_line_height), {
color: @font_color,
inline_format: [inline_format_opts],
align: @base_align.to_sym,
}.merge(opts)
margin_bottom bot_margin
end
def generate_manname_section node
title = node.attr 'manname-title', 'Name'
if (next_section = node.sections[0]) && (next_section_title = next_section.title) == next_section_title.upcase
title = title.upcase
end
sect = Section.new node, 1
sect.sectname = 'section'
sect.id = node.attr 'manname-id'
sect.title = title
sect << (Block.new sect, :paragraph, source: %(#{node.attr 'manname'} - #{node.attr 'manpurpose'}), subs: :normal)
sect
end
# Render the caption and return the height of the rendered content
#
# The subject argument can either be a String or an AbstractNode. If
# subject is an AbstractNode, only call this method if the node has a
# title (i.e., subject.title? return true).
#--
# TODO: allow margin to be zeroed
def layout_caption subject, opts = {}
if opts.delete :dry_run
height = nil
dry_run do
move_down 1 # HACK: force top margin to be applied
height = (layout_caption subject, opts) - 1
end
return height
end
mark = { cursor: cursor, page_number: page_number }
case subject
when ::String
string = subject
when ::Asciidoctor::AbstractBlock
string = subject.captioned_title
else
raise ArgumentError, 'invalid subject'
end
category_caption = (category = opts[:category]) ? %(#{category}_caption) : 'caption'
container_width = bounds.width
block_align = opts.delete :block_align
if (align = @theme[%(#{category_caption}_align)] || @theme.caption_align)
align = align == 'inherit' ? (block_align || @base_align) : align.to_sym
else
align = @base_align.to_sym
end
indent_by = [0, 0]
block_width = opts.delete :block_width
if (max_width = opts.delete :max_width) && max_width != 'none'
if max_width == 'fit-content'
max_width = block_width || container_width
else
max_width = [max_width.to_f / 100 * bounds.width, bounds.width].min if ::String === max_width && (max_width.end_with? '%')
block_align = align
end
if (remainder = container_width - max_width) > 0
case block_align
when :right
indent_by = [remainder, 0]
when :center
indent_by = [(side_margin = remainder * 0.5), side_margin]
else # :left, nil
indent_by = [0, remainder]
end
end
end
theme_font :caption do
theme_font category_caption do
caption_margin_outside = @theme[%(#{category_caption}_margin_outside)] || @theme.caption_margin_outside
caption_margin_inside = @theme[%(#{category_caption}_margin_inside)] || @theme.caption_margin_inside
if (side = (opts.delete :side) || :top) == :top
margin = { top: caption_margin_outside, bottom: caption_margin_inside }
else
margin = { top: caption_margin_inside, bottom: caption_margin_outside }
end
indent(*indent_by) do
layout_prose string, {
margin_top: margin[:top],
margin_bottom: margin[:bottom],
align: align,
normalize: false,
normalize_line_height: true,
hyphenate: true,
}.merge(opts)
end
if side == :top && (bb_color = @theme[%(#{category_caption}_border_bottom_color)] || @theme.caption_border_bottom_color)
stroke_horizontal_rule bb_color
# FIXME: HACK move down slightly so line isn't covered by filled area (half width of line)
move_down 0.25
end
end
end
# NOTE we assume we don't clear more than one page
if page_number > mark[:page_number]
mark[:cursor] + (bounds.top - cursor)
else
mark[:cursor] - cursor
end
end
# Render the caption for a table and return the height of the rendered content
def layout_table_caption node, table_alignment = :left, table_width = nil, max_width = nil, side = :top
layout_caption node, category: :table, side: side, block_align: table_alignment, block_width: table_width, max_width: max_width
end
def allocate_toc doc, toc_num_levels, toc_start_y, use_title_page
toc_page_nums = page_number
toc_end = nil
dry_run do
toc_page_nums = layout_toc doc, toc_num_levels, toc_page_nums, toc_start_y
move_down @theme.block_margin_bottom unless use_title_page
toc_end = @y
end
# NOTE reserve pages for the toc; leaves cursor on page after last page in toc
if use_title_page
toc_page_nums.each { start_new_page }
else
(toc_page_nums.size - 1).times { start_new_page }
@y = toc_end
end
@toc_extent = { page_nums: toc_page_nums, start_y: toc_start_y }
end
# NOTE num_front_matter_pages is not used during a dry run
def layout_toc doc, num_levels = 2, toc_page_number = 2, start_y = nil, num_front_matter_pages = 0
go_to_page toc_page_number unless (page_number == toc_page_number) || scratch?
start_page_number = page_number
@y = start_y if start_y
unless (toc_title = doc.attr 'toc-title').nil_or_empty?
theme_font :heading, level: 2 do
theme_font :toc_title do
toc_title_align = (@theme.toc_title_align || @theme.heading_h2_align || @theme.heading_align || @base_align).to_sym
layout_heading toc_title, align: toc_title_align, level: 2, outdent: true
end
end
end
# QUESTION should we skip this whole method if num_levels < 0?
unless num_levels < 0
dot_leader = theme_font :toc do
# TODO: we could simplify by using nested theme_font :toc_dot_leader
if (dot_leader_font_style = (@theme.toc_dot_leader_font_style || :normal).to_sym) != font_style
font_style dot_leader_font_style
end
{
font_color: @theme.toc_dot_leader_font_color || @font_color,
font_style: dot_leader_font_style,
levels: ((dot_leader_l = @theme.toc_dot_leader_levels) == 'none' ? ::Set.new :
(dot_leader_l && dot_leader_l != 'all' ? dot_leader_l.to_s.split.map(&:to_i).to_set : (0..num_levels).to_set)),
text: (dot_leader_text = @theme.toc_dot_leader_content || DotLeaderTextDefault),
width: dot_leader_text.empty? ? 0 : (rendered_width_of_string dot_leader_text),
# TODO: spacer gives a little bit of room between dots and page number
spacer: { text: NoBreakSpace, size: (spacer_font_size = @font_size * 0.25) },
spacer_width: (rendered_width_of_char NoBreakSpace, size: spacer_font_size),
}
end
line_metrics = calc_line_metrics @theme.toc_line_height
theme_margin :toc, :top
layout_toc_level doc.sections, num_levels, line_metrics, dot_leader, num_front_matter_pages
end
# NOTE range must be calculated relative to toc_page_number; absolute page number in scratch document is arbitrary
toc_page_numbers = (toc_page_number..(toc_page_number + (page_number - start_page_number)))
go_to_page page_count - 1 unless scratch?
toc_page_numbers
end
def layout_toc_level sections, num_levels, line_metrics, dot_leader, num_front_matter_pages = 0
# NOTE font options aren't always reliable, so store size separately
toc_font_info = theme_font :toc do
{ font: font, size: @font_size }
end
hanging_indent = @theme.toc_hanging_indent || 0
sections.each do |sect|
next if (num_levels_for_sect = (sect.attr 'toclevels', num_levels, false).to_i) < sect.level
theme_font :toc, level: (sect.level + 1) do
sect_title = ZeroWidthSpace + (@text_transform ? (transform_text sect.numbered_title, @text_transform) : sect.numbered_title)
pgnum_label_placeholder_width = rendered_width_of_string '0' * @toc_max_pagenum_digits
# NOTE only write section title (excluding dots and page number) if this is a dry run
if scratch?
indent 0, pgnum_label_placeholder_width do
# FIXME: use layout_prose
# NOTE must wrap title in empty anchor element in case links are styled with different font family / size
typeset_text %(#{sect_title}), line_metrics, inline_format: true, hanging_indent: hanging_indent
end
else
physical_pgnum = sect.attr 'pdf-page-start'
virtual_pgnum = physical_pgnum - num_front_matter_pages
pgnum_label = (virtual_pgnum < 1 ? (RomanNumeral.new physical_pgnum, :lower) : virtual_pgnum).to_s
start_page_number = page_number
start_cursor = cursor
start_dots = nil
sect_title_inherited = (apply_text_decoration ::Set.new, :toc, sect.level.next).merge anchor: (sect_anchor = sect.attr 'pdf-anchor'), color: @font_color
# NOTE use text formatter to add anchor overlay to avoid using inline format with synthetic anchor tag
sect_title_fragments = text_formatter.format sect_title, inherited: sect_title_inherited
indent 0, pgnum_label_placeholder_width do
sect_title_fragments[-1][:callback] = (last_fragment_pos = ::Asciidoctor::PDF::FormattedText::FragmentPositionRenderer.new)
typeset_formatted_text sect_title_fragments, line_metrics, hanging_indent: hanging_indent
start_dots = last_fragment_pos.right + hanging_indent
last_fragment_cursor = last_fragment_pos.top + line_metrics.padding_top
# NOTE this will be incorrect if wrapped line is all monospace
if (last_fragment_page_number = last_fragment_pos.page_number) > start_page_number ||
(start_cursor - last_fragment_cursor) > line_metrics.height
start_page_number = last_fragment_page_number
start_cursor = last_fragment_cursor
end
end
end_page_number = page_number
end_cursor = cursor
# TODO: it would be convenient to have a cursor mark / placement utility that took page number into account
go_to_page start_page_number if start_page_number != end_page_number
move_cursor_to start_cursor
if dot_leader[:width] > 0 && (dot_leader[:levels].include? sect.level)
pgnum_label_width = rendered_width_of_string pgnum_label
pgnum_label_font_settings = { color: @font_color, font: font_family, size: @font_size, styles: font_styles }
save_font do
# NOTE the same font is used for dot leaders throughout toc
set_font toc_font_info[:font], toc_font_info[:size]
font_style dot_leader[:font_style]
num_dots = ((bounds.width - start_dots - dot_leader[:spacer_width] - pgnum_label_width) / dot_leader[:width]).floor
# FIXME: dots don't line up in columns if width of page numbers differ
typeset_formatted_text [
{ text: (dot_leader[:text] * (num_dots < 0 ? 0 : num_dots)), color: dot_leader[:font_color] },
dot_leader[:spacer],
{ text: pgnum_label, anchor: sect_anchor }.merge(pgnum_label_font_settings),
], line_metrics, align: :right
end
else
typeset_formatted_text [{ text: pgnum_label, color: @font_color, anchor: sect_anchor }], line_metrics, align: :right
end
go_to_page end_page_number if page_number != end_page_number
move_cursor_to end_cursor
end
end
indent @theme.toc_indent do
layout_toc_level sect.sections, num_levels_for_sect, line_metrics, dot_leader, num_front_matter_pages
end if num_levels_for_sect > sect.level
end
end
# Reduce icon height to fit inside bounds.height. Icons will not render
# properly if they are larger than the current bounds.height.
def fit_icon_to_bounds preferred_size = 24
(max_height = bounds.height) < preferred_size ? max_height : preferred_size
end
def admonition_icon_data key
if (icon_data = @theme[%(admonition_icon_#{key})])
icon_data = (AdmonitionIcons[key] || {}).merge icon_data
if (icon_name = icon_data[:name])
unless icon_name.start_with?(*IconSetPrefixes)
logger.info { %(#{key} admonition in theme uses icon from deprecated fa icon set; use fas, far, or fab instead) } unless scratch?
icon_data[:name] = %(fa-#{icon_name}) unless icon_name.start_with? 'fa-'
end
end
icon_data
else
AdmonitionIcons[key]
end
end
# TODO: delegate to layout_page_header and layout_page_footer per page
def layout_running_content periphery, doc, opts = {}
skip, skip_pagenums = opts[:skip] || [1, 1]
body_start_page_number = opts[:body_start_page_number] || 1
# NOTE find and advance to first non-imported content page to use as model page
return unless (content_start_page = state.pages[skip..-1].index {|it| !it.imported_page? })
content_start_page += (skip + 1)
num_pages = page_count
prev_page_number = page_number
go_to_page content_start_page
# FIXME: probably need to treat doctypes differently
is_book = doc.doctype == 'book'
header = doc.header? ? doc.header : nil
sectlevels = (@theme[%(#{periphery}_sectlevels)] || 2).to_i
sections = doc.find_by(context: :section) {|sect| sect.level <= sectlevels && sect != header } || []
if (toc_page_nums = @toc_extent && @toc_extent[:page_nums])
toc_title = (doc.attr 'toc-title') || ''
end
title_method = TitleStyles[@theme[%(#{periphery}_title_style)]]
# FIXME: we need a proper model for all this page counting
# FIXME: we make a big assumption that part & chapter start on new pages
# index parts, chapters and sections by the physical page number on which they start
part_start_pages = {}
chapter_start_pages = {}
section_start_pages = {}
trailing_section_start_pages = {}
sections.each do |sect|
pgnum = (sect.attr 'pdf-page-start').to_i
if is_book && ((sect_is_part = sect.part?) || sect.chapter?)
if sect_is_part
part_start_pages[pgnum] ||= sect.send(*title_method)
else
chapter_start_pages[pgnum] ||= sect.send(*title_method)
if sect.sectname == 'appendix' && !part_start_pages.empty?
# FIXME: need a better way to indicate that part has ended
part_start_pages[pgnum] = ''
end
end
else
sect_title = trailing_section_start_pages[pgnum] = sect.send(*title_method)
section_start_pages[pgnum] ||= sect_title
end
end
# index parts, chapters, and sections by the physical page number on which they appear
parts_by_page = {}
chapters_by_page = {}
sections_by_page = {}
# QUESTION should the default part be the doctitle?
last_part = nil
# QUESTION should we enforce that the preamble is a preface?
last_chap = is_book ? :pre : nil
last_sect = nil
sect_search_threshold = 1
(1..num_pages).each do |pgnum|
if (part = part_start_pages[pgnum])
last_part = part
last_chap = nil
last_sect = nil
end
if (chap = chapter_start_pages[pgnum])
last_chap = chap
last_sect = nil
end
if (sect = section_start_pages[pgnum])
last_sect = sect
elsif part || chap
sect_search_threshold = pgnum
# NOTE we didn't find a section on this page; look back to find last section started
elsif last_sect
(sect_search_threshold..(pgnum - 1)).reverse_each do |prev|
if (sect = trailing_section_start_pages[prev])
last_sect = sect
break
end
end
end
parts_by_page[pgnum] = last_part
if last_chap == :pre
if pgnum >= body_start_page_number
chapters_by_page[pgnum] = is_book ? (doc.attr 'preface-title', 'Preface') : nil
elsif toc_page_nums && (toc_page_nums.cover? pgnum)
chapters_by_page[pgnum] = toc_title
else
chapters_by_page[pgnum] = doc.doctitle
end
else
chapters_by_page[pgnum] = last_chap
end
sections_by_page[pgnum] = last_sect
end
doctitle = doc.doctitle partition: true, use_fallback: true
# NOTE set doctitle again so it's properly escaped
doc.set_attr 'doctitle', doctitle.combined
doc.set_attr 'document-title', doctitle.main
doc.set_attr 'document-subtitle', doctitle.subtitle
doc.set_attr 'page-count', (num_pages - skip_pagenums)
pagenums_enabled = doc.attr? 'pagenums'
case @media == 'prepress' ? 'physical' : (doc.attr 'pdf-folio-placement')
when 'physical'
folio_basis, invert_folio = :physical, false
when 'physical-inverted'
folio_basis, invert_folio = :physical, true
when 'virtual-inverted'
folio_basis, invert_folio = :virtual, true
else
folio_basis, invert_folio = :virtual, false
end
periphery_layout_cache = {}
repeat (content_start_page..num_pages), dynamic: true do
# NOTE don't write on pages which are imported / inserts (otherwise we can get a corrupt PDF)
next if page.imported_page?
virtual_pgnum = (pgnum = page_number) - skip_pagenums
pgnum_label = (virtual_pgnum < 1 ? (RomanNumeral.new pgnum, :lower) : virtual_pgnum).to_s
side = page_side((folio_basis == :physical ? pgnum : virtual_pgnum), invert_folio)
# QUESTION should allocation be per side?
trim_styles, colspec_dict, content_dict, stamp_names = allocate_running_content_layout doc, page, periphery, periphery_layout_cache
# FIXME: we need to have a content setting for chapter pages
content_by_position, colspec_by_position = content_dict[side], colspec_dict[side]
# TODO: populate chapter-number
# TODO: populate numbered and unnumbered chapter and section titles
doc.set_attr 'page-number', pgnum_label if pagenums_enabled
# QUESTION should the fallback value be nil instead of empty string? or should we remove attribute if no value?
doc.set_attr 'part-title', (parts_by_page[pgnum] || '')
if toc_page_nums && (toc_page_nums.cover? pgnum)
if is_book
doc.set_attr 'chapter-title', (sect_or_chap_title = toc_title)
doc.set_attr 'section-title', ''
else
doc.set_attr 'chapter-title', ''
doc.set_attr 'section-title', (sect_or_chap_title = section_start_pages[pgnum] ? sections_by_page[pgnum] : toc_title)
end
doc.set_attr 'section-or-chapter-title', sect_or_chap_title
toc_page_nums = nil if toc_page_nums.end == pgnum
else
doc.set_attr 'chapter-title', (chapters_by_page[pgnum] || '')
doc.set_attr 'section-title', (sections_by_page[pgnum] || '')
doc.set_attr 'section-or-chapter-title', (sections_by_page[pgnum] || chapters_by_page[pgnum] || '')
end
stamp stamp_names[side] if stamp_names
theme_font periphery do
canvas do
bounding_box [trim_styles[:content_left][side], trim_styles[:top]], width: trim_styles[:content_width][side], height: trim_styles[:height] do
if (trim_column_rule_width = trim_styles[:column_rule_width]) > 0
trim_column_rule_spacing = trim_styles[:column_rule_spacing]
else
trim_column_rule_width = nil
end
prev_position = nil
ColumnPositions.each do |position|
next unless (content = content_by_position[position])
next unless (colspec = colspec_by_position[position])[:width] > 0
left, colwidth = colspec[:x], colspec[:width]
if trim_column_rule_width && colwidth < bounds.width
if (trim_column_rule = prev_position)
left += (trim_column_rule_spacing * 0.5)
colwidth -= trim_column_rule_spacing
else
colwidth -= (trim_column_rule_spacing * 0.5)
end
end
# FIXME: we need to have a content setting for chapter pages
case content
when ::Array
# NOTE float ensures cursor position is restored and returns us to current page if we overrun
float do
# NOTE bounding_box is redundant if both vertical padding and border width are 0
bounding_box [left, bounds.top - trim_styles[:padding][0] - trim_styles[:content_offset]], width: colwidth, height: trim_styles[:content_height] do
# NOTE image vposition respects padding; use negative image_vertical_align value to revert
image_opts = content[1].merge position: colspec[:align], vposition: trim_styles[:img_valign]
begin
image_info = image content[0], image_opts
if (image_link = content[2])
image_info = { width: image_info.scaled_width, height: image_info.scaled_height } unless image_opts[:format] == 'svg'
add_link_to_image image_link, image_info, image_opts
end
rescue
logger.warn %(could not embed image in running content: #{content[0]}; #{$!.message})
end
end
end
when ::String
theme_font %(#{periphery}_#{side}_#{position}) do
# NOTE minor optimization
if content == '{page-number}'
content = pagenums_enabled ? pgnum_label : nil
else
content = apply_subs_discretely doc, content, drop_lines_with_unresolved_attributes: true
content = transform_text content, @text_transform if @text_transform
end
formatted_text_box parse_text(content, color: @font_color, inline_format: [normalize: true]),
at: [left, bounds.top - trim_styles[:padding][0] - trim_styles[:content_offset] + ((Array trim_styles[:valign])[0] == :center ? font.descender * 0.5 : 0)],
width: colwidth,
height: trim_styles[:prose_content_height],
align: colspec[:align],
valign: trim_styles[:valign],
leading: trim_styles[:line_metrics].leading,
final_gap: false,
overflow: :truncate
end
end
bounding_box [colspec[:x], bounds.top - trim_styles[:padding][0] - trim_styles[:content_offset]], width: colspec[:width], height: trim_styles[:content_height] do
stroke_vertical_rule trim_styles[:column_rule_color], at: bounds.left, line_style: trim_styles[:column_rule_style], line_width: trim_column_rule_width
end if trim_column_rule
prev_position = position
end
end
end
end
end
go_to_page prev_page_number
nil
end
def allocate_running_content_layout doc, page, periphery, cache
cache[layout = page.layout] ||= begin
valign, valign_offset = @theme[%(#{periphery}_vertical_align)]
if (valign = (valign || :middle).to_sym) == :middle
valign = :center
end
trim_styles = {
line_metrics: (trim_line_metrics = calc_line_metrics @theme[%(#{periphery}_line_height)] || @theme.base_line_height),
# NOTE we've already verified this property is set
height: (trim_height = @theme[%(#{periphery}_height)]),
top: periphery == :header ? page_height : trim_height,
padding: (trim_padding = inflate_padding @theme[%(#{periphery}_padding)] || 0),
bg_color: (resolve_theme_color %(#{periphery}_background_color).to_sym),
border_color: (trim_border_color = resolve_theme_color %(#{periphery}_border_color).to_sym),
border_style: (@theme[%(#{periphery}_border_style)] || :solid).to_sym,
border_width: (trim_border_width = trim_border_color ? @theme[%(#{periphery}_border_width)] || @theme.base_border_width || 0 : 0),
column_rule_color: (trim_column_rule_color = resolve_theme_color %(#{periphery}_column_rule_color).to_sym),
column_rule_style: (@theme[%(#{periphery}_column_rule_style)] || :solid).to_sym,
column_rule_width: (trim_column_rule_color ? @theme[%(#{periphery}_column_rule_width)] || 0 : 0),
column_rule_spacing: (@theme[%(#{periphery}_column_rule_spacing)] || 0),
valign: valign_offset ? [valign, valign_offset] : valign,
img_valign: @theme[%(#{periphery}_image_vertical_align)],
left: {
recto: (trim_left_recto = @page_margin_by_side[:recto][3]),
verso: (trim_left_verso = @page_margin_by_side[:verso][3]),
},
width: {
recto: (trim_width_recto = page_width - trim_left_recto - @page_margin_by_side[:recto][1]),
verso: (trim_width_verso = page_width - trim_left_verso - @page_margin_by_side[:verso][1]),
},
content_left: {
recto: trim_left_recto + trim_padding[3],
verso: trim_left_verso + trim_padding[3],
},
content_width: (trim_content_width = {
recto: trim_width_recto - trim_padding[1] - trim_padding[3],
verso: trim_width_verso - trim_padding[1] - trim_padding[3],
}),
content_height: (content_height = trim_height - trim_padding[0] - trim_padding[2] - (trim_border_width * 0.5)),
prose_content_height: content_height - trim_line_metrics.padding_top - trim_line_metrics.padding_bottom,
# NOTE content offset adjusts y position to account for border
content_offset: (periphery == :footer ? trim_border_width * 0.5 : 0),
}
case trim_styles[:img_valign]
when nil
trim_styles[:img_valign] = valign
when 'middle'
trim_styles[:img_valign] = :center
when 'top', 'center', 'bottom'
trim_styles[:img_valign] = trim_styles[:img_valign].to_sym
end
if (trim_bg_image = resolve_background_image doc, @theme, %(#{periphery}_background_image).to_sym, container_size: [page_width, trim_height]) && trim_bg_image[0]
trim_styles[:bg_image] = trim_bg_image
else
trim_bg_image = nil
end
colspec_dict = PageSides.each_with_object({}) do |side, acc|
side_trim_content_width = trim_content_width[side]
if (custom_colspecs = @theme[%(#{periphery}_#{side}_columns)] || @theme[%(#{periphery}_columns)])
case (colspecs = (custom_colspecs.to_s.tr ',', ' ').split).size
when 0, 1
colspecs = { left: '0', center: colspecs[0] || '100', right: '0' }
when 2
colspecs = { left: colspecs[0], center: '0', right: colspecs[1] }
else # 3
colspecs = { left: colspecs[0], center: colspecs[1], right: colspecs[2] }
end
tot_width = 0
side_colspecs = colspecs.map {|col, spec|
if (alignment_char = spec.chr).to_i.to_s != alignment_char
alignment = AlignmentTable[alignment_char] || :left
rel_width = (spec.slice 1, spec.length).to_f
else
alignment = :left
rel_width = spec.to_f
end
tot_width += rel_width
[col, { align: alignment, width: rel_width, x: 0 }]
}.to_h
# QUESTION should we allow the columns to overlap (capping width at 100%)?
side_colspecs.each {|_, colspec| colspec[:width] = (colspec[:width] / tot_width) * side_trim_content_width }
side_colspecs[:right][:x] = (side_colspecs[:center][:x] = side_colspecs[:left][:width]) + side_colspecs[:center][:width]
acc[side] = side_colspecs
else
acc[side] = {
left: { align: :left, width: side_trim_content_width, x: 0 },
center: { align: :center, width: side_trim_content_width, x: 0 },
right: { align: :right, width: side_trim_content_width, x: 0 },
}
end
end
content_dict = PageSides.each_with_object({}) do |side, acc|
side_content = {}
ColumnPositions.each do |position|
unless (val = @theme[%(#{periphery}_#{side}_#{position}_content)]).nil_or_empty?
if (val.include? ':') && val =~ ImageAttributeValueRx
attrlist = $2
image_attrs = (AttributeList.new attrlist).parse %w(alt width)
image_path, image_format = ::Asciidoctor::Image.target_and_format $1, image_attrs
if (image_path = resolve_image_path doc, image_path, @themesdir, image_format) && (::File.readable? image_path)
image_opts = resolve_image_options image_path, image_attrs, container_size: [colspec_dict[side][position][:width], trim_styles[:content_height]], format: image_format
side_content[position] = [image_path, image_opts, image_attrs['link']]
else
# NOTE allows inline image handler to report invalid reference and replace with alt text
side_content[position] = %(image:#{image_path}[#{attrlist}])
end
else
side_content[position] = val
end
end
end
acc[side] = side_content
end
if (trim_bg_color = trim_styles[:bg_color]) || trim_bg_image || trim_border_width > 0
stamp_names = { recto: %(#{layout}_#{periphery}_recto), verso: %(#{layout}_#{periphery}_verso) }
PageSides.each do |side|
create_stamp stamp_names[side] do
canvas do
if trim_bg_color || trim_bg_image
bounding_box [0, trim_styles[:top]], width: bounds.width, height: trim_styles[:height] do
fill_bounds trim_bg_color if trim_bg_color
if trim_border_width > 0
stroke_horizontal_rule trim_styles[:border_color], line_width: trim_border_width, line_style: trim_styles[:border_style], at: (periphery == :header ? bounds.height : 0)
end
# NOTE: must draw line first or SVG will cause border to disappear
image trim_bg_image[0], ({ position: :center, vposition: :center }.merge trim_bg_image[1]) if trim_bg_image
end
elsif trim_border_width > 0
bounding_box [trim_styles[:left][side], trim_styles[:top]], width: trim_styles[:width][side], height: trim_styles[:height] do
stroke_horizontal_rule trim_styles[:border_color], line_width: trim_styles[:border_width], line_style: trim_styles[:border_style], at: (periphery == :header ? bounds.height : 0)
end
end
end
end
end
end
[trim_styles, colspec_dict, content_dict, stamp_names]
end
end
def add_outline doc, num_levels = 2, toc_page_nums = [], num_front_matter_pages = 0, has_front_cover = false
if ::String === num_levels
if num_levels.include? ':'
num_levels, expand_levels = num_levels.split ':', 2
num_levels = num_levels.empty? ? (doc.attr 'toclevels', 2).to_i : num_levels.to_i
expand_levels = expand_levels.to_i
else
num_levels = expand_levels = num_levels.to_i
end
else
expand_levels = num_levels
end
front_matter_counter = RomanNumeral.new 0, :lower
pagenum_labels = {}
num_front_matter_pages.times do |n|
pagenum_labels[n] = { P: (::PDF::Core::LiteralString.new front_matter_counter.next!.to_s) }
end
# add labels for each content page, which is required for reader's page navigator to work correctly
(num_front_matter_pages..(page_count - 1)).each_with_index do |n, i|
pagenum_labels[n] = { P: (::PDF::Core::LiteralString.new (i + 1).to_s) }
end
unless toc_page_nums.none? || (toc_title = doc.attr 'toc-title').nil_or_empty?
toc_section = insert_toc_section doc, toc_title, toc_page_nums
end
outline.define do
initial_pagenum = has_front_cover ? 2 : 1
# FIXME: use sanitize: :plain_text once available
if document.page_count >= initial_pagenum && (doctitle = doc.header? ? doc.doctitle : (doc.attr 'untitled-label'))
page title: (document.sanitize doctitle), destination: (document.dest_top has_front_cover ? 2 : 1)
end
# QUESTION is there any way to get add_outline_level to invoke in the context of the outline?
document.add_outline_level self, doc.sections, num_levels, expand_levels
end
toc_section.parent.blocks.delete toc_section if toc_section
catalog.data[:PageLabels] = state.store.ref Nums: pagenum_labels.flatten
primary_page_mode, secondary_page_mode = PageModes[(doc.attr 'pdf-page-mode') || @theme.page_mode]
catalog.data[:PageMode] = primary_page_mode
catalog.data[:NonFullScreenPageMode] = secondary_page_mode if secondary_page_mode
nil
end
def add_outline_level outline, sections, num_levels, expand_levels
sections.each do |sect|
sect_title = sanitize sect.numbered_title formal: true
sect_destination = sect.attr 'pdf-destination'
if (level = sect.level) == num_levels || !sect.sections?
outline.page title: sect_title, destination: sect_destination
elsif level <= num_levels
outline.section sect_title, destination: sect_destination, closed: expand_levels < 1 do
add_outline_level outline, sect.sections, num_levels, (expand_levels - 1)
end
end
end
end
def insert_toc_section doc, toc_title, toc_page_nums
if (doc.attr? 'toc-placement', 'macro') && (toc_node = (doc.find_by context: :toc)[0])
if (parent_section = toc_node.parent).context == :section
grandparent_section = parent_section.parent
toc_level = parent_section.level
insert_idx = (grandparent_section.blocks.index parent_section) + 1
else
grandparent_section = doc
toc_level = doc.sections[0].level
insert_idx = 0
end
toc_dest = toc_node.attr 'pdf-destination'
else
grandparent_section = doc
toc_level = doc.sections[0].level
insert_idx = 0
toc_dest = dest_top toc_page_nums.first
end
toc_section = Section.new grandparent_section, toc_level, false, attributes: { 'pdf-destination' => toc_dest }
toc_section.title = toc_title
grandparent_section.blocks.insert insert_idx, toc_section
toc_section
end
def write pdf_doc, target
if target.respond_to? :write
target = ::QuantifiableStdout.new STDOUT if target == STDOUT
pdf_doc.render target
else
pdf_doc.render_file target
# QUESTION restore attributes first?
@pdfmark&.generate_file target
(Optimizer.new @optimize, pdf_doc.min_version).generate_file target if @optimize && ((defined? ::Asciidoctor::PDF::Optimizer) || !(Helpers.require_library OptimizerRequirePath, 'rghost', :warn).nil?)
end
# write scratch document if debug is enabled (or perhaps DEBUG_STEPS env)
#get_scratch_document.render_file 'scratch.pdf'
nil
end
def register_fonts font_catalog, fonts_dir
return unless font_catalog
dirs = (fonts_dir.split ValueSeparatorRx, -1).map do |dir|
dir == 'GEM_FONTS_DIR' || dir.empty? ? ThemeLoader::FontsDir : dir
end
font_catalog.each do |key, styles|
styles = styles.each_with_object({}) do |(style, path), accum|
found = dirs.find do |dir|
resolved_font_path = font_path path, dir
if ::File.readable? resolved_font_path
accum[style.to_sym] = resolved_font_path
true
end
end
raise ::Errno::ENOENT, ((File.absolute_path? path) ? %(#{path} not found) : %(#{path} not found in #{fonts_dir.gsub ValueSeparatorRx, ' or '})) unless found
end
register_font key => styles
end
end
def font_path font_file, fonts_dir
# resolve relative to built-in font dir unless path is absolute
::File.absolute_path font_file, fonts_dir
end
def fallback_svg_font_name
@theme.svg_fallback_font_family || @theme.svg_font_family || @theme.base_font_family
end
def apply_text_decoration styles, category, level = nil
if (text_decoration_style = TextDecorationStyleTable[(level && @theme[%(#{category}_h#{level}_text_decoration)]) || @theme[%(#{category}_text_decoration)]])
{
styles: (styles << text_decoration_style),
text_decoration_color: (level && @theme[%(#{category}_h#{level}_text_decoration_color)]) || @theme[%(#{category}_text_decoration_color)],
text_decoration_width: (level && @theme[%(#{category}_h#{level}_text_decoration_width)]) || @theme[%(#{category}_text_decoration_width)],
}.compact
else
styles.empty? ? {} : { styles: styles }
end
end
def resolve_text_transform key, use_fallback = true
if (transform = ::Hash === key ? (key.delete :text_transform) : @theme[key.to_s])
transform == 'none' ? nil : transform
elsif use_fallback
@text_transform
end
end
# QUESTION should we pass a category as an argument?
# QUESTION should we make this a method on the theme ostruct? (e.g., @theme.resolve_color key, fallback)
def resolve_theme_color key, fallback_color = nil
if (color = @theme[key.to_s]) && color != 'transparent'
color
else
fallback_color
end
end
def resolve_font_kerning keyword, fallback = default_kerning?
keyword && (FontKerningTable.key? keyword) ? FontKerningTable[keyword] : fallback
end
def theme_fill_and_stroke_bounds category, opts = {}
bg_color = (opts.key? :background_color) ? opts[:background_color] : @theme[%(#{category}_background_color)]
fill_and_stroke_bounds bg_color, @theme[%(#{category}_border_color)],
line_width: (@theme[%(#{category}_border_width)] || 0),
radius: @theme[%(#{category}_border_radius)]
end
def theme_fill_and_stroke_block category, block_height, opts = {}
if (b_width = (opts.key? :border_width) ? opts[:border_width] : @theme[%(#{category}_border_width)])
b_width = nil unless b_width > 0
end
if (bg_color = opts[:background_color] || @theme[%(#{category}_background_color)]) == 'transparent'
bg_color = nil
end
unless b_width || bg_color
(node = opts[:caption_node]) && node.title? && (layout_caption node, category: category)
return
end
if (b_color = @theme[%(#{category}_border_color)]) == 'transparent'
b_color = @page_bg_color
end
b_radius = (@theme[%(#{category}_border_radius)] || 0) + (b_width || 0)
if b_width && b_color
if b_color == @page_bg_color # let page background cut into block background
b_gap_color, b_shift = @page_bg_color, b_width
elsif (b_gap_color = bg_color) && b_gap_color != b_color
b_shift = 0
else # let page background cut into border
b_gap_color, b_shift = @page_bg_color, 0
end
else # let page background cut into block background
b_shift, b_gap_color = (b_width ||= 0.5) * 0.5, @page_bg_color
end
# FIXME: due to the calculation error logged in #789, we must advance page even when content is split across pages
advance_page if (opts.fetch :split_from_top, true) && block_height > cursor && !at_page_top?
caption_height = (node = opts[:caption_node]) && node.title? ? (layout_caption node, category: category) - 1 : 0
float do
remaining_height = block_height - caption_height
initial_page = true
while remaining_height > 0
advance_page unless initial_page
chunk_height = [(available_height = cursor), remaining_height].min
bounding_box [0, available_height], width: bounds.width, height: chunk_height do
theme_fill_and_stroke_bounds category, background_color: bg_color
if b_width
indent b_radius, b_radius do
# dashed line indicates continuation from previous page; swell line slightly to cover background
stroke_horizontal_rule b_gap_color, line_width: b_width * 1.2, line_style: :dashed, at: b_shift
end unless initial_page
if remaining_height > chunk_height
move_down chunk_height - b_shift
indent b_radius, b_radius do
# dashed line indicates continuation from previous page; swell line slightly to cover background
stroke_horizontal_rule b_gap_color, line_width: b_width * 1.2, line_style: :dashed
end
end
end
end
initial_page = false
remaining_height -= chunk_height
end
end
end
# Insert a top margin equal to amount if cursor is not at the top of the
# page. Start a new page instead if amount is greater than the remaining
# space on the page.
def margin_top amount
margin amount, :top
end
# Insert a bottom margin equal to amount unless cursor is at the top of the
# page (not likely). Start a new page instead if amount is greater than the
# remaining space on the page.
def margin_bottom amount
margin amount, :bottom
end
# Insert a margin at the specified side if the cursor is not at the top of
# the page. Start a new page if amount is greater than the remaining space on
# the page.
def margin amount, _side
unless (amount || 0) == 0 || at_page_top?
# NOTE use low-level cursor calculation to workaround cursor bug in column_box context
if y - reference_bounds.absolute_bottom > amount
move_down amount
else
# set cursor at top of next page
reference_bounds.move_past_bottom
end
end
end
# Lookup margin for theme element and side, then delegate to margin method.
# If margin value is not found, assume:
# - 0 when side == :top
# - @theme.vertical_spacing when side == :bottom
def theme_margin category, side
margin((@theme[%(#{category}_margin_#{side})] || (side == :bottom ? @theme.vertical_spacing : 0)), side)
end
def theme_font category, opts = {}
result = nil
# TODO: inheriting from generic category should be an option
if opts.key? :level
hlevel_category = %(#{category}_h#{opts[:level]})
family = @theme[%(#{hlevel_category}_font_family)] || @theme[%(#{category}_font_family)] || @theme.base_font_family || font_family
size = @theme[%(#{hlevel_category}_font_size)] || @theme[%(#{category}_font_size)] || @root_font_size
style = @theme[%(#{hlevel_category}_font_style)] || @theme[%(#{category}_font_style)]
color = @theme[%(#{hlevel_category}_font_color)] || @theme[%(#{category}_font_color)]
kerning = resolve_font_kerning @theme[%(#{hlevel_category}_font_kerning)] || @theme[%(#{category}_font_kerning)], nil
# NOTE global text_transform is not currently supported
transform = @theme[%(#{hlevel_category}_text_transform)] || @theme[%(#{category}_text_transform)]
else
inherited_font = font_info
family = @theme[%(#{category}_font_family)] || inherited_font[:family]
size = @theme[%(#{category}_font_size)] || inherited_font[:size]
style = @theme[%(#{category}_font_style)] || inherited_font[:style]
color = @theme[%(#{category}_font_color)]
kerning = resolve_font_kerning @theme[%(#{category}_font_kerning)], nil
# NOTE global text_transform is not currently supported
transform = @theme[%(#{category}_text_transform)]
end
prev_color, @font_color = @font_color, color if color
prev_kerning, self.default_kerning = default_kerning?, kerning unless kerning.nil?
prev_transform, @text_transform = @text_transform, (transform == 'none' ? nil : transform) if transform
font family, size: size, style: (style && style.to_sym) do
result = yield
end
@font_color = prev_color if color
default_kerning prev_kerning unless kerning.nil?
@text_transform = prev_transform if transform
result
end
# Calculate the font size (down to the minimum font size) that would allow
# all the specified fragments to fit in the available width without wrapping lines.
#
# Return the calculated font size if an adjustment is necessary or nil if no
# font size adjustment is necessary.
def theme_font_size_autofit fragments, category
arranger = arrange_fragments_by_line fragments
theme_font category do
# NOTE finalizing the line here generates fragments & calculates their widths using the current font settings
# CAUTION it also removes zero-width spaces
arranger.finalize_line
actual_width = width_of_fragments arranger.fragments
unless ::Array === (padding = @theme[%(#{category}_padding)])
padding = ::Array.new 4, padding
end
available_width = bounds.width - (padding[3] || 0) - (padding[1] || 0)
if actual_width > available_width
adjusted_font_size = ((available_width * font_size).to_f / actual_width).truncate 4
if (min = @theme[%(#{category}_font_size_min)] || @theme.base_font_size_min) && adjusted_font_size < min
min
else
adjusted_font_size
end
end
end
end
# Arrange fragments by line in an arranger and return an unfinalized arranger.
#
# Finalizing the arranger is deferred since it must be done in the context of
# the global font settings you want applied to each fragment.
def arrange_fragments_by_line fragments, _opts = {}
arranger = ::Prawn::Text::Formatted::Arranger.new self
by_line = arranger.consumed = []
fragments.each do |fragment|
if (text = fragment[:text]) == LF
by_line << fragment
elsif text.include? LF
text.scan LineScanRx do |line|
by_line << (line == LF ? { text: LF } : (fragment.merge text: line))
end
else
by_line << fragment
end
end
arranger
end
# Calculate the width that is needed to print all the
# fragments without wrapping any lines.
#
# This method assumes endlines are represented as discrete entries in the
# fragments array.
def width_of_fragments fragments
line_widths = [0]
fragments.each do |fragment|
if fragment.text == LF
line_widths << 0
else
line_widths[-1] += fragment.width
end
end
line_widths.max
end
# Compute the rendered width of a string, taking fallback fonts into account
def rendered_width_of_string str, opts = {}
opts = opts.merge kerning: default_kerning?
if str.length == 1
rendered_width_of_char str, opts
elsif (chars = str.each_char).all? {|char| font.glyph_present? char }
width_of_string str, opts
else
char_widths = chars.map {|char| rendered_width_of_char char, opts }
char_widths.sum + (char_widths.length * character_spacing)
end
end
# Compute the rendered width of a char, taking fallback fonts into account
def rendered_width_of_char char, opts = {}
unless @fallback_fonts.empty? || (font.glyph_present? char)
@fallback_fonts.each do |fallback_font|
font fallback_font do
return width_of_string char, opts if font.glyph_present? char
end
end
end
width_of_string char, opts
end
# TODO: document me, esp the first line formatting functionality
def typeset_text string, line_metrics, opts = {}
move_down line_metrics.padding_top
opts = { leading: line_metrics.leading, final_gap: line_metrics.final_gap }.merge opts
string = string.gsub CjkLineBreakRx, ZeroWidthSpace if @cjk_line_breaks
if (hanging_indent = (opts.delete :hanging_indent) || 0) > 0
indent hanging_indent do
text string, (opts.merge indent_paragraphs: -hanging_indent)
end
elsif (first_line_opts = opts.delete :first_line_options)
# TODO: good candidate for Prawn enhancement!
text_with_formatted_first_line string, first_line_opts, opts
else
text string, opts
end
move_down line_metrics.padding_bottom
end
# QUESTION combine with typeset_text?
def typeset_formatted_text fragments, line_metrics, opts = {}
move_down line_metrics.padding_top
opts = { leading: line_metrics.leading, final_gap: line_metrics.final_gap }.merge opts
if (hanging_indent = (opts.delete :hanging_indent) || 0) > 0
indent hanging_indent do
formatted_text fragments, (opts.merge indent_paragraphs: -hanging_indent)
end
else
formatted_text fragments, opts
end
move_down line_metrics.padding_bottom
end
def height_of_typeset_text string, opts = {}
line_metrics = (calc_line_metrics opts[:line_height] || @theme.base_line_height)
(height_of string, leading: line_metrics.leading, final_gap: line_metrics.final_gap) + line_metrics.padding_top + (opts[:single_line] ? 0 : line_metrics.padding_bottom)
end
# NOTE only used when tabsize attribute is not specified
# tabs must always be replaced with spaces in order for the indentation guards to work
def expand_tabs string
if string.nil_or_empty?
''
elsif string.include? TAB
full_tab_space = ' ' * (tab_size = 4)
(string.split LF, -1).map {|line|
if line.empty?
line
elsif (tab_idx = line.index TAB)
if tab_idx == 0
leading_tabs = 0
line.each_byte do |b|
break unless b == 9
leading_tabs += 1
end
line = %(#{full_tab_space * leading_tabs}#{rest = line.slice leading_tabs, line.length})
next line unless rest.include? TAB
end
# keeps track of how many spaces were added to adjust offset in match data
spaces_added = 0
idx = 0
result = ''
line.each_char do |c|
if c == TAB
# calculate how many spaces this tab represents, then replace tab with spaces
if (offset = idx + spaces_added) % tab_size == 0
spaces_added += (tab_size - 1)
result += full_tab_space
else
unless (spaces = tab_size - offset % tab_size) == 1
spaces_added += (spaces - 1)
end
result += (' ' * spaces)
end
else
result += c
end
idx += 1
end
result
else
line
end
}.join LF
else
string
end
end
# Add an indentation guard at the start of indented lines.
# Expand tabs to spaces if tabs are present
def guard_indentation string
unless (string = expand_tabs string).empty?
string[0] = GuardedIndent if string.start_with? ' '
string.gsub! InnerIndent, GuardedInnerIndent if string.include? InnerIndent
end
string
end
def guard_indentation_in_fragments fragments
start_of_line = true
fragments.each do |fragment|
next if (text = fragment[:text]).empty?
if start_of_line && (text.start_with? ' ')
fragment[:text] = GuardedIndent + (((text = text.slice 1, text.length).include? InnerIndent) ? (text.gsub InnerIndent, GuardedInnerIndent) : text)
elsif text.include? InnerIndent
fragment[:text] = text.gsub InnerIndent, GuardedInnerIndent
end
start_of_line = text.end_with? LF
end
fragments
end
# Derive a PDF-safe, ASCII-only anchor name from the given value.
# Encodes value into hex if it contains characters outside the ASCII range.
# If value is nil, derive an anchor name from the default_value, if given.
def derive_anchor_from_id value, default_value = nil
if value
value.ascii_only? ? value : %(0x#{::PDF::Core.string_to_hex value})
elsif default_value
%(__anchor-#{default_value})
end
end
# If an id is provided or the node passed as the first argument has an id,
# add a named destination to the document equivalent to the node id at the
# current y position. If the node does not have an id and an id is not
# specified, do nothing.
#
# If the node is a section, and the current y position is the top of the
# page, set the y position equal to the page height to improve the navigation
# experience. If the current x position is at or inside the left margin, set
# the x position equal to 0 (left edge of page) to improve the navigation
# experience.
def add_dest_for_block node, id = nil
if !scratch? && (id ||= node.id)
dest_x = bounds.absolute_left.truncate 4
# QUESTION when content is aligned to left margin, should we keep precise x value or just use 0?
dest_x = 0 if dest_x <= page_margin_left
dest_y = at_page_top? && (node.context == :section || node.context == :document) ? page_height : y
# TODO: find a way to store only the ref of the destination; look it up when we need it
node.set_attr 'pdf-destination', (node_dest = (dest_xyz dest_x, dest_y))
add_dest id, node_dest
end
nil
end
def resolve_alignment_from_role roles
if (align_role = roles.reverse.find {|r| TextAlignmentRoles.include? r })
(align_role.slice 5, align_role.length).to_sym
end
end
# QUESTION is this method still necessary?
def resolve_imagesdir doc
if (imagesdir = doc.attr 'imagesdir').nil_or_empty? || (imagesdir = imagesdir.chomp '/') == '.'
nil
else
imagesdir
end
end
# Resolve the system path of the specified image path.
#
# Resolve and normalize the absolute system path of the specified image,
# taking into account the imagesdir attribute. If an image path is not
# specified, the path is read from the target attribute of the specified
# document node.
#
# If the target is a URI and the allow-uri-read attribute is set on the
# document, read the file contents to a temporary file and return the path to
# the temporary file. If the target is a URI and the allow-uri-read attribute
# is not set, or the URI cannot be read, this method returns a nil value.
#
# When a temporary file is used, the file is stored in @tmp_files to be cleaned up after conversion.
def resolve_image_path node, image_path = nil, relative_to = true, image_format = nil
doc = node.document
imagesdir = relative_to == true ? (resolve_imagesdir doc) : relative_to
image_path ||= node.attr 'target'
image_format ||= ::Asciidoctor::Image.format image_path, (::Asciidoctor::Image === node ? node.attributes : nil)
# NOTE base64 logic currently used for inline images
if ::Base64 === image_path
return (tmp_file = @tmp_files[image_path]) && tmp_file.path if @tmp_files.key? image_path
@tmp_files[image_path] = tmp_image = ::Tempfile.create ['image-', image_format && %(.#{image_format})]
tmp_image.binmode unless image_format == 'svg'
begin
tmp_image.write ::Base64.decode64 image_path
tmp_image.close
tmp_image.path
rescue
@tmp_files[image_path] = nil
tmp_image.close
unlink_tmp_file tmp_image
nil
end
# handle case when image is a URI
elsif (node.is_uri? image_path) ||
(imagesdir && (node.is_uri? imagesdir) && (image_path = node.normalize_web_path image_path, imagesdir, false))
unless allow_uri_read
logger.warn %(allow-uri-read is not enabled; cannot embed remote image: #{image_path}) unless scratch?
return
end
if @tmp_files.key? image_path
return (tmp_file = @tmp_files[image_path]) && tmp_file.path
elsif cache_uri
Helpers.require_library 'open-uri/cached', 'open-uri-cached' unless defined? ::OpenURI::Cache
else
::OpenURI
end
@tmp_files[image_path] = tmp_image = ::Tempfile.create ['image-', image_format && %(.#{image_format})]
tmp_image.binmode if (binary = image_format != 'svg')
begin
::OpenURI.open_uri(image_path, (binary ? 'rb' : 'r')) {|fd| tmp_image.write fd.read }
tmp_image.close
tmp_image.path
rescue
logger.warn %(could not retrieve remote image: #{image_path}; #{$!.message}) unless scratch?
@tmp_files[image_path] = nil
tmp_image.close
unlink_tmp_file tmp_image
nil
end
# handle case when image is a local file
else
node.normalize_system_path image_path, imagesdir, nil, target_name: 'image'
end
end
# Resolve the path and sizing of the background image either from a document attribute or theme key.
#
# Returns the argument list for the image method if the document attribute or theme key is found. Otherwise,
# nothing. The first argument in the argument list is the image path. If that value is nil, the background
# image is disabled. The second argument is the options hash to specify the dimensions, such as width and fit.
def resolve_background_image doc, theme, key, opts = {}
if ::String === key
image_path = (doc.attr key) || (from_theme = theme[(key.tr '-', '_').to_sym])
else
image_path = from_theme = theme[key]
end
if image_path
if image_path == 'none'
return []
elsif (image_path.include? ':') && image_path =~ ImageAttributeValueRx
image_attrs = (AttributeList.new $2).parse %w(alt width)
if from_theme
image_path = sub_attributes_discretely doc, $1
image_relative_to = @themesdir
else
image_path = $1
image_relative_to = true
end
elsif from_theme
image_path = sub_attributes_discretely doc, image_path
image_relative_to = @themesdir
end
image_path, image_format = ::Asciidoctor::Image.target_and_format image_path, image_attrs
image_path = resolve_image_path doc, image_path, image_relative_to, image_format
return unless image_path
unless ::File.readable? image_path
logger.warn %(#{key.to_s.tr '-_', ' '} not found or readable: #{image_path})
return
end
[image_path, (resolve_image_options image_path, image_attrs, (opts.merge background: true, format: image_format))]
end
end
def resolve_image_options image_path, image_attrs, opts = {}
if (image_format = opts[:format] || (::Asciidoctor::Image.format image_path)) == 'svg'
image_opts = {
enable_file_requests_with_root: (::File.dirname image_path),
enable_web_requests: allow_uri_read,
cache_images: cache_uri,
fallback_font_name: fallback_svg_font_name,
format: 'svg',
}
else
image_opts = {}
end
background = opts[:background]
container_size = opts[:container_size] || (background ? [page_width, page_height] : [bounds.width, bounds.height])
if image_attrs
if background && (image_pos = image_attrs['position']) && (image_pos = resolve_background_position image_pos, nil)
image_opts.update image_pos
end
if (image_fit = image_attrs['fit'] || (background ? 'contain' : nil))
image_fit = 'contain' if image_format == 'svg' && image_fit == 'fill'
container_width, container_height = container_size
case image_fit
when 'none'
if (image_width = resolve_explicit_width image_attrs, container_width)
image_opts[:width] = image_width
end
when 'scale-down'
# NOTE if width and height aren't set in SVG, real width and height are computed after stretching viewbox to fit page
if (image_width = resolve_explicit_width image_attrs, container_width) && image_width > container_width
image_opts[:fit] = container_size
elsif (image_size = intrinsic_image_dimensions image_path, image_format) &&
(image_width ? image_width * (image_size[:height].to_f / image_size[:width]) > container_height : (to_pt image_size[:width], :px) > container_width || (to_pt image_size[:height], :px) > container_height)
image_opts[:fit] = container_size
elsif image_width
image_opts[:width] = image_width
end
when 'cover'
# QUESTION should we take explicit width into account?
if (image_size = intrinsic_image_dimensions image_path, image_format)
if container_width * (image_size[:height].to_f / image_size[:width]) < container_height
image_opts[:height] = container_height
else
image_opts[:width] = container_width
end
end
when 'fill'
image_opts[:width] = container_width
image_opts[:height] = container_height
else # when 'contain'
image_opts[:fit] = container_size
end
elsif (image_width = resolve_explicit_width image_attrs, container_size[0])
image_opts[:width] = image_width
else # default to fit=contain if sizing is not specified
image_opts[:fit] = container_size
end
else
image_opts[:fit] = container_size
end
image_opts
end
# Resolves the explicit width as a PDF pt value if the value is specified in
# absolute units, but defers resolving a percentage value until later.
#
# See resolve_explicit_width method for details about which attributes are considered.
def preresolve_explicit_width attrs
if attrs.key? 'pdfwidth'
((width = attrs['pdfwidth']).end_with? '%') ? width : (str_to_pt width)
elsif attrs.key? 'scaledwidth'
# NOTE the parser automatically appends % if value is unitless
((width = attrs['scaledwidth']).end_with? '%') ? width : (str_to_pt width)
elsif attrs.key? 'width'
# QUESTION should we honor percentage width value?
to_pt attrs['width'].to_f, :px
end
end
# Resolves the explicit width as a PDF pt value, if specified.
#
# Resolves the explicit width, first considering the pdfwidth attribute, then
# the scaledwidth attribute and finally the width attribute. If the specified
# value is in pixels, the value is scaled by 75% to perform approximate
# CSS px to PDF pt conversion. If the resolved width is larger than the
# max_width, the max_width value is returned.
#--
# QUESTION should we enforce positive result?
def resolve_explicit_width attrs, max_width = bounds.width, opts = {}
# QUESTION should we restrict width to max_width for pdfwidth?
if attrs.key? 'pdfwidth'
if (width = attrs['pdfwidth']).end_with? '%'
(width.to_f / 100) * max_width
elsif opts[:support_vw] && (width.end_with? 'vw')
(width.chomp 'vw').extend ViewportWidth
else
str_to_pt width
end
elsif attrs.key? 'scaledwidth'
# NOTE the parser automatically appends % if value is unitless
if (width = attrs['scaledwidth']).end_with? '%'
(width.to_f / 100) * max_width
else
str_to_pt width
end
elsif opts[:use_fallback] && (width = @theme.image_width)
if ::Numeric === width
width
elsif (width = width.to_s).end_with? '%'
(width.to_f / 100) * max_width
elsif opts[:support_vw] && (width.end_with? 'vw')
(width.chomp 'vw').extend ViewportWidth
else
str_to_pt width
end
elsif attrs.key? 'width'
if (width = attrs['width']).end_with? '%'
width = (width.to_f / 100) * max_width
else
width = to_pt width.to_f, :px
end
opts[:constrain_to_bounds] ? [max_width, width].min : width
end
end
def resolve_background_position value, default_value = {}
if value.include? ' '
result = {}
center = nil
(value.split ' ', 2).each do |keyword|
if keyword == 'left' || keyword == 'right'
result[:position] = keyword.to_sym
elsif keyword == 'top' || keyword == 'bottom'
result[:vposition] = keyword.to_sym
elsif keyword == 'center'
center = true
end
end
if center
result[:position] ||= :center
result[:vposition] ||= :center
result
elsif (result.key? :position) && (result.key? :vposition)
result
else
default_value
end
elsif value == 'left' || value == 'right' || value == 'center'
{ position: value.to_sym, vposition: :center }
elsif value == 'top' || value == 'bottom'
{ position: :center, vposition: value.to_sym }
else
default_value
end
end
def resolve_top val
if val.end_with? 'vh'
page_height * (1 - (val.to_f / 100))
elsif val.end_with? '%'
@y - effective_page_height * (val.to_f / 100)
else
@y - (str_to_pt val)
end
end
def add_link_to_image uri, image_info, image_opts
image_width = image_info[:width]
image_height = image_info[:height]
case image_opts[:position]
when :center
image_x = bounds.left_side + (bounds.width - image_width) * 0.5
when :right
image_x = bounds.right_side - image_width
else # :left or not set
image_x = bounds.left_side
end
case image_opts[:vposition]
when :top
image_y = bounds.absolute_top
when :center
image_y = bounds.absolute_top - (bounds.height - image_height) * 0.5
when :bottom
image_y = bounds.absolute_bottom + image_height
else
image_y = y
end unless (image_y = image_opts[:y])
link_annotation [image_x, (image_y - image_height), (image_x + image_width), image_y], Border: [0, 0, 0], A: { Type: :Action, S: :URI, URI: uri.as_pdf }
end
def clean_up_tmp_files
@tmp_files.values.each {|tmp_file| unlink_tmp_file tmp_file if tmp_file }
@tmp_files.clear
end
def unlink_tmp_file file
path = file.path
::File.unlink path if ::File.exist? path
rescue
logger.warn %(could not delete temporary file: #{path}; #{$!.message}) unless scratch?
end
def apply_subs_discretely doc, value, opts = {}
imagesdir = doc.attr 'imagesdir'
doc.set_attr 'imagesdir', @themesdir
# FIXME: get sub_attributes to handle drop-line w/o a warning
doc.set_attr 'attribute-missing', 'skip' unless (attribute_missing = doc.attr 'attribute-missing') == 'skip'
value = value.gsub '\{', '\\\\\\{' if (escaped_attr_ref = value.include? '\{')
value = doc.apply_subs value
value = (value.split LF).delete_if {|line| SimpleAttributeRefRx.match? line }.join LF if opts[:drop_lines_with_unresolved_attributes] && (value.include? '{')
value = value.gsub '\{', '{' if escaped_attr_ref
doc.set_attr 'attribute-missing', attribute_missing unless attribute_missing == 'skip'
if imagesdir
doc.set_attr 'imagesdir', imagesdir
else
doc.remove_attr 'imagesdir'
end
value
end
def sub_attributes_discretely doc, value
doc.set_attr 'attribute-missing', 'skip' unless (attribute_missing = doc.attr 'attribute-missing') == 'skip'
value = doc.apply_subs value, [:attributes]
doc.set_attr 'attribute-missing', attribute_missing unless attribute_missing == 'skip'
value
end
def promote_author doc, idx = 1
doc.remove_attr 'url' if (original_url = doc.attr 'url')
email = nil
if idx > 1
original_attrs = AuthorAttributeNames.each_with_object({}) do |name, accum|
accum[name] = doc.attr name
if (val = doc.attr %(#{name}_#{idx}))
doc.set_attr name, val
# NOTE email holds url as well
email = val if name == 'email'
else
doc.remove_attr name
end
end
doc.set_attr 'url', ((email.include? '@') ? %(mailto:#{email}) : email) if email
result = yield
original_attrs.each {|name, val| val ? (doc.set_attr name, val) : (doc.remove_attr name) }
else
if (email = doc.attr 'email')
doc.set_attr 'url', ((email.include? '@') ? %(mailto:#{email}) : email)
end
result = yield
end
if original_url
doc.set_attr 'url', original_url
elsif email
doc.remove_attr 'url'
end
result
end
# NOTE assume URL is escaped (i.e., contains character references such as &)
def breakable_uri uri
scheme, address = uri.split UriSchemeBoundaryRx, 2
address, scheme = scheme, address unless address
unless address.nil_or_empty?
address = address.gsub UriBreakCharsRx, UriBreakCharRepl
# NOTE require at least two characters after a break
address.slice!(-2) if address[-2] == ZeroWidthSpace
end
%(#{scheme}#{address})
end
def consolidate_ranges nums
if nums.size > 1
prev = nil
nums.each_with_object([]) {|num, accum|
if prev && (prev.to_i + 1) == num.to_i
accum[-1][1] = num
else
accum << [num]
end
prev = num
}.map {|range| range.join '-' }
else
nums
end
end
def resolve_pagenums val
pgnums = []
((val.include? ',') ? (val.split ',') : (val.split ';')).each do |entry|
if entry.include? '..'
from, _, to = entry.partition '..'
pgnums += ([from.to_i, 1].max..[to.to_i, 1].max).to_a
else
pgnums << entry.to_i
end
end
pgnums
end
def get_char code
(code.start_with? '\u') ? ([((code.slice 2, code.length).to_i 16)].pack 'U1') : code
end
# QUESTION move to prawn/extensions.rb?
def init_scratch_prototype
@save_state = nil
@scratch_depth = 0
# NOTE can't marshall tmp_files, so clear them before creating prototype
saved_tmp_files, @tmp_files = @tmp_files, {}
# IMPORTANT don't set font before using Marshal, it causes serialization to fail
@prototype = ::Marshal.load ::Marshal.dump self
@prototype.state.store.info.data[:Scratch] = @prototype.text_formatter.scratch = true
# NOTE we're now starting a new page each time, so no need to do it here
#@prototype.start_new_page if @prototype.page_number == 0
@tmp_files = saved_tmp_files
end
def push_scratch doc
if (@scratch_depth += 1) == 1
@save_state = {
catalog: {}.tap {|accum| doc.catalog.each {|k, v| accum[k] = v.dup } },
attributes: doc.attributes.dup,
}
end
end
def pop_scratch doc
if (@scratch_depth -= 1) == 0
doc.catalog.replace @save_state[:catalog]
doc.attributes.replace @save_state[:attributes]
@save_state = nil
end
end
end
end
Pdf = PDF unless const_defined? :Pdf, false
end