prawn-svg 0.23.1 → 0.24.0

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

@@ -1,12 +1,11 @@
 class Prawn::SVG::Elements::Container < Prawn::SVG::Elements::Base
   def parse
-    state.disable_drawing = true if name == "clipPath"
-  end
-
-  def apply
-    process_child_elements
+    state.disable_drawing = true if name == 'clipPath'
 
-    raise SkipElementQuietly if %w(symbol defs clipPath).include?(name)
+    if %w(symbol defs clipPath).include?(name)
+      properties.display = 'none'
+      computed_properties.display = 'none'
+    end
   end
 
   def container?

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

@@ -51,16 +51,16 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def load_gradient_configuration
-    @units = attributes["gradientunits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
+    @units = attributes["gradientUnits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
 
-    if transform = attributes["gradienttransform"]
+    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
     end
 
-    if (spread_method = attributes['spreadmethod']) && spread_method != "pad"
+    if (spread_method = attributes['spreadMethod']) && spread_method != "pad"
       warnings << "prawn-svg only currently supports the 'pad' spreadMethod attribute value"
     end
   end
@@ -98,7 +98,7 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
         offset = result.last.first
       end
 
-      if color_hex = Prawn::SVG::Color.color_to_hex(child.attributes["stop-color"])
+      if color_hex = Prawn::SVG::Color.color_to_hex(child.properties.stop_color)
         result << [offset, color_hex]
       end
     end

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

@@ -13,7 +13,7 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
   def parse
     require_attributes 'width', 'height'
 
-    raise SkipElementQuietly if state.display == "none"
+    raise SkipElementQuietly if state.computed_properties.display == "none"
 
     @url = attributes['xlink:href'] || attributes['href']
     if @url.nil?

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

@@ -1,16 +1,24 @@
 class Prawn::SVG::Elements::Line < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
   def parse
-    @x1 = x(attributes['x1'] || '0')
-    @y1 = y(attributes['y1'] || '0')
-    @x2 = x(attributes['x2'] || '0')
-    @y2 = y(attributes['y2'] || '0')
+    @x1 = points(attributes['x1'] || '0', :x)
+    @y1 = points(attributes['y1'] || '0', :y)
+    @x2 = points(attributes['x2'] || '0', :x)
+    @y2 = points(attributes['y2'] || '0', :y)
   end
 
   def apply
-    add_call 'line', @x1, @y1, @x2, @y2
+    apply_commands
+    apply_markers
   end
 
-  def bounding_box
-    [@x1, @y1, @x2, @y2]
+  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
+    properties.display = 'none'
+    computed_properties.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 = document.distance(attributes['refX']) || 0
+      ref_y = document.distance(attributes['refY']) || 0
+
+      element.add_call 'transformation_matrix', 1, 0, 0, 1, -ref_x * sizing.x_scale, ref_y * sizing.y_scale
+
+      # `overflow: visible` must be on the <marker> element
+      if properties.overflow != 'visible'
+        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
+
+      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/path.rb

@@ -1,4 +1,7 @@
 class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Calculators::ArcToBezierCurve
+  include Prawn::SVG::Pathable
+
   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])e[+-]?[0-9]+)?)/
@@ -24,36 +27,20 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
       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}
-      run_path_command(command, values)
+      parse_path_command(command, values)
     end
   end
 
   def apply
     add_call 'join_style', :bevel
 
-    @commands.collect do |command, args|
-      if args && args.length > 0
-        point_to = [x(args[0]), y(args[1])]
-        if command == 'curve_to'
-          opts = {:bounds => [[x(args[2]), y(args[3])], [x(args[4]), y(args[5])]]}
-        end
-        add_call command, point_to, opts
-      else
-        add_call command
-      end
-    end
-  end
-
-  def bounding_box
-    x1, x2 = @commands.map {|_, args| x(args[0]) if args}.compact.minmax
-    y2, y1 = @commands.map {|_, args| y(args[1]) if args}.compact.minmax
-
-    [x1, y1, x2, y2]
+    apply_commands
+    apply_markers
   end
 
   protected
 
-  def run_path_command(command, values)
+  def parse_path_command(command, values)
     upcase_command = command.upcase
     relative = command != upcase_command
 
@@ -67,16 +54,14 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         y += @last_point.last
       end
 
-      @last_point = @subpath_initial_point = [x, y]
-      @commands << ["move_to", @last_point]
+      @subpath_initial_point = [x, y]
+      push_command Prawn::SVG::Pathable::Move.new(@subpath_initial_point)
 
-      return run_path_command(relative ? 'l' : 'L', values) if values.any?
+      return parse_path_command(relative ? 'l' : 'L', values) if values.any?
 
     when 'Z' # closepath
       if @subpath_initial_point
