chunky_png 1.3.11 → 1.3.14

data/lib/chunky_png/rmagick.rb

@@ -1,33 +1,33 @@
-require 'rmagick'
+# frozen-string-literal: true
+
+require "rmagick"
 
 module ChunkyPNG
-  
   # Methods for importing and exporting RMagick image objects.
   #
   # By default, this module is disabled because of the dependency on RMagick.
-  # You need to include this module yourself if you want to use it. 
+  # You need to include this module yourself if you want to use it.
   #
   # @example
   #
   #    require 'rmagick'
   #    require 'chunky_png/rmagick'
-  #    
+  #
   #    canvas = ChunkyPNG::Canvas.from_file('filename.png')
   #    image = ChunkyPNG::RMagick.export(canvas)
-  #    
+  #
   #    # do something with the image using RMagick
-  #    
+  #
   #    updated_canvas = ChunkyPNG::RMagick.import(image)
   #
   module RMagick
-    
     extend self
-    
+
     # Imports an RMagick image as Canvas object.
     # @param [Magick::Image] image The image to import
     # @return [ChunkyPNG::Canvas] The canvas, constructed from the RMagick image.
     def import(image)
-      pixels = image.export_pixels_to_str(0, 0, image.columns, image.rows, 'RGBA')
+      pixels = image.export_pixels_to_str(0, 0, image.columns, image.rows, "RGBA")
       ChunkyPNG::Canvas.from_rgba_stream(image.columns, image.rows, pixels)
     end
 
@@ -36,7 +36,7 @@ module ChunkyPNG
     # @return [Magick::Image] The RMagick image constructed from the Canvas instance.
     def export(canvas)
       image = Magick::Image.new(canvas.width, canvas.height)
-      image.import_pixels(0,0, canvas.width, canvas.height, 'RGBA', canvas.pixels.pack('N*'))
+      image.import_pixels(0, 0, canvas.width, canvas.height, "RGBA", canvas.pixels.pack("N*"))
       image
     end
   end

data/lib/chunky_png/vector.rb

@@ -1,9 +1,10 @@
-module ChunkyPNG
+# frozen-string-literal: true
 
+module ChunkyPNG
   # Factory method for {ChunkyPNG::Vector} instances.
   #
   # @overload Vector(x0, y0, x1, y1, x2, y2, ...)
-  #   Creates a vector by parsing two subsequent values in the argument list 
+  #   Creates a vector by parsing two subsequent values in the argument list
   #   as x- and y-coordinate of a point.
   #   @return [ChunkyPNG::Vector] The instantiated vector.
   # @overload Vector(string)
@@ -17,27 +18,25 @@ module ChunkyPNG
   # @raise [ArgumentError] If the given arguments could not be understood as a vector.
   # @see ChunkyPNG::Vector
   def self.Vector(*args)
-    
-    return args.first if args.length == 1 && args.first.kind_of?(ChunkyPNG::Vector)
-    
+    return args.first if args.length == 1 && args.first.is_a?(ChunkyPNG::Vector)
+
     if args.length == 1 && args.first.respond_to?(:scan)
       ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_string(args.first)) # e.g. ['1,1 2,2 3,3']
     else
       ChunkyPNG::Vector.new(ChunkyPNG::Vector.multiple_from_array(args)) # e.g. [[1,1], [2,2], [3,3]] or [1,1,2,2,3,3]
     end
   end
-  
+
   # Class that represents a vector of points, i.e. a list of {ChunkyPNG::Point} instances.
   #
-  # Vectors can be created quite flexibly. See the {ChunkyPNG.Vector} factory methods for 
+  # Vectors can be created quite flexibly. See the {ChunkyPNG.Vector} factory methods for
   # more information on how to construct vectors.
   class Vector
-    
     include Enumerable
-    
+
     # @return [Array<ChunkyPNG::Point>] The array that holds all the points in this vector.
     attr_reader :points
-    
+
     # Initializes a vector based on a list of Point instances.
     #
     # You usually do not want to use this method directly, but call {ChunkyPNG.Vector} instead.
@@ -47,7 +46,7 @@ module ChunkyPNG
     def initialize(points = [])
       @points = points
     end
-    
+
     # Iterates over all the edges in this vector.
     #
     # An edge is a combination of two subsequent points in the vector. Together, they will form
@@ -63,14 +62,14 @@ module ChunkyPNG
       points.each_cons(2) { |a, b| yield(a, b) }
       yield(points.last, points.first) if close
     end
