chunky_png 1.3.8 → 1.4.0

data/spec/chunky_png/color_spec.rb

@@ -1,22 +1,22 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe 'ChunyPNG.Color' do
-  it 'should interpret 4 arguments as RGBA values' do
+describe "ChunyPNG.Color" do
+  it "should interpret 4 arguments as RGBA values" do
     expect(ChunkyPNG::Color(1, 2, 3, 4)).to eql ChunkyPNG::Color.rgba(1, 2, 3, 4)
   end
 
-  it 'should interpret 3 arguments as RGBA values' do
+  it "should interpret 3 arguments as RGBA values" do
     expect(ChunkyPNG::Color(1, 2, 3)).to eql ChunkyPNG::Color.rgb(1, 2, 3)
   end
 
-  it 'should interpret 2 arguments as a color to parse and an opacity value' do
-    expect(ChunkyPNG::Color('0x0a649664', 0xaa)).to eql 0x0a6496aa
-    expect(ChunkyPNG::Color('spring green @ 0.6666', 0xff)).to eql 0x00ff7fff
+  it "should interpret 2 arguments as a color to parse and an opacity value" do
+    expect(ChunkyPNG::Color("0x0a649664", 0xaa)).to eql 0x0a6496aa
+    expect(ChunkyPNG::Color("spring green @ 0.6666", 0xff)).to eql 0x00ff7fff
   end
 
-  it 'should interpret 1 argument as a color to parse' do
-    expect(ChunkyPNG::Color).to receive(:parse).with('0x0a649664')
-    ChunkyPNG::Color('0x0a649664')
+  it "should interpret 1 argument as a color to parse" do
+    expect(ChunkyPNG::Color).to receive(:parse).with("0x0a649664")
+    ChunkyPNG::Color("0x0a649664")
   end
 end
 
@@ -34,85 +34,87 @@ describe ChunkyPNG::Color do
     @blue              = 0x0000ffff
   end
 
-  describe '#parse' do
-    it 'should interpret a hex string correctly' do
-      expect(parse('0x0a649664')).to eql ChunkyPNG::Color.from_hex('#0a649664')
+  describe "#parse" do
+    it "should interpret a hex string correctly" do
+      expect(parse("0x0a649664")).to eql ChunkyPNG::Color.from_hex("#0a649664")
     end
 
-    it 'should interpret a color name correctly' do
+    it "should interpret a color name correctly" do
       expect(parse(:spring_green)).to eql 0x00ff7fff
-      expect(parse('spring green')).to eql 0x00ff7fff
-      expect(parse('spring green @ 0.6666')).to eql 0x00ff7faa
+      expect(parse("spring green")).to eql 0x00ff7fff
+      expect(parse("spring green @ 0.6666")).to eql 0x00ff7faa
     end
 
-    it 'should return numbers as is' do
-      expect(parse('12345')).to eql 12345
+    it "should return numbers as is" do
+      expect(parse("12345")).to eql 12345
       expect(parse(12345)).to eql 12345
     end
   end
 
-  describe '#pixel_bytesize' do
-    it 'should return the normal amount of bytes with a bit depth of 8' do
+  describe "#pixel_bytesize" do
+    it "should return the normal amount of bytes with a bit depth of 8" do
       expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8)).to eql 3
     end
 
-    it 'should return a multiple of the normal amount of bytes with a bit depth greater than 8' do
+    it "should return a multiple of the normal amount of bytes with a bit depth greater than 8" do
       expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 16)).to eql 6
       expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 16)).to eql 8
       expect(pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 16)).to eql 4
     end
 
-    it 'should return 1 with a bit depth lower than 0' do
+    it "should return 1 with a bit depth lower than 0" do
       expect(pixel_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 4)).to eql 1
       expect(pixel_bytesize(ChunkyPNG::COLOR_INDEXED, 2)).to eql 1
       expect(pixel_bytesize(ChunkyPNG::COLOR_GRAYSCALE_ALPHA, 1)).to eql 1
     end
   end
 
