prawnx 0.1.1

data/lib/prawn/svg/gradient_renderer.rb

@@ -0,0 +1,332 @@
+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)
+
+    x0, y0, x1, y1 = bounding_box || prawn_bounding_box
+
+    offset_x, offset_y = prawn.bounds.anchor
+    x0 += offset_x
+    y0 += offset_y
+    x1 += offset_x
+    y1 += offset_y
+
+    width = x1 - x0
+    height = y0 - y1
+
+    transparency_group = prawn.ref!(
+      Type:      :XObject,
+      Subtype:   :Form,
+      BBox:      [x0, y1, x1, y0],
+      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([x0, y1, width, height])
+
+      <<~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 ||= 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
+    @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/gradients.rb

@@ -0,0 +1,53 @@
+module Prawn::SVG
+  class Gradients
+    def initialize(document)
+      @document = document
+      @gradients_by_id = {}
+    end
+
+    def [](id)
+      id &&= id.strip
+      return unless id && id != ''
+
+      if (element = @gradients_by_id[id])
+        element
+      elsif (raw_element = find_raw_gradient_element_by_id(id))
+        create_gradient_element(raw_element)
+      end
+    end
+
+    def []=(id, gradient)
+      @gradients_by_id[id] = gradient
+    end
+
+    private
+
+    PAINT_SERVER_CLASSES = [Elements::Gradient, Elements::Pattern].freeze
+
+    def find_raw_gradient_element_by_id(id)
+      raw_element = find_raw_element_by_id(id)
+      raw_element if gradient_element?(raw_element)
+    end
+
+    def create_gradient_element(raw_element)
+      element_class = Elements::TAG_CLASS_MAPPING[raw_element.name.to_sym]
+      element_class.new(@document, raw_element, [], new_state).tap(&:process)
+    end
+
+    def find_raw_element_by_id(id)
+      REXML::XPath.match(@document.root, %(//*[@id="#{id.gsub('"', '\"')}"])).first
+    end
+
+    def gradient_element?(raw_element)
+      return false if raw_element.nil? || raw_element.name.nil?
+
+      PAINT_SERVER_CLASSES.include?(Elements::TAG_CLASS_MAPPING[raw_element.name.to_sym])
+    end
+
+    def new_state
+      State.new.tap do |state|
+        state.viewport_sizing = @document.sizing
+      end
+    end
+  end
+end

data/lib/prawn/svg/interface.rb

@@ -0,0 +1,72 @@
+#
+# Prawn::SVG::Interface makes a Prawn::SVG::Document instance, uses that object to parse the supplied
+# SVG into Prawn-compatible method calls, and then calls the Prawn methods.
+#
+module Prawn
+  module SVG
+    class Interface
+      VALID_OPTIONS = %i[
+        at position vposition width height cache_images enable_web_requests
+        enable_file_requests_with_root fallback_font_name color_mode language
+        log_warnings
+      ].freeze
+
+      INHERITABLE_OPTIONS = %i[
+        enable_web_requests enable_file_requests_with_root
+        cache_images fallback_font_name color_mode
+      ].freeze
+
+      attr_reader :data, :prawn, :document, :options
+
+      #
+      # Creates a Prawn::SVG object.
+      #
+      # +data+ is the SVG data to convert.  +prawn+ is your Prawn::Document object.
+      #
+      # See README.md for the options that can be passed to this method.
+      #
+      def initialize(data, prawn, options, &block)
+        Prawn.verify_options VALID_OPTIONS, options
+
+        @data = data
+        @prawn = prawn
+        @options = options
+
+        font_registry = Prawn::SVG::FontRegistry.new(prawn.font_families)
+
+        @document = Document.new(
+          data, [prawn.bounds.width, prawn.bounds.height], options,
+          font_registry: font_registry, &block
+        )
+
+        @renderer = Renderer.new(prawn, document, options)
+      end
+
+      #
+      # Draws the SVG to the Prawn::Document object.
+      #
+      def draw
+        @renderer.draw
+
+        document.warnings.each { |w| warn w } if options[:log_warnings]
+      end
+
+      def sizing
+        document.sizing
+      end
+
+      def resize(width: nil, height: nil)
+        document.calculate_sizing(requested_width: width, requested_height: height)
+      end
+
+      def position
+        @renderer.position
+      end
+
+      # backwards support for when the font_path used to be stored on this class
+      def self.font_path
+        Prawn::SVG::FontRegistry.font_path
+      end
+    end
+  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

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/loaders/data.rb

@@ -0,0 +1,17 @@
+module Prawn::SVG::Loaders
+  class Data
+    REGEXP = %r{\Adata:image/(png|jpeg|svg\+xml);base64(;[a-z0-9]+)*,}i.freeze
+
+    def from_url(url)
+      return if url[0..4].downcase != 'data:'
+
+      matches = url.match(REGEXP)
+      if matches.nil?
+        raise Prawn::SVG::UrlLoader::Error,
+          'prawn-svg only supports base64-encoded image/png, image/jpeg, and image/svg+xml data URLs'
+      end
+
+      matches.post_match.unpack1('m')
+    end
+  end
+end

data/lib/prawn/svg/loaders/file.rb

@@ -0,0 +1,111 @@
+require 'addressable/uri'
+
+#
+# Load a file from disk.
+#
+# WINDOWS
+# =======
+# Windows is supported, but must use URLs in the modern structure like:
+#   file:///x:/path/to/the/file.png
+# or as a relative path:
+#   directory/file.png
+# or as an absolute path from the current drive:
+#   /path/to/the/file.png
+#
+# Ruby's URI parser does not like backslashes, nor can it handle filenames as URLs starting
+# with a drive letter as it thinks you're giving it a scheme.
+#
+# URL ENCODING
+# ============
+# This module assumes the URL that is passed in has been URL-encoded.  If for some reason
+# you're passing in a filename that hasn't been taken from an XML document's attribute,
+# you will want to URL encode it before you pass it in.
+#
+# FILES READ AS BINARY
+# ====================
+# At the moment, prawn-svg uses this class only to load graphical files, which are binary.
+# This class therefore uses File.binread to read file data.  If it is ever used in the future
+# to load text files, it will have to be taught about what kind of file it's expecting to
+# read, and adjust the file read function accordingly.
+#
+module Prawn::SVG::Loaders
+  class File
+    attr_reader :root_path
+
+    def initialize(root_path)
+      if root_path.empty?
+        raise ArgumentError,
+          "An empty string is not a valid root path.  Use '.' if you want the current working directory."
+      end
+
+      @root_path = ::File.expand_path(root_path)
+
+      raise ArgumentError, "#{root_path} is not a directory" unless Dir.exist?(@root_path)
+    end
+
+    def from_url(url)
+      uri = build_uri(url)
+
+      if uri && uri.scheme.nil? && uri.path
+        load_file(uri.path)
+
+      elsif uri && uri.scheme == 'file'
+        assert_valid_file_uri!(uri)
+        path = windows? ? fix_windows_path(uri.path) : uri.path
+        load_file(path)
+      end
+    end
+
+    private
+
+    def load_file(path)
+      path = Addressable::URI.unencode(path)
+      path = build_absolute_and_expand_path(path)
+      assert_valid_path!(path)
+      assert_file_exists!(path)
+      ::File.binread(path)
+    end
+
+    def build_uri(url)
+      URI(url)
+    rescue URI::InvalidURIError
+    end
+
+    def assert_valid_path!(path)
+      # TODO : case sensitive comparison, but it's going to be a bit of a headache
+      # making it dependent on whether the file system is case sensitive or not.
+      # Leaving it like this until it's a problem for someone.
+
+      unless path.start_with?("#{root_path}#{::File::SEPARATOR}")
+        raise Prawn::SVG::UrlLoader::Error, "file path is not inside the root path of #{root_path}"
+      end
+    end
+
+    def build_absolute_and_expand_path(path)
+      ::File.expand_path(path, root_path)
+    end
+
+    def assert_valid_file_uri!(uri)
+      unless uri.host.nil? || uri.host.empty?
+        raise Prawn::SVG::UrlLoader::Error,
+          "prawn-svg does not suport file: URLs with a host. Your URL probably doesn't start with three slashes, and it should."
+      end
+    end
+
+    def assert_file_exists!(path)
+      raise Prawn::SVG::UrlLoader::Error, "File #{path} does not exist" unless ::File.exist?(path)
+    end
+
+    def fix_windows_path(path)
+      if path.match(%r{\A/[a-z]:/}i)
+        path[1..]
+      else
+        path
+      end
+    end
+
+    def windows?
+      !!(RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/)
+    end
+  end
+end

data/lib/prawn/svg/loaders/web.rb

@@ -0,0 +1,24 @@
+require 'net/http'
+
+module Prawn::SVG::Loaders
+  class Web
+    def from_url(url)
+      uri = build_uri(url)
+
+      perform_request(uri) if uri && %w[http https].include?(uri.scheme)
+    end
+
+    private
+
+    def build_uri(url)
+      URI(url)
+    rescue URI::InvalidURIError
+    end
+
+    def perform_request(uri)
+      Net::HTTP.get(uri)
+    rescue StandardError => e
+      raise Prawn::SVG::UrlLoader::Error, e.message
+    end
+  end
+end