-    
+
     # Returns the point with the given indexof this vector.
     # @param [Integer] index The 0-based index of the point in this vector.
-    # @param [ChunkyPNG::Point] The point instance.
+    # @return [ChunkyPNG::Point] The point instance.
     def [](index)
       points[index]
     end
-    
+
     # Returns an enumerator that will iterate over all the edges in this vector.
     # @param (see #each_edge)
     # @return [Enumerator] The enumerator that iterates over the edges.
@@ -79,28 +78,28 @@ module ChunkyPNG
     def edges(close = true)
       to_enum(:each_edge, close)
     end
-    
+
     # Returns the number of points in this vector.
     # @return [Integer] The length of the points array.
     def length
       points.length
     end
-    
+
     # Iterates over all the points in this vector
     # @yield [ChunkyPNG::Point] The points in the correct order.
     # @return [void]
     def each(&block)
       points.each(&block)
     end
-    
+
     # Comparison between two vectors for quality.
     # @param [ChunkyPNG::Vector] other The vector to compare with.
     # @return [true, false] true if the list of points are identical
     def eql?(other)
       other.points == points
     end
-    
-    alias_method :==, :eql?
+
+    alias == eql?
 
     # Returns the range in x-coordinates for all the points in this vector.
     # @return [Range] The (inclusive) range of x-coordinates.
@@ -113,13 +112,13 @@ module ChunkyPNG
     def y_range
       Range.new(*points.map { |p| p.y }.minmax)
     end
-    
+
     # Finds the lowest x-coordinate in this vector.
     # @return [Integer] The lowest x-coordinate of all the points in the vector.
     def min_x
       x_range.first
     end
-    
+
     # Finds the highest x-coordinate in this vector.
     # @return [Integer] The highest x-coordinate of all the points in the vector.
     def max_x
@@ -131,13 +130,13 @@ module ChunkyPNG
     def min_y
       y_range.first
     end
-    
+
     # Finds the highest y-coordinate in this vector.
     # @return [Integer] The highest y-coordinate of all the points in the vector.
     def max_y
       y_range.last
     end
-    
+
     # Returns the offset from (0,0) of the minimal bounding box of all the
     # points in this vector
     # @return [ChunkyPNG::Point] A point that describes the top left corner if a
@@ -145,7 +144,7 @@ module ChunkyPNG
     def offset
       ChunkyPNG::Point.new(min_x, min_y)
     end
-    
+
     # Returns the width of the minimal bounding box of all the points in this vector.
     # @return [Integer] The x-distance between the points that are farthest from each other.
     def width
@@ -157,17 +156,17 @@ module ChunkyPNG
     def height
       1 + (max_y - min_y)
     end
-    
+
     # Returns the dimension of the minimal bounding rectangle of the points in this vector.
-    # @return [ChunkyPNG::Dimension] The dimension instance with the width and height 
+    # @return [ChunkyPNG::Dimension] The dimension instance with the width and height
     def dimension
       ChunkyPNG::Dimension.new(width, height)
     end
-    
+
     # @return [Array<ChunkyPNG::Point>] The list of points interpreted from the input array.
     def self.multiple_from_array(source)
       return [] if source.empty?
-      if source.first.kind_of?(Numeric) || source.first =~ /^\d+$/
+      if source.first.is_a?(Numeric) || source.first =~ /^\d+$/
         raise ArgumentError, "The points array is expected to have an even number of items!" if source.length % 2 != 0
 
         points = []
@@ -177,7 +176,7 @@ module ChunkyPNG
         source.map { |p| ChunkyPNG::Point(p) }
       end
     end
-    
+
     # @return [Array<ChunkyPNG::Point>] The list of points parsed from the string.
     def self.multiple_from_string(source_str)
       multiple_from_array(source_str.scan(/[\(\[\{]?(\d+)\s*[,x]?\s*(\d+)[\)\]\}]?/))

data/lib/chunky_png/version.rb

@@ -1,5 +1,7 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   # The current version of ChunkyPNG.
   # Set it and commit the change this before running rake release.
-  VERSION = "1.3.11"
+  VERSION = "1.3.14"
 end

data/spec/chunky_png/canvas/adam7_interlacing_spec.rb

@@ -1,48 +1,48 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Adam7Interlacing do
   include ChunkyPNG::Canvas::Adam7Interlacing
 