-  describe '#pass_bytesize' do
-    it 'should calculate a pass size correctly' do
+  describe "#pass_bytesize" do
+    it "should calculate a pass size correctly" do
       expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 10)).to eql 310
     end
 
-    it 'should return 0 if one of the dimensions is zero' do
+    it "should return 0 if one of the dimensions is zero" do
       expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 0, 10)).to eql 0
       expect(pass_bytesize(ChunkyPNG::COLOR_TRUECOLOR, 8, 10, 0)).to eql 0
     end
   end
 
-  describe '#rgba' do
-    it 'should represent pixels as the correct number' do
+  describe "#rgba" do
+    it "should represent pixels as the correct number" do
+      # rubocop:disable Layout/ExtraSpacing, Layout/SpaceInsideParens
       expect(rgba(255, 255, 255, 255)).to eql @white
       expect(rgba(  0,   0,   0, 255)).to eql @black
       expect(rgba( 10, 100, 150, 255)).to eql @opaque
       expect(rgba( 10, 100, 150, 100)).to eql @non_opaque
       expect(rgba( 10, 100, 150,   0)).to eql @fully_transparent
+      # rubocop:enable Layout/ExtraSpacing, Layout/SpaceInsideParens
     end
   end
 
-  describe '#from_hex' do
-    it 'should load colors correctly from hex notation' do
-      expect(from_hex('0a649664')).to   eql @non_opaque
-      expect(from_hex('#0a649664')).to  eql @non_opaque
-      expect(from_hex('0x0a649664')).to eql @non_opaque
-      expect(from_hex('0a6496')).to     eql @opaque
-      expect(from_hex('#0a6496')).to    eql @opaque
-      expect(from_hex('0x0a6496')).to   eql @opaque
-      expect(from_hex('abc')).to        eql 0xaabbccff
-      expect(from_hex('#abc')).to       eql 0xaabbccff
-      expect(from_hex('0xabc')).to      eql 0xaabbccff
-    end
-
-    it 'should allow setting opacity explicitly' do
-      expect(from_hex('0x0a6496', 0x64)).to eql @non_opaque
-      expect(from_hex('#0a6496', 0x64)).to  eql @non_opaque
-      expect(from_hex('0xabc', 0xdd)).to    eql 0xaabbccdd
-      expect(from_hex('#abc', 0xdd)).to     eql 0xaabbccdd
+  describe "#from_hex" do
+    it "should load colors correctly from hex notation" do
+      expect(from_hex("0a649664")).to   eql @non_opaque
+      expect(from_hex("#0a649664")).to  eql @non_opaque
+      expect(from_hex("0x0a649664")).to eql @non_opaque
+      expect(from_hex("0a6496")).to     eql @opaque
+      expect(from_hex("#0a6496")).to    eql @opaque
+      expect(from_hex("0x0a6496")).to   eql @opaque
+      expect(from_hex("abc")).to        eql 0xaabbccff
+      expect(from_hex("#abc")).to       eql 0xaabbccff
+      expect(from_hex("0xabc")).to      eql 0xaabbccff
+    end
+
+    it "should allow setting opacity explicitly" do
+      expect(from_hex("0x0a6496", 0x64)).to eql @non_opaque
+      expect(from_hex("#0a6496", 0x64)).to  eql @non_opaque
+      expect(from_hex("0xabc", 0xdd)).to    eql 0xaabbccdd
+      expect(from_hex("#abc", 0xdd)).to     eql 0xaabbccdd
     end
   end
 
-  describe '#from_hsv' do
-    it 'should load colors correctly from an HSV triple' do
+  describe "#from_hsv" do
+    it "should load colors correctly from an HSV triple" do
       # At 0 brightness, should be @black independent of hue or sat
       expect(from_hsv(0, 0, 0)).to        eql @black
       expect(from_hsv(100, 1, 0)).to      eql @black
