prawnx 0.1.1

data/lib/prawnx/document/span.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    # A column of the given width across pages, positioned within the margins, starting at the cursor.
+    def span(width, options = {})
+      PrawnX.verify_options([:position], options)
+      original_position = y
+      left_boundary =
+        case options.fetch(:position, :left)
+        when :left then margin_box.absolute_left
+        when :center then margin_box.absolute_left + (margin_box.width / 2.0) - (width / 2.0)
+        when :right then margin_box.absolute_right - width
+        when Numeric then margin_box.absolute_left + options[:position]
+        else raise ArgumentError, "Invalid option for :position"
+        end
+      canvas do
+        bounding_box([left_boundary, margin_box.absolute_top], width:) do
+          self.y = original_position
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/prawnx/document.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    include Internals
+    include Graphics
+    include Text
+    include TransformationStack
+    include Annotations
+    include Destinations
+    include Security
+    include Images
+    include PdfA
+    include Table::Interface
+    include Stamp
+    include SoftMask
+
+    VALID_OPTIONS = %i[
+      page_size page_layout margin left_margin right_margin top_margin bottom_margin skip_page_creation compress
+      background info text_formatter print_scaling pdf_a
+    ].freeze
+
+    attr_accessor :margin_box, :page_number, :text_formatter
+    attr_reader :margins, :y
+
+    # Modules every new document extends itself with: a subclass starts with its parent's.
+    def self.extensions
+      @extensions ||= []
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.extensions.concat(extensions)
+    end
+
+    def self.generate(filename, options = {}, &)
+      new(options, &).render_file(filename)
+    end
+
+    def initialize(options = {}, &block)
+      options = options.dup
+      PrawnX.verify_options(VALID_OPTIONS, options)
+      self.class.extensions.reverse_each { extend(it) }
+
+      initialize_internals(options)
+      @pdf_a = options.delete(:pdf_a) == true
+      @background = options[:background]
+      @background_scale = options[:background_scale] || 1
+      @font_size = 12
+      @bounding_box = nil
+      @margin_box = nil
+      @page_number = 0
+      @text_formatter = options.delete(:text_formatter) || Text::Formatted::Parser
+      options[:size] = options.delete(:page_size)
+      options[:layout] = options.delete(:page_layout)
+
+      initialize_first_page(options)
+      @bounding_box = @margin_box
+
+      return unless block
+
+      block.arity < 1 ? instance_eval(&block) : block.call(self)
+    end
+
+    def start_new_page(options = {})
+      last_page = page
+      page_options = {size: options[:size] || last_page&.size, layout: options[:layout] || last_page&.layout, margins: last_page&.margins&.dup}
+      if last_page
+        new_graphic_state = last_page.graphic_state&.dup
+        new_graphic_state&.color_space = {}
+        page_options[:graphic_state] = new_graphic_state
+      end
+
+      @page = Page.new(self, page_options)
+      apply_margin_options(options)
+      generate_margin_box
+      @bounding_box = @margin_box if last_page && (last_page.size != page.size || last_page.layout != page.layout)
+      use_graphic_settings
+      return if options[:orphan]
+
+      insert_page(page, @page_number)
+      @page_number += 1
+      canvas { image(@background, scale: @background_scale, at: bounds.top_left) } if @background
+      @y = @bounding_box.absolute_top
+      float { @on_page_create&.call(self) }
+    end
+
+    def delete_page(index)
+      return false if index.abs > pages.count - 1
+
+      pages.delete_at(index)
+      pages_reference.data[:Kids].delete_at(index)
+      pages_reference.data[:Count] -= 1
+      @page_number -= 1
+      true
+    end
+
+    def page_count
+      pages.size
+    end
+
+    def go_to_page(page_number)
+      @page_number = page_number
+      @page = pages[page_number - 1]
+      generate_margin_box
+      @y = @bounding_box.absolute_top
+    end
+
+    def y=(new_y)
+      @y = new_y
+      bounds.update_height
+    end
+
+    def cursor
+      y - bounds.absolute_bottom
+    end
+
+    def move_cursor_to(new_y)
+      self.y = new_y + bounds.absolute_bottom
+    end
+
+    def float
+      original_page = page_number
+      original_y = y
+      yield
+      go_to_page(original_page) unless page_number == original_page
+      self.y = original_y
+    end
+
+    def render(*arguments)
+      output = arguments.first
+      (1..page_count).each do |page_number|
+        go_to_page(page_number)
+        repeaters.each { it.run(page_number) }
+      end
+      pdf = render_document
+      output << pdf if output.respond_to?(:<<)
+      pdf
+    end
+
+    def svg(data, options = {}, &)
+      require "prawn-svg"
+      SVG::Extension.instance_method(:svg).bind_call(self, data, options, &)
+    end
+
+    def render_file(filename)
+      File.binwrite(filename, render)
+    end
+
+    def bounds
+      @bounding_box
+    end
+
+    def bounds=(bounding_box)
+      @bounding_box = bounding_box
+    end
+
+    def reference_bounds
+      @bounding_box.reference_bounds
+    end
+
+    def move_up(amount)
+      self.y += amount
+    end
+
+    def move_down(amount)
+      self.y -= amount
+    end
+
+    def pad_top(amount)
+      move_down(amount)
+      yield
+    end
+
+    def pad_bottom(amount)
+      yield
+      move_down(amount)
+    end
+
+    def pad(amount)
+      move_down(amount)
+      yield
+      move_down(amount)
+    end
+
+    def indent(left, right = 0, &)
+      bounds.indent(left, right, &)
+    end
+
+    def page_match?(page_filter, page_number)
+      case page_filter
+      when :all then true
+      when :odd then page_number.odd?
+      when :even then page_number.even?
+      when Range, Array then page_filter.include?(page_number)
+      when Proc then page_filter.call(page_number)
+      end
+    end
+
+    def group(*)
+      raise NotImplementedError, "Document#group has been disabled because its implementation lead to corrupted documents whenever a page boundary was crossed"
+    end
+
+    def transaction
+      raise NotImplementedError, "Document#transaction has been disabled because its implementation lead to corrupted documents whenever a page boundary was crossed"
+    end
+
+    def initialize_first_page(options)
+      start_new_page(options[:skip_page_creation] ? options.merge(orphan: true) : options)
+    end
+
+    def repeaters
+      @repeaters ||= []
+    end
+
+    private
+
+    def use_graphic_settings(override_settings = false)
+      set_fill_color if current_fill_color != "000000" || override_settings
+      set_stroke_color if current_stroke_color != "000000" || override_settings
+      write_line_width if line_width != 1 || override_settings
+      write_stroke_cap_style if cap_style != :butt || override_settings
+      write_stroke_join_style if join_style != :miter || override_settings
+      write_stroke_dash if dashed? || override_settings
+    end
+
+    def generate_margin_box
+      old_margin_box = @margin_box
+      _left, _bottom, page_width, page_height = page.dimensions
+      @margin_box = BoundingBox.new(
+        self, nil, [page.margins[:left], page_height - page.margins[:top]],
+        width: page_width - (page.margins[:left] + page.margins[:right]),
+        height: page_height - (page.margins[:top] + page.margins[:bottom]),
+      )
+      if old_margin_box
+        @margin_box.add_left_padding(old_margin_box.total_left_padding)
+        @margin_box.add_right_padding(old_margin_box.total_right_padding)
+      end
+      @bounding_box = @margin_box unless @bounding_box&.parent
+    end
+
+    MARGIN_POSITIONS_BY_COUNT = {4 => [0, 1, 2, 3], 3 => [0, 1, 2, 1], 2 => [0, 1, 0, 1], 1 => [0, 0, 0, 0], 0 => []}.freeze
+
+    def apply_margin_options(options)
+      margin = Array(options[:margin])
+      positions = MARGIN_POSITIONS_BY_COUNT[margin.length]
+      %i[top right bottom left].zip(positions).each do |side, position|
+        new_margin = options[:"#{side}_margin"] || (margin[position] if position)
+        page.margins[side] = new_margin if new_margin
+      end
+    end
+  end
+end

