chunky_png 1.3.7 → 1.4.0

data/spec/chunky_png/image_spec.rb

@@ -1,31 +1,28 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Image do
-  describe '#metadata' do
-
+  describe "#metadata" do
     it "should load metadata from an existing file" do
-      image = ChunkyPNG::Image.from_file(resource_file('text_chunk.png'))
-      expect(image.metadata['Title']).to  eql 'My amazing icon!'
-      expect(image.metadata['Author']).to eql 'Willem van Bergen'
+      image = ChunkyPNG::Image.from_file(resource_file("text_chunk.png"))
+      expect(image.metadata["Title"]).to  eql "My amazing icon!"
+      expect(image.metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should write metadata to the file correctly" do
-      filename = resource_file('_metadata.png')
+      filename = resource_file("_metadata.png")
 
       image = ChunkyPNG::Image.new(10, 10)
-      image.metadata['Title']  = 'My amazing icon!'
-      image.metadata['Author'] = 'Willem van Bergen'
+      image.metadata["Title"]  = "My amazing icon!"
+      image.metadata["Author"] = "Willem van Bergen"
       image.save(filename)
 
       metadata = ChunkyPNG::Datastream.from_file(filename).metadata
-      expect(metadata['Title']).to  eql 'My amazing icon!'
-      expect(metadata['Author']).to eql 'Willem van Bergen'
+      expect(metadata["Title"]).to  eql "My amazing icon!"
+      expect(metadata["Author"]).to eql "Willem van Bergen"
     end
 
     it "should load empty images correctly" do
-      expect do
-        ChunkyPNG::Image.from_file(resource_file('empty.png'))
-      end.to_not raise_error
+      expect { ChunkyPNG::Image.from_file(resource_file("empty.png")) }.to_not raise_error
     end
   end
 end

data/spec/chunky_png/point_spec.rb

@@ -1,58 +1,56 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Point do
-
   subject { ChunkyPNG::Point.new(1, 2) }
 
   it { should respond_to(:x) }
   it { should respond_to(:y) }
 
-  describe '#within_bounds?' do
+  describe "#within_bounds?" do
     it { should     be_within_bounds(2, 3)  }
-    it { should_not be_within_bounds('1x3') }
+    it { should_not be_within_bounds("1x3") }
     it { should_not be_within_bounds(2, 2) }
-    it { should_not be_within_bounds('[1 2]') }
+    it { should_not be_within_bounds("[1 2]") }
   end
 
-  describe '#<=>' do
+  describe "#<=>" do
     it "should return 0 if the coordinates are identical" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 2))).to eql 0
+      expect((subject <=> ChunkyPNG::Point.new(1, 2))).to eql(0)
     end
 
     it "should return -1 if the y coordinate is smaller than the other one" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 3))).to eql -1
-      expect((subject <=> ChunkyPNG::Point.new(0, 3))).to eql -1 # x doesn't matter
-      expect((subject <=> ChunkyPNG::Point.new(2, 3))).to eql -1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 3))).to eql(-1)
+      expect((subject <=> ChunkyPNG::Point.new(0, 3))).to eql(-1) # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 3))).to eql(-1) # x doesn't matter
     end
 
     it "should return 1 if the y coordinate is larger than the other one" do
-      expect((subject <=> ChunkyPNG::Point.new(1, 0))).to eql 1
-      expect((subject <=> ChunkyPNG::Point.new(0, 0))).to eql 1 # x doesn't matter
-      expect((subject <=> ChunkyPNG::Point.new(2, 0))).to eql 1 # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(1, 0))).to eql(1)
+      expect((subject <=> ChunkyPNG::Point.new(0, 0))).to eql(1) # x doesn't matter
+      expect((subject <=> ChunkyPNG::Point.new(2, 0))).to eql(1) # x doesn't matter
     end
 
     it "should return -1 if the x coordinate is smaller and y is the same" do