@@ -135,7 +137,7 @@ describe ChunkyPNG::Color do
       expect(from_hsv(0, 0.5, 0.5)).to eql from_hsv(360.0, 0.5, 0.5)
     end
 
-    it 'should optionally accept a fourth param for alpha' do
+    it "should optionally accept a fourth param for alpha" do
       expect(from_hsv(0, 1, 1, 255)).to   eql @red
       expect(from_hsv(120, 1, 1, 255)).to eql @green
       expect(from_hsv(240, 1, 1, 255)).to eql @blue
@@ -145,8 +147,8 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe '#from_hsl' do
-    it 'should load colors correctly from an HSL triple' do
+  describe "#from_hsl" do
+    it "should load colors correctly from an HSL triple" do
       # At 0 lightness, should always be black
       expect(from_hsl(0, 0, 0)).to         eql @black
       expect(from_hsl(100, 0, 0)).to       eql @black
@@ -163,16 +165,16 @@ describe ChunkyPNG::Color do
       expect(from_hsl(240, 1, 0.5)).to     eql @blue
 
       # Random colors
-      from_hsl(87.27, 0.5, 0.5686)     == 0x96c85aff
-      from_hsl(271.83, 0.5399, 0.4176) == 0x6e31a4ff
-      from_hsl(63.6, 0.5984, 0.4882)   == 0xbec732ff
+      expect(from_hsl(87.27, 0.5, 0.5686)).to     eql 0x95c759ff
+      expect(from_hsl(271.83, 0.5399, 0.4176)).to eql 0x6d30a3ff
+      expect(from_hsl(63.6, 0.5984, 0.4882)).to   eql 0xbec631ff
 
       # Hue 0 and hue 360 should be equivalent
       expect(from_hsl(0, 0.5, 0.5)).to eql from_hsl(360, 0.5, 0.5)
       expect(from_hsl(0, 0.5, 0.5)).to eql from_hsl(360.0, 0.5, 0.5)
     end
 
-    it 'should optionally accept a fourth param for alpha' do
+    it "should optionally accept a fourth param for alpha" do
       expect(from_hsl(0, 1, 0.5, 255)).to   eql @red
       expect(from_hsl(120, 1, 0.5, 255)).to eql @green
       expect(from_hsl(240, 1, 0.5, 255)).to eql @blue
@@ -182,35 +184,35 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe '#html_color' do
-    it 'should find the correct color value' do
+  describe "#html_color" do
+    it "should find the correct color value" do
       expect(html_color(:springgreen)).to   eql 0x00ff7fff
       expect(html_color(:spring_green)).to  eql 0x00ff7fff
-      expect(html_color('springgreen')).to  eql 0x00ff7fff
-      expect(html_color('spring green')).to eql 0x00ff7fff
-      expect(html_color('SpringGreen')).to  eql 0x00ff7fff
-      expect(html_color('SPRING_GREEN')).to eql 0x00ff7fff
+      expect(html_color("springgreen")).to  eql 0x00ff7fff
+      expect(html_color("spring green")).to eql 0x00ff7fff
+      expect(html_color("SpringGreen")).to  eql 0x00ff7fff
+      expect(html_color("SPRING_GREEN")).to eql 0x00ff7fff
     end
 
-    it 'should set the opacity level explicitly' do
+    it "should set the opacity level explicitly" do
       expect(html_color(:springgreen, 0xff)).to eql 0x00ff7fff
       expect(html_color(:springgreen, 0xaa)).to eql 0x00ff7faa
       expect(html_color(:springgreen, 0x00)).to eql 0x00ff7f00
     end
 
-    it 'should set opacity levels from the color name' do
-      expect(html_color('Spring green @ 1.0')).to   eql 0x00ff7fff
-      expect(html_color('Spring green @ 0.666')).to eql 0x00ff7faa
-      expect(html_color('Spring green @ 0.0')).to   eql 0x00ff7f00
+    it "should set opacity levels from the color name" do
+      expect(html_color("Spring green @ 1.0")).to   eql 0x00ff7fff
+      expect(html_color("Spring green @ 0.666")).to eql 0x00ff7faa
+      expect(html_color("Spring green @ 0.0")).to   eql 0x00ff7f00
     end
 