data/lib/prawnx/encoding.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PrawnX
+  module Encoding
+    # WinAnsiEncoding, ISO 32000-1 Annex D.2: the glyph name of each Windows-1252 byte, .notdef where it has none.
+    module WinAnsi
+      CHARACTERS = [
+        *Array.new(32, ".notdef"),
+        *%w[
+          space exclam quotedbl numbersign dollar percent ampersand quotesingle parenleft parenright asterisk plus comma
+          hyphen period slash zero one two three four five six seven eight nine colon semicolon less equal greater
+          question at A B C D E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft backslash bracketright
+          asciicircum underscore grave a b c d e f g h i j k l m n o p q r s t u v w x y z braceleft bar braceright
+          asciitilde .notdef Euro .notdef quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex
+          perthousand Scaron guilsinglleft OE .notdef Zcaron .notdef .notdef quoteleft quoteright quotedblleft
+          quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe .notdef zcaron Ydieresis space
+          exclamdown cent sterling currency yen brokenbar section dieresis copyright ordfeminine guillemotleft
+          logicalnot hyphen registered macron degree plusminus twosuperior threesuperior acute mu paragraph
+          periodcentered cedilla onesuperior ordmasculine guillemotright onequarter onehalf threequarters
+          questiondown Agrave Aacute Acircumflex Atilde Adieresis Aring AE Ccedilla Egrave Eacute Ecircumflex
+          Edieresis Igrave Iacute Icircumflex Idieresis Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis multiply
+          Oslash Ugrave Uacute Ucircumflex Udieresis Yacute Thorn germandbls agrave aacute acircumflex atilde adieresis
+          aring ae ccedilla egrave eacute ecircumflex edieresis igrave iacute icircumflex idieresis eth ntilde ograve
+          oacute ocircumflex otilde odieresis divide oslash ugrave uacute ucircumflex udieresis yacute thorn ydieresis
+        ],
+      ].freeze
+    end
+  end
+end