-      expect((subject <=> ChunkyPNG::Point.new(2, 2))).to eql -1
+      expect((subject <=> ChunkyPNG::Point.new(2, 2))).to eql(-1)
     end
 
     it "should return 1 if the x coordinate is larger and y is the same" do
-      expect((subject <=> ChunkyPNG::Point.new(0, 2))).to eql 1
+      expect((subject <=> ChunkyPNG::Point.new(0, 2))).to eql(1)
     end
   end
 end
 
-describe 'ChunkyPNG.Point' do
+describe "ChunkyPNG.Point" do
   subject { ChunkyPNG::Point.new(1, 2) }
 
-
   it "should create a point from a 2-item array" do
     expect(ChunkyPNG::Point([1, 2])).to     eql subject
-    expect(ChunkyPNG::Point(['1', '2'])).to eql subject
+    expect(ChunkyPNG::Point(["1", "2"])).to eql subject
   end
 
   it "should create a point from a hash with x and y keys" do
-    expect(ChunkyPNG::Point(:x => 1, :y => 2)).to       eql subject
-    expect(ChunkyPNG::Point('x' => '1', 'y' => '2')).to eql subject
+    expect(ChunkyPNG::Point(x: 1, y: 2)).to             eql subject
+    expect(ChunkyPNG::Point("x" => "1", "y" => "2")).to eql subject
   end
 
   it "should create a point from a ChunkyPNG::Dimension object" do
@@ -62,9 +60,9 @@ describe 'ChunkyPNG.Point' do
 
   it "should create a point from a point-like string" do
     [
-      ChunkyPNG::Point('1,2'),
-      ChunkyPNG::Point('1   2'),
-      ChunkyPNG::Point('(1 , 2)'),
+      ChunkyPNG::Point("1,2"),
+      ChunkyPNG::Point("1   2"),
+      ChunkyPNG::Point("(1 , 2)"),
       ChunkyPNG::Point("{1,\t2}"),
       ChunkyPNG::Point("[1 2}"),
     ].all? { |point| point == subject }

data/spec/chunky_png/rmagick_spec.rb

@@ -1,23 +1,22 @@
-require 'spec_helper'
+require "spec_helper"
 
 begin
-  require 'chunky_png/rmagick'
+  require "chunky_png/rmagick"
 
   describe ChunkyPNG::RMagick do
-
     it "should import an image from RMagick correctly" do
-      image = Magick::Image.read(resource_file('composited.png')).first
+      image = Magick::Image.read(resource_file("composited.png")).first
       canvas = ChunkyPNG::RMagick.import(image)
-      expect(canvas).to eql reference_canvas('composited')
+      expect(canvas).to eql reference_canvas("composited")
     end
 
     it "should export an image to RMagick correctly" do
-      canvas = reference_canvas('composited')
+      canvas = reference_canvas("composited")
       image  = ChunkyPNG::RMagick.export(canvas)
-      image.format = 'PNG32'
+      image.format = "PNG32"
       expect(canvas).to eql ChunkyPNG::Canvas.from_blob(image.to_blob)
     end
   end
-rescue LoadError => e
+rescue LoadError
   # skipping RMagick tests
 end

data/spec/chunky_png/vector_spec.rb

@@ -1,17 +1,17 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG::Vector do
   subject { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]) }
 
   it { should respond_to(:points) }
 
-  describe '#length' do
+  describe "#length" do
     it "shopuld have 3 items" do
       expect(subject.length).to eql(3)
     end
   end
 
-  describe '#x_range' do
+  describe "#x_range" do
     it "should get the right range of x values" do
       expect(subject.x_range).to eql(1..4)
     end
@@ -29,7 +29,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#y_range' do
+  describe "#y_range" do
     it "should get the right range of y values" do
       expect(subject.y_range).to eql(3..6)
     end
@@ -47,7 +47,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#offset' do
+  describe "#offset" do
     it "should return a ChunkyPNG::Point" do
       expect(subject.offset).to be_kind_of(ChunkyPNG::Point)
     end
