prawnx 0.1.1

data/lib/prawn/svg/ttc.rb

@@ -0,0 +1,35 @@
+class Prawn::SVG::TTC
+  TTC_TAG = 'ttcf'.freeze
+
+  attr_reader :fonts
+
+  def initialize(filename)
+    @fonts = []
+    load_data_from_file(filename)
+  end
+
+  private
+
+  def load_data_from_file(filename)
+    File.open(filename, 'rb') do |f|
+      tag = f.read(4)
+      next unless tag == TTC_TAG
+
+      _major, _minor = f.read(4).unpack('nn')
+      font_count = f.read(4).unpack1('N')
+      offsets = f.read(font_count * 4).unpack('N*')
+
+      offsets.each_with_index do |offset, index|
+        result = Prawn::SVG::TTF.read_name_table(f, offset)
+        next unless result
+
+        family, subfamily = result
+        next unless family
+
+        weight_class = Prawn::SVG::TTF.read_weight_class(f, offset)
+        @fonts << { family: family, subfamily: subfamily, index: index, weight_class: weight_class }
+      end
+    end
+  rescue Errno::ENOENT
+  end
+end

data/lib/prawn/svg/ttf.rb

@@ -0,0 +1,95 @@
+class Prawn::SVG::TTF
+  SFNT_VERSION_STRINGS = ["\x00\x01\x00\x00", 'true', 'typ1'].freeze
+  LANGUAGE_IDS = [0, 0x409].freeze # English, US English
+  UTF_16BE_PLATFORM_IDS = [0, 3].freeze # Unicode, Microsoft
+
+  attr_reader :family, :subfamily, :weight_class
+
+  def initialize(filename)
+    load_data_from_file(filename)
+  end
+
+  def self.read_weight_class(io, font_offset)
+    io.seek(font_offset)
+    offset_table = io.read(12)
+    return unless offset_table&.length == 12 && SFNT_VERSION_STRINGS.include?(offset_table[0..3])
+
+    table_count = (offset_table[4].ord * 256) + offset_table[5].ord
+    tables = io.read(table_count * 16)
+    return unless tables&.length == table_count * 16
+
+    table_count.times do |index|
+      start = index * 16
+      next unless tables[start..start + 3] == 'OS/2'
+
+      offset, = tables[start + 8..start + 15].unpack('NN')
+      io.seek(offset)
+      data = io.read(6)
+      return data[4..5].unpack1('n') if data&.length == 6
+    end
+
+    nil
+  end
+
+  def self.read_name_table(io, font_offset)
+    io.seek(font_offset)
+    offset_table = io.read(12)
+    return unless offset_table && offset_table.length == 12 && SFNT_VERSION_STRINGS.include?(offset_table[0..3])
+
+    table_count = (offset_table[4].ord * 256) + offset_table[5].ord
+    tables = io.read(table_count * 16)
+    return unless tables && tables.length == table_count * 16
+
+    offset, length = table_count.times do |index|
+      start = index * 16
+      break tables[start + 8..start + 15].unpack('NNN') if tables[start..start + 3] == 'name'
+    end
+
+    return unless length
+
+    io.seek(offset)
+    data = io.read(length)
+    return unless data && data.length == length
+
+    _, name_count, string_offset = data[0..5].unpack('nnn')
+
+    names = {}
+    name_count.times do |index|
+      start = 6 + (index * 12)
+      platform_id, _, language_id, name_id, length, offset = data[start..start + 11].unpack('nnnnnn')
+      next unless offset
+      next unless LANGUAGE_IDS.include?(language_id)
+      next unless [1, 2, 16, 17].include?(name_id)
+
+      offset += string_offset
+      field = data[offset..offset + length - 1]
+      next unless field && field.length == length
+
+      names[name_id] =
+        if UTF_16BE_PLATFORM_IDS.include?(platform_id)
+          begin
+            field.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8)
+          rescue StandardError
+            field
+          end
+        else
+          field
+        end
+    end
+
+    family = names[16] || names[1]
+    subfamily = names[17] || names[2]
+    [family, subfamily]
+  end
+
+  private
+
+  def load_data_from_file(filename)
+    File.open(filename, 'rb') do |f|
+      result = self.class.read_name_table(f, 0)
+      @family, @subfamily = result if result
+      @weight_class = self.class.read_weight_class(f, 0)
+    end
+  rescue Errno::ENOENT # in case the file disappears between the scan and the load, we don't want to crash
+  end
+end