data/lib/prawnx/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Errors Prawn raises from PDF::Core keep that name: apps rescue them by it.
+module PDF
+  module Core
+    module Errors
+      EmptyGraphicStateStack = Class.new(StandardError)
+      FailedObjectConversion = Class.new(StandardError)
+      InvalidPageLayout = Class.new(StandardError)
+    end
+  end
+end
+
+module PrawnX
+  module Errors
+    EmptyGraphicStateStack = PDF::Core::Errors::EmptyGraphicStateStack
+    FailedObjectConversion = PDF::Core::Errors::FailedObjectConversion
+    InvalidPageLayout = PDF::Core::Errors::InvalidPageLayout
+    BlockRequired = Class.new(StandardError)
+    CannotFit = Class.new(StandardError)
+    CannotGroup = Class.new(StandardError)
+    IncompatibleStringEncoding = Class.new(StandardError)
+    InvalidGraphicsPath = Class.new(StandardError)
+    InvalidJoinStyle = Class.new(StandardError)
+    InvalidName = Class.new(StandardError)
+    InvalidTableSpan = Class.new(StandardError)
+    NameTaken = Class.new(StandardError)
+    NotOnPage = Class.new(StandardError)
+    RequiredOption = Class.new(StandardError)
+    UndefinedObjectName = Class.new(StandardError)
+    UnknownFont = Class.new(StandardError)
+    UnknownOption = Class.new(StandardError)
+    UnknownOutlineTitle = Class.new(StandardError)
+    UnrecognizedTableContent = Class.new(StandardError)
+    UnsupportedImageType = Class.new(StandardError)
+  end
+end