@@ -58,7 +58,7 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#dimension' do
+  describe "#dimension" do
     it "should return a ChunkyPNG::Dimension" do
       expect(subject.dimension).to be_kind_of(ChunkyPNG::Dimension)
     end
@@ -69,26 +69,30 @@ describe ChunkyPNG::Vector do
     end
   end
 
-  describe '#edges' do
+  describe "#edges" do
     it "should get three edges when closing the path" do
-      expect(subject.edges(true).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
-                                          [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
-                                          [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)]]
+      expect(subject.edges(true).to_a).to eql [
+        [ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+        [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
+        [ChunkyPNG::Point.new(4, 6), ChunkyPNG::Point.new(2, 5)],
+      ]
     end
 
     it "should get two edges when not closing the path" do
-      expect(subject.edges(false).to_a).to eql [[ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
-                                           [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)]]
+      expect(subject.edges(false).to_a).to eql [
+        [ChunkyPNG::Point.new(2, 5), ChunkyPNG::Point.new(1, 3)],
+        [ChunkyPNG::Point.new(1, 3), ChunkyPNG::Point.new(4, 6)],
+      ]
     end
   end
 end
 
-describe 'ChunkyPNG.Vector' do
+describe "ChunkyPNG.Vector" do
   let(:example) { ChunkyPNG::Vector.new([ChunkyPNG::Point.new(2, 4), ChunkyPNG::Point.new(1, 2), ChunkyPNG::Point.new(3, 6)]) }
 
   it "should return an empty vector when given an empty array" do
     expect(ChunkyPNG::Vector()).to eql ChunkyPNG::Vector.new([])
-    expect(ChunkyPNG::Vector(*[])).to eql ChunkyPNG::Vector.new([])
+    expect(ChunkyPNG::Vector(*[])).to eql ChunkyPNG::Vector.new([]) # rubocop:disable Lint/UnneededSplatExpansion
   end
 
   it "should raise an error when an odd number of numerics is given" do
@@ -96,14 +100,14 @@ describe 'ChunkyPNG.Vector' do
   end
 
   it "should create a vector from a string" do
-    expect(ChunkyPNG::Vector('(2,4) (1,2) (3,6)')).to eql example
+    expect(ChunkyPNG::Vector("(2,4) (1,2) (3,6)")).to eql example
   end
 
   it "should create a vector from a flat array" do
-    expect(ChunkyPNG::Vector(2,4,1,2,3,6)).to eql example
+    expect(ChunkyPNG::Vector(2, 4, 1, 2, 3, 6)).to eql example
   end
 
   it "should create a vector from a nested array" do
-    expect(ChunkyPNG::Vector('(2,4)', [1, 2], :x => 3, :y => 6)).to eql example
+    expect(ChunkyPNG::Vector("(2,4)", [1, 2], x: 3, y: 6)).to eql example
   end
 end

data/spec/chunky_png_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe ChunkyPNG do
   it "should have a VERSION constant" do
-    expect(ChunkyPNG.const_defined?('VERSION')).to eql true
+    expect(ChunkyPNG.const_defined?("VERSION")).to be_truthy
   end
 end

data/spec/png_suite_spec.rb

@@ -1,8 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
-describe 'PNG testuite' do
-
-  context 'Decoding broken images' do
+describe "PNG testuite" do
+  context "Decoding broken images" do
     png_suite_files(:broken).each do |file|
       it "should report #{File.basename(file)} as broken" do
         expect { ChunkyPNG::Image.from_file(file) }.to raise_error(ChunkyPNG::Exception)
@@ -10,24 +9,22 @@ describe 'PNG testuite' do
     end
   end
 
-  context 'Decoding supported images' do
-    png_suite_files(:basic, '*.png').each do |file|
-
-      reference  = file.sub(/\.png$/, '.rgba')
+  context "Decoding supported images" do
+    png_suite_files(:basic, "*.png").each do |file|
+      reference  = file.sub(/\.png$/, ".rgba")
       color_mode = file.match(/[in](\d)[apgc](\d\d)\.png$/)[1].to_i
       bit_depth  = file.match(/[in](\d)[apgc](\d\d)\.png$/)[2].to_i
 
       it "should decode #{File.basename(file)} (color mode: #{color_mode}, bit depth: #{bit_depth}) exactly the same as the reference image" do
         decoded = ChunkyPNG::Canvas.from_file(file)
-        File.open(reference, 'rb') { |f| expect(decoded.to_rgba_stream).to eql f.read }
+        expect(decoded.to_rgba_stream).to eql(File.read(reference, mode: "rb"))
       end
     end
   end
 
-  context 'Decoding text chunks' do
-
+  context "Decoding text chunks" do
     it "should not find metadata in a file without text chunks" do
-      image = ChunkyPNG::Image.from_file(png_suite_file(:metadata, 'cm0n0g04.png'))
+      image = ChunkyPNG::Image.from_file(png_suite_file(:metadata, "cm0n0g04.png"))
       expect(image.metadata).to be_empty
     end
 
@@ -42,10 +39,9 @@ describe 'PNG testuite' do
     # end
   end
 
-  context 'Decoding filter methods' do
-    png_suite_files(:filtering, '*_reference.png').each do |reference_file|
-
-      file = reference_file.sub(/_reference\.png$/, '.png')
+  context "Decoding filter methods" do
+    png_suite_files(:filtering, "*_reference.png").each do |reference_file|
+      file = reference_file.sub(/_reference\.png$/, ".png")
       filter_method = file.match(/f(\d\d)[a-z0-9]+\.png/)[1].to_i
 
       it "should decode #{File.basename(file)} (filter method: #{filter_method}) exactly the same as the reference image" do
@@ -56,54 +52,53 @@ describe 'PNG testuite' do
     end
   end
 
-  context 'Decoding different chunk splits' do
+  context "Decoding different chunk splits" do
     it "should decode grayscale images successfully regardless of the data chunk ordering and splitting" do
-      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi1n0g16.png')).imagedata
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n0g16.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n0g16.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n0g16.png')).imagedata).to eql reference
+      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi1n0g16.png")).imagedata
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi2n0g16.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi4n0g16.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi9n0g16.png")).imagedata).to eql reference
     end
 
     it "should decode color images successfully regardless of the data chunk ordering and splitting" do
-      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi1n2c16.png')).imagedata
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi2n2c16.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi4n2c16.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, 'oi9n2c16.png')).imagedata).to eql reference
+      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi1n2c16.png")).imagedata
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi2n2c16.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi4n2c16.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:chunk_ordering, "oi9n2c16.png")).imagedata).to eql reference
     end
   end
 
