chunky_png 1.3.8 → 1.4.0

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

data/spec/chunky_png/canvas/masking_spec.rb

@@ -1,41 +1,40 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Masking do
-
-  subject { reference_canvas('clock') }
+  subject { reference_canvas("clock") }
 
   before(:all) do
-    @theme_color      = ChunkyPNG::Color('#e10f7a')
-    @new_color        = ChunkyPNG::Color('#ff0000')
-    @background_color = ChunkyPNG::Color('white')
+    @theme_color      = ChunkyPNG::Color("#e10f7a")
+    @new_color        = ChunkyPNG::Color("#ff0000")
+    @background_color = ChunkyPNG::Color("white")
   end
 
-  describe '#change_theme_color!' do
+  describe "#change_theme_color!" do
     it "should change the theme color correctly" do
       subject.change_theme_color!(@theme_color, @new_color)
-      expect(subject).to eql reference_canvas('clock_updated')
+      expect(subject).to eql reference_canvas("clock_updated")
     end
   end
 
-  describe '#extract_mask' do
+  describe "#extract_mask" do
     it "should create the correct base and mask image" do
       base, mask = subject.extract_mask(@theme_color, @background_color)
-      expect(base).to eql reference_canvas('clock_base')
-      expect(mask).to eql reference_canvas('clock_mask')
+      expect(base).to eql reference_canvas("clock_base")
+      expect(mask).to eql reference_canvas("clock_mask")
     end
 
     it "should create a mask image with only one opaque color" do
-      base, mask = subject.extract_mask(@theme_color, @background_color)
+      _, mask = subject.extract_mask(@theme_color, @background_color)
       expect(mask.palette.opaque_palette.size).to eql 1
     end
   end
 
-  describe '#change_mask_color!' do
-    before { @mask = reference_canvas('clock_mask') }
+  describe "#change_mask_color!" do
+    before { @mask = reference_canvas("clock_mask") }
 
     it "should replace the mask color correctly" do
       @mask.change_mask_color!(@new_color)
-      expect(@mask).to eql reference_canvas('clock_mask_updated')
+      expect(@mask).to eql reference_canvas("clock_mask_updated")
     end
 
     it "should still only have one opaque color" do
@@ -44,7 +43,7 @@ describe ChunkyPNG::Canvas::Masking do
     end
 
     it "should raise an exception when the mask image has more than once color" do
-      not_a_mask = reference_canvas('operations')
+      not_a_mask = reference_canvas("operations")
       expect { not_a_mask.change_mask_color!(@new_color) }.to raise_error(ChunkyPNG::ExpectationFailed)
     end
   end

data/spec/chunky_png/canvas/operations_spec.rb

@@ -1,16 +1,15 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Canvas::Operations do
+  subject { reference_canvas("operations") }
 
-  subject { reference_canvas('operations') }
-
-  describe '#grayscale' do
+  describe "#grayscale" do
     it "should not return itself" do
       subject.grayscale.should_not equal(subject)
     end
 
     it "should convert the image correctly" do
-      expect(subject.grayscale).to eql reference_canvas('operations_grayscale')
+      expect(subject.grayscale).to eql reference_canvas("operations_grayscale")
     end
 
     it "should not adjust the current image" do
@@ -18,20 +17,20 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#grayscale!' do
+  describe "#grayscale!" do
     it "should return itself" do
       expect(subject.grayscale!).to equal(subject)
     end
 
     it "should convert the image correctly" do
       subject.grayscale!
-      expect(subject).to eql reference_canvas('operations_grayscale')
+      expect(subject).to eql reference_canvas("operations_grayscale")
     end
   end
 
-  describe '#crop' do
+  describe "#crop" do
     it "should crop the right pixels from the original canvas" do
-      expect(subject.crop(10, 5, 4, 8)).to eql reference_canvas('cropped')
+      expect(subject.crop(10, 5, 4, 8)).to eql reference_canvas("cropped")
     end
 
     it "should not return itself" do
@@ -47,18 +46,19 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#crop!' do
-    context 'when cropping both width and height' do
+  describe "#crop!" do
+    context "when cropping both width and height" do
       let(:crop_opts) { [10, 5, 4, 8] }
 
       it "should crop the right pixels from the original canvas" do
         subject.crop!(*crop_opts)
-        expect(subject).to eql reference_canvas('cropped')
+        expect(subject).to eql reference_canvas("cropped")
       end
 
       it "should have a new width and height" do
-        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }.
-            from(ChunkyPNG::Dimension('16x16')).to(ChunkyPNG::Dimension('4x8'))
+        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }
+          .from(ChunkyPNG::Dimension("16x16"))
+          .to(ChunkyPNG::Dimension("4x8"))
       end
 
       it "should return itself" do
