prawnx 0.1.1

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

@@ -0,0 +1,184 @@
+class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
+  attr_reader :parent_gradient
+  attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :r, :fx, :fy, :fr, :units, :stops, :transform_matrix, :wrap
+
+  TAG_NAME_TO_TYPE = {
+    'linearGradient' => :linear,
+    'radialGradient' => :radial
+  }.freeze
+
+  def parse
+    # A gradient tag without an ID is inaccessible and can never be used
+    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
+    load_coordinates
+    load_stops
+
+    document.gradients[attributes['id']] = self
+
+    raise SkipElementQuietly # we don't want anything pushed onto the call stack
+  end
+
+  def gradient_arguments(element)
+    bbox = element.bounding_box
+
+    stroke_width = element.stroke_width
+    bbox_with_stroke = bbox&.zip([-stroke_width, stroke_width, stroke_width, -stroke_width])&.map(&:sum)
+
+    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_with_stroke
+      }
+    else
+      {
+        from:         [x1, y1],
+        to:           [x2, y2],
+        stops:        stops,
+        matrix:       matrix_for_bounding_box(bbox),
+        wrap:         wrap,
+        bounding_box: bbox_with_stroke
+      }
+    end
+  end
+
+  def derive_attribute(name)
+    attributes[name] || parent_gradient&.derive_attribute(name)
+  end
+
+  private
+
+  def matrix_for_bounding_box(bbox)
+    if bbox && units == :bounding_box
+      bounding_x1, bounding_y1, bounding_x2, bounding_y2 = *bbox
+
+      width = bounding_x2 - bounding_x1
+      height = bounding_y1 - bounding_y2
+
+      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
+      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
+
+  def assert_compatible_prawn_version
+    if (Prawn::VERSION.split('.').map(&:to_i) <=> [2, 2, 0]) == -1
+      raise SkipElementError, "Prawn 2.2.0+ must be used if you'd like prawn-svg to render gradients"
+    end
+  end
+
+  def load_gradient_configuration
+    @units = derive_attribute('gradientUnits') == 'userSpaceOnUse' ? :user_space : :bounding_box
+
+    if (transform = derive_attribute('gradientTransform'))
+      @transform_matrix = parse_transform_attribute(transform, space: :svg)
+    end
+
+    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 = 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(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 = 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(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'
+    end
+  end
+
+  def load_stops
+    stop_elements = source.elements.map do |child|
+      element = Prawn::SVG::Elements::Base.new(document, child, [], Prawn::SVG::State.new)
+      element.process
+      element
+    end.select do |element|
+      element.name == 'stop' && element.attributes['offset']
+    end
+
+    @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[:offset] if result.last && result.last[:offset] > offset
+
+      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
+
+    if stops.empty?
+      if parent_gradient.nil? || parent_gradient.stops.empty?
+        raise SkipElementError, 'gradient does not have any valid stops'
+      end
+
+      @stops = parent_gradient.stops
+    else
+      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
+end

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

@@ -0,0 +1,5 @@
+class Prawn::SVG::Elements::Ignored < Prawn::SVG::Elements::Base
+  def parse
+    raise SkipElementQuietly
+  end
+end

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

@@ -0,0 +1,177 @@
+class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
+  class FakeIO
+    def initialize(data)
+      @data = data
+    end
+
+    def read
+      @data
+    end
+
+    def rewind; end
+  end
+
+  ImageData = Struct.new(:dimensions, :document)
+
+  def parse
+    require_attributes 'width', 'height'
+
+    raise SkipElementQuietly if state.computed_properties.display == 'none'
+
+    @url = href_attribute
+    raise SkipElementError, 'image tag must have an href or xlink:href' if @url.nil?
+
+    @url, @fragment = extract_fragment(@url)
+
+    x = x(attributes['x'] || 0)
+    y = y(attributes['y'] || 0)
+    width = x_pixels(attributes['width'])
+    height = y_pixels(attributes['height'])
+    preserve_aspect_ratio = attributes['preserveAspectRatio']
+
+    raise SkipElementQuietly if width.zero? || height.zero?
+
+    require_positive_value width, height
+
+    @image = begin
+      @document.url_loader.load(@url)
+    rescue Prawn::SVG::UrlLoader::Error => e
+      raise SkipElementError, "Error retrieving URL #{@url}: #{e.message}"
+    end
+
+    @image_data = process_image(@image, width, height, preserve_aspect_ratio)
+
+    @aspect = Prawn::SVG::Calculators::AspectRatio.new(preserve_aspect_ratio, [width, height], @image_data.dimensions)
+
+    @clip_x = x
+    @clip_y = y
+    @clip_width = width
+    @clip_height = height
+
+    @width = @aspect.width
+    @height = @aspect.height
+    @x = x + @aspect.x
+    @y = y - @aspect.y
+  end
+
+  def apply
+    if @aspect.slice?
+      add_call 'save'
+      add_call 'rectangle', [@clip_x, @clip_y], @clip_width, @clip_height
+      add_call 'clip'
+    end
+
+    if (document = @image_data.document)
+      add_call_and_enter 'translate', @x, @y
+      add_call 'svg:render_sub_document', document
+    else
+      options = { width: @width, height: @height, at: [@x, @y] }
+
+      add_call 'image', FakeIO.new(@image), options
+    end
+
+    add_call 'restore' if @aspect.slice?
+  end
+
+  def bounding_box
+    [@x, @y, @x + @width, @y - @height]
+  end
+
+  protected
+
+  def process_image(data, width, height, preserve_aspect_ratio)
+    if (handler = find_image_handler(data))
+      image = handler.new(data)
+      ImageData.new([image.width.to_f, image.height.to_f], nil)
+
+    elsif potentially_svg?(data)
+      attribute_overrides = {}
+      attribute_overrides['preserveAspectRatio'] = preserve_aspect_ratio if preserve_aspect_ratio
+
+      if @fragment
+        view_attrs = resolve_svg_fragment(data, @fragment)
+        attribute_overrides.merge!(view_attrs) if view_attrs
+      end
+
+      has_web_loader = @document.url_loader.loaders.any? { |l| l.is_a?(Prawn::SVG::Loaders::Web) }
+      document = Prawn::SVG::Document.new(
+        data, [width, height], { width: width, height: height, enable_web_requests: has_web_loader },
+        attribute_overrides: attribute_overrides
+      )
+
+      dimensions = [document.sizing.output_width, document.sizing.output_height]
+      ImageData.new(dimensions, document)
+
+    else
+      raise_invalid_image_type
+    end
+  rescue Prawn::SVG::Document::InvalidSVGData
+    raise_invalid_image_type
+  end
+
+  def extract_fragment(url)
+    return [url, nil] if url.start_with?('data:')
+
+    if url.include?('#')
+      index = url.rindex('#')
+      [url[0...index], url[(index + 1)..]]
+    else
+      [url, nil]
+    end
+  end
+
+  def resolve_svg_fragment(data, fragment)
+    if fragment.start_with?('svgView(') && fragment.end_with?(')')
+      parse_svg_view_specification(fragment)
+    else
+      find_view_element_attributes(data, fragment)
+    end
+  end
+
+  SVG_VIEW_PARAM_REGEXP = /(\w+)\(([^)]*)\)/.freeze
+
+  def parse_svg_view_specification(fragment)
+    spec = fragment[8..-2]
+    attrs = {}
+
+    spec.split(';').each do |part|
+      next unless (match = part.strip.match(SVG_VIEW_PARAM_REGEXP))
+
+      case match[1]
+      when 'viewBox' then attrs['viewBox'] = match[2]
+      when 'preserveAspectRatio' then attrs['preserveAspectRatio'] = match[2]
+      end
+    end
+
+    attrs.empty? ? nil : attrs
+  end
+
+  def find_view_element_attributes(data, fragment)
+    root = REXML::Document.new(data).root
+    return unless root
+
+    element = REXML::XPath.match(root, %(//*[@id="#{fragment.gsub('"', '\\"')}"])).first
+    return unless element&.name == 'view'
+
+    attrs = {}
+    attrs['viewBox'] = element.attributes['viewBox'] if element.attributes['viewBox']
+    attrs['preserveAspectRatio'] = element.attributes['preserveAspectRatio'] if element.attributes['preserveAspectRatio']
+    attrs.empty? ? nil : attrs
+  rescue REXML::ParseException
+    nil
+  end
+
+  def find_image_handler(data)
+    Prawn.image_handler.find(data)
+  rescue StandardError
+    nil
+  end
+
+  def potentially_svg?(data)
+    data.include?('<svg')
+  end
+
+  def raise_invalid_image_type
+    raise SkipElementError, 'Unsupported image type supplied to image tag'
+  end
+end

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

@@ -0,0 +1,27 @@
+class Prawn::SVG::Elements::Line < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
+  def parse
+    # Lines are one dimensional, so cannot be filled.
+    computed_properties.fill = Prawn::SVG::Paint.none
+
+    @x1 = x_pixels(attributes['x1'] || 0)
+    @y1 = y_pixels(attributes['y1'] || 0)
+    @x2 = x_pixels(attributes['x2'] || 0)
+    @y2 = y_pixels(attributes['y2'] || 0)
+  end
+
+  def apply
+    apply_commands
+    apply_markers
+  end
+
+  protected
+
+  def commands
+    @commands ||= [
+      Prawn::SVG::Pathable::Move.new([@x1, @y1]),
+      Prawn::SVG::Pathable::Line.new([@x2, @y2])
+    ]
+  end
+end

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

@@ -0,0 +1,72 @@
+class Prawn::SVG::Elements::Marker < Prawn::SVG::Elements::Base
+  def parse
+    set_display_none
+  end
+
+  def container?
+    true
+  end
+
+  def apply_marker(element, point: nil, angle: 0)
+    sizing = Prawn::SVG::Calculators::DocumentSizing.new([0, 0], attributes)
+    sizing.document_width = attributes['markerWidth'] || 3
+    sizing.document_height = attributes['markerHeight'] || 3
+    sizing.calculate
+
+    if sizing.invalid?
+      document.warnings << '<marker> cannot be rendered due to invalid sizing information'
+      return
+    end
+
+    element.new_call_context_from_base do
+      element.add_call 'save'
+
+      # LATER : these will probably change when we separate out properties from attributes
+      element.parse_transform_attribute_and_call
+      element.parse_opacity_attributes_and_call
+      element.parse_clip_path_attribute_and_call
+
+      element.add_call 'transformation_matrix', 1, 0, 0, 1, point[0], -point[1]
+
+      if attributes['orient'] != 'auto'
+        angle = attributes['orient'].to_f # defaults to 0 if not specified
+      end
+
+      element.push_call_position
+      element.add_call_and_enter 'rotate', -angle, origin: [0, y('0')] if angle != 0
+
+      if attributes['markerUnits'] != 'userSpaceOnUse'
+        scale = element.state.stroke_width
+        element.add_call 'transformation_matrix', scale, 0, 0, scale, 0, 0
+      end
+
+      ref_x = x_pixels(attributes['refX']) || 0
+      ref_y = y_pixels(attributes['refY']) || 0
+
+      element.add_call 'transformation_matrix', 1, 0, 0, 1, -ref_x * sizing.x_scale, ref_y * sizing.y_scale
+
+      if overflow_hidden?
+        point = [sizing.x_offset * sizing.x_scale, y(sizing.y_offset * sizing.y_scale)]
+        element.add_call 'rectangle', point, sizing.output_width, sizing.output_height
+        element.add_call 'clip'
+      end
+
+      element.add_call 'transformation_matrix', sizing.x_scale, 0, 0, sizing.y_scale, 0, 0
+
+      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)
+      container.parse_and_apply
+      container.add_calls_from_element(self)
+
+      element.add_calls_from_element(container)
+
+      element.pop_call_position
+      element.add_call 'restore'
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+class Prawn::SVG::Elements::Mask < Prawn::SVG::Elements::Base
+  def parse
+    set_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
+end