data/lib/prawn/svg/url_loader.rb

@@ -0,0 +1,46 @@
+class Prawn::SVG::UrlLoader
+  Error = Class.new(StandardError)
+
+  attr_reader :enable_cache, :loaders
+
+  def initialize(enable_cache: false, enable_web: true, enable_file_with_root: nil)
+    @url_cache = {}
+    @enable_cache = enable_cache
+
+    @loaders = []
+    loaders << Prawn::SVG::Loaders::Data.new
+    loaders << Prawn::SVG::Loaders::Web.new if enable_web
+    loaders << Prawn::SVG::Loaders::File.new(enable_file_with_root) if enable_file_with_root
+  end
+
+  def load(url)
+    retrieve_from_cache(url) || perform_and_cache(url)
+  end
+
+  def add_to_cache(url, data)
+    @url_cache[url] = data
+  end
+
+  def retrieve_from_cache(url)
+    @url_cache[url]
+  end
+
+  private
+
+  def perform_and_cache(url)
+    data = perform(url)
+    add_to_cache(url, data) if enable_cache
+    data
+  end
+
+  def perform(url)
+    try_each_loader(url) or raise Error, 'No handler available for this URL scheme'
+  end
+
+  def try_each_loader(url)
+    loaders.detect do |loader|
+      data = loader.from_url(url)
+      break data if data
+    end
+  end
+end

data/lib/prawn/svg/version.rb

@@ -0,0 +1,5 @@
+module Prawn
+  module SVG
+    VERSION = '0.40.4'.freeze
+  end
+end

data/lib/prawn/table.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Tables are part of PrawnX: this file only keeps `require "prawn/table"` working.
+require "prawn"

data/lib/prawn-svg.rb

@@ -0,0 +1,53 @@
+require 'matrix'
+require 'rexml/document'
+
+require 'prawn'
+require 'prawn/svg/version'
+
+require 'css_parser'
+
+require 'prawn/svg/font_registry'
+require 'prawn/svg/font_metrics'
+require 'prawn/svg/calculators/arc_to_bezier_curve'
+require 'prawn/svg/calculators/aspect_ratio'
+require 'prawn/svg/calculators/document_sizing'
+require 'prawn/svg/calculators/path_length'
+require 'prawn/svg/calculators/pixels'
+require 'prawn/svg/pdfmatrix'
+require 'prawn/svg/transform_parser'
+require 'prawn/svg/url_loader'
+require 'prawn/svg/loaders/data'
+require 'prawn/svg/loaders/file'
+require 'prawn/svg/loaders/web'
+require 'prawn/svg/color'
+require 'prawn/svg/funciri'
+require 'prawn/svg/length'
+require 'prawn/svg/paint'
+require 'prawn/svg/percentage'
+require 'prawn/svg/attributes'
+require 'prawn/svg/properties'
+require 'prawn/svg/pathable'
+require 'prawn/svg/elements'
+require 'prawn/svg/extension'
+require 'prawn/svg/renderer'
+require 'prawn/svg/interface'
+require 'prawn/svg/css/font_face_parser'
+require 'prawn/svg/css/font_parser'
+require 'prawn/svg/css/font_family_parser'
+require 'prawn/svg/css/selector_parser'
+require 'prawn/svg/css/stylesheets'
+require 'prawn/svg/css/values_parser'
+require 'prawn/svg/ttf'
+require 'prawn/svg/ttc'
+require 'prawn/svg/font'
+require 'prawn/svg/gradients'
+require 'prawn/svg/gradient_renderer'
+require 'prawn/svg/pattern_renderer'
+require 'prawn/svg/link_renderer'
+require 'prawn/svg/document'
+require 'prawn/svg/state'
+
+module Prawn
+  Svg = SVG # backwards compatibility
+end
+