-    it 'should raise for an unkown color name' do
+    it "should raise for an unkown color name" do
       expect { html_color(:nonsense) }.to raise_error(ArgumentError)
     end
   end
 
-  describe '#opaque?' do
-    it 'should correctly check for opaqueness' do
+  describe "#opaque?" do
+    it "should correctly check for opaqueness" do
       expect(opaque?(@white)).to eql true
       expect(opaque?(@black)).to eql true
       expect(opaque?(@opaque)).to eql true
@@ -219,8 +221,8 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe 'extraction of separate color channels' do
-    it 'should extract components from a color correctly' do
+  describe "extraction of separate color channels" do
+    it "should extract components from a color correctly" do
       expect(r(@opaque)).to eql 10
       expect(g(@opaque)).to eql 100
       expect(b(@opaque)).to eql 150
@@ -228,47 +230,47 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe '#grayscale_teint' do
-    it 'should calculate the correct grayscale teint' do
+  describe "#grayscale_teint" do
+    it "should calculate the correct grayscale teint" do
       expect(grayscale_teint(@opaque)).to     eql 79
       expect(grayscale_teint(@non_opaque)).to eql 79
     end
   end
 
-  describe '#to_grayscale' do
-    it 'should use the grayscale teint for r, g and b' do
+  describe "#to_grayscale" do
+    it "should use the grayscale teint for r, g and b" do
       gs = to_grayscale(@non_opaque)
       expect(r(gs)).to eql grayscale_teint(@non_opaque)
       expect(g(gs)).to eql grayscale_teint(@non_opaque)
       expect(b(gs)).to eql grayscale_teint(@non_opaque)
     end
 
-    it 'should preserve the alpha channel' do
+    it "should preserve the alpha channel" do
       expect(a(to_grayscale(@non_opaque))).to eql a(@non_opaque)
       expect(a(to_grayscale(@opaque))).to eql ChunkyPNG::Color::MAX
     end
   end
 
-  describe '#to_hex' do
-    it 'should represent colors correcly using hex notation' do
-      expect(to_hex(@white)).to eql '#ffffffff'
-      expect(to_hex(@black)).to eql '#000000ff'
-      expect(to_hex(@opaque)).to eql '#0a6496ff'
-      expect(to_hex(@non_opaque)).to eql '#0a649664'
-      expect(to_hex(@fully_transparent)).to eql '#0a649600'
+  describe "#to_hex" do
+    it "should represent colors correcly using hex notation" do
+      expect(to_hex(@white)).to eql "#ffffffff"
+      expect(to_hex(@black)).to eql "#000000ff"
+      expect(to_hex(@opaque)).to eql "#0a6496ff"
+      expect(to_hex(@non_opaque)).to eql "#0a649664"
+      expect(to_hex(@fully_transparent)).to eql "#0a649600"
     end
 
-    it 'should represent colors correcly using hex notation without alpha channel' do
-      expect(to_hex(@white, false)).to eql '#ffffff'
-      expect(to_hex(@black, false)).to eql '#000000'
-      expect(to_hex(@opaque, false)).to eql '#0a6496'
-      expect(to_hex(@non_opaque, false)).to eql '#0a6496'
-      expect(to_hex(@fully_transparent, false)).to eql '#0a6496'
+    it "should represent colors correcly using hex notation without alpha channel" do
+      expect(to_hex(@white, false)).to eql "#ffffff"
+      expect(to_hex(@black, false)).to eql "#000000"
+      expect(to_hex(@opaque, false)).to eql "#0a6496"
+      expect(to_hex(@non_opaque, false)).to eql "#0a6496"
+      expect(to_hex(@fully_transparent, false)).to eql "#0a6496"
     end
   end
 