-        #@commands << ["line_to", @subpath_initial_point]
-        @commands << ["close_path"]
-        @last_point = @subpath_initial_point
+        push_command Prawn::SVG::Pathable::Close.new(@subpath_initial_point)
       end
 
     when 'L' # lineto
@@ -87,24 +72,22 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
           x += @last_point.first
           y += @last_point.last
         end
-        @last_point = [x, y]
-        @commands << ["line_to", @last_point]
+
+        push_command Prawn::SVG::Pathable::Line.new([x, y])
       end
 
     when 'H' # horizontal lineto
       while values.any?
         x = values.shift
         x += @last_point.first if relative && @last_point
-        @last_point = [x, @last_point.last]
-        @commands << ["line_to", @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 += @last_point.last if relative && @last_point
-        @last_point = [@last_point.first, y]
-        @commands << ["line_to", @last_point]
+        push_command Prawn::SVG::Pathable::Line.new([@last_point.first, y])
       end
 
     when 'C' # curveto
@@ -119,9 +102,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
           y2 += @last_point.last
         end
 
-        @last_point = [x, y]
         @previous_control_point = [x2, y2]
-        @commands << ["curve_to", [x, y, x1, y1, x2, y2]]
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [x1, y1], [x2, y2])
       end
 
     when 'S' # shorthand/smooth curveto
@@ -141,9 +123,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
           x1, y1 = @last_point
         end
 
-        @last_point = [x, y]
         @previous_control_point = [x2, y2]
-        @commands << ["curve_to", [x, y, x1, y1, x2, y2]]
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [x1, y1], [x2, y2])
       end
 
     when 'Q', 'T' # quadratic curveto
@@ -176,10 +157,9 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         cx2 = cx1 + (x - @last_point.first) / 3.0
         cy2 = cy1 + (y - @last_point.last) / 3.0
 
-        @last_point = [x, y]
         @previous_quadratic_control_point = [x1, y1]
 
-        @commands << ["curve_to", [x, y, cx1, cy1, cx2, cy2]]
+        push_command Prawn::SVG::Pathable::Curve.new([x, y], [cx1, cy1], [cx2, cy2])
       end
 
     when 'A'
@@ -206,8 +186,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
         # F.6.2: If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.
         if within_float_delta?(rx, 0) || within_float_delta?(ry, 0)
-          @last_point = [x2, y2]
-          @commands << ["line_to", @last_point]
+          push_command Prawn::SVG::Pathable::Line.new([x2, y2])
           return
         end
 
@@ -271,8 +250,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         theta_2 = theta_1 + d_theta
 
         calculate_bezier_curve_points_for_arc(cx, cy, rx, ry, theta_1, theta_2, phi).each do |points|
-          @commands << ["curve_to", points[:p2] + points[:q1] + points[:q2]]
-          @last_point = points[:p2]
+          push_command Prawn::SVG::Pathable::Curve.new(points[:p2], points[:q1], points[:q2])
         end
       end
     end
@@ -296,110 +274,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     result
   end
 