data/lib/prawn.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+if Gem.loaded_specs.key?("prawn")
+  raise LoadError, "PrawnX replaces the prawn gem, which is in your bundle too: remove prawn (and prawn-table, " \
+    "prawn-svg) from your Gemfile"
+end
+
+require "prawnx"
+
+Prawn = PrawnX

data/lib/prawnx/annotations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PrawnX
+  module Annotations
+    def annotate(options)
+      options = options.merge(Type: :Annot)
+      options[:F] ||= PdfA::PRINT_FLAG if pdf_a?
+      options[:Dest] = PDF::LiteralString.new(options[:Dest]) if options[:Dest].is_a?(String)
+      (page.dictionary.data[:Annots] ||= []) << ref!(options)
+      options
+    end
+
+    def text_annotation(rect, contents, options = {})
+      annotate(options.merge(Subtype: :Text, Rect: rect, Contents: contents))
+    end
+
+    def link_annotation(rect, options = {})
+      annotate(options.merge(Subtype: :Link, Rect: rect))
+    end
+  end
+end

data/lib/prawnx/document/bounding_box.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    def bounding_box(point, *arguments, &block)
+      init_bounding_box(block) do |parent_box|
+        @bounding_box = BoundingBox.new(self, parent_box, map_to_absolute(point), *arguments)
+      end
+    end
+
+    def canvas(&block)
+      init_bounding_box(block, hold_position: true) do
+        _left, _bottom, page_width, page_height = page.dimensions
+        @bounding_box = BoundingBox.new(self, nil, [0, page_height], width: page_width, height: page_height)
+      end
+    end
+
+    private
+
+    def init_bounding_box(user_block, options = {})
+      raise ArgumentError, "bounding boxes require a block to be drawn within the box" unless user_block
+
+      parent_box = @bounding_box
+      original_y = y
+      yield parent_box
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = original_y if y == @bounding_box.absolute_top
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position] || @bounding_box.stretchy?
+      created_box = @bounding_box
+      @bounding_box = parent_box
+      created_box
+    end
+
+    # A rectangle the document draws into, positioned from its top left corner; without a height, it stretches
+    # down to wherever the cursor ends.
+    class BoundingBox
+      class NoReferenceBounds < StandardError
+        def initialize(message = "Can't find reference bounds: my parent is unset")
+          super
+        end
+      end
+
+      attr_reader :document, :parent, :total_left_padding, :total_right_padding, :width
+
+      def initialize(document, parent, point, options = {})
+        raise ArgumentError, "BoundingBox needs the :width option to be set" unless options[:width]
+
+        @document = document
+        @parent = parent
+        @x, @y = point
+        @width = options[:width]
+        @height = options[:height]
+        @total_left_padding = 0
+        @total_right_padding = 0
+        @stretched_height = nil
+      end
+
+      def anchor
+        [@x, @y - height]
+      end
+
+      def indent(left_padding, right_padding = 0)
+        add_left_padding(left_padding)
+        add_right_padding(right_padding)
+        yield
+      ensure
+        @document.bounds.subtract_left_padding(left_padding)
+        @document.bounds.subtract_right_padding(right_padding)
+      end
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+        @width -= left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+        @width += left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+        @width -= right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+        @width += right_padding
+      end
+
+      def left
+        0
+      end
+
+      def right
+        @width
+      end
+
+      def top
+        height
+      end
+
+      def bottom
+        0
+      end
+
+      def top_left
+        [left, top]
+      end
+
+      def top_right
+        [right, top]
+      end
+
+      def bottom_right
+        [right, bottom]
+      end
+
+      def bottom_left
+        [left, bottom]
+      end
+
+      def absolute_left
+        @x
+      end
+
+      def absolute_right
+        @x + width
+      end
+
+      def absolute_top
+        @y
+      end
+
+      def absolute_bottom
+        @y - height
+      end
+
+      def absolute_top_left
+        [absolute_left, absolute_top]
+      end
+
+      def absolute_top_right
+        [absolute_right, absolute_top]
+      end
+
+      def absolute_bottom_left
+        [absolute_left, absolute_bottom]
+      end
+
+      def absolute_bottom_right
+        [absolute_right, absolute_bottom]
+      end
+
+      def height
+        return @height if @height
+
+        @stretched_height = [absolute_top - @document.y, Float(@stretched_height || 0.0)].max
+      end
+      alias update_height height
+
+      def left_side
+        absolute_left
+      end
+
+      def right_side
+        absolute_right
+      end
+
+      def move_past_bottom
+        if @document.page_number == @document.page_count
+          @document.start_new_page
+        else
+          @document.go_to_page(@document.page_number + 1)
+        end
+      end
+
+      def stretchy?
+        !@height
+      end
+
+      def reference_bounds
+        return self unless stretchy?
+        raise NoReferenceBounds unless @parent
+
+        @parent.reference_bounds
+      end
+    end
+  end
+end

