prawn-svg 0.27.1 → 0.31.0

data/lib/prawn/svg/document.rb

@@ -12,7 +12,8 @@ class Prawn::SVG::Document
     :fallback_font_name,
     :font_registry,
     :url_loader,
-    :css_parser, :elements_by_id, :gradients
+    :elements_by_id, :gradients,
+    :element_styles
 
   def initialize(data, bounds, options, font_registry: nil, css_parser: CssParser::Parser.new)
     @root = REXML::Document.new(data).root
@@ -31,7 +32,6 @@ class Prawn::SVG::Document
     @gradients = {}
     @fallback_font_name = options.fetch(:fallback_font_name, DEFAULT_FALLBACK_FONT_NAME)
     @font_registry = font_registry
-    @css_parser = css_parser
 
     @url_loader = Prawn::SVG::UrlLoader.new(
       enable_cache:          options[:cache_images],
@@ -42,7 +42,7 @@ class Prawn::SVG::Document
     @sizing = Prawn::SVG::Calculators::DocumentSizing.new(bounds, @root.attributes)
     calculate_sizing(requested_width: options[:width], requested_height: options[:height])
 
-    parse_style_elements
+    @element_styles = Prawn::SVG::CSS::Stylesheets.new(css_parser, root).load
 
     yield self if block_given?
   end
@@ -52,16 +52,4 @@ class Prawn::SVG::Document
     sizing.requested_height = requested_height
     sizing.calculate
   end
-
-  private
-
-  # <style> elements specified anywhere in the document apply to the entire
-  # document.  Because of this, we load all <style> elements before parsing
-  # the rest of the document.
-  def parse_style_elements
-    REXML::XPath.match(root, '//style').each do |source|
-      data = source.texts.map(&:value).join
-      css_parser.add_block!(data)
-    end
-  end
 end

data/lib/prawn/svg/elements.rb

@@ -4,7 +4,7 @@ end
 
 require 'prawn/svg/elements/call_duplicator'
 
-%w(base depth_first_base root container viewport text text_component line polyline polygon circle ellipse rect path use image gradient marker ignored).each do |filename|
+%w(base depth_first_base root container clip_path viewport text text_component line polyline polygon circle ellipse rect path use image gradient marker ignored).each do |filename|
   require "prawn/svg/elements/#{filename}"
 end
 
@@ -13,7 +13,8 @@ module Prawn::SVG::Elements
     g: Prawn::SVG::Elements::Container,
     symbol: Prawn::SVG::Elements::Container,
     defs: Prawn::SVG::Elements::Container,
-    clipPath: Prawn::SVG::Elements::Container,
+    a: Prawn::SVG::Elements::Container,
+    clipPath: Prawn::SVG::Elements::ClipPath,
     switch: Prawn::SVG::Elements::Container,
     svg: Prawn::SVG::Elements::Viewport,
     text: Prawn::SVG::Elements::Text,
@@ -27,6 +28,7 @@ module Prawn::SVG::Elements
     use: Prawn::SVG::Elements::Use,
     image: Prawn::SVG::Elements::Image,
     linearGradient: Prawn::SVG::Elements::Gradient,
+    radialGradient: Prawn::SVG::Elements::Gradient,
     marker: Prawn::SVG::Elements::Marker,
     style: Prawn::SVG::Elements::Ignored, # because it is pre-parsed by Document
     title: Prawn::SVG::Elements::Ignored,

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

@@ -11,6 +11,8 @@ class Prawn::SVG::Elements::Base
   include Prawn::SVG::Attributes::Stroke
   include Prawn::SVG::Attributes::Space
 
+  include Prawn::SVG::TransformParser
+
   PAINT_TYPES = %w(fill stroke)
   COMMA_WSP_REGEXP = Prawn::SVG::Elements::COMMA_WSP_REGEXP
   SVG_NAMESPACE = "http://www.w3.org/2000/svg"
@@ -157,14 +159,23 @@ class Prawn::SVG::Elements::Base
   end
 
   def apply_drawing_call
-    if !state.disable_drawing && drawable?
-      draw_types = PAINT_TYPES.select { |property| computed_properties.send(property) != 'none' }
+    return if state.disable_drawing || !drawable?
+
+    fill   = computed_properties.fill != 'none'
+    stroke = computed_properties.stroke != 'none'
 
-      if draw_types.empty?
-        add_call_and_enter("end_path")
+    if fill
+      command = stroke ? 'fill_and_stroke' : 'fill'
+
+      if computed_properties.fill_rule == 'evenodd'
+        add_call_and_enter(command, {fill_rule: :even_odd})
       else
-        add_call_and_enter(draw_types.join("_and_"))
+        add_call_and_enter(command)
       end
+    elsif stroke
+      add_call_and_enter('stroke')
+    else
+      add_call_and_enter('end_path')
     end
   end
 
@@ -207,32 +218,20 @@ class Prawn::SVG::Elements::Base
   end
 
   def extract_attributes_and_properties
-    if @document && @document.css_parser
-      tag_style = @document.css_parser.find_by_selector(source.name)
-      id_style = @document.css_parser.find_by_selector("##{source.attributes["id"]}") if source.attributes["id"]
-
-      if classes = source.attributes["class"]
-        class_styles = classes.split(' ').collect do |class_name|
-          @document.css_parser.find_by_selector(".#{class_name}")
-        end
+    if styles = document.element_styles[source]
+      # TODO : implement !important, at the moment it's just ignored
+      styles.each do |name, value, _important|
+        @properties.set(name, value)
       end
-
-      element_style = source.attributes['style']
-
-      style = [tag_style, class_styles, id_style, element_style].flatten.collect do |s|
-        s.nil? || s.strip == "" ? "" : "#{s}#{";" unless s.match(/;\s*\z/)}"
-      end.join
-    else
-      style = source.attributes['style'] || ""
     end
 
+    @properties.load_hash(parse_css_declarations(source.attributes['style'] || ''))
+
     source.attributes.each do |name, value|
       # Properties#set returns nil if it's not a recognised property name
       @properties.set(name, value) or @attributes[name] = value
     end
 
-    @properties.load_hash(parse_css_declarations(style))
-
     state.computed_properties.compute_properties(@properties)
   end
 
@@ -268,4 +267,8 @@ class Prawn::SVG::Elements::Base
     element = document.elements_by_id[matches[1]] if matches
     element if element && (expected_type.nil? || element.name == expected_type)
   end
+
+  def href_attribute
+    attributes['xlink:href'] || attributes['href']
+  end
 end

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

@@ -0,0 +1,12 @@
+class Prawn::SVG::Elements::ClipPath < Prawn::SVG::Elements::Base
+  def parse
+    state.inside_clip_path = true
+    properties.display = 'none'
+    computed_properties.display = 'none'
+  end
+
+  def container?
+    true
+  end
+end
+

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

@@ -1,9 +1,7 @@
 class Prawn::SVG::Elements::Container < Prawn::SVG::Elements::Base
   def parse
-    state.disable_drawing = true if name == 'clipPath'
-
     set_display_none if name == 'symbol' && !state.inside_use
-    set_display_none if %w(defs clipPath).include?(name)
+    set_display_none if name == 'defs'
   end
 
   def container?

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

@@ -1,10 +1,18 @@
 class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
-  TAG_NAME_TO_TYPE = {"linearGradient" => :linear}
+  attr_reader :parent_gradient
+  attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :fx, :fy, :radius, :units, :stops, :transform_matrix
+
+  TAG_NAME_TO_TYPE = {
+    "linearGradient" => :linear,
+    "radialGradient" => :radial
+  }
 
   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..-1]] if href_attribute && href_attribute[0] == '#'