-  def calculate_eta_from_lambda(a, b, lambda_1, lambda_2)
-    # 2.2.1
-    eta1 = Math.atan2(Math.sin(lambda_1) / b, Math.cos(lambda_1) / a)
-    eta2 = Math.atan2(Math.sin(lambda_2) / b, Math.cos(lambda_2) / a)
-
-    # ensure eta1 <= eta2 <= eta1 + 2*PI
-    eta2 -= 2 * Math::PI * ((eta2 - eta1) / (2 * Math::PI)).floor
-    eta2 += 2 * Math::PI if lambda_2 - lambda_1 > Math::PI && eta2 - eta1 < Math::PI
-
-    [eta1, eta2]
-  end
-
-  # Convert the elliptical arc to a cubic bézier curve using this algorithm:
-  # http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
-  def calculate_bezier_curve_points_for_arc(cx, cy, a, b, lambda_1, lambda_2, theta)
-    e = lambda do |eta|
-      [
-        cx + a * Math.cos(theta) * Math.cos(eta) - b * Math.sin(theta) * Math.sin(eta),
-        cy + a * Math.sin(theta) * Math.cos(eta) + b * Math.cos(theta) * Math.sin(eta)
-      ]
-    end
-
-    ep = lambda do |eta|
-      [
-        -a * Math.cos(theta) * Math.sin(eta) - b * Math.sin(theta) * Math.cos(eta),
-        -a * Math.sin(theta) * Math.sin(eta) + b * Math.cos(theta) * Math.cos(eta)
-      ]
-    end
-
-    iterations = 1
-    d_lambda = lambda_2 - lambda_1
-
-    while iterations < 1024
-      if d_lambda.abs <= Math::PI / 2.0
-        # TODO : run error algorithm, see whether it meets threshold or not
-        # puts "error = #{calculate_curve_approximation_error(a, b, eta1, eta1 + d_eta)}"
-        break
-      end
-      iterations *= 2
-      d_lambda = (lambda_2 - lambda_1) / iterations
-    end
-
-    (0...iterations).collect do |iteration|
-      eta_a, eta_b = calculate_eta_from_lambda(a, b, lambda_1+iteration*d_lambda, lambda_1+(iteration+1)*d_lambda)
-      d_eta = eta_b - eta_a
-
-      alpha = Math.sin(d_eta) * ((Math.sqrt(4 + 3 * Math.tan(d_eta / 2) ** 2) - 1) / 3)
-
-      x1, y1 = e[eta_a]
-      x2, y2 = e[eta_b]
-
-      ep_eta1_x, ep_eta1_y = ep[eta_a]
-      q1_x = x1 + alpha * ep_eta1_x
-      q1_y = y1 + alpha * ep_eta1_y
-
-      ep_eta2_x, ep_eta2_y = ep[eta_b]
-      q2_x = x2 - alpha * ep_eta2_x
-      q2_y = y2 - alpha * ep_eta2_y
-
-      {:p2 => [x2, y2], :q1 => [q1_x, q1_y], :q2 => [q2_x, q2_y]}
-    end
-  end
-
-  ERROR_COEFFICIENTS_A = [
-    [
-      [3.85268, -21.229, -0.330434, 0.0127842],
-      [-1.61486, 0.706564, 0.225945, 0.263682],
-      [-0.910164, 0.388383, 0.00551445, 0.00671814],
-      [-0.630184, 0.192402, 0.0098871, 0.0102527]
-    ],
-    [
-      [-0.162211, 9.94329, 0.13723, 0.0124084],
-      [-0.253135, 0.00187735, 0.0230286, 0.01264],
-      [-0.0695069, -0.0437594, 0.0120636, 0.0163087],
-      [-0.0328856, -0.00926032, -0.00173573, 0.00527385]
-    ]
-  ]
-
-  ERROR_COEFFICIENTS_B = [
-    [
-      [0.0899116, -19.2349, -4.11711, 0.183362],
-      [0.138148, -1.45804, 1.32044, 1.38474],
-      [0.230903, -0.450262, 0.219963, 0.414038],
-      [0.0590565, -0.101062, 0.0430592, 0.0204699]
-    ],
-    [
-      [0.0164649, 9.89394, 0.0919496, 0.00760802],
-      [0.0191603, -0.0322058, 0.0134667, -0.0825018],
-      [0.0156192, -0.017535, 0.00326508, -0.228157],
-      [-0.0236752, 0.0405821, -0.0173086, 0.176187]
-    ]
-  ]
-
-  def calculate_curve_approximation_error(a, b, eta1, eta2)
-    b_over_a = b / a
-    coefficents = b_over_a < 0.25 ? ERROR_COEFFICIENTS_A : ERROR_COEFFICIENTS_B
-
-    c = lambda do |i|
-      (0..3).inject(0) do |accumulator, j|
-        coef = coefficents[i][j]
-        accumulator + ((coef[0] * b_over_a**2 + coef[1] * b_over_a + coef[2]) / (b_over_a * coef[3])) * Math.cos(j * (eta1 + eta2))
-      end
-    end
-
-    ((0.001 * b_over_a**2 + 4.98 * b_over_a + 0.207) / (b_over_a * 0.0067)) * a * Math.exp(c[0] + c[1] * (eta2 - eta1))
+  def push_command(command)
+    @commands << command
+    @last_point = command.destination
   end
 end

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

@@ -1,17 +1,25 @@
 class Prawn::SVG::Elements::Polygon < Prawn::SVG::Elements::Base
+  include Prawn::SVG::Pathable
+
   def parse
     require_attributes('points')
     @points = parse_points(attributes['points'])
   end
 
   def apply
-    add_call 'polygon', *@points
+    apply_commands
+    apply_markers
   end
 
-  def bounding_box
-    x1, x2 = @points.map(&:first).minmax
-    y2, y1 = @points.map(&:last).minmax
-    [x1, y1, x2, y2]
+  protected
+
+  def commands
+    @commands ||= [
+      Prawn::SVG::Pathable::Move.new(@points[0])
+    ] + @points[1..-1].map { |point|
+      Prawn::SVG::Pathable::Line.new(point)
+    } + [
+      Prawn::SVG::Pathable::Close.new(@points[0])
+    ]
   end
 end
-