@@ -71,12 +71,13 @@ describe ChunkyPNG::Canvas::Operations do
 
       it "should crop the right pixels from the original canvas" do
         subject.crop!(*crop_opts)
-        expect(subject).to eql reference_canvas('cropped_height')
+        expect(subject).to eql reference_canvas("cropped_height")
       end
 
       it "should have a new width and height" do
-        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }.
-            from(ChunkyPNG::Dimension('16x16')).to(ChunkyPNG::Dimension('16x8'))
+        expect { subject.crop!(*crop_opts) }.to change { subject.dimension }
+          .from(ChunkyPNG::Dimension("16x16"))
+          .to(ChunkyPNG::Dimension("16x8"))
       end
 
       it "should return itself" do
@@ -91,91 +92,90 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#compose' do
+  describe "#compose" do
     it "should compose pixels correctly" do
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
-      expect(subject.compose(subcanvas, 8, 4)).to eql reference_canvas('composited')
+      expect(subject.compose(subcanvas, 8, 4)).to eql reference_canvas("composited")
     end
 
     it "should leave the original intact" do
-      subject.compose(ChunkyPNG::Canvas.new(1,1))
-      expect(subject).to eql reference_canvas('operations')
+      subject.compose(ChunkyPNG::Canvas.new(1, 1))
+      expect(subject).to eql reference_canvas("operations")
     end
 
     it "should not return itself" do
-      subject.compose(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+      subject.compose(ChunkyPNG::Canvas.new(1, 1)).should_not equal(subject)
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
-      expect { subject.compose(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#compose!' do
+  describe "#compose!" do
     it "should compose pixels correctly" do
       subcanvas = ChunkyPNG::Canvas.new(4, 8, ChunkyPNG::Color.rgba(0, 0, 0, 75))
       subject.compose!(subcanvas, 8, 4)
-      expect(subject).to eql reference_canvas('composited')
+      expect(subject).to eql reference_canvas("composited")
     end
 
     it "should return itself" do
-      expect(subject.compose!(ChunkyPNG::Canvas.new(1,1))).to equal(subject)
+      expect(subject.compose!(ChunkyPNG::Canvas.new(1, 1))).to equal(subject)
     end
 
     it "should compose a base image and mask correctly" do
-      base = reference_canvas('clock_base')
-      mask = reference_canvas('clock_mask_updated')
+      base = reference_canvas("clock_base")
+      mask = reference_canvas("clock_mask_updated")
       base.compose!(mask)
-      expect(base).to eql reference_canvas('clock_updated')
+      expect(base).to eql reference_canvas("clock_updated")
     end
 
     it "should raise an exception when the pixels to compose fall outside the image" do
-      expect { subject.compose!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.compose!(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#replace' do
+  describe "#replace" do
     it "should replace the correct pixels" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
-      expect(subject.replace(subcanvas, 5, 4)).to eql reference_canvas('replaced')
+      expect(subject.replace(subcanvas, 5, 4)).to eql reference_canvas("replaced")
     end
 
     it "should not return itself" do
-      subject.replace(ChunkyPNG::Canvas.new(1,1)).should_not equal(subject)
+      subject.replace(ChunkyPNG::Canvas.new(1, 1)).should_not equal(subject)
     end
 
     it "should leave the original intact" do
-      subject.replace(ChunkyPNG::Canvas.new(1,1))
-      expect(subject).to eql reference_canvas('operations')
+      subject.replace(ChunkyPNG::Canvas.new(1, 1))
+      expect(subject).to eql reference_canvas("operations")
     end
 
     it "should raise an exception when the pixels to replace fall outside the image" do
-      expect { subject.replace(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 
-  describe '#replace!' do
+  describe "#replace!" do
     it "should replace the correct pixels" do
       subcanvas = ChunkyPNG::Canvas.new(3, 2, ChunkyPNG::Color.rgb(200, 255, 0))
       subject.replace!(subcanvas, 5, 4)
-      expect(subject).to eql reference_canvas('replaced')
+      expect(subject).to eql reference_canvas("replaced")
     end
 
     it "should return itself" do
-      expect(subject.replace!(ChunkyPNG::Canvas.new(1,1))).to equal(subject)
+      expect(subject.replace!(ChunkyPNG::Canvas.new(1, 1))).to equal(subject)
     end
 
     it "should raise an exception when the pixels to replace fall outside the image" do
-      expect { subject.replace!(ChunkyPNG::Canvas.new(1,1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
+      expect { subject.replace!(ChunkyPNG::Canvas.new(1, 1), 16, 16) }.to raise_error(ChunkyPNG::OutOfBounds)
     end
   end
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(2, 3, [1, 2, 3, 4, 5, 6]) }
 
-  describe '#flip_horizontally!' do
+  describe "#flip_horizontally!" do
     it "should flip the pixels horizontally in place" do
       subject.flip_horizontally!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
@@ -186,7 +186,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_horizontally' do
+  describe "#flip_horizontally" do
     it "should flip the pixels horizontally" do
       expect(subject.flip_horizontally).to eql ChunkyPNG::Canvas.new(2, 3, [5, 6, 3, 4, 1, 2])
     end
@@ -200,7 +200,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_vertically!' do
+  describe "#flip_vertically!" do
     it "should flip the pixels vertically" do
       subject.flip_vertically!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
@@ -211,7 +211,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#flip_vertically' do
+  describe "#flip_vertically" do
     it "should flip the pixels vertically" do
       expect(subject.flip_vertically).to eql ChunkyPNG::Canvas.new(2, 3, [2, 1, 4, 3, 6, 5])
     end
@@ -225,9 +225,9 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_left' do
+  describe "#rotate_left" do
     it "should rotate the pixels 90 degrees counter-clockwise" do
-      expect(subject.rotate_left).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+      expect(subject.rotate_left).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5])
     end
 
     it "should not return itself" do
@@ -251,10 +251,10 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_left!' do
+  describe "#rotate_left!" do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_left!
-      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5] )
+      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [2, 4, 6, 1, 3, 5])
     end
 
     it "should return itself" do
@@ -262,14 +262,14 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.rotate_left! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+      expect { subject.rotate_left! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("2x3")).to(ChunkyPNG::Dimension("3x2"))
     end
   end
 
-  describe '#rotate_right' do
+  describe "#rotate_right" do
     it "should rotate the pixels 90 degrees clockwise" do
-      expect(subject.rotate_right).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+      expect(subject.rotate_right).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2])
     end
 
     it "should not return itself" do
@@ -293,10 +293,10 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_right!' do
+  describe "#rotate_right!" do
     it "should rotate the pixels 90 degrees clockwise" do
       subject.rotate_right!
-      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2] )
+      expect(subject).to eql ChunkyPNG::Canvas.new(3, 2, [5, 3, 1, 6, 4, 2])
     end
 
     it "should return itself" do