-  describe '#adam7_pass_sizes' do
+  describe "#adam7_pass_sizes" do
     it "should get the pass sizes for a 8x8 image correctly" do
       expect(adam7_pass_sizes(8, 8)).to eql [
-          [1, 1], [1, 1], [2, 1], [2, 2], [4, 2], [4, 4], [8, 4]
-        ]
+        [1, 1], [1, 1], [2, 1], [2, 2], [4, 2], [4, 4], [8, 4],
+      ]
     end
 
     it "should get the pass sizes for a 12x12 image correctly" do
       expect(adam7_pass_sizes(12, 12)).to eql [
-          [2, 2], [1, 2], [3, 1], [3, 3], [6, 3], [6, 6], [12, 6]
-        ]
+        [2, 2], [1, 2], [3, 1], [3, 3], [6, 3], [6, 6], [12, 6],
+      ]
     end
 
     it "should get the pass sizes for a 33x47 image correctly" do
       expect(adam7_pass_sizes(33, 47)).to eql [
-          [5, 6], [4, 6], [9, 6], [8, 12], [17, 12], [16, 24], [33, 23]
-        ]
+        [5, 6], [4, 6], [9, 6], [8, 12], [17, 12], [16, 24], [33, 23],
+      ]
     end
 
     it "should get the pass sizes for a 1x1 image correctly" do
       expect(adam7_pass_sizes(1, 1)).to eql [
-          [1, 1], [0, 1], [1, 0], [0, 1], [1, 0], [0, 1], [1, 0]
-        ]
+        [1, 1], [0, 1], [1, 0], [0, 1], [1, 0], [0, 1], [1, 0],
+      ]
     end
 
     it "should get the pass sizes for a 0x0 image correctly" do
       expect(adam7_pass_sizes(0, 0)).to eql [
-          [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
-        ]
+        [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0],
+      ]
     end
 
     it "should always maintain the same amount of pixels in total" do
       [[8, 8], [12, 12], [33, 47], [1, 1], [0, 0]].each do |(width, height)|
         pass_sizes = adam7_pass_sizes(width, height)
-        expect(pass_sizes.inject(0) { |sum, (w, h)| sum + (w*h) }).to eql width * height
+        expect(pass_sizes.inject(0) { |sum, (w, h)| sum + (w * h) }).to eql width * height
       end
     end
   end
 
-  describe '#adam7_multiplier_offset' do
+  describe "#adam7_multiplier_offset" do
     it "should get the multiplier and offset values for pass 1 correctly" do
       expect(adam7_multiplier_offset(0)).to eql [3, 0, 3, 0]
     end
@@ -72,7 +72,7 @@ describe ChunkyPNG::Canvas::Adam7Interlacing do
     end
   end
 
-  describe '#adam7_merge_pass' do
+  describe "#adam7_merge_pass" do
     it "should merge the submatrices correctly" do
       submatrices = [
         ChunkyPNG::Canvas.new(1, 1,  168430335), # r = 10
@@ -84,23 +84,22 @@ describe ChunkyPNG::Canvas::Adam7Interlacing do
         ChunkyPNG::Canvas.new(8, 4, 1175063295), # r = 70
       ]
 
-      canvas = ChunkyPNG::Image.new(8,8)
+      canvas = ChunkyPNG::Image.new(8, 8)
       submatrices.each_with_index { |m, pass| adam7_merge_pass(pass, canvas, m) }
-      expect(canvas).to eql reference_image('adam7')
+      expect(canvas).to eql reference_image("adam7")
     end
   end
 
-  describe '#adam7_extract_pass' do
-    before(:each) { @canvas = reference_canvas('adam7') }
+  describe "#adam7_extract_pass" do
+    before(:each) { @canvas = reference_canvas("adam7") }
 
     1.upto(7) do |pass|
       it "should extract pass #{pass} correctly" do
         sm = adam7_extract_pass(pass - 1, @canvas)
         expect(sm.pixels.length).to eql sm.width * sm.height
         expect(sm.pixels.uniq.length).to eql 1
-        expect(ChunkyPNG::Color.r(sm[0,0])).to eql pass * 10
+        expect(ChunkyPNG::Color.r(sm[0, 0])).to eql pass * 10
       end
     end
   end
-
 end

data/spec/chunky_png/canvas/data_url_exporting_spec.rb

@@ -1,11 +1,14 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas do
-
-  describe '#to_data_url' do
+  describe "#to_data_url" do
     it "should export a sample canvas to an RGBA stream correctly" do