-  describe '#to_hsv' do
-    it 'should return a [hue, saturation, value] array' do
+  describe "#to_hsv" do
+    it "should return a [hue, saturation, value] array" do
       expect(to_hsv(@white)).to     eql [0,   0.0, 1.0]
       expect(to_hsv(@black)).to     eql [0,   0.0, 0.0]
       expect(to_hsv(@red)).to       eql [0,   1.0, 1.0]
@@ -279,7 +281,7 @@ describe ChunkyPNG::Color do
       expect(to_hsv(0x805440ff)[2]).to be_within(0.01).of(0.5)
     end
 
-    it 'should optionally include the alpha channel' do
+    it "should optionally include the alpha channel" do
       expect(to_hsv(@white, true)).to                eql [0,   0.0, 1.0, 255]
       expect(to_hsv(@red, true)).to                  eql [0,   1.0, 1.0, 255]
       expect(to_hsv(@blue, true)).to                 eql [240, 1.0, 1.0, 255]
@@ -289,8 +291,8 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe '#to_hsl' do
-    it 'should return a [hue, saturation, lightness] array' do
+  describe "#to_hsl" do
+    it "should return a [hue, saturation, lightness] array" do
       expect(to_hsl(@white)).to eql [0,   0.0, 1.0]
       expect(to_hsl(@black)).to eql [0,   0.0, 0.0]
       expect(to_hsl(@red)).to   eql [0,   1.0, 0.5]
@@ -298,7 +300,7 @@ describe ChunkyPNG::Color do
       expect(to_hsl(@green)).to eql [120, 1.0, 0.5]
     end
 
-    it 'should optionally include the alpha channel in the returned array' do
+    it "should optionally include the alpha channel in the returned array" do
       expect(to_hsl(@white, true)).to          eql [0,   0.0, 1.0, 255]
       expect(to_hsl(@black, true)).to          eql [0,   0.0, 0.0, 255]
       expect(to_hsl(@red, true)).to            eql [0,   1.0, 0.5, 255]
@@ -309,79 +311,78 @@ describe ChunkyPNG::Color do
     end
   end
 
-  describe 'conversion to other formats' do
-    it 'should convert the individual color values back correctly' do
+  describe "conversion to other formats" do
+    it "should convert the individual color values back correctly" do
       expect(to_truecolor_bytes(@opaque)).to eql [10, 100, 150]
       expect(to_truecolor_alpha_bytes(@non_opaque)).to eql [10, 100, 150, 100]
     end
   end
 
-  describe '#compose' do
-
-    it 'should use the foregorund color as is when the background color is fully transparent' do
+  describe "#compose" do
+    it "should use the foregorund color as is when the background color is fully transparent" do
       expect(compose(@non_opaque, @fully_transparent)).to eql @non_opaque
     end
 
-    it 'should use the foregorund color as is when an opaque color is given as foreground color' do
+    it "should use the foregorund color as is when an opaque color is given as foreground color" do
       expect(compose(@opaque, @white)).to eql @opaque
     end
 
-    it 'should use the background color as is when a fully transparent pixel is given as foreground color' do
+    it "should use the background color as is when a fully transparent pixel is given as foreground color" do
       expect(compose(@fully_transparent, @white)).to eql @white
     end
 
-    it 'should compose pixels correctly with both algorithms' do
+    it "should compose pixels correctly with both algorithms" do
       expect(compose_quick(@non_opaque, @white)).to   eql 0x9fc2d6ff
       expect(compose_precise(@non_opaque, @white)).to eql 0x9fc2d6ff
     end
   end
 
-  describe '#decompose_alpha' do
-    it 'should decompose the alpha channel correctly' do
+  describe "#decompose_alpha" do
+    it "should decompose the alpha channel correctly" do
       expect(decompose_alpha(0x9fc2d6ff, @opaque, @white)).to eql 0x00000064
     end
 
-    it 'should return fully transparent if the background channel matches the resulting color' do
+    it "should return fully transparent if the background channel matches the resulting color" do
       expect(decompose_alpha(0xabcdefff, 0xff000000, 0xabcdefff)).to eql 0x00
     end
 