data/lib/prawnx/document/column_box.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    def column_box(*arguments, &block)
+      init_column_box(block) do |parent_box|
+        map_to_absolute!(arguments[0])
+        @bounding_box = ColumnBox.new(self, parent_box, *arguments)
+      end
+    end
+
+    private
+
+    def init_column_box(user_block, options = {})
+      parent_box = @bounding_box
+      yield parent_box
+      self.y = @bounding_box.absolute_top
+      user_block.call
+      self.y = @bounding_box.absolute_bottom unless options[:hold_position]
+      @bounding_box = parent_box
+    end
+
+    # A bounding box whose text flows down one column, then the next, then onto a new page.
+    class ColumnBox < BoundingBox
+      DEFAULT_COLUMN_COUNT = 3
+
+      def initialize(document, parent, point, options = {})
+        super
+        @columns = options[:columns] || DEFAULT_COLUMN_COUNT
+        @spacer = options[:spacer] || @document.font_size
+        @current_column = 0
+        @reflow_margins = options[:reflow_margins]
+      end
+
+      def bare_column_width
+        (@width - (@spacer * (@columns - 1))) / @columns
+      end
+
+      def width
+        bare_column_width - (@total_left_padding + @total_right_padding)
+      end
+
+      def width_of_column
+        bare_column_width + @spacer
+      end
+
+      def left_side
+        absolute_left + (width_of_column * @current_column)
+      end
+
+      def left
+        width_of_column * @current_column
+      end
+
+      def right_side
+        absolute_right - (width_of_column * (@columns - (1 + @current_column)))
+      end
+
+      def right
+        left + width
+      end
+
+      def move_past_bottom
+        @current_column = (@current_column + 1) % @columns
+        @document.y = @y
+        return unless @current_column.zero?
+
+        @y = @parent.absolute_top if @reflow_margins
+        @document.start_new_page
+      end
+
+      def add_left_padding(left_padding)
+        @total_left_padding += left_padding
+        @x += left_padding
+      end
+
+      def subtract_left_padding(left_padding)
+        @total_left_padding -= left_padding
+        @x -= left_padding
+      end
+
+      def add_right_padding(right_padding)
+        @total_right_padding += right_padding
+      end
+
+      def subtract_right_padding(right_padding)
+        @total_right_padding -= right_padding
+      end
+    end
+  end
+end