data/lib/prawnx/font.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    DEFAULT_FONT_OPTIONS = {}.freeze
+    BUILT_IN_FONT_FAMILIES = {
+      "Courier" => {bold: "Courier-Bold", italic: "Courier-Oblique", bold_italic: "Courier-BoldOblique", normal: "Courier"},
+      "Times-Roman" => {bold: "Times-Bold", italic: "Times-Italic", bold_italic: "Times-BoldItalic", normal: "Times-Roman"},
+      "Helvetica" => {bold: "Helvetica-Bold", italic: "Helvetica-Oblique", bold_italic: "Helvetica-BoldOblique", normal: "Helvetica"},
+    }.freeze
+
+    def font(name = nil, options = DEFAULT_FONT_OPTIONS)
+      return @font || font("Helvetica") if name.nil?
+      raise Errors::NotOnPage if pages.empty? && !page.in_stamp_stream?
+
+      new_font = find_font(name.to_s, options)
+      if block_given?
+        save_font do
+          set_font(new_font, options[:size])
+          yield
+        end
+      else
+        set_font(new_font, options[:size])
+      end
+      @font
+    end
+
+    def font_size(points = nil)
+      return @font_size unless points
+
+      size_before_yield = @font_size
+      @font_size = points
+      return unless block_given?
+
+      yield
+      @font_size = size_before_yield
+    end
+
+    def font_size=(size)
+      font_size(size)
+    end
+
+    def width_of(string, options = {})
+      return width_of_string(string, options) unless options.key?(:inline_format)
+
+      inline_format = options[:inline_format]
+      arranger = Text::Formatted::Arranger.new(self, options)
+      arranger.consumed = text_formatter.format(string, *(inline_format.is_a?(Array) ? inline_format : []))
+      arranger.finalize_line
+      arranger.line_width
+    end
+
+    def font_families
+      @font_families ||= BUILT_IN_FONT_FAMILIES.transform_values(&:dup)
+    end
+
+    def set_font(font, size = nil)
+      @font = font
+      @font_size = size if size
+    end
+
+    def save_font
+      @font ||= find_font("Helvetica")
+      original_font = @font
+      original_size = @font_size
+      yield
+    ensure
+      set_font(original_font, original_size) if original_font
+    end
+
+    def find_font(name, options = {})
+      if font_families.key?(name)
+        family = name
+        name = font_families[name][options[:style] || :normal]
+        if name.is_a?(::Hash)
+          options = options.merge(name)
+          name = options[:file]
+        end
+      end
+      key = "#{family}:#{name}:#{options[:font] || 0}:#{Array(options[:features]).join(",")}"
+      return font_registry[key] = name if name.is_a?(PrawnX::Font)
+
+      font_registry[key] ||= Font.load(self, name, options.merge(family:))
+    end
+
+    def font_registry
+      @font_registry ||= {}
+    end
+
+    private
+
+    def width_of_string(string, options = {})
+      font_metric_cache.width_of(string, options)
+    end
+
+    def font_metric_cache
+      @font_metric_cache ||= FontMetricCache.new(self)
+    end
+  end
+
+  # A font as a document uses it: metrics scaled to the document's current size, and its PDF resource.
+  class Font
+    attr_reader :name, :family, :options
+
+    def self.load(document, source, options = {})
+      case font_format(source, options)
+      when "ttf" then Fonts::TTF.new(document, source, options)
+      when "otf" then Fonts::OTF.new(document, source, options)
+      when "dfont" then Fonts::DFont.new(document, source, options)
+      when "ttc" then Fonts::TTC.new(document, source, options)
+      else Fonts::AFM.new(document, source, options)
+      end
+    end
+
+    def self.font_format(source, options)
+      return options.fetch(:format, "ttf") if source.respond_to?(:read)
+
+      case source.to_s
+      when /\.ttf$/i then "ttf"
+      when /\.otf$/i then "otf"
+      when /\.dfont$/i then "dfont"
+      when /\.ttc$/i then "ttc"
+      else "afm"
+      end
+    end
+
+    def initialize(document, name, options = {})
+      @document = document
+      @name = name
+      @options = options
+      @family = options[:family]
+      @identifier = generate_unique_id
+      @references = {}
+      @subset_name_cache = {}
+      @full_font_embedding = options.key?(:subset) && !options[:subset]
+    end
+
+    def ascender
+      @ascender / 1000.0 * size
+    end
+
+    def descender
+      -@descender / 1000.0 * size
+    end
+
+    def line_gap
+      @line_gap / 1000.0 * size
+    end
+
+    def height_at(size)
+      @normalized_height ||= (@ascender - @descender + @line_gap) / 1000.0
+      @normalized_height * size
+    end
+
+    def height
+      height_at(size)
+    end
+
+    def add_to_current_page(subset)
+      @references[subset] ||= register(subset)
+      @document.page.fonts[identifier_for(subset)] = @references[subset]
+    end
+
+    def identifier_for(subset)
+      @subset_name_cache[subset] ||= @full_font_embedding ? @identifier.to_sym : :"#{@identifier}.#{subset}"
+    end
+
+    # PrawnX answers to Prawn's name: apps print this, and documents show it.
+    def inspect
+      "#{self.class.name.sub(/\APrawnX::/, "Prawn::")}< #{name}: #{size} >"
+    end
+
+    def hash
+      [self.class, name, family].hash
+    end
+
+    def eql?(other)
+      self.class == other.class && name == other.name && family == other.family && size == other.size
+    end
+
+    protected
+
+    def size
+      @document.font_size
+    end
+
+    private
+
+    def generate_unique_id
+      font_count = @document.font_registry.size + 1
+      font_count += 1 until @document.page.fonts.keys.none? { it.to_s.start_with?("F#{font_count}.") }
+      :"F#{font_count}"
+    end
+  end
+
+  # Widths of strings, cached per font, size and options: text layout measures the same words again and again.
+  # Nested hashes, so a lookup hashes the string only.
+  class FontMetricCache
+    def initialize(document)
+      @document = document
+      @width_by_string_by_settings = Hash.new { |cache, settings| cache[settings] = {} }.compare_by_identity
+    end
+
+    def width_of(string, options)
+      font = options[:style] ? @document.find_font(@document.font.family, style: options[:style]) : @document.font
+      encoded_string = font.normalize_encoding(string)
+      by_size = @width_by_string_by_settings[font]
+      width_by_string = (by_size[[@document.font_size, options[:size], options[:kerning]]] ||= {})
+      width = width_by_string[encoded_string] ||= font.compute_width_of(encoded_string, options)
+      character_count = @document.font.character_count(encoded_string)
+      character_count.positive? ? width + (@document.character_spacing * (character_count - 1)) : width
+    end
+  end
+end