-    it 'should return fully opaque if the background channel matches the mask color' do
+    it "should return fully opaque if the background channel matches the mask color" do
       expect(decompose_alpha(0xff000000, 0xabcdefff, 0xabcdefff)).to eql 0xff
     end
 
-    it 'should return fully opaque if the resulting color matches the mask color' do
+    it "should return fully opaque if the resulting color matches the mask color" do
       expect(decompose_alpha(0xabcdefff, 0xabcdefff, 0xffffffff)).to eql 255
     end
   end
 
-  describe '#blend' do
-    it 'should blend colors correctly' do
+  describe "#blend" do
+    it "should blend colors correctly" do
       expect(blend(@opaque, @black)).to eql 0x05324bff
     end
 
-    it 'should not matter what color is used as foreground, and what as background' do
+    it "should not matter what color is used as foreground, and what as background" do
       expect(blend(@opaque, @black)).to eql blend(@black, @opaque)
     end
   end
 
-  describe '#euclidean_distance_rgba' do
+  describe "#euclidean_distance_rgba" do
     subject { euclidean_distance_rgba(color_a, color_b) }
 
-    context 'with white and black' do
+    context "with white and black" do
       let(:color_a) { @white }
       let(:color_b) { @black }
 
       it { should == Math.sqrt(195_075) } # sqrt(255^2 * 3)
     end
 
-    context 'with black and white' do
+    context "with black and white" do
       let(:color_a) { @black }
       let(:color_b) { @white }
 
       it { should == Math.sqrt(195_075) } # sqrt(255^2 * 3)
     end
 
-    context 'with the same colors' do
+    context "with the same colors" do
       let(:color_a) { @white }
       let(:color_b) { @white }
 

data/spec/chunky_png/datastream_spec.rb

@@ -1,15 +1,14 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Datastream do
-
-  describe '.from_io'do
+  describe ".from_io" do
     it "should raise an error when loading a file with a bad signature" do
-      filename = resource_file('damaged_signature.png')
+      filename = resource_file("damaged_signature.png")
       expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error(ChunkyPNG::SignatureMismatch)
     end
 
     it "should raise an error if the CRC of a chunk is incorrect" do
-      filename = resource_file('damaged_chunk.png')
+      filename = resource_file("damaged_chunk.png")
       expect { ChunkyPNG::Datastream.from_file(filename) }.to raise_error(ChunkyPNG::CRCMismatch)
     end
 
@@ -19,31 +18,37 @@ describe ChunkyPNG::Datastream do
     end
 
     it "should read a stream with trailing data without failing" do
-      filename = resource_file('trailing_bytes_after_iend_chunk.png')
+      filename = resource_file("trailing_bytes_after_iend_chunk.png")
       image = ChunkyPNG::Datastream.from_file(filename)
       expect(image).to be_instance_of(ChunkyPNG::Datastream)
     end
   end
 
-  describe '#metadata' do
+  describe "#metadata" do
     it "should load uncompressed tXTt chunks correctly" do
