gamba 2.0.0

data/lib/gamba/true_type/subset.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Gamba
+  module TrueType
+    # A new TrueType font holding only the glyphs a document uses, numbered in the order it first used them
+    # (glyph 0, .notdef, stays first). Composite glyphs bring their components along.
+    class Subset
+      # Tables ISO 32000-1 §9.9 requires in an embedded TrueType font, plus OS/2 and post for strict readers, and
+      # gasp, which tells rasterizers like Poppler at which sizes to hint and smooth glyphs.
+      COPIED_TABLES = %w[cvt\  fpgm prep OS/2 gasp].freeze
+      # Composite glyph flags (OpenType 'glyf' table).
+      ARGUMENTS_ARE_WORDS = 0x0001
+      HAS_SCALE = 0x0008
+      MORE_COMPONENTS = 0x0020
+      HAS_X_AND_Y_SCALE = 0x0040
+      HAS_TWO_BY_TWO = 0x0080
+      CHECKSUM_MAGIC = 0xB1B0AFBA
+
+      def initialize(file)
+        @file = file
+        @new_glyph_by_original = {0 => 0}
+      end
+
+      def glyph_for(original_glyph)
+        @new_glyph_by_original[original_glyph] ||= @new_glyph_by_original.size
+      end
+
+      def original_glyphs
+        @new_glyph_by_original.keys
+      end
+
+      # Numbers the components of composite glyphs, level by level, in the order of their composites' indices.
+      def add_components(originals)
+        level = originals
+        loop do
+          components = level.flat_map { component_glyphs(@file.glyph_data(_1)) }
+          break if components.empty?
+
+          components.each { glyph_for(_1) }
+          level = components
+        end
+      end
+
+      def bytes(extra_tables = {})
+        glyphs = glyph_data_including_components
+        offsets = [0]
+        glyf = glyphs.each_with_object(+"".b) do |data, table|
+          table << data << ("\x00" * ((4 - (data.bytesize % 4)) % 4))
+          offsets << table.bytesize
+        end
+        glyph_count = glyphs.size
+        widths = @file.advance_widths
+        left_side_bearings = original_glyphs.map { left_side_bearing(_1) }
+
+        bounds = glyphs.filter_map { |glyph| glyph.unpack("s>5") if glyph.bytesize >= 10 }
+        advances = original_glyphs.map { widths[_1] }
+        tables = {
+          "head" => head_table(bounds),
+          "hhea" => horizontal_header(bounds, advances, left_side_bearings, glyph_count),
+          "maxp" => maximum_profile(bounds, glyphs, glyph_count),
+          "hmtx" => horizontal_metrics(original_glyphs, widths, left_side_bearings),
+          "loca" => offsets.pack("N*"),
+          "glyf" => glyf,
+          "post" => post_table
+        }
+        COPIED_TABLES.each { |tag| tables[tag] = @file.table(tag) if @file.table?(tag) }
+        Subset.assemble(tables.merge(extra_tables))
+      end
+
+      # Version 3, no glyph names: the 32-byte header of the font's own post table, zeros where it has none or a
+      # shorter one, which the file accepts since the fields it reads stop at byte 16.
+      def post_table
+        post = (@file.table("post") || "".b).byteslice(0, 32).ljust(32, "\x00".b)
+        post[0, 4] = "\x00\x03\x00\x00".b
+        post
+      end
+
+      # An sfnt file of these tables, with its directory and checksums (OpenType specification, "Font file").
+      def self.assemble(tables, sfnt_version: 0x00010000)
+        tags = tables.keys.sort
+        table_count = tags.size
+        search_range = (2**Math.log2(table_count).floor) * 16
+        directory = [sfnt_version, table_count, search_range, Math.log2(search_range / 16).to_i, (table_count * 16) - search_range].pack("Nn4")
+        body = +"".b
+        offset = 12 + (table_count * 16)
+        tags.each do |tag|
+          data = tables[tag]
+          directory << [tag, Subset.checksum(data), offset + body.bytesize, data.bytesize].pack("a4N3")
+          body << data << ("\x00" * ((4 - (data.bytesize % 4)) % 4))
+        end
+        font = directory << body
+        head_offset = 12 + (table_count * 16) + tags.take_while { _1 != "head" }.sum { |tag| (tables[tag].bytesize + 3) & ~3 }
+        font[head_offset + 8, 4] = [(CHECKSUM_MAGIC - Subset.checksum(font)) & 0xFFFFFFFF].pack("N")
+        font
+      end
+
+      def self.checksum(data)
+        padded = data + ("\x00" * ((4 - (data.bytesize % 4)) % 4))
+        padded.unpack("N*").sum & 0xFFFFFFFF
+      end
+
+      private
+
+      def glyph_data_including_components
+        glyphs = []
+        index = 0
+        while index < original_glyphs.size
+          glyphs << remap_components(@file.glyph_data(original_glyphs[index]))
+          index += 1
+        end
+        glyphs
+      end
+
+      def component_glyphs(data)
+        return [] if data.bytesize < 10 || data.unpack1("s>") >= 0
+
+        glyphs = []
+        position = 10
+        loop do
+          break if position + 4 > data.bytesize
+
+          flags, original = data.unpack("@#{position} n2")
+          glyphs << original if original < @file.glyph_count
+          position += 4 + ((flags & ARGUMENTS_ARE_WORDS).zero? ? 2 : 4)
+          position += 2 if (flags & HAS_SCALE).nonzero?
+          position += 4 if (flags & HAS_X_AND_Y_SCALE).nonzero?
+          position += 8 if (flags & HAS_TWO_BY_TWO).nonzero?
+          break if (flags & MORE_COMPONENTS).zero?
+        end
+        glyphs
+      end
+
+      def remap_components(data)
+        return data if data.bytesize < 10 || data.unpack1("s>") >= 0
+
+        data = data.dup
+        position = 10
+        loop do
+          raise Error, "Truncated composite glyph" if position + 4 > data.bytesize
+
+          flags, original = data.unpack("@#{position} n2")
+          raise Error, "Composite glyph component #{original} beyond the font's #{@file.glyph_count} glyphs" if original >= @file.glyph_count
+
+          data[position + 2, 2] = [glyph_for(original)].pack("n")
+          position += 4 + ((flags & ARGUMENTS_ARE_WORDS).zero? ? 2 : 4)
+          position += 2 if (flags & HAS_SCALE).nonzero?
+          position += 4 if (flags & HAS_X_AND_Y_SCALE).nonzero?
+          position += 8 if (flags & HAS_TWO_BY_TWO).nonzero?
+          break if (flags & MORE_COMPONENTS).zero?
+        end
+        data
+      end
+
+      # Each glyph's advance width then left side bearing, packed: one array, no pairs to flatten.
+      def horizontal_metrics(original_glyphs, widths, left_side_bearings)
+        metrics = []
+        original_glyphs.each_with_index { |glyph, index| metrics.push(widths[glyph], left_side_bearings[index]) }
+        metrics.pack("n*")
+      end
+
+      def left_side_bearing(glyph)
+        metric_count = @file.table("hhea").unpack1("@34 n")
+        hmtx = @file.table("hmtx")
+        raw = (glyph < metric_count) ? hmtx.unpack1("@#{(glyph * 4) + 2} n") : hmtx.unpack1("@#{(metric_count * 4) + ((glyph - metric_count) * 2)} n")
+        raw.to_i
+      end
+
+      # The subset's own extremes, as the OpenType specification defines them: readers like Poppler size their
+      # glyph caches from the font's bounding box.
+      def head_table(bounds)
+        head = @file.table("head").dup
+        head[8, 4] = "\x00\x00\x00\x00".b
+        head[36, 8] = [bounds.map { _1[1] }.min || 0, bounds.map { _1[2] }.min || 0, bounds.map { _1[3] }.max || 0, bounds.map { _1[4] }.max || 0].pack("s>4")
+        head[50, 2] = [1].pack("n")
+        head
+      end
+
+      def horizontal_header(bounds, advances, left_side_bearings, glyph_count)
+        hhea = @file.table("hhea").dup
+        right_side_bearings = bounds.zip(advances).filter_map { |bound, advance| advance - (bound[3] - bound[1]) - bound[1] if bound && advance }
+        extents = bounds.map { _1[3] }
+        hhea[10, 8] = [advances.compact.max || 0, left_side_bearings.min || 0, right_side_bearings.min || 0, extents.max || 0].pack("n s>3")
+        hhea[34, 2] = [glyph_count].pack("n")
+        hhea
+      end
+
+      # Largest simple glyph, in points and contours; composite figures stay those of the whole font.
+      def maximum_profile(bounds, glyphs, glyph_count)
+        maxp = @file.table("maxp").dup
+        maxp[4, 2] = [glyph_count].pack("n")
+        return maxp if maxp.bytesize < 10
+
+        simple = glyphs.select { |glyph| glyph.bytesize >= 10 && glyph.unpack1("s>") >= 0 }
+        contours = simple.map { _1.unpack1("s>") }
+        points = simple.zip(contours).map! do |glyph, count|
+          next 0 if count.zero?
+          raise Error, "Truncated simple glyph" if glyph.bytesize < 10 + (count * 2)
+
+          glyph.unpack1("@#{10 + ((count - 1) * 2)} n") + 1
+        end
+        maxp[6, 4] = [points.max || 0, contours.max || 0].pack("n2")
+        maxp
+      end
+    end
+  end
+end