data/lib/prawnx/document/internals.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Document
+    # The document's objects, pages and graphic state stack: what Prawn splits between PDF::Core's renderer and its
+    # document state.
+    module Internals
+      attr_reader :page, :pages, :pages_reference
+
+      def ref(data)
+        ref!(data).identifier
+      end
+
+      def ref!(data, stream = nil)
+        reference = PDF::Reference.new(@objects.size + 1, data, stream)
+        @objects << reference
+        reference
+      end
+
+      def deref(object)
+        object.is_a?(PDF::Reference) ? object.data : object
+      end
+
+      def add_content(string)
+        open_graphics_state if page.stack.empty?
+        page.content_stream << string << "\n"
+      end
+
+      def names
+        @root.data[:Names] ||= ref!(Type: :Names)
+      end
+
+      def outlines_reference
+        @root.data[:Outlines] ||= ref!(PDF::OutlineRoot.new)
+      end
+
+      def names?
+        @root.data.key?(:Names)
+      end
+
+      def before_render(&block)
+        @before_render_callbacks << block
+      end
+
+      def on_page_create(&block)
+        @on_page_create = block
+      end
+
+      def compression_enabled?
+        @compress
+      end
+
+      def min_version(version)
+        @version = version if version > @version
+      end
+
+      # Like Prawn, reading the state of a page whose stack was emptied opens a new one.
+      def graphic_state
+        open_graphics_state if page.stack.empty?
+        page.stack.last
+      end
+
+      def save_graphics_state(graphic_state = nil)
+        save_transformation_stack
+        page.stack.push(GraphicState.new(graphic_state || self.graphic_state))
+        add_content("q")
+        return unless block_given?
+
+        yield
+        restore_graphics_state
+      end
+
+      def restore_graphics_state
+        restore_transformation_stack
+        raise Errors::EmptyGraphicStateStack, "\n You have reached the end of the graphic state stack" if page.stack.empty?
+
+        add_content("Q")
+        page.stack.pop
+      end
+
+      def trailer
+        @trailer
+      end
+
+      # What Prawn splits into a renderer and a state is this document itself: code written for Prawn calls both.
+      def renderer
+        self
+      end
+
+      def state
+        self
+      end
+
+      def info
+        @info.data
+      end
+
+      private
+
+      def open_graphics_state
+        page.stack.push(GraphicState.new)
+        page.content_stream << "q\n"
+      end
+
+      def initialize_internals(options)
+        @objects = []
+        @info = ref!({Creator: "PrawnX", Producer: "PrawnX"}.merge(options[:info] || {}))
+        @root = ref!(Type: :Catalog)
+        @pages_reference = ref!(Type: :Pages, Count: 0, Kids: [])
+        @root.data[:Pages] = @pages_reference
+        @root.data[:ViewerPreferences] = {PrintScaling: :None} if options[:print_scaling] == :none
+        @version = 1.3
+        min_version(1.6) if options[:print_scaling] == :none
+        @pages = []
+        @page = nil
+        @trailer = options.fetch(:trailer, {})
+        @compress = options.fetch(:compress, false)
+        @before_render_callbacks = []
+        @on_page_create = nil
+      end
+
+      def insert_page(page, page_number)
+        pages.insert(page_number, page)
+        pages_reference.data[:Kids].insert(page_number, page.dictionary)
+        pages_reference.data[:Count] += 1
+      end
+
+      def render_document
+        pages.each_with_index do |page, index|
+          go_to_page(index + 1)
+          until page.stack.empty?
+            page.content_stream << "Q\n"
+            page.stack.pop
+          end
+          page.finalize
+        end
+        @before_render_callbacks.each { it.call(self) }
+        finalize_pdf_a if pdf_a?
+        PDF::Writer.call(objects: @objects, root: @root, info: @info, version: @version, trailer: @trailer, encryption: @encryption,
+          identified: pdf_a?)
+      end
+    end
+  end
+end