prawn-svg 0.34.2 → 0.35.1

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

@@ -3,15 +3,15 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   attr_reader :x1, :y1, :x2, :y2, :cx, :cy, :fx, :fy, :radius, :units, :stops, :transform_matrix
 
   TAG_NAME_TO_TYPE = {
-    "linearGradient" => :linear,
-    "radialGradient" => :radial
-  }
+    '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..-1]] if href_attribute && href_attribute[0] == '#'
+    @parent_gradient = document.gradients[href_attribute[1..]] if href_attribute && href_attribute[0] == '#'
 
     assert_compatible_prawn_version
     load_gradient_configuration
@@ -28,10 +28,10 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
     # 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}
+    base_arguments = { stops: stops, apply_transformations: transform_matrix || true }
 
     arguments = specific_gradient_arguments(element)
-    arguments.merge(base_arguments) if arguments
+    arguments&.merge(base_arguments)
   end
 
   private
@@ -47,31 +47,31 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
 
     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]
+      from = [bounding_x1 + (width * x1), bounding_y1 - (height * y1)]
+      to   = [bounding_x1 + (width * x2), bounding_y1 - (height * y2)]
 
-      {from: from, to: to}
+      { from: from, to: to }
 
     when [:linear, :user_space]
-      {from: [x1, y1], to: [x2, y2]}
+      { 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]
+      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
+      # 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}
+      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}
+      { from: [fx, fy], r1: 0, to: [cx, cy], r2: radius }
 
     else
-      raise "unexpected type/unit system"
+      raise 'unexpected type/unit system'
     end
   end
 
@@ -80,19 +80,19 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   end
 
   def assert_compatible_prawn_version
-    if (Prawn::VERSION.split(".").map(&:to_i) <=> [2, 2, 0]) == -1
+    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 = attributes["gradientUnits"] == 'userSpaceOnUse' ? :user_space : :bounding_box
+    @units = attributes['gradientUnits'] == 'userSpaceOnUse' ? :user_space : :bounding_box
 
-    if transform = attributes["gradientTransform"]
+    if (transform = attributes['gradientTransform'])
       @transform_matrix = parse_transform_attribute(transform)
     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
@@ -100,33 +100,33 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
   def load_coordinates
     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)
+      @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 [:linear, :user_space]
-      @x1 = x(attributes["x1"])
-      @y1 = y(attributes["y1"])
-      @x2 = x(attributes["x2"])
-      @y2 = y(attributes["y2"])
+      @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)
+      @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%')
+      @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"
+      raise 'unexpected type/unit system'
     end
   end
 
@@ -136,40 +136,38 @@ class Prawn::SVG::Elements::Gradient < Prawn::SVG::Elements::Base
       element.process
       element
     end.select do |element|
-      element.name == 'stop' && element.attributes["offset"]
+      element.name == 'stop' && element.attributes['offset']
     end
 
     @stops = stop_elements.each.with_object([]) do |child, result|
-      offset = parse_zero_to_one(child.attributes["offset"])
+      offset = parse_zero_to_one(child.attributes['offset'])
 
       # Offsets must be strictly increasing (SVG 13.2.4)
-      if result.last && result.last.first > offset
-        offset = result.last.first
-      end
+      offset = result.last.first if result.last && result.last.first > offset
 
-      if color = Prawn::SVG::Color.css_color_to_prawn_color(child.properties.stop_color)
+      if (color = Prawn::SVG::Color.css_color_to_prawn_color(child.properties.stop_color))
         result << [offset, color]
       end
     end
 
     if stops.empty?
       if parent_gradient.nil? || parent_gradient.stops.empty?
-        raise SkipElementError, "gradient does not have any valid stops"
+        raise SkipElementError, 'gradient does not have any valid stops'
       end
 
       @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
+      stops.unshift([0, stops.first.last]) if stops.first.first.positive?
+      stops.push([1, stops.last.last])     if stops.last.first < 1
     end
   end
 
   def parse_zero_to_one(string, default = 0)
     string = string.to_s.strip
-    return default if string == ""
+    return default if string == ''
 
     value = string.to_f
-    value /= 100.0 if string[-1..-1] == '%'
+    value /= 100.0 if string[-1..] == '%'
     [0.0, value, 1.0].sort[1]
   end
 end

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

@@ -25,7 +25,7 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
     y = y(attributes['y'] || 0)
     width = x_pixels(attributes['width'])
     height = y_pixels(attributes['height'])