data/lib/gamba/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Prawn
+  # Prawn extensions check Prawn::VERSION: we report the version of the API we mirror.
+  VERSION = "2.5.0"
+end
+
+module Gamba
+  VERSION = "2.0.0"
+end

data/lib/gamba/view.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Prawn
+  # Mixed into a class, turns it into a document: Prawn's methods are called on an implicit Prawn::Document.
+  module View
+    def document
+      @document ||= Document.new
+    end
+
+    def method_missing(method_name, ...)
+      return super unless document.respond_to?(method_name)
+
+      document.public_send(method_name, ...)
+    end
+
+    def respond_to_missing?(method_name, include_all = false)
+      document.respond_to?(method_name) || super
+    end
+
+    def update(&)
+      instance_eval(&)
+    end
+
+    def save_as(filename)
+      document.render_file(filename)
+    end
+  end
+end

data/lib/gamba.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+if Gem.loaded_specs.key?("prawn")
+  raise LoadError, "Gamba replaces the prawn gem, which is in your bundle too: remove prawn (and prawn-table, " \
+    "prawn-svg) from your Gemfile"
+end
+
+require_relative "gamba/version"
+
+module Prawn
+  BASEDIR = File.expand_path("..", __dir__)
+  DATADIR = File.join(BASEDIR, "data")
+  FLOAT_PRECISION = 1.0e-9
+
+  class << self
+    attr_accessor :debug
+
+    def verify_options(accepted, actual)
+      return unless debug || $DEBUG
+
+      unknown = actual.keys - Array(accepted)
+      raise Errors::UnknownOption, "\nDetected unknown option(s): #{unknown.inspect}\nAccepted options are: #{Array(accepted).inspect}" unless unknown.empty?
+
+      yield if block_given?
+    end
+  end
+end
+
+require_relative "gamba/errors"
+require_relative "gamba/pdf"
+require_relative "gamba/pdf/reference"
+require_relative "gamba/pdf/writer"
+require_relative "gamba/pdf/outline_node"
+require_relative "gamba/page_geometry"
+require_relative "gamba/encoding"
+require_relative "gamba/graphic_state"
+require_relative "gamba/page"
+require_relative "gamba/transformation_stack"
+require_relative "gamba/graphics/color"
+require_relative "gamba/graphics/style"
+require_relative "gamba/graphics/patterns"
+require_relative "gamba/graphics"
+require_relative "gamba/text"
+require_relative "gamba/text/formatted/parser"
+require_relative "gamba/text/formatted/fragment"
+require_relative "gamba/text/formatted/arranger"
+require_relative "gamba/text/formatted/line_wrap"
+require_relative "gamba/text/formatted/wrap"
+require_relative "gamba/text/formatted/box"
+require_relative "gamba/text/box"
+require_relative "gamba/annotations"
+require_relative "gamba/stamp"
+require_relative "gamba/measurements"
+require_relative "gamba/view"
+require_relative "gamba/images"
+require_relative "gamba/images/png_decoder"
+require_relative "gamba/images/image"
+require_relative "gamba/repeater"
+require_relative "gamba/grid"
+require_relative "gamba/outline"
+require_relative "gamba/table"
+require_relative "gamba/table/cells"
+require_relative "gamba/table/cell"
+require_relative "gamba/table/cell/kinds"
+require_relative "gamba/security"
+require_relative "gamba/pdf_a"
+require_relative "gamba/pdf_a/srgb_profile"
+require_relative "gamba/document/internals"
+require_relative "gamba/document/bounding_box"
+require_relative "gamba/document/span"
+require_relative "gamba/document/column_box"
+require_relative "gamba/document"
+require_relative "gamba/font"
+require_relative "gamba/fonts/afm"
+
+# TrueType fonts load on first use: a document of standard fonts never needs them.
+module Gamba
+  module TrueType
+    autoload :Error, ::File.expand_path("gamba/true_type/file", __dir__)
+    autoload :File, ::File.expand_path("gamba/true_type/file", __dir__)
+    autoload :Subset, ::File.expand_path("gamba/true_type/subset", __dir__)
+    autoload :SimpleSubsets, ::File.expand_path("gamba/true_type/simple_subsets", __dir__)
+    autoload :CffSubset, ::File.expand_path("gamba/true_type/cff_subset", __dir__)
+    autoload :OpenTypeLayout, ::File.expand_path("gamba/true_type/open_type_layout", __dir__)
+  end
+end
+
+module Prawn
+  module Fonts
+    %i[TTF TTC DFont].each { autoload _1, ::File.expand_path("gamba/fonts/ttf", __dir__) }
+    autoload :OTF, ::File.expand_path("gamba/fonts/otf", __dir__)
+  end
+
+  class Font
+    %i[TTF TTC DFont].each { autoload _1, ::File.expand_path("gamba/fonts/ttf", __dir__) }
+  end
+end
+
+module Gamba
+  autoload :Combine, ::File.expand_path("gamba/combine", __dir__)
+
+  # The pages of other PDF files, one after the other in a new one:
+  # Gamba.combine([label, label], page_size: [288, 432]). See Gamba::Combine#initialize for the options.
+  def self.combine(sources, page_size: nil, orientation: nil)
+    Combine.new(page_size:, orientation:).call(sources)
+  end
+
+  # Loads what Gamba otherwise loads on first use, SVG support included: call it before a server forks its
+  # workers, so they share that memory instead of each loading its own copy.
+  def self.eager_load!
+    [TrueType::File, TrueType::Subset, Prawn::Fonts::TTF, Combine, PDF::Core::Reader]
+    require "prawn-svg"
+  end
+end
+
+module PDF
+  module Core
+    autoload :Reader, ::File.expand_path("gamba/pdf/reader", __dir__)
+    autoload :Decryption, ::File.expand_path("gamba/pdf/decryption", __dir__)
+  end
+end
+
+Prawn.image_handler.register(Prawn::Images::JPG)
+Prawn.image_handler.register(Prawn::Images::PNG)