@@ -304,12 +304,13 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.rotate_right! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('2x3')).to(ChunkyPNG::Dimension('3x2'))
+      expect { subject.rotate_right! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("2x3"))
+        .to(ChunkyPNG::Dimension("3x2"))
     end
   end
 
-  describe '#rotate_180' do
+  describe "#rotate_180" do
     it "should rotate the pixels 180 degrees" do
       expect(subject.rotate_180).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
     end
@@ -323,7 +324,7 @@ describe ChunkyPNG::Canvas::Operations do
     end
   end
 
-  describe '#rotate_180!' do
+  describe "#rotate_180!" do
     it "should rotate the pixels 180 degrees" do
       subject.rotate_180!
       expect(subject).to eql ChunkyPNG::Canvas.new(2, 3, [6, 5, 4, 3, 2, 1])
@@ -336,7 +337,6 @@ describe ChunkyPNG::Canvas::Operations do
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(4, 4).rect(1, 1, 2, 2, 255, 255) }
 
   describe "#trim" do
@@ -368,19 +368,19 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.trim! }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('2x2'))
+      expect { subject.trim! }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("4x4"))
+        .to(ChunkyPNG::Dimension("2x2"))
     end
   end
 end
 
 describe ChunkyPNG::Canvas::Operations do
-
   subject { ChunkyPNG::Canvas.new(4, 4) }
 
   describe "#border" do
     it "should add the border" do
-      expect(subject.border(2)).to eql reference_canvas('operations_border')
+      expect(subject.border(2)).to eql reference_canvas("operations_border")
     end
 
     it "should not return itself" do
@@ -395,7 +395,7 @@ describe ChunkyPNG::Canvas::Operations do
   describe "#border!" do
     it "should add the border" do
       subject.border!(2)
-      expect(subject).to eql reference_canvas('operations_border')
+      expect(subject).to eql reference_canvas("operations_border")
     end
 
     it "should return itself" do
@@ -408,8 +408,9 @@ describe ChunkyPNG::Canvas::Operations do
     end
 
     it "should change the image dimensions" do
-      expect { subject.border!(1) }.to change { subject.dimension }.
-          from(ChunkyPNG::Dimension('4x4')).to(ChunkyPNG::Dimension('6x6'))
+      expect { subject.border!(1) }.to change { subject.dimension }
+        .from(ChunkyPNG::Dimension("4x4"))
+        .to(ChunkyPNG::Dimension("6x6"))
     end
   end
 end