-    preserveAspectRatio = attributes['preserveAspectRatio']
+    preserve_aspect_ratio = attributes['preserveAspectRatio']
 
     raise SkipElementQuietly if width.zero? || height.zero?
 
@@ -37,9 +37,9 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
       raise SkipElementError, "Error retrieving URL #{@url}: #{e.message}"
     end
 
-    @image_data = process_image(@image, width, height, preserveAspectRatio)
+    @image_data = process_image(@image, width, height, preserve_aspect_ratio)
 
-    @aspect = Prawn::SVG::Calculators::AspectRatio.new(preserveAspectRatio, [width, height], @image_data.dimensions)
+    @aspect = Prawn::SVG::Calculators::AspectRatio.new(preserve_aspect_ratio, [width, height], @image_data.dimensions)
 
     @clip_x = x
     @clip_y = y
@@ -77,7 +77,7 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
 
   protected
 
-  def process_image(data, width, height, preserveAspectRatio)
+  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)
@@ -85,7 +85,7 @@ class Prawn::SVG::Elements::Image < Prawn::SVG::Elements::Base
     elsif potentially_svg?(data)
       document = Prawn::SVG::Document.new(
         data, [width, height], { width: width, height: height },
-        attribute_overrides: { 'preserveAspectRatio' => preserveAspectRatio }
+        attribute_overrides: { 'preserveAspectRatio' => preserve_aspect_ratio }
       )
 
       dimensions = [document.sizing.output_width, document.sizing.output_height]

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

@@ -10,12 +10,12 @@ class Prawn::SVG::Elements::Marker < Prawn::SVG::Elements::Base
 
   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.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"
+      document.warnings << '<marker> cannot be rendered due to invalid sizing information'
       return
     end
 
@@ -48,8 +48,8 @@ class Prawn::SVG::Elements::Marker < Prawn::SVG::Elements::Base
 
       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"
+        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

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