data/lib/pdf/core.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Gamba replaces pdf-core too: this file keeps `require "pdf/core"` working.
+require "gamba"

data/lib/prawn/measurement_extensions.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "prawn"
+require "gamba/measurement_extensions"

data/lib/prawn/svg/attributes/clip_path.rb

@@ -0,0 +1,46 @@
+module Prawn::SVG::Attributes::ClipPath
+  def parse_clip_path_attribute_and_call
+    return unless (clip_path = properties.clip_path)
+    return if clip_path == "none"
+
+    clip_path_element = extract_element_from_url_id_reference(clip_path, "clipPath")
+
+    if clip_path_element.nil?
+      document.warnings << "Could not resolve clip-path URI to a clipPath element"
+    else
+      clip_calls = clip_path_element.build_clip_calls(self)
+      return if clip_calls.nil?
+
+      add_call_and_enter "save_graphics_state"
+
+      if clip_path_contains_text?(clip_calls)
+        # Text in clip paths is implemented using a PDF soft mask. The text
+        # renders in white fill inside the mask to define the visible region.
+        # This correctly unions multiple text elements, unlike PDF text
+        # rendering mode 7 which intersects separate text objects.
+        @calls << ["soft_mask", [], {}, clip_calls]
+      else
+        @calls.concat clip_calls
+
+        # SVG's clip-rule applies per-element (determining each shape's interior),
+        # then elements are unioned. PDF's W* applies even-odd to the entire combined
+        # path, which incorrectly creates holes between separate shapes. Only use W*
+        # when there's a single child element, where self-intersection matters.
+        child_elements = clip_path_element.svg_child_elements
+        if child_elements.length == 1 && clip_path_element.computed_properties.clip_rule == "evenodd"
+          add_call "clip", clip_rule: :even_odd
+        else
+          add_call "clip"
+        end
+      end
+    end
+  end
+
+  private
+
+  def clip_path_contains_text?(calls)
+    calls.any? do |call, _arguments, _kwarguments, children|
+      call == "svg:render" || clip_path_contains_text?(children)
+    end
+  end
+end

