gamba 2.0.0

data/lib/gamba/document.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Prawn
+  class Document
+    include Internals
+    include Graphics
+    include Text
+    include TransformationStack
+    include PDF::Core::Annotations
+    include PDF::Core::Destinations
+    include Security
+    include Images
+    include Gamba::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
+      Prawn.verify_options(VALID_OPTIONS, options)
+      self.class.extensions.reverse_each { extend(_1) }
+
+      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) : yield(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 = {}
+        last_blend_mode = new_graphic_state&.blend_mode
+        new_graphic_state&.blend_mode = nil
+        new_graphic_state&.reset_text_state
+        page_options[:graphic_state] = new_graphic_state
+      end
+
+      @page = PDF::Core::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
+      resume_text_state
+      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) }
+      header_blend_mode = page.stack.last&.blend_mode
+      reopen_ext_gstate_blocks
+      # The blend mode in effect on the last page, which the new one resets to Normal (ISO 32000-1 §8.4.1), once the
+      # blocks still open are reopened, unless the page's header set one of its own.
+      return if header_blend_mode || graphic_state.blend_mode == last_blend_mode
+
+      write_ext_gstate(last_blend_mode || blend_mode_ext_gstate(:Normal))
+    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
+      close_restored_graphics_states
+      reopen_ext_gstate_blocks_on_existing_page
+      resume_text_state
+    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 { _1.run(page_number) }
+      end
+      pdf = render_document
+      output << pdf if output.respond_to?(:<<)
+      pdf
+    end
+
+    def svg(data, options = {}, &)
+      require "prawn-svg"
+      Prawn::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
+
+    # A gradient set as the fill or stroke stays it on the new page, in place of the colour Prawn writes.
+    def use_graphic_settings(override_settings = false)
+      write_fill_paint if graphic_state.fill_pattern || current_fill_color != "000000" || override_settings
+      write_stroke_paint if graphic_state.stroke_pattern || 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/gamba/encoding.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prawn
+  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"),
+        "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/gamba/errors.rb

@@ -0,0 +1,39 @@
+# 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 Prawn
+  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)
+    EncryptedPDF = Class.new(StandardError)
+    IncompatibleStringEncoding = Class.new(StandardError)
+    InvalidGraphicsPath = Class.new(StandardError)
+    InvalidJoinStyle = Class.new(StandardError)
+    InvalidName = Class.new(StandardError)
+    InvalidTableSpan = Class.new(StandardError)
+    MalformedPDF = 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/gamba/font.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Prawn
+  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?(Prawn::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
+
+    # The string in the font's encoding, only to be measured: TTF reads a UTF-8 string as it is, without a copy.
+    def measured_string(string)
+      normalize_encoding(string)
+    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
+
+    def inspect
+      "#{self.class.name}< #{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? { _1.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.measured_string(string)
+      width = width_by_string(font, @document.font_size, options[:size], options[:kerning])[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
+
+    private
+
+    # The table of the last settings stays at hand: the words of a paragraph are all measured with the same ones.
+    def width_by_string(font, font_size, size, kerning)
+      unless font.equal?(@last_font) && font_size.eql?(@last_font_size) && size.eql?(@last_size) && kerning.eql?(@last_kerning)
+        @last_font, @last_font_size, @last_size, @last_kerning = font, font_size, size, kerning
+        @last_width_by_string = @width_by_string_by_settings[font][[font_size, size, kerning]] ||= {}
+      end
+      @last_width_by_string
+    end
+  end
+end