+
     assert_compatible_prawn_version
     load_gradient_configuration
     load_coordinates
@@ -16,26 +24,56 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def gradient_arguments(element)
-    case @units
-    when :bounding_box
-      x1, y1, x2, y2 = element.bounding_box
-      return if y2.nil?
+    # 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) if arguments
+  end
 
-      width = x2 - x1
-      height = y1 - y2
+  private
 
-      from = [x1 + width * @x1, y1 - height * @y1]
-      to   = [x1 + width * @x2, y1 - height * @y2]
+  def specific_gradient_arguments(element)
+    if units == :bounding_box
+      bounding_x1, bounding_y1, bounding_x2, bounding_y2 = element.bounding_box
+      return if bounding_y2.nil?
 
-    when :user_space
-      from = [@x1, @y1]
-      to   = [@x2, @y2]
+      width = bounding_x2 - bounding_x1
+      height = bounding_y1 - bounding_y2
     end
 
-    {from: from, to: to, stops: @stops}
-  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]
 
-  private
+      {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}
+
+    else
+      raise "unexpected type/unit system"
+    end
+  end
 
   def type
     TAG_NAME_TO_TYPE.fetch(name)
@@ -51,10 +89,7 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
     @units = attributes["gradientUnits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
 
     if transform = attributes["gradientTransform"]
-      matrix = transform.split(COMMA_WSP_REGEXP).map(&:to_f)
-      if matrix != [1, 0, 0, 1, 0, 0]
-        raise SkipElementError, "prawn-svg does not yet support gradients with a non-identity gradientTransform attribute"
-      end
+      @transform_matrix = parse_transform_attribute(transform)
     end
 
     if (spread_method = attributes['spreadMethod']) && spread_method != "pad"
@@ -63,18 +98,35 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def load_coordinates
-    case @units
-    when :bounding_box
+    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)
 