data/lib/prawn/svg/attributes/mask.rb

@@ -0,0 +1,16 @@
+module Prawn::SVG::Attributes::Mask
+  def parse_mask_attribute_and_call
+    return unless (mask = properties.mask)
+    return if mask == "none"
+
+    mask_element = extract_element_from_url_id_reference(mask, "mask")
+
+    if mask_element.nil?
+      document.warnings << "Could not resolve mask URI to a mask element"
+    else
+      add_call_and_enter "save_graphics_state"
+      mask_calls = mask_element.build_mask_calls(self)
+      @calls << ["soft_mask", [], {}, mask_calls]
+    end
+  end
+end

data/lib/prawn/svg/attributes/opacity.rb

@@ -0,0 +1,30 @@
+module Prawn::SVG::Attributes::Opacity
+  def parse_opacity_attributes_and_call
+    # The opacity property is not inherited, but the opacity applies to all children underneath the element.
+    #
+    # Having an opacity property on a parent, and again on a child, multiplies the parent and child's opacities
+    # when drawing the children.
+    #
+    # The fill-opacity and stroke-opacity properties are inherited, but children which have a different value
+    # are displayed at that opacity rather than multiplying the parent's fill/stroke opacity with the child's.
+    #
+    # opacity and fill/stroke opacity can both be applied to the same element, and they multiply together.
+
+    opacity = computed_properties.opacity&.to_f&.clamp(0, 1)
+    fill_opacity = computed_properties.fill_opacity.to_f.clamp(0, 1)
+    stroke_opacity = computed_properties.stroke_opacity.to_f.clamp(0, 1)
+
+    state.opacity *= opacity if opacity
+
+    fill_opacity = (fill_opacity || 1) * state.opacity
+    stroke_opacity = (stroke_opacity || 1) * state.opacity
+
+    fill_opacity = stroke_opacity = 0 if computed_properties.visibility != "visible"
+
+    if state.last_fill_opacity != fill_opacity || state.last_stroke_opacity != stroke_opacity
+      state.last_fill_opacity = fill_opacity
+      state.last_stroke_opacity = stroke_opacity
+      add_call_and_enter "transparent", fill_opacity, stroke_opacity
+    end
+  end
+end