-      canvas = ChunkyPNG::Canvas.new(2, 2, [ChunkyPNG::Color.rgba(1,2,3,4), ChunkyPNG::Color.rgba(5,6,7,8),
-                                            ChunkyPNG::Color.rgba(4,3,2,1), ChunkyPNG::Color.rgba(8,7,6,5)])
+      canvas = ChunkyPNG::Canvas.new(2, 2, [
+        ChunkyPNG::Color.rgba(1, 2, 3, 4),
+        ChunkyPNG::Color.rgba(5, 6, 7, 8),
+        ChunkyPNG::Color.rgba(4, 3, 2, 1),
+        ChunkyPNG::Color.rgba(8, 7, 6, 5),
+      ])
 
       expect(canvas.to_data_url).to eql "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAACAgMAAAAP2OW3AAAADFBMVEUBAgMEAwIFBgcIBwazgAAdAAAABHRSTlMEAQgFhYDlfQAAAAxJREFUeJxjUmAKAAAAwAB1GNhIEwAAAABJRU5ErkJggg=="
     end

data/spec/chunky_png/canvas/data_url_importing_spec.rb

@@ -1,15 +1,14 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas do
-
-  describe '.from_data_url' do
+  describe ".from_data_url" do
     it "should import an image from a data URL" do
-      data_url = reference_canvas('operations').to_data_url
-      expect(ChunkyPNG::Canvas.from_data_url(data_url)).to eql reference_canvas('operations')
+      data_url = reference_canvas("operations").to_data_url
+      expect(ChunkyPNG::Canvas.from_data_url(data_url)).to eql reference_canvas("operations")
     end
 
     it "should raise an exception if the string is not a proper data URL" do
-      expect { ChunkyPNG::Canvas.from_data_url('whatever') }.to raise_error(ChunkyPNG::SignatureMismatch)
+      expect { ChunkyPNG::Canvas.from_data_url("whatever") }.to raise_error(ChunkyPNG::SignatureMismatch)
     end
   end
 end

data/spec/chunky_png/canvas/drawing_spec.rb

@@ -1,12 +1,11 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Drawing do
-
-  describe '#compose_pixel' do
+  describe "#compose_pixel" do
     subject { ChunkyPNG::Canvas.new(1, 1, ChunkyPNG::Color.rgb(200, 150, 100)) }
 
     it "should compose colors correctly" do
-      subject.compose_pixel(0,0, ChunkyPNG::Color(100, 150, 200, 128))
+      subject.compose_pixel(0, 0, ChunkyPNG::Color(100, 150, 200, 128))
       expect(subject[0, 0]).to eql ChunkyPNG::Color(150, 150, 150)
     end
 
@@ -20,11 +19,11 @@ describe ChunkyPNG::Canvas::Drawing do
     end
   end
 
-  describe '#line' do
+  describe "#line" do
     it "should draw lines correctly with anti-aliasing" do
-
       canvas = ChunkyPNG::Canvas.new(31, 31, ChunkyPNG::Color::WHITE)
 
+      # rubocop:disable Layout/SpaceInsideParens # for improved readability
       canvas.line( 0,  0, 30, 30, ChunkyPNG::Color::BLACK)
       canvas.line( 0, 30, 30,  0, ChunkyPNG::Color::BLACK)
       canvas.line(15, 30, 15,  0, ChunkyPNG::Color.rgba(200,   0,   0, 128))
@@ -33,13 +32,14 @@ describe ChunkyPNG::Canvas::Drawing do
       canvas.line( 0, 15, 30,  0, ChunkyPNG::Color.rgba(  0, 200,   0, 128))
       canvas.line( 0, 30, 15,  0, ChunkyPNG::Color.rgba(  0,   0, 200, 128), false)
       canvas.line(15,  0, 30, 30, ChunkyPNG::Color.rgba(  0,   0, 200, 128))
+      # rubocop:enable Layout/SpaceInsideParens
 
-      expect(canvas).to eql reference_canvas('lines')
+      expect(canvas).to eql reference_canvas("lines")
     end
 
     it "should draw partial lines if the coordinates are partially out of bounds" do
       canvas = ChunkyPNG::Canvas.new(1, 2, ChunkyPNG::Color::WHITE)
-      canvas.line(-5, -5, 0, 0, '#000000')
+      canvas.line(-5, -5, 0, 0, "#000000")
       expect(canvas.pixels).to eql [ChunkyPNG::Color::BLACK, ChunkyPNG::Color::WHITE]
     end
 
