prawn-svg 0.38.1 → 0.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48e3c463c4c8684671c20e26e701c51d07fd58322f2a7557d03b1ccccd1621c3
-  data.tar.gz: 12e77f6409d625d9e2682f1efdd9519f983a8dc24e8dcc7371ff79febe2a43ea
+  metadata.gz: 3c524e2dc0d6754bcd60ca3d4e056f64069621b4412ff90b2f07c01123837e80
+  data.tar.gz: 3edb96730b5a94d0c5db17ac5cd47e6dd4ab4af4e93b409555fc94e69b12dde4
 SHA512:
-  metadata.gz: 9f212b78477d9211a1ca009f7667d05f27f0138e467939d19d1c252a017a416e2a0267e613426142c50b77e83a613cc12e2e65af8d38e3e7c71bcf0816cc062a
-  data.tar.gz: fb5f095597da89d3d6127429b51f4fe8cc125ef14c01f3046bd0a7fced4379abb9ad2bf89a35ec2f38c96e4d06775a2c8dd7edec85bca947e385c90e00b6435a
+  metadata.gz: 344edee9e2156c94d4d82aa995d38df4a73cad64966979d70da1220a30875da3837dbc962d968347b52d1bc55ee843e141275f62e013de31362ea064fbc24f92
+  data.tar.gz: a65858effa7cabdff362876b3e877bed5d1e35a9b9dcc70fbc68d23849faea060f14f63fe710baf510e011e5f5433014b365146ac47acef4fd35f2ad02221fbd