data/lib/prawn/svg/attributes/space.rb

@@ -0,0 +1,10 @@
+module Prawn::SVG::Attributes::Space
+  def parse_xml_space_attribute
+    case attributes["xml:space"]
+    when "preserve"
+      state.preserve_space = true
+    when "default"
+      state.preserve_space = false
+    end
+  end
+end

data/lib/prawn/svg/attributes/stroke.rb

@@ -0,0 +1,50 @@
+module Prawn::SVG::Attributes::Stroke
+  CAP_STYLE_TRANSLATIONS = {"butt" => :butt, "round" => :round, "square" => :projecting_square}.freeze
+  JOIN_STYLE_TRANSLATIONS = {"miter" => :miter, "round" => :round, "bevel" => :bevel}.freeze
+
+  def parse_stroke_attributes_and_call
+    if (width_string = properties.stroke_width)
+      width = pixels(width_string)
+      state.stroke_width = width
+      add_call("line_width", width)
+    end
+
+    if (linecap = properties.stroke_linecap) && linecap != "inherit"
+      add_call("cap_style", CAP_STYLE_TRANSLATIONS.fetch(linecap, :butt))
+    end
+
+    if (linejoin = properties.stroke_linejoin) && linejoin != "inherit"
+      add_call("join_style", JOIN_STYLE_TRANSLATIONS.fetch(linejoin, :miter))
+    end
+
+    if (miterlimit = properties.stroke_miterlimit) && miterlimit != "inherit"
+      add_call("miter_limit", miterlimit)
+    end
+
+    if (dasharray = properties.stroke_dasharray)
+      case dasharray
+      when "inherit"
+        # don't do anything
+      when "none"
+        add_call("undash")
+      when Array
+        dasharray *= 2 if dasharray.length.odd?
+        values = dasharray.map { |value| pixels(value) }
+
+        if values.sum.zero?
+          add_call("undash")
+        else
+          options = {}
+          offset = computed_properties.stroke_dashoffset
+          if offset && offset != 0 && offset != "inherit"
+            phase = pixels(offset)
+            options[:phase] = phase unless phase.zero?
+          end
+          add_call("dash", values, **options)
+        end
+      else
+        raise "Unknown dasharray value: #{dasharray.inspect}"
+      end
+    end
+  end
+end