@@ -47,15 +47,23 @@ describe ChunkyPNG::Canvas::Drawing do
       canvas = ChunkyPNG::Canvas.new(16, 16, ChunkyPNG::Color::WHITE)
       expect(canvas.line(1, 1, 10, 10, :black)).to equal(canvas)
     end
+
+    it "should draw a single pixel when the start and end point are the same" do
+      canvas = ChunkyPNG::Canvas.new(5, 5, ChunkyPNG::Color::WHITE)
+      canvas.line(2, 2, 2, 2, ChunkyPNG::Color::BLACK)
+
+      non_white_pixels = canvas.pixels.count { |pixel| pixel != ChunkyPNG::Color::WHITE }
+      expect(non_white_pixels).to eql 1
+    end
   end
 
-  describe '#rect' do
-    subject { ChunkyPNG::Canvas.new(16, 16, '#ffffff') }
+  describe "#rect" do
+    subject { ChunkyPNG::Canvas.new(16, 16, "#ffffff") }
 
     it "should draw a rectangle with the correct colors" do
-      subject.rect(1, 1, 10, 10, ChunkyPNG::Color.rgba(0, 255, 0,  80), ChunkyPNG::Color.rgba(255, 0, 0, 100))
+      subject.rect(1, 1, 10, 10, ChunkyPNG::Color.rgba(0, 255, 0, 80), ChunkyPNG::Color.rgba(255, 0, 0, 100))
       subject.rect(5, 5, 14, 14, ChunkyPNG::Color.rgba(0, 0, 255, 160), ChunkyPNG::Color.rgba(255, 255, 0, 100))
-      expect(subject).to eql reference_canvas('rect')
+      expect(subject).to eql reference_canvas("rect")
     end
 
     it "should return itself to allow chaining" do
@@ -73,19 +81,19 @@ describe ChunkyPNG::Canvas::Drawing do
     end
   end
 
-  describe '#circle' do
+  describe "#circle" do
     subject { ChunkyPNG::Canvas.new(32, 32, ChunkyPNG::Color.rgba(0, 0, 255, 128)) }
 
     it "should draw circles" do
-      subject.circle(11, 11, 10, ChunkyPNG::Color('red @ 0.5'), ChunkyPNG::Color('white @ 0.2'))
-      subject.circle(21, 21, 10, ChunkyPNG::Color('green @ 0.5'))
-      expect(subject).to eql reference_canvas('circles')
+      subject.circle(11, 11, 10, ChunkyPNG::Color("red @ 0.5"), ChunkyPNG::Color("white @ 0.2"))
+      subject.circle(21, 21, 10, ChunkyPNG::Color("green @ 0.5"))
+      expect(subject).to eql reference_canvas("circles")
     end
 
     it "should draw partial circles when going of the canvas bounds" do
       subject.circle(0, 0, 10, ChunkyPNG::Color(:red))
       subject.circle(31, 16, 10, ChunkyPNG::Color(:black), ChunkyPNG::Color(:white, 0xaa))
-      expect(subject).to eql reference_canvas('partial_circles')
+      expect(subject).to eql reference_canvas("partial_circles")
     end
 
     it "should return itself to allow chaining" do
@@ -93,78 +101,78 @@ describe ChunkyPNG::Canvas::Drawing do
     end
   end
 
-  describe '#polygon' do
+  describe "#polygon" do
     subject { ChunkyPNG::Canvas.new(22, 22) }
 
     it "should draw an filled triangle when using 3 control points" do
-      subject.polygon('(2,2) (20,5) (5,20)', ChunkyPNG::Color(:black, 0xaa), ChunkyPNG::Color(:red, 0x44))
-      expect(subject).to eql reference_canvas('polygon_triangle_filled')
+      subject.polygon("(2,2) (20,5) (5,20)", ChunkyPNG::Color(:black, 0xaa), ChunkyPNG::Color(:red, 0x44))
+      expect(subject).to eql reference_canvas("polygon_triangle_filled")
     end
 
     it "should draw a unfilled polygon with 6 control points" do
-      subject.polygon('(2,2) (12, 1) (20,5) (18,18) (5,20) (1,12)', ChunkyPNG::Color(:black))
-      expect(subject).to eql reference_canvas('polygon_unfilled')
+      subject.polygon("(2,2) (12, 1) (20,5) (18,18) (5,20) (1,12)", ChunkyPNG::Color(:black))
+      expect(subject).to eql reference_canvas("polygon_unfilled")
     end
 
     it "should draw a vertically crossed filled polygon with 4 control points" do
