prawn-svg 0.35.0 → 0.36.0

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

@@ -1,6 +1,6 @@
 class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   attr_reader :parent_gradient
-  attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :fx, :fy, :radius, :units, :stops, :transform_matrix
+  attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :r, :fx, :fy, :fr, :units, :stops, :transform_matrix, :wrap
 
   TAG_NAME_TO_TYPE = {
     'linearGradient' => :linear,
@@ -12,6 +12,8 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
     raise SkipElementQuietly if attributes['id'].nil?
 
     @parent_gradient = document.gradients[href_attribute[1..]] if href_attribute && href_attribute[0] == '#'
+    @transform_matrix = Matrix.identity(3)
+    @wrap = :pad
 
     assert_compatible_prawn_version
     load_gradient_configuration
@@ -24,57 +26,58 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def gradient_arguments(element)
-    # Passing in a transformation matrix to the apply_transformations option is supported
-    # by a monkey patch installed by prawn-svg.  Prawn only sees this as a truthy variable.
-    #
-    # See Prawn::SVG::Extensions::AdditionalGradientTransforms for details.
-    base_arguments = { stops: stops, apply_transformations: transform_matrix || true }
-
-    arguments = specific_gradient_arguments(element)
-    arguments&.merge(base_arguments)
+    bbox = element.bounding_box
+
+    if type == :radial
+      {
+        from:         [fx, fy],
+        r1:           fr,
+        to:           [cx, cy],
+        r2:           r,
+        stops:        stops,
+        matrix:       matrix_for_bounding_box(*bbox),
+        wrap:         wrap,
+        bounding_box: bbox
+      }
+    else
+      {
+        from:         [x1, y1],
+        to:           [x2, y2],
+        stops:        stops,
+        matrix:       matrix_for_bounding_box(*bbox),
+        wrap:         wrap,
+        bounding_box: bbox
+      }
+    end
+  end
+
+  def derive_attribute(name)
+    attributes[name] || parent_gradient&.derive_attribute(name)
   end
 
   private
 
-  def specific_gradient_arguments(element)
+  def matrix_for_bounding_box(bounding_x1, bounding_y1, bounding_x2, bounding_y2)
     if units == :bounding_box
-      bounding_x1, bounding_y1, bounding_x2, bounding_y2 = element.bounding_box
-      return if bounding_y2.nil?
-
       width = bounding_x2 - bounding_x1
       height = bounding_y1 - bounding_y2
-    end
-
-    case [type, units]
-    when [:linear, :bounding_box]
-      from = [bounding_x1 + (width * x1), bounding_y1 - (height * y1)]
-      to   = [bounding_x1 + (width * x2), bounding_y1 - (height * y2)]
-
-      { from: from, to: to }
-
-    when [:linear, :user_space]
-      { from: [x1, y1], to: [x2, y2] }
-
-    when [:radial, :bounding_box]
-      center = [bounding_x1 + (width * cx), bounding_y1 - (height * cy)]
-      focus  = [bounding_x1 + (width * fx), bounding_y1 - (height * fy)]
 
-      # NOTE: Chrome, at least, implements radial bounding box radiuses as
-      # having separate X and Y components, so in bounding box mode their
-      # gradients come out as ovals instead of circles.  PDF radial shading
-      # doesn't have the option to do this, and it's confusing why the
-      # Chrome user space gradients don't apply the same logic anyway.
-      hypot = Math.sqrt((width * width) + (height * height))
-      { from: focus, r1: 0, to: center, r2: radius * hypot }
-
-    when [:radial, :user_space]
-      { from: [fx, fy], r1: 0, to: [cx, cy], r2: radius }
+      bounding_box_to_user_space_matrix = Matrix[
+        [width, 0.0, bounding_x1],
+        [0.0, height, document.sizing.output_height - bounding_y1],
+        [0.0, 0.0, 1.0]
+      ]
 
+      svg_to_pdf_matrix * bounding_box_to_user_space_matrix * transform_matrix
     else
-      raise 'unexpected type/unit system'
+      svg_to_pdf_matrix * transform_matrix
     end
   end
 
+  def svg_to_pdf_matrix
+    @svg_to_pdf_matrix ||= Matrix[[1.0, 0.0, 0.0], [0.0, -1.0, document.sizing.output_height], [0.0, 0.0, 1.0]]
+  end
+
   def type
     TAG_NAME_TO_TYPE.fetch(name)
   end
@@ -86,44 +89,47 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def load_gradient_configuration
-    @units = attributes['gradientUnits'] == 'userSpaceOnUse' ? :user_space : :bounding_box
+    @units = derive_attribute('gradientUnits') == 'userSpaceOnUse' ? :user_space : :bounding_box
 
-    if (transform = attributes['gradientTransform'])
-      @transform_matrix = parse_transform_attribute(transform)
+    if (transform = derive_attribute('gradientTransform'))
+      @transform_matrix = parse_transform_attribute(transform, space: :svg)
     end
 
-    if (spread_method = attributes['spreadMethod']) && spread_method != 'pad'
-      warnings << "prawn-svg only currently supports the 'pad' spreadMethod attribute value"
+    if (spread_method = derive_attribute('spreadMethod'))
+      spread_method = spread_method.to_sym
+      @wrap = [:pad, :reflect, :repeat].include?(spread_method) ? spread_method : :pad
     end
   end
 
   def load_coordinates
     case [type, units]
     when [:linear, :bounding_box]
-      @x1 = parse_zero_to_one(attributes['x1'], 0)
-      @y1 = parse_zero_to_one(attributes['y1'], 0)
-      @x2 = parse_zero_to_one(attributes['x2'], 1)
-      @y2 = parse_zero_to_one(attributes['y2'], 0)
+      @x1 = percentage_or_proportion(derive_attribute('x1'), 0.0)
+      @y1 = percentage_or_proportion(derive_attribute('y1'), 0.0)
+      @x2 = percentage_or_proportion(derive_attribute('x2'), 1.0)
+      @y2 = percentage_or_proportion(derive_attribute('y2'), 0.0)
 
     when [:linear, :user_space]
-      @x1 = x(attributes['x1'])
-      @y1 = y(attributes['y1'])
-      @x2 = x(attributes['x2'])
-      @y2 = y(attributes['y2'])
+      @x1 = x(derive_attribute('x1'))
+      @y1 = y_pixels(derive_attribute('y1'))
+      @x2 = x(derive_attribute('x2'))
+      @y2 = y_pixels(derive_attribute('y2'))
 
     when [:radial, :bounding_box]
-      @cx = parse_zero_to_one(attributes['cx'], 0.5)
-      @cy = parse_zero_to_one(attributes['cy'], 0.5)
-      @fx = parse_zero_to_one(attributes['fx'], cx)
-      @fy = parse_zero_to_one(attributes['fy'], cy)
-      @radius = parse_zero_to_one(attributes['r'], 0.5)
+      @cx = percentage_or_proportion(derive_attribute('cx'), 0.5)
+      @cy = percentage_or_proportion(derive_attribute('cy'), 0.5)
+      @r = percentage_or_proportion(derive_attribute('r'), 0.5)
+      @fx = percentage_or_proportion(derive_attribute('fx'), cx)
+      @fy = percentage_or_proportion(derive_attribute('fy'), cy)
+      @fr = percentage_or_proportion(derive_attribute('fr'), 0.0)
 
     when [:radial, :user_space]
-      @cx = x(attributes['cx'] || '50%')
-      @cy = y(attributes['cy'] || '50%')
-      @fx = x(attributes['fx'] || attributes['cx'])
-      @fy = y(attributes['fy'] || attributes['cy'])
-      @radius = pixels(attributes['r'] || '50%')
+      @cx = x(derive_attribute('cx') || '50%')
+      @cy = y_pixels(derive_attribute('cy') || '50%')
+      @r = pixels(derive_attribute('r') || '50%')
+      @fx = x(derive_attribute('fx') || derive_attribute('cx'))
+      @fy = y_pixels(derive_attribute('fy') || derive_attribute('cy'))
+      @fr = pixels(derive_attribute('fr') || '0%')
 
     else
       raise 'unexpected type/unit system'
@@ -139,14 +145,14 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
       element.name == 'stop' && element.attributes['offset']
     end
 
-    @stops = stop_elements.each.with_object([]) do |child, result|
-      offset = parse_zero_to_one(child.attributes['offset'])
+    @stops = stop_elements.each_with_object([]) do |child, result|
+      offset = percentage_or_proportion(child.attributes['offset']).clamp(0.0, 1.0)
 
       # Offsets must be strictly increasing (SVG 13.2.4)
-      offset = result.last.first if result.last && result.last.first > offset
+      offset = result.last[:offset] if result.last && result.last[:offset] > offset
 
-      if (color = Prawn::SVG::Color.css_color_to_prawn_color(child.properties.stop_color))
-        result << [offset, color]
+      if (color = child.properties.stop_color&.value)
+        result << { offset: offset, color: color, opacity: (child.properties.stop_opacity || 1.0).clamp(0.0, 1.0) }
       end
     end
 
@@ -157,17 +163,36 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
 
       @stops = parent_gradient.stops
     else
-      stops.unshift([0, stops.first.last]) if stops.first.first.positive?
-      stops.push([1, stops.last.last])     if stops.last.first < 1
+      if stops.first[:offset].positive?
+        start_stop = stops.first.dup
+        start_stop[:offset] = 0
+        stops.unshift(start_stop)
+      end
+
+      if stops.last[:offset] < 1
+        end_stop = stops.last.dup
+        end_stop[:offset] = 1
+        stops.push(end_stop)
+      end
     end
   end
 
-  def parse_zero_to_one(string, default = 0)
+  def percentage_or_proportion(string, default = 0)
     string = string.to_s.strip
-    return default if string == ''
+    percentage = false
+
+    if string[-1] == '%'
+      percentage = true
+      string = string[0..-2]
+    end
 
-    value = string.to_f
-    value /= 100.0 if string[-1..] == '%'
-    [0.0, value, 1.0].sort[1]
+    value = Float(string, exception: false)
+    return default unless value
+
+    if percentage
+      value / 100.0
+    else
+      value
+    end
   end
 end

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

@@ -3,7 +3,7 @@ class Prawn::SVG::Elements::Line < Prawn::SVG::Elements::Base
 
   def parse
     # Lines are one dimensional, so cannot be filled.
-    computed_properties.fill = 'none'
+    computed_properties.fill = Prawn::SVG::Paint.none
 
     @x1 = x_pixels(attributes['x1'] || 0)
     @y1 = y_pixels(attributes['y1'] || 0)

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

@@ -56,6 +56,8 @@ class Prawn::SVG::Elements::Marker < Prawn::SVG::Elements::Base
 
       new_state = state.dup
       new_state.computed_properties = computed_properties.dup
+      new_state.last_fill_opacity = element.state.last_fill_opacity
+      new_state.last_stroke_opacity = element.state.last_stroke_opacity
 
       container = Prawn::SVG::Elements::Container.new(document, nil, [], new_state)
       container.properties.compute_properties(new_state.computed_properties)

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

@@ -8,7 +8,7 @@ class Prawn::SVG::Elements::Root < Prawn::SVG::Elements::Base
   end
 
   def apply
-    if [nil, 'inherit', 'none', 'currentColor'].include?(properties.fill)
+    if [nil, 'inherit'].include?(properties.fill) || properties.fill.none? || properties.fill.color == :currentcolor
       add_call 'fill_color', Prawn::SVG::Color.default_color(@document.color_mode).value
     end
 

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

@@ -46,7 +46,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
     # text_anchor and dominant_baseline aren't Prawn options; we have to do some math to support them
     # and so we handle them in Prawn::SVG::Interface#rewrite_call_arguments
     opts = {
-      size:        computed_properties.numerical_font_size,
+      size:        computed_properties.numeric_font_size,
       style:       font&.subfamily,
       text_anchor: computed_properties.text_anchor
     }
@@ -222,8 +222,8 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   end
 
   def calculate_text_rendering_mode
-    fill = computed_properties.fill != 'none'
-    stroke = computed_properties.stroke != 'none'
+    fill = !computed_properties.fill.none? # rubocop:disable Style/InverseMethods
+    stroke = !computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
 
     if fill && stroke
       :fill_stroke

data/lib/prawn/svg/funciri.rb

@@ -0,0 +1,14 @@
+Prawn::SVG::FuncIRI = Struct.new(:url) do
+  def self.parse(value)
+    case Prawn::SVG::CSS::ValuesParser.parse(value)
+    in [['url', [url]]]
+      new(url.strip)
+    else
+      nil
+    end
+  end
+
+  def to_s
+    "url(#{url})"
+  end
+end

data/lib/prawn/svg/gradient_renderer.rb

@@ -0,0 +1,313 @@
+class Prawn::SVG::GradientRenderer
+  include Prawn::SVG::PDFMatrix
+
+  @mutex = Mutex.new
+  @counter = 0
+
+  def initialize(prawn, draw_type, from:, to:, stops:, matrix: nil, r1: nil, r2: nil, wrap: :pad, bounding_box: nil)
+    @prawn = prawn
+    @draw_type = draw_type
+    @from = from
+    @to = to
+    @bounding_box = bounding_box
+
+    if r1
+      @shading_type = 3
+      @coordinates = [*from, r1, *to, r2]
+    else
+      @shading_type = 2
+      @coordinates = [*from, *to]
+    end
+
+    @stop_offsets, @color_stops, @opacity_stops = process_stop_arguments(stops)
+    @gradient_matrix = matrix ? load_matrix(matrix) : Matrix.identity(3)
+    @wrap = wrap
+  end
+
+  def draw
+    key = self.class.next_key
+
+    # If we need transparency, add an ExtGState to the page and enable it.
+    if opacity_stops
+      prawn.page.ext_gstates["PSVG-ExtGState-#{key}"] = create_transparency_graphics_state
+      prawn.renderer.add_content("/PSVG-ExtGState-#{key} gs")
+    end
+
+    # Add pattern to the PDF page resources dictionary.
+    prawn.page.resources[:Pattern] ||= {}
+    prawn.page.resources[:Pattern]["PSVG-Pattern-#{key}"] = create_gradient_pattern
+
+    # Finally set the pattern with the drawing operator for fill/stroke.
+    prawn.send(:set_color_space, draw_type, :Pattern)
+    draw_operator = draw_type == :fill ? 'scn' : 'SCN'
+    prawn.renderer.add_content("/PSVG-Pattern-#{key} #{draw_operator}")
+  end
+
+  def self.next_key
+    @mutex.synchronize { @counter += 1 }
+  end
+
+  private
+
+  attr_reader :prawn, :draw_type, :shading_type, :coordinates, :from, :to,
+    :stop_offsets, :color_stops, :opacity_stops, :gradient_matrix, :wrap, :bounding_box
+
+  def process_stop_arguments(stops)
+    stop_offsets = []
+    color_stops = []
+    opacity_stops = []
+
+    transparency = false
+
+    stops.each do |stop|
+      opacity = stop[:opacity] || 1.0
+
+      transparency = true if opacity < 1
+
+      stop_offsets << stop[:offset]
+      color_stops << prawn.send(:normalize_color, stop[:color])
+      opacity_stops << [opacity]
+    end
+
+    opacity_stops = nil unless transparency
+
+    [stop_offsets, color_stops, opacity_stops]
+  end
+
+  def create_transparency_graphics_state
+    prawn.renderer.min_version(1.4)
+
+    repeat_count, repeat_offset, transform = compute_wrapping(wrap, from, to, current_pdf_translation)
+
+    transparency_group = prawn.ref!(
+      Type:      :XObject,
+      Subtype:   :Form,
+      BBox:      prawn.state.page.dimensions,
+      Group:     {
+        Type: :Group,
+        S:    :Transparency,
+        I:    true,
+        CS:   :DeviceGray
+      },
+      Resources: {
+        Pattern: {
+          'TGP01' => {
+            PatternType: 2,
+            Matrix:      matrix_for_pdf(transform),
+            Shading:     {
+              ShadingType: shading_type,
+              ColorSpace:  :DeviceGray,
+              Coords:      coordinates,
+              Domain:      [0, repeat_count],
+              Function:    create_shading_function(stop_offsets, opacity_stops, wrap, repeat_count, repeat_offset),
+              Extend:      [true, true]
+            }
+          }
+        }
+      }
+    )
+
+    transparency_group.stream << begin
+      box = PDF::Core.real_params(prawn.state.page.dimensions)
+
+      <<~CMDS.strip
+        /Pattern cs
+        /TGP01 scn
+        #{box} re
+        f
+      CMDS
+    end
+
+    prawn.ref!(
+      Type:  :ExtGState,
+      SMask: {
+        Type: :Mask,
+        S:    :Luminosity,
+        G:    transparency_group
+      },
+      AIS:   false
+    )
+  end
+
+  def create_gradient_pattern
+    repeat_count, repeat_offset, transform = compute_wrapping(wrap, from, to, current_pdf_transform)
+
+    prawn.ref!(
+      PatternType: 2,
+      Matrix:      matrix_for_pdf(transform),
+      Shading:     {
+        ShadingType: shading_type,
+        ColorSpace:  prawn.send(:color_space, color_stops.first),
+        Coords:      coordinates,
+        Domain:      [0, repeat_count],
+        Function:    create_shading_function(stop_offsets, color_stops, wrap, repeat_count, repeat_offset),
+        Extend:      [true, true]
+      }
+    )
+  end
+
+  def create_shading_function(offsets, stop_values, wrap = :pad, repeat_count = 1, repeat_offset = 0)
+    gradient_func = create_shading_function_for_stops(offsets, stop_values)
+
+    # Return the gradient function if there is no need to repeat.
+    return gradient_func if wrap == :pad
+
+    even_odd_encode = wrap == :reflect ? [[0, 1], [1, 0]] : [[0, 1], [0, 1]]
+    encode = repeat_count.times.flat_map { |num| even_odd_encode[(num + repeat_offset) % 2] }
+
+    prawn.ref!(
+      FunctionType: 3, # stitching function
+      Domain:       [0, repeat_count],
+      Functions:    Array.new(repeat_count, gradient_func),
+      Bounds:       Range.new(1, repeat_count - 1).to_a,
+      Encode:       encode
+    )
+  end
+
+  def create_shading_function_for_stops(offsets, stop_values)
+    linear_funcs = stop_values.each_cons(2).map do |c0, c1|
+      prawn.ref!(FunctionType: 2, Domain: [0.0, 1.0], C0: c0, C1: c1, N: 1.0)
+    end
+
+    # If there's only two stops, we can use the single shader.
+    return linear_funcs.first if linear_funcs.length == 1
+
+    # Otherwise we stitch the multiple shaders together.
+    prawn.ref!(
+      FunctionType: 3, # stitching function
+      Domain:       [0.0, 1.0],
+      Functions:    linear_funcs,
+      Bounds:       offsets[1..-2],
+      Encode:       [0.0, 1.0] * linear_funcs.length
+    )
+  end
+
+  def current_pdf_transform
+    @current_pdf_transform ||= load_matrix(
+      prawn.current_transformation_matrix_with_translation(*prawn.bounds.anchor)
+    )
+  end
+
+  def current_pdf_translation
+    @current_pdf_translation ||= begin
+      bounds_x, bounds_y = prawn.bounds.anchor
+      Matrix[[1, 0, bounds_x], [0, 1, bounds_y], [0, 0, 1]]
+    end
+  end
+
+  def bounding_box_corners(matrix)
+    if bounding_box
+      transformed_corners(gradient_matrix.inverse, *bounding_box)
+    else
+      transformed_corners(matrix.inverse, *prawn_bounding_box)
+    end
+  end
+
+  def prawn_bounding_box
+    [*prawn.bounds.top_left, *prawn.bounds.bottom_right]
+  end
+
+  def transformed_corners(matrix, left, top, right, bottom)
+    [
+      matrix * Vector[left, top, 1.0],
+      matrix * Vector[left, bottom, 1.0],
+      matrix * Vector[right, top, 1.0],
+      matrix * Vector[right, bottom, 1.0]
+    ]
+  end
+
+  def compute_wrapping(wrap, from, to, page_transform)
+    matrix = page_transform * gradient_matrix
+
+    return [1, 0, matrix] if wrap == :pad
+
+    from = Vector[from[0], from[1], 1.0]
+    to = Vector[to[0], to[1], 1.0]
+
+    # Transform the bounding box into gradient space where lines are straight
+    # and circles are round.
+    box_corners = bounding_box_corners(matrix)
+
+    repeat_count, repeat_offset, delta = if shading_type == 2 # Linear
+                                           project_bounding_box_for_linear(from, to, box_corners)
+                                         else # Radial
+                                           project_bounding_box_for_radial(from, to, box_corners)
+                                         end
+
+    repeat_count = [repeat_count, 50].min
+
+    wrap_transform = translation_matrix(delta[0], delta[1]) *
+                     translation_matrix(from[0], from[1]) *
+                     scale_matrix(repeat_count) *
+                     translation_matrix(-from[0], -from[1])
+
+    [repeat_count, repeat_offset, matrix * wrap_transform]
+  end
+
+  def project_bounding_box_for_linear(from, to, box_corners)
+    ab = to - from
+
+    # Project each corner of the bounding box onto the line made by the
+    # gradient. The formula for projecting a point C onto a line formed from
+    # point A to point B is as follows:
+    #
+    # AB = B - A
+    # AC = C - A
+    # t = (AB dot AC) / (AB dot AB)
+    # P = A + (AB * t)
+    #
+    # We don't actually need the final point P, we only need the parameter "t",
+    # so that we know how many times to repeat the gradient.
+    t_for_corners = box_corners.map do |corner|
+      ac = corner - from
+      ab.dot(ac) / ab.dot(ab)
+    end
+
+    t_min, t_max = t_for_corners.minmax
+
+    repeat_count = (t_max - t_min).ceil + 1
+
+    shift_count = t_min.floor
+    delta = ab * shift_count
+    repeat_offset = shift_count % 2
+
+    [repeat_count, repeat_offset, delta]
+  end
+
+  def project_bounding_box_for_radial(from, to, box_corners)
+    r1 = coordinates[2]
+    r2 = coordinates[5]
+
+    # For radial gradients, the approach is similar. We need to find "t" to
+    # know how far along the gradient line each corner of the bounding box
+    # lies. Only this time we need to solve the simultaneous equation for the
+    # point on both inner and outer circles.
+    #
+    # You can find the derivation for this here:
+    # https://github.com/libpixman/pixman/blob/85467ec308f8621a5410c007491797b7b1847601/pixman/pixman-radial-gradient.c#L162-L241
+    #
+    # Do this for all 4 corners and pick the biggest number to repeat.
+    t = box_corners.reduce(1) do |max, corner|
+      cdx, cdy = *(to - from)
+      pdx, pdy = *(corner - from)
+      dr = r2 - r1
+
+      a = cdx.abs2 + cdy.abs2 - dr.abs2
+      b = (pdx * cdx) + (pdy * cdy) + (r1 * dr)
+      c = pdx.abs2 + pdy.abs2 - r1.abs2
+      det_root = Math.sqrt(b.abs2 - (a * c))
+
+      t0 = (b + det_root) / a
+      t1 = (b - det_root) / a
+
+      [t0, t1, max].max
+    end
+
+    repeat_count = t.ceil
+
+    delta = [0.0, 0.0]
+    repeat_offset = 0
+
+    [repeat_count, repeat_offset, delta]
+  end
+end

data/lib/prawn/svg/length.rb

@@ -0,0 +1,43 @@
+module Prawn::SVG
+  Length = Struct.new(:value, :unit)
+
+  class Length
+    REGEXP = /\A([+-]?\d*(?:\.\d+)?)(em|rem|ex|px|in|cm|mm|pt|pc)?\z/i.freeze
+
+    def self.parse(value, positive_only: false)
+      if (matches = value.match(REGEXP))
+        number = Float(matches[1], exception: false)
+        new(number, matches[2]&.downcase&.to_sym) if number && (!positive_only || number >= 0)
+      end
+    end
+
+    def to_f
+      value
+    end
+
+    def to_s
+      "#{value}#{unit}"
+    end
+
+    def to_pixels(_axis_length, font_size)
+      case unit
+      when :em
+        value * font_size
+      when :rem
+        value * Properties::EM
+      when :ex
+        value * (font_size / 2.0) # we don't have access to the x-height, so this is an approximation approved by the CSS spec
+      when :pc
+        value * 15 # according to http://www.w3.org/TR/SVG11/coords.html
+      when :in
+        value * 72
+      when :cm
+        value * 10 * (72 / 25.4)
+      when :mm
+        value * (72 / 25.4)
+      else
+        value
+      end
+    end
+  end
+end