@@ -2,17 +2,17 @@ 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])[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}/
+  INSIDE_SPACE_REGEXP = /[ \t\r\n,]*/.freeze
+  OUTSIDE_SPACE_REGEXP = /[ \t\r\n]*/.freeze
+  INSIDE_REGEXP = /#{INSIDE_SPACE_REGEXP}(?>([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:(?<=[0-9])[eE][+-]?[0-9]+)?))/.freeze
+  FLAG_REGEXP = /#{INSIDE_SPACE_REGEXP}([01])/.freeze
+  COMMAND_REGEXP = /^#{OUTSIDE_SPACE_REGEXP}([A-Za-z])((?:#{INSIDE_REGEXP})*)#{OUTSIDE_SPACE_REGEXP}/.freeze
+
+  A_PARAMETERS_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{FLAG_REGEXP}#{FLAG_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  ONE_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}/.freeze
+  TWO_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  FOUR_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
+  SIX_PARAMETER_REGEXP = /^#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}#{INSIDE_REGEXP}/.freeze
 
   COMMAND_MATCH_MAP = {
     'A' => A_PARAMETERS_REGEXP,
@@ -24,8 +24,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     'S' => FOUR_PARAMETER_REGEXP,
     'T' => TWO_PARAMETER_REGEXP,
     'V' => ONE_PARAMETER_REGEXP,
-    'Z' => //,
-  }
+    'Z' => //
+  }.freeze
 
   PARAMETERLESS_COMMANDS = COMMAND_MATCH_MAP.select { |_, v| v == // }.map(&:first)
 
@@ -39,10 +39,10 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
     @commands = []
     @last_point = nil
 
-    data = attributes["d"].gsub(/#{OUTSIDE_SPACE_REGEXP}$/, '')
+    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?
+    raise SkipElementError, 'Invalid/unsupported syntax for SVG path data' if matched_commands.nil?
 
     matched_commands.each do |(command, parameters)|
       regexp = COMMAND_MATCH_MAP[command.upcase] or break
@@ -80,9 +80,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
       return parse_path_command(relative ? 'l' : 'L', values) if values.any?
 
     when 'Z' # closepath
-      if @subpath_initial_point
-        push_command Prawn::SVG::Pathable::Close.new(@subpath_initial_point)
-      end
+      push_command Prawn::SVG::Pathable::Close.new(@subpath_initial_point) if @subpath_initial_point
 
     when 'L' # lineto
       while values.any?
@@ -138,8 +136,8 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         end
 
         if @previous_control_point
-          x1 = 2 * @last_point.first - @previous_control_point.first
-          y1 = 2 * @last_point.last - @previous_control_point.last
+          x1 = (2 * @last_point.first) - @previous_control_point.first
+          y1 = (2 * @last_point.last) - @previous_control_point.last
         else
           x1, y1 = @last_point
         end
@@ -150,7 +148,7 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
     when 'Q', 'T' # quadratic curveto
       while values.any?
-        if shorthand = upcase_command == 'T'
+        if (shorthand = upcase_command == 'T')
           x, y = values.shift
         else
           x1, y1, x, y = values.shift
@@ -165,18 +163,18 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
 
         if shorthand
           if @previous_quadratic_control_point
-            x1 = 2 * @last_point.first - @previous_quadratic_control_point.first
-            y1 = 2 * @last_point.last - @previous_quadratic_control_point.last
+            x1 = (2 * @last_point.first) - @previous_quadratic_control_point.first
+            y1 = (2 * @last_point.last) - @previous_quadratic_control_point.last
           else
             x1, y1 = @last_point
           end
         end
 
         # convert from quadratic to cubic
-        cx1 = @last_point.first + (x1 - @last_point.first) * 2 / 3.0
-        cy1 = @last_point.last + (y1 - @last_point.last) * 2 / 3.0
-        cx2 = cx1 + (x - @last_point.first) / 3.0
-        cy2 = cy1 + (y - @last_point.last) / 3.0
+        cx1 = @last_point.first + ((x1 - @last_point.first) * 2 / 3.0)
+        cy1 = @last_point.last + ((y1 - @last_point.last) * 2 / 3.0)
+        cx2 = cx1 + ((x - @last_point.first) / 3.0)
+        cy2 = cy1 + ((y - @last_point.last) / 3.0)
 
         @previous_quadratic_control_point = [x1, y1]
 
@@ -216,13 +214,13 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         # points.  To do this, we use the algorithm documented in the SVG specification section F.6.5.
 
         # F.6.5.1
-        xp1 = Math.cos(phi) * ((x1-x2)/2.0) + Math.sin(phi) * ((y1-y2)/2.0)
-        yp1 = -Math.sin(phi) * ((x1-x2)/2.0) + Math.cos(phi) * ((y1-y2)/2.0)
+        xp1 = (Math.cos(phi) * ((x1 - x2) / 2.0)) + (Math.sin(phi) * ((y1 - y2) / 2.0))
+        yp1 = (-Math.sin(phi) * ((x1 - x2) / 2.0)) + (Math.cos(phi) * ((y1 - y2) / 2.0))
 
         # F.6.6.2
         r2x = rx * rx
         r2y = ry * ry
-        hat = xp1 * xp1 / r2x + yp1 * yp1 / r2y
+        hat = (xp1 * xp1 / r2x) + (yp1 * yp1 / r2y)
         if hat > 1
           rx *= Math.sqrt(hat)
           ry *= Math.sqrt(hat)
@@ -231,22 +229,22 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         # F.6.5.2
         r2x = rx * rx
         r2y = ry * ry
-        square = (r2x * r2y - r2x * yp1 * yp1 - r2y * xp1 * xp1) / (r2x * yp1 * yp1 + r2y * xp1 * xp1)
-        square = 0 if square < 0 && square > -FLOAT_ERROR_DELTA # catch rounding errors
+        square = ((r2x * r2y) - (r2x * yp1 * yp1) - (r2y * xp1 * xp1)) / ((r2x * yp1 * yp1) + (r2y * xp1 * xp1))
+        square = 0 if square.negative? && square > -FLOAT_ERROR_DELTA # catch rounding errors
         base = Math.sqrt(square)
         base *= -1 if fa == fs
         cpx = base * rx * yp1 / ry
         cpy = base * -ry * xp1 / rx
 
         # F.6.5.3
-        cx = Math.cos(phi) * cpx + -Math.sin(phi) * cpy + (x1 + x2) / 2
-        cy = Math.sin(phi) * cpx + Math.cos(phi) * cpy + (y1 + y2) / 2
+        cx = (Math.cos(phi) * cpx) + (-Math.sin(phi) * cpy) + ((x1 + x2) / 2)
+        cy = (Math.sin(phi) * cpx) + (Math.cos(phi) * cpy) + ((y1 + y2) / 2)
 
         # F.6.5.5
         vx = (xp1 - cpx) / rx
         vy = (yp1 - cpy) / ry
-        theta_1 = Math.acos(vx / Math.sqrt(vx * vx + vy * vy))
-        theta_1 *= -1 if vy < 0
+        theta_1 = Math.acos(vx / Math.sqrt((vx * vx) + (vy * vy)))
+        theta_1 *= -1 if vy.negative?
 
         # F.6.5.6
         ux = vx
@@ -254,19 +252,19 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
         vx = (-xp1 - cpx) / rx
         vy = (-yp1 - cpy) / ry
 
-        numerator = ux * vx + uy * vy
-        denominator = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
+        numerator = (ux * vx) + (uy * vy)
+        denominator = Math.sqrt((ux * ux) + (uy * uy)) * Math.sqrt((vx * vx) + (vy * vy))
         division = numerator / denominator
         division = -1 if division < -1 # for rounding errors
 
         d_theta = Math.acos(division) % (2 * Math::PI)
-        d_theta *= -1 if ux * vy - uy * vx < 0
+        d_theta *= -1 if ((ux * vy) - (uy * vx)).negative?
 
         # Adjust range
-        if fs == 0
-          d_theta -= 2 * Math::PI if d_theta > 0
-        else
-          d_theta += 2 * Math::PI if d_theta < 0
+        if fs.zero?
+          d_theta -= 2 * Math::PI if d_theta.positive?
+        elsif d_theta.negative?
+          d_theta += 2 * Math::PI
         end
 
         theta_2 = theta_1 + d_theta
@@ -277,17 +275,18 @@ class Prawn::SVG::Elements::Path < Prawn::SVG::Elements::Base
       end
     end
 
-    @previous_control_point = nil unless %w(C S).include?(upcase_command)
-    @previous_quadratic_control_point = nil unless %w(Q T).include?(upcase_command)
+    @previous_control_point = nil unless %w[C S].include?(upcase_command)
+    @previous_quadratic_control_point = nil unless %w[Q T].include?(upcase_command)
   end
 
   def within_float_delta?(a, b)
     (a - b).abs < FLOAT_ERROR_DELTA
   end
 
-  def match_all(string, regexp) # regexp must start with ^
+  # regexp must start with ^
+  def match_all(string, regexp)
     result = []
-    while string != ""
+    while string != ''
       matches = string.match(regexp) or return
       result << matches.captures
       string = matches.post_match

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

@@ -16,7 +16,7 @@ class Prawn::SVG::Elements::Polygon < Prawn::SVG::Elements::Base
   def commands
     @commands ||= [
       Prawn::SVG::Pathable::Move.new(@points[0])
-    ] + @points[1..-1].map { |point|
+    ] + @points[1..].map { |point|
       Prawn::SVG::Pathable::Line.new(point)
     } + [
       Prawn::SVG::Pathable::Close.new(@points[0])

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

@@ -16,8 +16,8 @@ class Prawn::SVG::Elements::Polyline < Prawn::SVG::Elements::Base
   def commands
     @commands ||= [
       Prawn::SVG::Pathable::Move.new(@points[0])
-    ] + @points[1..-1].map { |point|
+    ] + @points[1..].map do |point|
       Prawn::SVG::Pathable::Line.new(point)
-    }
+    end
   end
 end

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

@@ -14,16 +14,16 @@ class Prawn::SVG::Elements::Rect < Prawn::SVG::Elements::Base
       # If you implement separate rx and ry in the future, you'll want to change this
       # so that rx is constrained to @width/2 and ry is constrained to @height/2.
       max_value = [@width, @height].min / 2.0
-      @radius = clamp(@radius, 0, max_value)
+      @radius = @radius.clamp(0, max_value)
     end
   end
 
   def apply
     if @radius
       # n.b. does not support both rx and ry being specified with different values
-      add_call "rounded_rectangle", [@x, @y], @width, @height, @radius
+      add_call 'rounded_rectangle', [@x, @y], @width, @height, @radius
     else
-      add_call "rectangle", [@x, @y], @width, @height
+      add_call 'rectangle', [@x, @y], @width, @height
     end
   end
 

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

@@ -17,7 +17,7 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::DepthFirstBase
 
   def apply_step(calls)
     @base_calls = @calls = calls
-    add_call_and_enter "text_group"
+    add_call_and_enter 'text_group'
     @text_root.apply_step(@calls)
   end
 

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

@@ -5,19 +5,17 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   TextState = Struct.new(:parent, :x, :y, :dx, :dy, :rotation, :spacing, :mode, :text_length, :length_adjust)
 
   def parse
-    if state.inside_clip_path
-      raise SkipElementError, "<text> elements are not supported in clip paths"
-    end
+    raise SkipElementError, '<text> elements are not supported in clip paths' if state.inside_clip_path
 
     if state.text.nil?
-      raise SkipElementError, "attempted to <use> an component inside a text element, this is not supported"
+      raise SkipElementError, 'attempted to <use> an component inside a text element, this is not supported'
     end
 
-    state.text.x = (attributes['x'] || "").split(COMMA_WSP_REGEXP).collect { |n| x(n) }
-    state.text.y = (attributes['y'] || "").split(COMMA_WSP_REGEXP).collect { |n| y(n) }
-    state.text.dx = (attributes['dx'] || "").split(COMMA_WSP_REGEXP).collect { |n| x_pixels(n) }
-    state.text.dy = (attributes['dy'] || "").split(COMMA_WSP_REGEXP).collect { |n| y_pixels(n) }
-    state.text.rotation = (attributes['rotate'] || "").split(COMMA_WSP_REGEXP).collect(&:to_f)
+    state.text.x = (attributes['x'] || '').split(COMMA_WSP_REGEXP).collect { |n| x(n) }
+    state.text.y = (attributes['y'] || '').split(COMMA_WSP_REGEXP).collect { |n| y(n) }
+    state.text.dx = (attributes['dx'] || '').split(COMMA_WSP_REGEXP).collect { |n| x_pixels(n) }
+    state.text.dy = (attributes['dy'] || '').split(COMMA_WSP_REGEXP).collect { |n| y_pixels(n) }
+    state.text.rotation = (attributes['rotate'] || '').split(COMMA_WSP_REGEXP).collect(&:to_f)
     state.text.text_length = normalize_length(attributes['textLength'])
     state.text.length_adjust = attributes['lengthAdjust']
     state.text.spacing = calculate_character_spacing
@@ -40,7 +38,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   end
 
   def apply
-    raise SkipElementQuietly if computed_properties.display == "none"
+    raise SkipElementQuietly if computed_properties.display == 'none'
 
     font = select_font
     apply_font(font) if font
@@ -49,18 +47,21 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
     # and so we handle them in Prawn::SVG::Interface#rewrite_call_arguments
     opts = {
       size:        computed_properties.numerical_font_size,
-      style:       font && font.subfamily,
-      text_anchor: computed_properties.text_anchor,
+      style:       font&.subfamily,
+      text_anchor: computed_properties.text_anchor
     }
 
-    opts[:dominant_baseline] = computed_properties.dominant_baseline unless computed_properties.dominant_baseline == 'auto'
+    unless computed_properties.dominant_baseline == 'auto'
+      opts[:dominant_baseline] =
+        computed_properties.dominant_baseline
+    end
     opts[:decoration] = computed_properties.text_decoration unless computed_properties.text_decoration == 'none'
 
     if state.text.parent
       add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing == state.text.parent.spacing
       add_call_and_enter 'text_rendering_mode', state.text.mode unless state.text.mode == state.text.parent.mode
     else
-      add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing == 0
+      add_call_and_enter 'character_spacing', state.text.spacing unless state.text.spacing.zero?
       add_call_and_enter 'text_rendering_mode', state.text.mode unless state.text.mode == :fill
     end
 
@@ -107,7 +108,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   end
 
   def apply_text(text, opts)
-    while text != ""
+    while text != ''
       x = y = dx = dy = rotate = nil
       remaining = rotation_remaining = false
 
@@ -152,7 +153,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
 
       if remaining
         add_call 'draw_text', text[0..0], **opts.dup
-        text = text[1..-1]
+        text = text[1..]
       else
         add_call 'draw_text', text, **opts.dup
 
@@ -160,11 +161,11 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
         # solve this by shifting them out by the number of
         # characters we've just drawn
         shift = text.length - 1
-        if rotation_remaining && shift > 0
+        if rotation_remaining && shift.positive?
           list = state.text
           while list
             count = [shift, list.rotation.length - 1].min
-            list.rotation.shift(count) if count > 0
+            list.rotation.shift(count) if count.positive?
             list = list.parent
           end
         end
@@ -197,7 +198,7 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
     href = href_attribute
 
     if href && href[0..0] == '#'
-      element = document.elements_by_id[href[1..-1]]
+      element = document.elements_by_id[href[1..]]
       element if element.name == 'text'
     end
   end
@@ -241,10 +242,9 @@ class Prawn::SVG::Elements::TextComponent < Prawn::SVG::Elements::DepthFirstBase
   end
 
   # overridden, we don't want to call fill/stroke as draw_text does this for us
-  def apply_drawing_call
-  end
+  def apply_drawing_call; end
 
   def normalize_length(length)
-    x_pixels(length) if length && length.match(/\d/)
+    x_pixels(length) if length&.match(/\d/)
   end
 end