-    when :user_space
+    when [:linear, :user_space]
       @x1 = x(attributes["x1"])
       @y1 = y(attributes["y1"])
       @x2 = x(attributes["x2"])
       @y2 = y(attributes["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)
+
+    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%')
+
+    else
+      raise "unexpected type/unit system"
     end
   end
 
@@ -100,10 +152,16 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
       end
     end
 
-    raise SkipElementError, "gradient does not have any valid stops" if @stops.empty?
+    if stops.empty?
+      if parent_gradient.nil? || parent_gradient.stops.empty?
+        raise SkipElementError, "gradient does not have any valid stops"
+      end
 
-    @stops.unshift([0, @stops.first.last]) if @stops.first.first > 0
-    @stops.push([1, @stops.last.last])     if @stops.last.first  < 1
+      @stops = parent_gradient.stops
+    else
+      stops.unshift([0, stops.first.last]) if stops.first.first > 0
+      stops.push([1, stops.last.last])     if stops.last.first  < 1
+    end
   end
 
   def parse_zero_to_one(string, default = 0)

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

@@ -15,9 +15,9 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
 
     raise SkipElementQuietly if state.computed_properties.display == "none"
 
-    @url = attributes['xlink:href'] || attributes['href']
+    @url = href_attribute
     if @url.nil?
-      raise SkipElementError, "image tag must have an xlink:href"
+      raise SkipElementError, "image tag must have an href or xlink:href"
     end
 
     x = x(attributes['x'] || 0)

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

@@ -4,10 +4,31 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
   INSIDE_SPACE_REGEXP = /[ \t\r\n,]*/
   OUTSIDE_SPACE_REGEXP = /[ \t\r\n]*/
-  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?)/
-  VALUES_REGEXP = /^#{INSIDE_REGEXP}/
+  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}(?>([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?))/
+  FLAG_REGEXP = /#{INSIDE_SPACE_REGEXP}([01])/
   COMMAND_REGEXP = /^#{OUTSIDE_SPACE_REGEXP}([A-Za-z])((?:#{INSIDE_REGEXP})*)#{OUTSIDE_SPACE_REGEXP}/
 
+  A_PARAMETERS_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{FLAG_REGEXP}#{FLAG_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  ONE_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}/
+  TWO_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  FOUR_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+  SIX_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/
+
+  COMMAND_MATCH_MAP = {
+    'A' => A_PARAMETERS_REGEXP,
+    'C' => SIX_PARAMETER_REGEXP,
+    'H' => ONE_PARAMETER_REGEXP,
+    'L' => TWO_PARAMETER_REGEXP,
+    'M' => TWO_PARAMETER_REGEXP,
+    'Q' => FOUR_PARAMETER_REGEXP,
+    'S' => FOUR_PARAMETER_REGEXP,
+    'T' => TWO_PARAMETER_REGEXP,
+    'V' => ONE_PARAMETER_REGEXP,
+    'Z' => //,
+  }
+
+  PARAMETERLESS_COMMANDS = COMMAND_MATCH_MAP.select { |_, v| v == // }.map(&:first)
+
   FLOAT_ERROR_DELTA = 1e-10
 
   attr_reader :commands
@@ -16,20 +37,20 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     require_attributes 'd'
 
     @commands = []
+    @last_point = nil
 
     data = attributes["d"].gsub(/#{OUTSIDE_SPACE_REGEXP}$/, '')
 
     matched_commands = match_all(data, COMMAND_REGEXP)
     raise SkipElementError, "Invalid/unsupported syntax for SVG path data" if matched_commands.nil?
 
-    catch :invalid_command do
-      matched_commands.each do |matched_command|
-        command = matched_command[1]
-        matched_values = match_all(matched_command[2], VALUES_REGEXP)
-        raise "should be impossible to have invalid inside data, but we ended up here" if matched_values.nil?
-        values = matched_values.collect {|value| value[1].to_f}
-        parse_path_command(command, values)
-      end
+    matched_commands.each do |(command, parameters)|
+      regexp = COMMAND_MATCH_MAP[command.upcase] or break
+      matched_values = match_all(parameters, regexp) or break
+      values = matched_values.map { |value| value.map(&:to_f) }
+      break if values.empty? && !PARAMETERLESS_COMMANDS.include?(command.upcase)
+
+      parse_path_command(command, values)
     end
   end
 
@@ -48,8 +69,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     case upcase_command
     when 'M' # moveto
-      x = values.shift or throw :invalid_command
-      y = values.shift or throw :invalid_command
+      x, y = values.shift
 
       if relative && @last_point
         x += @last_point.first
@@ -68,8 +88,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'L' # lineto
       while values.any?
-        x = values.shift
-        y = values.shift or throw :invalid_command
+        x, y = values.shift
         if relative && @last_point
           x += @last_point.first
           y += @last_point.last
@@ -80,22 +99,21 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'H' # horizontal lineto
       while values.any?
-        x = values.shift
+        x = values.shift.first
         x += @last_point.first if relative && @last_point
         push_command Prawn::SVG::Pathable::Line.new([x, @last_point.last])
       end
 
     when 'V' # vertical lineto
       while values.any?
-        y = values.shift
+        y = values.shift.first
         y += @last_point.last if relative && @last_point
         push_command Prawn::SVG::Pathable::Line.new([@last_point.first, y])
       end
 
     when 'C' # curveto
       while values.any?
-        x1, y1, x2, y2, x, y = values.shift(6)
-        throw :invalid_command unless y
+        x1, y1, x2, y2, x, y = values.shift
 
         if relative && @last_point
           x += @last_point.first
@@ -112,8 +130,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'S' # shorthand/smooth curveto
       while values.any?
-        x2, y2, x, y = values.shift(4)
-        throw :invalid_command unless y
+        x2, y2, x, y = values.shift
 
         if relative && @last_point
           x += @last_point.first
@@ -136,13 +153,11 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     when 'Q', 'T' # quadratic curveto
       while values.any?
         if shorthand = upcase_command == 'T'
-          x, y = values.shift(2)
+          x, y = values.shift
         else
-          x1, y1, x, y = values.shift(4)
+          x1, y1, x, y = values.shift
         end
 
-        throw :invalid_command unless y
-
         if relative && @last_point
           x += @last_point.first
           x1 += @last_point.first if x1
@@ -174,8 +189,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
       return unless @last_point
 
       while values.any?
-        rx, ry, phi, fa, fs, x2, y2 = values.shift(7)
-        throw :invalid_command unless y2
+        rx, ry, phi, fa, fs, x2, y2 = values.shift
 
         x1, y1 = @last_point
 
@@ -276,9 +290,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
   def match_all(string, regexp) # regexp must start with ^
     result = []
     while string != ""
-      matches = string.match(regexp)
-      result << matches
-      return if matches.nil?
+      matches = string.match(regexp) or return
+      result << matches.captures
       string = matches.post_match
     end
     result