-      subject.polygon('(2,2) (21,2) (2,21) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
-      expect(subject).to eql reference_canvas('polygon_filled_vertical')
+      subject.polygon("(2,2) (21,2) (2,21) (21,21)", ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
+      expect(subject).to eql reference_canvas("polygon_filled_vertical")
     end
 
     it "should draw a vertically crossed filled polygon with 4 control points" do
-      subject.polygon('(2,2) (2,21) (21,2) (21,21)', ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
-      expect(subject).to eql reference_canvas('polygon_filled_horizontal')
+      subject.polygon("(2,2) (2,21) (21,2) (21,21)", ChunkyPNG::Color(:black), ChunkyPNG::Color(:red))
+      expect(subject).to eql reference_canvas("polygon_filled_horizontal")
     end
 
     it "should return itself to allow chaining" do
-      expect(subject.polygon('(2,2) (20,5) (5,20)')).to equal(subject)
+      expect(subject.polygon("(2,2) (20,5) (5,20)")).to equal(subject)
     end
   end
 
-  describe '#bezier_curve' do
+  describe "#bezier_curve" do
     subject { ChunkyPNG::Canvas.new(24, 24, ChunkyPNG::Color::WHITE) }
 
     it "should draw a bezier curve starting at the first point" do
-      subject.bezier_curve('3,20 10,10, 20,20')
+      subject.bezier_curve("3,20 10,10, 20,20")
       expect(subject[3, 20]).to eql ChunkyPNG::Color::BLACK
     end
 
     it "should draw a bezier curve ending at the last point" do
-      subject.bezier_curve('3,20 10,10, 20,20')
+      subject.bezier_curve("3,20 10,10, 20,20")
       expect(subject[20, 20]).to eql ChunkyPNG::Color::BLACK
     end
 
     it "should draw a bezier curve with a color of green" do
-      subject.bezier_curve('3,20 10,10, 20,20', :green)
+      subject.bezier_curve("3,20 10,10, 20,20", :green)
       expect(subject[3, 20]).to eql ChunkyPNG::Color(:green)
     end
 
     it "should draw a three point bezier curve" do
-      expect(subject.bezier_curve('1,23 12,10 23,23')).to eql reference_canvas('bezier_three_point')
+      expect(subject.bezier_curve("1,23 12,10 23,23")).to eql reference_canvas("bezier_three_point")
     end
 
     it "should draw a three point bezier curve flipped" do
-      expect(subject.bezier_curve('1,1 12,15 23,1')).to eql reference_canvas('bezier_three_point_flipped')
+      expect(subject.bezier_curve("1,1 12,15 23,1")).to eql reference_canvas("bezier_three_point_flipped")
     end
 
     it "should draw a four point bezier curve" do
-      expect(subject.bezier_curve('1,23 1,5 22,5 22,23')).to eql reference_canvas('bezier_four_point')
+      expect(subject.bezier_curve("1,23 1,5 22,5 22,23")).to eql reference_canvas("bezier_four_point")
     end
 
     it "should draw a four point bezier curve flipped" do
-      expect(subject.bezier_curve('1,1 1,19 22,19 22,1')).to eql reference_canvas('bezier_four_point_flipped')
+      expect(subject.bezier_curve("1,1 1,19 22,19 22,1")).to eql reference_canvas("bezier_four_point_flipped")
     end
 
     it "should draw a four point bezier curve with a shape of an s" do
-      expect(subject.bezier_curve('1,23 1,5 22,23 22,5')).to eql reference_canvas('bezier_four_point_s')
+      expect(subject.bezier_curve("1,23 1,5 22,23 22,5")).to eql reference_canvas("bezier_four_point_s")
     end
 
     it "should draw a five point bezier curve" do
-      expect(subject.bezier_curve('10,23 1,10 12,5 23,10 14,23')).to eql reference_canvas('bezier_five_point')
+      expect(subject.bezier_curve("10,23 1,10 12,5 23,10 14,23")).to eql reference_canvas("bezier_five_point")
     end
 
     it "should draw a six point bezier curve" do
-      expect(subject.bezier_curve('1,23 4,15 8,20 2,2 23,15 23,1')).to eql reference_canvas('bezier_six_point')
+      expect(subject.bezier_curve("1,23 4,15 8,20 2,2 23,15 23,1")).to eql reference_canvas("bezier_six_point")
     end
   end
 end