data/.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 spec/sample_output/*.pdf
+spec/sample_ttf/NotoSansJP-Regular.ttf
 prawn-svg-*.gem
 .rvmrc
 .*.swp

data/README.md

@@ -77,6 +77,8 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
 
  - `<clipPath>`
 
+ - `<mask>` with attributes `maskUnits` and `maskContentUnits`
+
  - `<marker>`
 
  - `<linearGradient>` and `<radialGradient>` are implemented on Prawn 2.2.0+ with attributes `gradientUnits` and
@@ -120,7 +122,7 @@ Pseudo-elements and the other pseudo-classes are not supported.
 
 ## Not supported
 
-prawn-svg does not support hyperlinks, patterns, masks or filters.
+prawn-svg does not support patterns or filters.
 
 It does not support text in the clip area, but you can clip shapes and text by any shape.
 

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.rb

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

data/lib/prawn/svg/document.rb

@@ -54,6 +54,14 @@ class Prawn::SVG::Document
     sizing.calculate
   end
 
+  def with_sizing(temporary_sizing)
+    original = @sizing
+    @sizing = temporary_sizing
+    yield
+  ensure
+    @sizing = original
+  end
+
   private
 
   def load_color_mode

data/lib/prawn/svg/elements/anchor.rb

@@ -0,0 +1,9 @@
+class Prawn::SVG::Elements::Anchor < Prawn::SVG::Elements::Base
+  def parse
+    state.anchor_href = href_attribute
+  end
+
+  def container?
+    true
+  end
+end

data/lib/prawn/svg/elements/base.rb

@@ -8,6 +8,7 @@ class Prawn::SVG::Elements::Base
   include Prawn::SVG::Attributes::Transform
   include Prawn::SVG::Attributes::Opacity
   include Prawn::SVG::Attributes::ClipPath
+  include Prawn::SVG::Attributes::Mask
   include Prawn::SVG::Attributes::Stroke
   include Prawn::SVG::Attributes::Space
 
@@ -56,6 +57,10 @@ class Prawn::SVG::Elements::Base
     apply_calls_from_standard_attributes
     apply
 
+    if state.anchor_href && bounding_box
+      add_call('svg:add_link', state.anchor_href, bounding_box)
+    end
+
     process_child_elements if container?
 
     append_calls_to_parent unless computed_properties.display == 'none'
@@ -154,6 +159,7 @@ class Prawn::SVG::Elements::Base
     parse_transform_attribute_and_call
     parse_opacity_attributes_and_call
     parse_clip_path_attribute_and_call
+    parse_mask_attribute_and_call
     apply_colors
     parse_stroke_attributes_and_call
     apply_drawing_call

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

@@ -0,0 +1,153 @@
+class Prawn::SVG::Elements::Mask < Prawn::SVG::Elements::Base
+  def parse
+    properties.display = 'none'
+    computed_properties.display = 'none'
+  end
+
+  def container?
+    true
+  end
+
+  def build_mask_calls(element)
+    bbox = element.bounding_box
+    mask_units = attributes['maskUnits'] || 'objectBoundingBox'
+    content_units = attributes['maskContentUnits'] || 'userSpaceOnUse'
+
+    if content_units == 'objectBoundingBox' && bbox.nil?
+      document.warnings << 'mask with maskContentUnits="objectBoundingBox" requires element to have a bounding box'
+      return []
+    end
+
+    calls = []
+
+    calls.concat(build_clip_calls(bbox, mask_units)) if bbox || mask_units == 'userSpaceOnUse'
+
+    if content_units == 'objectBoundingBox'
+      calls.concat(build_object_bounding_box_calls(bbox))
+    else
+      calls.concat(duplicate_calls(base_calls))
+    end
+
+    calls
+  end
+
+  private
+
+  def build_clip_calls(bbox, mask_units)
+    if mask_units == 'objectBoundingBox'
+      mask_x = Float(attributes['x'] || '-0.1')
+      mask_y = Float(attributes['y'] || '-0.1')
+      mask_w = Float(attributes['width'] || '1.2')
+      mask_h = Float(attributes['height'] || '1.2')
+
+      bbox_left = bbox[0]
+      bbox_top = bbox[1]
+      bbox_right = bbox[2]
+      bbox_bottom = bbox[3]
+      bbox_w = bbox_right - bbox_left
+      bbox_h = bbox_top - bbox_bottom
+
+      clip_left = bbox_left + (mask_x * bbox_w)
+      clip_top = bbox_top - (mask_y * bbox_h)
+      clip_width = mask_w * bbox_w
+      clip_height = mask_h * bbox_h
+    else
+      clip_left = x_pixels(attributes['x'] || '-10%')
+      clip_top = y(attributes['y'] || '-10%')
+      clip_width = x_pixels(attributes['width'] || '120%')
+      clip_height = y_pixels(attributes['height'] || '120%')
+    end
+
+    [
+      ['rectangle', [[clip_left, clip_top], clip_width, clip_height], {}, []],
+      ['clip', [], {}, []]
+    ]
+  end
+
+  def build_object_bounding_box_calls(bbox)
+    bbox_left = bbox[0]
+    bbox_top = bbox[1]
+    bbox_right = bbox[2]
+    bbox_bottom = bbox[3]
+    bbox_w = bbox_right - bbox_left
+    bbox_h = bbox_top - bbox_bottom
+
+    # Prawn's soft_mask doesn't support transformation_matrix inside the block,
+    # so we must produce calls with final Prawn coordinates.
+    #
+    # Set up sizing so that:
+    # - viewport = 1x1 (objectBoundingBox fractions resolve as-is for unitless values)
+    # - output_height = bbox_top, so y(frac) = bbox_top - frac = correct when bbox_h=1
+    #
+    # Then scale x by bbox_w, offset x by bbox_left, and scale y displacement by bbox_h.
+
+    unit_sizing = Prawn::SVG::Calculators::DocumentSizing.new([1, 1])
+    unit_sizing.document_width = 1
+    unit_sizing.document_height = 1
+    unit_sizing.calculate
+
+    result_calls = document.with_sizing(unit_sizing) do
+      new_state = state.dup
+      new_state.viewport_sizing = unit_sizing
+      new_state.inside_use = true
+
+      container = Prawn::SVG::Elements::Container.new(document, source, [], new_state)
+      container.process
+
+      container.base_calls
+    end
+
+    scale_calls_to_bbox(duplicate_calls(result_calls), bbox_left, bbox_top, bbox_w, bbox_h)
+  end
+
+  def scale_calls_to_bbox(calls, bbox_left, bbox_top, bbox_w, bbox_h)
+    calls.map do |name, args, kwargs, children|
+      new_args = case name
+                 when 'rectangle'
+                   point, width, height = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), width * bbox_w, height * bbox_h]
+                 when 'rounded_rectangle'
+                   point, width, height, radius = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), width * bbox_w, height * bbox_h, radius * bbox_w]
+                 when 'move_to', 'line_to'
+                   [scale_point(args[0], bbox_left, bbox_top, bbox_w, bbox_h)]
+                 when 'circle'
+                   point, radius = args
+                   scaled_point = scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h)
+                   if bbox_w == bbox_h
+                     [scaled_point, radius * bbox_w]
+                   else
+                     new_children = children.any? ? scale_calls_to_bbox(children, bbox_left, bbox_top, bbox_w, bbox_h) : children
+                     next ['ellipse', [scaled_point, radius * bbox_w, radius * bbox_h], kwargs, new_children]
+                   end
+                 when 'ellipse'
+                   point, rx, ry = args
+                   [scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h), rx * bbox_w, ry * bbox_h]
+                 when 'curve_to'
+                   dest = scale_point(args[0], bbox_left, bbox_top, bbox_w, bbox_h)
+                   [dest]
+                 else
+                   args
+                 end
+
+      new_kwargs = if name == 'curve_to' && kwargs[:bounds]
+                     b = kwargs[:bounds]
+                     { bounds: b.map { |p| scale_point(p, bbox_left, bbox_top, bbox_w, bbox_h) } }
+                   else
+                     kwargs
+                   end
+
+      new_children = children.any? ? scale_calls_to_bbox(children, bbox_left, bbox_top, bbox_w, bbox_h) : children
+      [name, new_args, new_kwargs, new_children]
+    end
+  end
+
+  def scale_point(point, bbox_left, bbox_top, bbox_w, bbox_h)
+    # point is [x, 1.0 - svg_y] from unit sizing where output_height = 1
+    # We need [bbox_left + svg_x * bbox_w, bbox_top - svg_y * bbox_h]
+    # svg_x = point[0], svg_y = 1.0 - point[1]
+    x = bbox_left + (point[0] * bbox_w)
+    y = bbox_top - ((1.0 - point[1]) * bbox_h)
+    [x, y]
+  end
+end

data/lib/prawn/svg/elements/text_component.rb

@@ -2,7 +2,7 @@ module Prawn::SVG
   class Elements::TextComponent < Elements::DirectRenderBase
     attr_reader :children, :parent_component
     attr_reader :x_values, :y_values, :dx, :dy, :rotation, :text_length, :length_adjust
-    attr_reader :font
+    attr_reader :font, :fallback_fonts
 
     def initialize(document, source, _calls, state, parent_component = nil)
       if parent_component.nil? && source.name != 'text'
@@ -24,7 +24,7 @@ module Prawn::SVG
       @text_length = normalize_length(attributes['textLength'])
       @length_adjust = attributes['lengthAdjust']
 
-      @font = select_font
+      @font, @fallback_fonts = select_fonts
 
       @children = svg_text_children.flat_map do |child|
         if child.node_type == :text
@@ -42,9 +42,8 @@ module Prawn::SVG
     end
 
     def lay_out(prawn)
-      @children.each do |child|
-        prawn.save_font do
-          prawn.font(font.name, style: font.subfamily) if font
+      with_svg_fonts(prawn) do
+        @children.each do |child|
           child.lay_out(prawn)
         end
       end
@@ -73,9 +72,7 @@ module Prawn::SVG
           y_offset = -height / 2.0
         end
 
-        prawn.save_font do
-          prawn.font(font.name, style: font.subfamily) if font
-
+        with_svg_fonts(prawn) do
           children.each do |child|
             case child
             when Elements::TextNode
@@ -165,18 +162,42 @@ module Prawn::SVG
       end
     end
 
-    def select_font
-      font_families = [computed_properties.font_family, document.fallback_font_name]
+    def select_fonts
       font_style = :italic if computed_properties.font_style == 'italic'
       font_weight = computed_properties.font_weight
+      fonts = []
 
-      font_families.compact.each do |name|
+      font_family_names.each do |name|
         font = document.font_registry.load(name, font_weight, font_style)
-        return font if font
+        next unless font
+        next if fonts.any? { |existing| existing.name == font.name && existing.subfamily == font.subfamily }
+
+        fonts << font
       end
 
+      _, *fallback_font_names = fonts.map(&:name).uniq
+
+      return [fonts.first, fallback_font_names] if fonts.any?
+
       warnings << "Font family '#{computed_properties.font_family}' style '#{computed_properties.font_style}' is not a known font, and the fallback font could not be found."
-      nil
+      []
+    end
+
+    def with_svg_fonts(prawn)
+      prawn.save_font do
+        if font
+          prawn.font(font.name, style: font.subfamily)
+          prawn.fallback_fonts(fallback_fonts)
+        end
+
+        yield
+      end
+    end
+
+    def font_family_names
+      names = CSS::FontFamilyParser.parse(computed_properties.font_family.to_s)
+      names << document.fallback_font_name if document.fallback_font_name
+      names.map(&:strip).reject(&:empty?)
     end
 
     def total_flexible_and_fixed_width

data/lib/prawn/svg/elements/text_node.rb

@@ -1,6 +1,6 @@
 module Prawn::SVG
   class Elements::TextNode
-    Chunk = Struct.new(:text, :x, :y, :dx, :dy, :rotate, :base_width, :offset, :fixed_width)
+    Chunk = Struct.new(:text, :x, :y, :dx, :dy, :rotate, :base_width, :offset, :fixed_width, :font_runs)
 
     attr_reader :component, :chunks
     attr_accessor :text
@@ -75,12 +75,15 @@ module Prawn::SVG
 
         opts = { size: component.computed_properties.numeric_font_size, kerning: true }
 
+        fallback_fonts = component.fallback_fonts
+        font_runs = fallback_fonts&.any? ? split_into_font_runs(prawn, text_to_draw, fallback_fonts) : nil
+
         total_spacing = text_to_draw.length > 1 ? (component.letter_spacing_pixels || 0) * (text_to_draw.length - 1) : 0
-        base_width = prawn.width_of(text_to_draw, opts) + total_spacing
+        base_width = width_of_text(prawn, text_to_draw, font_runs, opts) + total_spacing
 
         offset = dx ? [0, dx].max : 0
 
-        @chunks << Chunk.new(text_to_draw, x, y, dx, dy, rotate, base_width, offset, nil)
+        @chunks << Chunk.new(text_to_draw, x, y, dx, dy, rotate, base_width, offset, nil, font_runs)
 
         if remaining
           remaining_text = remaining_text[1..]
@@ -110,9 +113,12 @@ module Prawn::SVG
         cursor.y = chunk.y if chunk.y
         cursor.y -= chunk.dy if chunk.dy
 
-        render_underline(prawn, size, cursor, y_offset, chunk.fixed_width || chunk.base_width) if component.computed_properties.text_decoration == 'underline'
+        width = chunk.fixed_width || chunk.base_width
+
+        render_underline(prawn, size, cursor, y_offset, width) if component.computed_properties.text_decoration == 'underline'
+        render_link_annotation(prawn, size, cursor, y_offset, width)
 
-        opts = { size: size, at: [cursor.x, cursor.y + (y_offset || 0)] }
+        opts = { size: size, at: [cursor.x, cursor.y + (y_offset || 0)], kerning: true }
         opts[:rotate] = chunk.rotate if chunk.rotate
 
         scaling =
@@ -137,7 +143,7 @@ module Prawn::SVG
         prawn.horizontal_text_scaling(scaling) do
           prawn.character_spacing(spacing || component.letter_spacing_pixels || prawn.character_spacing) do
             prawn.text_rendering_mode(calculate_text_rendering_mode) do
-              prawn.draw_text(chunk.text, **opts)
+              render_text_directly(prawn, chunk.text, chunk.font_runs, opts)
             end
           end
         end
@@ -150,12 +156,97 @@ module Prawn::SVG
       end
     end
 
+    def width_of_text(prawn, text, font_runs, opts)
+      if font_runs.nil?
+        prawn.width_of(text, **opts)
+      else
+        font_runs.sum(0.0) do |font_name, run_text|
+          if font_name
+            width = nil
+            prawn.font(font_name) { width = prawn.width_of(run_text, **opts) }
+            width
+          else
+            prawn.width_of(run_text, **opts)
+          end
+        end
+      end
+    end
+
+    def render_text_directly(prawn, text, font_runs, opts)
+      if font_runs.nil?
+        prawn.draw_text(text, **opts)
+      else
+        x = opts[:at][0]
+        font_runs.each do |font_name, run_text|
+          run_opts = opts.merge(at: [x, opts[:at][1]])
+          if font_name
+            prawn.font(font_name) do
+              prawn.draw_text(run_text, **run_opts)
+              x += prawn.width_of(run_text, size: opts[:size], kerning: true)
+            end
+          else
+            prawn.draw_text(run_text, **run_opts)
+            x += prawn.width_of(run_text, size: opts[:size], kerning: true)
+          end
+        end
+      end
+    end
+
+    def split_into_font_runs(prawn, text, fallback_fonts)
+      original_font = prawn.font.family
+      runs = []
+      current_font = nil
+      current_text = +''
+
+      prawn.save_font do
+        text.each_char do |char|
+          font_for_char = font_for_glyph(prawn, char, original_font, fallback_fonts)
+
+          if font_for_char != current_font && !current_text.empty?
+            runs << [current_font, current_text]
+            current_text = +''
+          end
+          current_font = font_for_char
+          current_text << char
+        end
+      end
+
+      runs << [current_font, current_text] unless current_text.empty?
+      runs
+    end
+
+    def font_for_glyph(prawn, char, original_font, fallback_fonts)
+      prawn.font(original_font)
+      return nil if prawn.font.glyph_present?(char)
+
+      fallback_fonts.each do |fb|
+        prawn.font(fb)
+        return fb if prawn.font.glyph_present?(char)
+      end
+
+      nil
+    end
+
     def render_underline(prawn, size, cursor, y_offset, width)
       offset, thickness = FontMetrics.underline_metrics(prawn, size)
 
       prawn.fill_rectangle [cursor.x, cursor.y + (y_offset || 0) + offset + (thickness / 2.0)], width, thickness
     end
 
+    def render_link_annotation(prawn, size, cursor, y_offset, width)
+      href = component.state.anchor_href
+      return unless href
+
+      text_bottom = cursor.y + (y_offset || 0) - scaled_font_size(prawn, :descender, size)
+      font_height = scaled_font_size(prawn, :height, size)
+
+      LinkRenderer.new(href, [cursor.x, text_bottom + font_height, cursor.x + width, text_bottom]).render(prawn)
+    end
+
+    def scaled_font_size(prawn, method_name, size)
+      (prawn.font.public_send(method_name) / prawn.font_size) * size
+    end
+
     def calculate_text_rendering_mode
       fill = !component.computed_properties.fill.none? # rubocop:disable Style/InverseMethods
       stroke = !component.computed_properties.stroke.none? # rubocop:disable Style/InverseMethods

data/lib/prawn/svg/elements.rb

@@ -4,7 +4,7 @@ end
 
 require 'prawn/svg/elements/call_duplicator'
 
-%w[base direct_render_base root container clip_path viewport text text_component text_node line polyline polygon circle ellipse
+%w[base direct_render_base root anchor container clip_path mask viewport text text_component text_node line polyline polygon circle ellipse
    rect path use image gradient marker ignored].each do |filename|
   require "prawn/svg/elements/#{filename}"
 end
@@ -14,7 +14,7 @@ module Prawn::SVG::Elements
     g:              Prawn::SVG::Elements::Container,
     symbol:         Prawn::SVG::Elements::Container,
     defs:           Prawn::SVG::Elements::Container,
-    a:              Prawn::SVG::Elements::Container,
+    a:              Prawn::SVG::Elements::Anchor,
     clipPath:       Prawn::SVG::Elements::ClipPath,
     switch:         Prawn::SVG::Elements::Container,
     svg:            Prawn::SVG::Elements::Viewport,
@@ -38,6 +38,6 @@ module Prawn::SVG::Elements
     foreignObject:  Prawn::SVG::Elements::Ignored,
     'font-face':    Prawn::SVG::Elements::Ignored,
     filter:         Prawn::SVG::Elements::Ignored, # unsupported
-    mask:           Prawn::SVG::Elements::Ignored # unsupported
+    mask:           Prawn::SVG::Elements::Mask
   }.freeze
 end

data/lib/prawn/svg/font_metrics.rb

@@ -4,33 +4,44 @@ class Prawn::SVG::FontMetrics
     DEFAULT_X_HEIGHT_RATIO = 0.5
 
     def x_height_in_points(pdf, font_size)
-      @x_height_cache ||= {}
-
-      cache_key = cache_key_for(pdf)
-
-      @x_height_cache[cache_key] ||= calculate_x_height_ratio(pdf)
-      @x_height_cache[cache_key] * font_size
+      x_height = cache(:x_height, pdf.font) { calculate_x_height_ratio(pdf) }
+      x_height * font_size
     end
 
     def underline_metrics(pdf, size)
-      @underline_metrics_cache ||= {}
-
-      cache_key = cache_key_for(pdf)
-
-      @underline_metrics_cache[cache_key] ||= fetch_underline_metrics(pdf, size)
-      @underline_metrics_cache[cache_key]
+      cache(:underline, pdf.font, size) do
+        fetch_underline_metrics(pdf, size)
+      end
     end
 
     private
 
-    def cache_key_for(pdf)
-      return 'default' unless pdf && pdf.font.is_a?(Prawn::Fonts::TTF)
+    def cache(name, *args)
+      @font_metrics_cache ||= {}
 
-      ttf = pdf.font.ttf
+      cache_key = generate_cache_key([name, *args])
+      return @font_metrics_cache[cache_key] if @font_metrics_cache.key?(cache_key)
+
+      @font_metrics_cache[cache_key] = yield
+      @font_metrics_cache[cache_key]
+    end
+
+    def generate_cache_key(key)
+      case
+      when key.is_a?(Prawn::Fonts::TTF) then font_cache_key(key)
+      when key.is_a?(Prawn::Font)       then 'default'
+      when key.is_a?(Array)             then key.map { |element| generate_cache_key(element) }.join('/')
+      when key.respond_to?(:to_a)       then generate_cache_key(key.to_a)
+      else                              key.to_s
+      end.to_s
+    end
+
+    def font_cache_key(font)
+      ttf = font.ttf
       return 'default' unless ttf
 
       # Use font family name from TTF metadata, which doesn't include size
-      ttf.name&.font_family&.first || pdf&.font&.name || 'default'
+      ttf.name&.font_family&.first || font&.name || 'default'
     end
 
     def calculate_x_height_ratio(pdf)

data/lib/prawn/svg/gradient_renderer.rb

@@ -194,9 +194,17 @@ class Prawn::SVG::GradientRenderer
   end
 
   def current_pdf_transform
-    @current_pdf_transform ||= load_matrix(
-      prawn.current_transformation_matrix_with_translation(*prawn.bounds.anchor)
-    )
+    @current_pdf_transform ||= if prawn.state.page.in_stamp_stream?
+                                 # Inside a soft_mask Form XObject, the CTM resets to identity but Prawn's
+                                 # internal tracking still reflects the page CTM. The geometry coordinates
+                                 # only have the bounds offset applied (no scaling), so the pattern matrix
+                                 # should match by using only the bounds translation.
+                                 current_pdf_translation
+                               else
+                                 load_matrix(
+                                   prawn.current_transformation_matrix_with_translation(*prawn.bounds.anchor)
+                                 )
+                               end
   end
 
   def current_pdf_translation

data/lib/prawn/svg/link_renderer.rb

@@ -0,0 +1,40 @@
+class Prawn::SVG::LinkRenderer
+  include Prawn::SVG::PDFMatrix
+
+  def initialize(href, bounding_box)
+    @href = href
+    @bounding_box = bounding_box
+  end
+
+  def render(prawn)
+    prawn.link_annotation(transformed_bounding_box(prawn), {
+      Border: [0, 0, 0],
+      A:      { Type: :Action, S: :URI, URI: PDF::Core::LiteralString.new(href) }
+    })
+  end
+
+  private
+
+  attr_reader :href, :bounding_box
+
+  def transformed_bounding_box(prawn)
+    x0, y0, x1, y1 = bounding_box
+
+    matrix = load_matrix(prawn.current_transformation_matrix_with_translation(*prawn.bounds.anchor))
+
+    corners = [
+      matrix * Vector[x0, y0, 1.0],
+      matrix * Vector[x0, y1, 1.0],
+      matrix * Vector[x1, y0, 1.0],
+      matrix * Vector[x1, y1, 1.0]
+    ]
+
+    xs = corners.map { |c| c[0] }
+    ys = corners.map { |c| c[1] }
+
+    tx0, tx1 = xs.minmax
+    ty0, ty1 = ys.minmax
+
+    [tx0, ty0, tx1, ty1]
+  end
+end

data/lib/prawn/svg/properties.rb

@@ -32,6 +32,7 @@ module Prawn::SVG
       'marker-end'        => Config.new('none', true, [:funciri, 'none']),
       'marker-mid'        => Config.new('none', true, [:funciri, 'none']),
       'marker-start'      => Config.new('none', true, [:funciri, 'none']),
+      'mask'              => Config.new('none', false, [:funciri, 'none']),
       'opacity'           => Config.new(1.0, false, [:number]),
       'overflow'          => Config.new('visible', false, %w[visible hidden scroll auto]),
       'stop-color'        => Config.new(Color.black, false, [:color_with_icc, 'currentcolor']),