-  context 'Decoding different compression levels' do
+  context "Decoding different compression levels" do
     it "should decode the image successfully regardless of the compression level" do
-      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z00n2c08.png')).imagedata
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z03n2c08.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z06n2c08.png')).imagedata).to eql reference
-      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, 'z09n2c08.png')).imagedata).to eql reference
+      reference = ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, "z00n2c08.png")).imagedata
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, "z03n2c08.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, "z06n2c08.png")).imagedata).to eql reference
+      expect(ChunkyPNG::Datastream.from_file(png_suite_file(:compression_levels, "z09n2c08.png")).imagedata).to eql reference
     end
   end
 
-  context 'Decoding transparency' do
-    png_suite_files(:transparency, 'tp0*.png').each do |file|
+  context "Decoding transparency" do
+    png_suite_files(:transparency, "tp0*.png").each do |file|
       it "should not have transparency in #{File.basename(file)}" do
-        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 255
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0, 0])).to eql 255
       end
     end
 
-    png_suite_files(:transparency, 'tp1*.png').each do |file|
+    png_suite_files(:transparency, "tp1*.png").each do |file|
       it "should have transparency in #{File.basename(file)}" do
-        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 0
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0, 0])).to eql 0
       end
     end
 
-    png_suite_files(:transparency, 'tb*.png').each do |file|
+    png_suite_files(:transparency, "tb*.png").each do |file|
       it "should have transparency in #{File.basename(file)}" do