-      filename = resource_file('text_chunk.png')
+      filename = resource_file("text_chunk.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
-      expect(ds.metadata['Title']).to  eql 'My amazing icon!'
-      expect(ds.metadata['Author']).to eql "Willem van Bergen"
+      expect(ds.metadata["Title"]).to  eql "My amazing icon!"
+      expect(ds.metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should load compressed zTXt chunks correctly" do
-      filename = resource_file('ztxt_chunk.png')
+      filename = resource_file("ztxt_chunk.png")
+      ds = ChunkyPNG::Datastream.from_file(filename)
+      expect(ds.metadata["Title"]).to eql "PngSuite"
+      expect(ds.metadata["Copyright"]).to eql "Copyright Willem van Schaik, Singapore 1995-96"
+    end
+
+    it "ignores iTXt chunks" do
+      filename = resource_file("itxt_chunk.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
-      expect(ds.metadata['Title']).to eql 'PngSuite'
-      expect(ds.metadata['Copyright']).to eql "Copyright Willem van Schaik, Singapore 1995-96"
+      expect(ds.metadata).to be_empty
     end
   end
 
-  describe '#physical_chunk' do
-    it 'should read and write pHYs chunks correctly' do
-      filename = resource_file('clock.png')
+  describe "#physical_chunk" do
+    it "should read and write pHYs chunks correctly" do
+      filename = resource_file("clock.png")
       ds = ChunkyPNG::Datastream.from_file(filename)
       expect(ds.physical_chunk.unit).to eql :meters
       expect(ds.physical_chunk.dpix.round).to eql 72
@@ -52,10 +57,84 @@ describe ChunkyPNG::Datastream do
       expect(ds.physical_chunk).not_to be_nil
     end
 
-    it 'should raise ChunkyPNG::UnitsUnknown if we request dpi but the units are unknown' do
+    it "should raise ChunkyPNG::UnitsUnknown if we request dpi but the units are unknown" do
       physical_chunk = ChunkyPNG::Chunk::Physical.new(2835, 2835, :unknown)
-      expect{physical_chunk.dpix}.to raise_error(ChunkyPNG::UnitsUnknown)
-      expect{physical_chunk.dpiy}.to raise_error(ChunkyPNG::UnitsUnknown)
+      expect { physical_chunk.dpix }.to raise_error(ChunkyPNG::UnitsUnknown)
+      expect { physical_chunk.dpiy }.to raise_error(ChunkyPNG::UnitsUnknown)
+    end
+  end
+
+  describe "#iTXt_chunk" do
+    it "should read iTXt chunks correctly" do
+      filename = resource_file("itxt_chunk.png")
+      ds = ChunkyPNG::Datastream.from_file(filename)
+      int_text_chunks = ds.chunks.select { |chunk| chunk.is_a?(ChunkyPNG::Chunk::InternationalText) }
+      expect(int_text_chunks.length).to eq(2)
+
+      coach_uk = int_text_chunks.find { |chunk| chunk.language_tag == "en-gb" }
+      coach_us = int_text_chunks.find { |chunk| chunk.language_tag == "en-us" }
+      expect(coach_uk).to_not be_nil
+      expect(coach_us).to_not be_nil
+
+      expect(coach_uk.keyword).to eq("coach")
+      expect(coach_uk.text).to eq("bus with of higher standard of comfort, usually chartered or used for longer journeys")
+      expect(coach_uk.translated_keyword).to eq("bus")
+      expect(coach_uk.compressed).to eq(ChunkyPNG::UNCOMPRESSED_CONTENT)
+      expect(coach_uk.compression).to eq(ChunkyPNG::COMPRESSION_DEFAULT)
+
+      expect(coach_us.keyword).to eq("coach")
+      expect(coach_us.text).to eq("US extracurricular sports teacher at a school (UK: PE teacher) lowest class on a passenger aircraft (UK: economy)")
+      expect(coach_us.translated_keyword).to eq("trainer")
+      expect(coach_us.compressed).to eq(ChunkyPNG::COMPRESSED_CONTENT)
+      expect(coach_us.compression).to eq(ChunkyPNG::COMPRESSION_DEFAULT)
+    end
+
+    it "should write iTXt chunks correctly" do
+      expected_hex = %w[0000 001d 6954 5874 436f 6d6d 656e 7400 0000 0000 4372 6561 7465 6420 7769 7468 2047 494d 5064 2e65 07].join("")
+      stream = StringIO.new
+      itext = ChunkyPNG::Chunk::InternationalText.new("Comment", "Created with GIMP")
+      itext.write(stream)
+      generated_hex = stream.string.unpack("H*").join("")
+
+      expect(generated_hex).to eq(expected_hex)
+    end
+
+    it "should handle incorrect UTF-8 encoding in iTXt chunks" do
+      incorrect_text_encoding = [0, 0, 0, 14, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 0, 195, 40, 17, 87, 97, 213].pack("C*")
+      incorrect_translated_keyword_encoding = [0, 0, 0, 19, 105, 84, 88, 116, 67, 111, 109, 109, 101, 110, 116, 0, 0, 0, 0, 226, 130, 40, 0, 116, 101, 115, 116, 228, 53, 113, 182].pack("C*")
+
+      expect { ChunkyPNG::Chunk.read(StringIO.new(incorrect_text_encoding)) }.to raise_error(ChunkyPNG::InvalidUTF8)
+      expect { ChunkyPNG::Chunk.read(StringIO.new(incorrect_translated_keyword_encoding)) }.to raise_error(ChunkyPNG::InvalidUTF8)
+    end
+
+    it "should handle UTF-8 in iTXt compressed chunks correctly" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "✨", "", "💩", ChunkyPNG::COMPRESSED_CONTENT))
+
+      expect(parsed.text).to eq("✨")
+      expect(parsed.text.encoding).to eq(Encoding::UTF_8)
+
+      expect(parsed.translated_keyword).to eq("💩")
+      expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "should handle UTF-8 in iTXt chunks correctly" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "✨", "", "💩"))
+
+      expect(parsed.text).to eq("✨")
+      expect(parsed.text.encoding).to eq(Encoding::UTF_8)
+
+      expect(parsed.translated_keyword).to eq("💩")
+      expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
+    end
+
+    it "should transform non UTF-8 iTXt fields to UTF-8 on write" do
+      parsed = serialized_chunk(ChunkyPNG::Chunk::InternationalText.new("Comment", "®".encode("Windows-1252"), "", "ƒ".encode("Windows-1252")))
+
+      expect(parsed.text).to eq("®")
+      expect(parsed.text.encoding).to eq(Encoding::UTF_8)
+
+      expect(parsed.translated_keyword).to eq("ƒ")
+      expect(parsed.translated_keyword.encoding).to eq(Encoding::UTF_8)
     end
   end
 end