data/lib/prawn/svg/attributes/transform.rb

@@ -0,0 +1,10 @@
+module Prawn::SVG::Attributes::Transform
+  def parse_transform_attribute_and_call
+    # Some elements do not support transforms
+    return unless transformable?
+    return unless (transform = attributes["transform"])
+
+    matrix = matrix_for_pdf(parse_transform_attribute(transform))
+    add_call_and_enter "transformation_matrix", *matrix unless matrix == [1, 0, 0, 1, 0, 0]
+  end
+end

data/lib/prawn/svg/attributes.rb

@@ -0,0 +1,6 @@
+module Prawn::SVG::Attributes
+end
+
+%w[transform opacity clip_path mask stroke space].each do |name|
+  require "prawn/svg/attributes/#{name}"
+end

data/lib/prawn/svg/calculators/arc_to_bezier_curve.rb

@@ -0,0 +1,57 @@
+module Prawn::SVG::Calculators
+  module ArcToBezierCurve
+    protected
+
+    # Convert the elliptical arc to a cubic bézier curve using this algorithm:
+    # http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
+    #
+    # eta_1 and eta_2 are the eccentric anomaly angles (the parametric angles on the
+    # unit circle that map to points on the ellipse). theta is the ellipse rotation angle.
+    def calculate_bezier_curve_points_for_arc(cx, cy, a, b, eta_1, eta_2, theta)
+      e = lambda do |eta|
+        [
+          cx + (a * Math.cos(theta) * Math.cos(eta)) - (b * Math.sin(theta) * Math.sin(eta)),
+          cy + (a * Math.sin(theta) * Math.cos(eta)) + (b * Math.cos(theta) * Math.sin(eta))
+        ]
+      end
+
+      ep = lambda do |eta|
+        [
+          (-a * Math.cos(theta) * Math.sin(eta)) - (b * Math.sin(theta) * Math.cos(eta)),
+          (-a * Math.sin(theta) * Math.sin(eta)) + (b * Math.cos(theta) * Math.cos(eta))
+        ]
+      end
+
+      iterations = 1
+      d_eta = eta_2 - eta_1
+
+      while iterations < 1024
+        break if d_eta.abs <= Math::PI / 2.0
+
+        iterations *= 2
+        d_eta = (eta_2 - eta_1) / iterations
+      end
+
+      (0...iterations).collect do |iteration|
+        seg_eta_a = eta_1 + (iteration * d_eta)
+        seg_eta_b = eta_1 + ((iteration + 1) * d_eta)
+        seg_d_eta = seg_eta_b - seg_eta_a
+
+        alpha = Math.sin(seg_d_eta) * ((Math.sqrt(4 + (3 * (Math.tan(seg_d_eta / 2)**2))) - 1) / 3)
+
+        x1, y1 = e[seg_eta_a]
+        x2, y2 = e[seg_eta_b]
+
+        ep_eta1_x, ep_eta1_y = ep[seg_eta_a]
+        q1_x = x1 + (alpha * ep_eta1_x)
+        q1_y = y1 + (alpha * ep_eta1_y)
+
+        ep_eta2_x, ep_eta2_y = ep[seg_eta_b]
+        q2_x = x2 - (alpha * ep_eta2_x)
+        q2_y = y2 - (alpha * ep_eta2_y)
+
+        {p2: [x2, y2], q1: [q1_x, q1_y], q2: [q2_x, q2_y]}
+      end
+    end
+  end
+end