-        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0,0])).to eql 0
+        expect(ChunkyPNG::Color.a(ChunkyPNG::Image.from_file(file)[0, 0])).to eql 0
       end
     end
   end
 
-  context 'Decoding different sizes' do
-
-    png_suite_files(:sizes, '*n*.png').each do |file|
+  context "Decoding different sizes" do
+    png_suite_files(:sizes, "*n*.png").each do |file|
       dimension = file.match(/s(\d\d)n\dp\d\d/)[1].to_i
 
       it "should create a canvas with a #{dimension}x#{dimension} size" do

data/spec/spec_helper.rb

@@ -1,9 +1,8 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'chunky_png'
+require "rubygems"
+require "bundler/setup"
+require "chunky_png"
 
 module PNGSuite
-
   def png_suite_file(kind, file)
     File.join(png_suite_dir(kind), file)
   end
@@ -12,21 +11,19 @@ module PNGSuite
     File.expand_path("./png_suite/#{kind}", File.dirname(__FILE__))
   end
 
-  def png_suite_files(kind, pattern = '*.png')
+  def png_suite_files(kind, pattern = "*.png")
     Dir[File.join(png_suite_dir(kind), pattern)]
   end
 end
 
-
 module ResourceFileHelper
-
   def resource_file(name)
     File.expand_path("./resources/#{name}", File.dirname(__FILE__))
   end
 
   def resource_data(name)
     data = nil
-    File.open(resource_file(name), 'rb') { |f| data = f.read }
+    File.open(resource_file(name), "rb") { |f| data = f.read }
     data
   end
 
@@ -39,16 +36,25 @@ module ResourceFileHelper
   end
 
   def display(png)
-    filename = resource_file('_tmp.png')
+    filename = resource_file("_tmp.png")
     png.save(filename)
     `open #{filename}`
   end
 end
 
+module ChunkOperationsHelper
+  def serialized_chunk(chunk)
+    chunk.write(stream = StringIO.new)
+    stream.rewind
+    ChunkyPNG::Chunk.read(stream)
+  end
+end
+
 RSpec.configure do |config|
   config.extend PNGSuite
   config.include PNGSuite
   config.include ResourceFileHelper
+  config.include ChunkOperationsHelper
 
   config.expect_with :rspec do |c|
     c.syntax = [:should, :expect]

data/tasks/benchmarks.rake

@@ -1,24 +1,23 @@
 all_benchamrk_tasks = []
 
 namespace(:benchmark) do
-  
-  Dir[File.join(File.dirname(__FILE__), '..', 'benchmarks', '*_benchmark.rb')]. each do |benchmark_file|
-    task_name = File.basename(benchmark_file, '_benchmark.rb').to_sym
-    
+  Dir[File.join(File.dirname(__FILE__), "..", "benchmarks", "*_benchmark.rb")]. each do |benchmark_file|
+    task_name = File.basename(benchmark_file, "_benchmark.rb").to_sym
+
     desc "Run the #{task_name} benchmark."
     task(task_name, :n) do |task, args|
-      ENV['N'] = args[:n] if args[:n]
+      ENV["N"] = args[:n] if args[:n]
       load(File.expand_path(benchmark_file))
     end
-    
+
     all_benchamrk_tasks << "benchmark:#{task_name}"
   end
 end
 
 unless all_benchamrk_tasks.empty?
-  desc 'Run the whole benchmark suite'
+  desc "Run the whole benchmark suite"
   task(:benchmark, :n) do |task, args|
-    all_benchamrk_tasks.each do |t| 
+    all_benchamrk_tasks.each do |t|
       task(t).invoke(args[:n])
       puts
     end