gamba 2.0.0

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

@@ -0,0 +1,183 @@
+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] == "#" # rubocop:disable Performance/ArraySemiInfiniteRangeSlice -- String
+    @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:,
+        matrix: matrix_for_bounding_box(bbox),
+        wrap:,
+        bounding_box: bbox_with_stroke
+      }
+    else
+      {
+        from: [x1, y1],
+        to: [x2, y2],
+        stops:,
+        matrix: matrix_for_bounding_box(bbox),
+        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
+    stop_elements.select! { |element| element.name == "stop" && element.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[:offset] if result.last && result.last[:offset] > offset
+
+      if (color = child.properties.stop_color&.value)
+        result << {offset:, 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,178 @@
+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 = Data.define(: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?(Prawn::SVG::Loaders::Web)
+      document = Prawn::SVG::Document.new(
+        data, [width, height], {width:, height:, enable_web_requests: has_web_loader},
+        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+)\(([^)]*)\)/
+
+  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
+    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