data/lib/prawn/svg/calculators/aspect_ratio.rb

@@ -0,0 +1,60 @@
+module Prawn::SVG::Calculators
+  class AspectRatio
+    attr_reader :align, :defer
+    attr_reader :width, :height, :x, :y
+
+    def initialize(value, container_dimensions, object_dimensions)
+      values = (value || "xMidYMid meet").split
+      @x = @y = 0
+
+      if values.first == "defer"
+        @defer = true
+        values.shift
+      end
+
+      @align, @meet_or_slice = values
+
+      w_container, h_container = container_dimensions
+      w_object, h_object = object_dimensions
+
+      container_ratio = w_container / h_container.to_f
+      object_ratio = w_object / h_object.to_f
+
+      if @align == "none"
+        @width, @height = container_dimensions
+      else
+        matches = @align.to_s.strip.match(/\Ax(Min|Mid|Max)Y(Min|Mid|Max)\z/i) || [nil, "Mid", "Mid"]
+
+        if (container_ratio > object_ratio) == slice?
+          @width = w_container
+          @height = w_container / object_ratio
+          @y = case matches[2].downcase
+          when "min" then 0
+          when "mid" then (h_container - (w_container / object_ratio)) / 2
+          when "max" then h_container - (w_container / object_ratio)
+          end
+        else
+          @width = h_container * object_ratio
+          @height = h_container
+          @x = case matches[1].downcase
+          when "min" then 0
+          when "mid" then (w_container - (h_container * object_ratio)) / 2
+          when "max" then w_container - (h_container * object_ratio)
+          end
+        end
+      end
+    end
+
+    def slice?
+      @meet_or_slice == "slice"
+    end
+
+    def meet?
+      @meet_or_slice != "slice"
+    end
+
+    def inspect
+      "[AspectRatio: #{@width},#{@height} offset #{@x},#{@y}]"
+    end
+  end
+end