data/spec/chunky_png/dimension_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Dimension do
   subject { ChunkyPNG::Dimension.new(2, 3) }
@@ -6,31 +6,31 @@ describe ChunkyPNG::Dimension do
   it { should respond_to(:width) }
   it { should respond_to(:height) }
 
-  describe '#area' do
+  describe "#area" do
     it "should calculate the area correctly" do
       expect(subject.area).to eql 6
     end
   end
 end
 
-describe 'ChunkyPNG.Dimension' do
+describe "ChunkyPNG.Dimension" do
   subject { ChunkyPNG::Dimension.new(1, 2) }
 
   it "should create a dimension from a 2-item array" do
     expect(ChunkyPNG::Dimension([1, 2])).to     eql subject
-    expect(ChunkyPNG::Dimension(['1', '2'])).to eql subject
+    expect(ChunkyPNG::Dimension(["1", "2"])).to eql subject
   end
 
-  it "should create a dimension from a hash with x and y keys" do
-    expect(ChunkyPNG::Dimension(:width => 1, :height => 2)).to       eql subject
-    expect(ChunkyPNG::Dimension('width' => '1', 'height' => '2')).to eql subject
+  it "should create a dimension from a hash with width and height keys" do
+    expect(ChunkyPNG::Dimension(width: 1, height: 2)).to eql subject
+    expect(ChunkyPNG::Dimension("width" => "1", "height" => "2")).to eql subject
   end
 
   it "should create a dimension from a point-like string" do
     [
-      ChunkyPNG::Dimension('1,2'),
-      ChunkyPNG::Dimension('1   2'),
-      ChunkyPNG::Dimension('(1 , 2)'),
+      ChunkyPNG::Dimension("1,2"),
+      ChunkyPNG::Dimension("1   2"),
+      ChunkyPNG::Dimension("(1 , 2)"),
       ChunkyPNG::Dimension("{1x2}"),
       ChunkyPNG::Dimension("[1\t2}"),
     ].all? { |point| point == subject }