image_optim 0.13.3 → 0.14.0

data/spec/image_optim/handler_spec.rb

@@ -1,47 +1,58 @@
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/handler'
 
 describe ImageOptim::Handler do
-  it "should use original as source for first conversion and two temp files for further conversions" do
+  it 'should use original as source for first conversion '\
+      'and two temp files for further conversions' do
     original = double(:original)
-    original.stub(:temp_path){ raise 'temp_path called unexpectedly' }
+    allow(original).to receive(:temp_path) do
+      fail 'temp_path called unexpectedly'
+    end
 
     handler = ImageOptim::Handler.new(original)
+    temp_a = double(:temp_a)
+    temp_b = double(:temp_b)
+    expect(original).to receive(:temp_path).once.and_return(temp_a)
+    expect(original).to receive(:temp_path).once.and_return(temp_b)
 
-    original.should_receive(:temp_path).once.and_return(temp_a = double(:temp_a))
+    # first unsuccessful run
     handler.process do |src, dst|
-      [src, dst].should == [original, temp_a]; false
+      expect([src, dst]).to eq([original, temp_a]); false
     end
-    handler.result.should == nil
+    expect(handler.result).to be_nil
 
+    # first successful run
     handler.process do |src, dst|
-      [src, dst].should == [original, temp_a]; true
+      expect([src, dst]).to eq([original, temp_a]); true
     end
-    handler.result.should == temp_a
+    expect(handler.result).to eq(temp_a)
 
-    original.should_receive(:temp_path).once.and_return(temp_b = double(:temp_b))
+    # second unsuccessful run
     handler.process do |src, dst|
-      [src, dst].should == [temp_a, temp_b]; false
+      expect([src, dst]).to eq([temp_a, temp_b]); false
     end
-    handler.result.should == temp_a
+    expect(handler.result).to eq(temp_a)
 
+    # second successful run
     handler.process do |src, dst|
-      [src, dst].should == [temp_a, temp_b]; true
+      expect([src, dst]).to eq([temp_a, temp_b]); true
     end
-    handler.result.should == temp_b
+    expect(handler.result).to eq(temp_b)
 
+    # third successful run
     handler.process do |src, dst|
-      [src, dst].should == [temp_b, temp_a]; true
+      expect([src, dst]).to eq([temp_b, temp_a]); true
     end
-    handler.result.should == temp_a
+    expect(handler.result).to eq(temp_a)
 
+    # forth successful run
     handler.process do |src, dst|
-      [src, dst].should == [temp_a, temp_b]; true
+      expect([src, dst]).to eq([temp_a, temp_b]); true
     end
-    handler.result.should == temp_b
+    expect(handler.result).to eq(temp_b)
 
-    temp_a.should_receive(:unlink).once
+    expect(temp_a).to receive(:unlink).once
     handler.cleanup
     handler.cleanup
   end

data/spec/image_optim/hash_helpers_spec.rb

@@ -1,55 +1,53 @@
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/hash_helpers'
 
 describe ImageOptim::HashHelpers do
   HH = ImageOptim::HashHelpers
 
-  it "should deep stringify hash keys" do
-    HH.deep_stringify_keys({
+  context 'stringify/simbolyze' do
+    WITH_SYMBOL_KEYS = {
       :a => 1,
       :b => {
-        :c => :a,
+        :c => [:a, 'a'],
         :d => {},
       },
-    }).should == {
-      'a' => 1,
-      'b' => {
-        'c' => :a,
-        'd' => {},
-      },
     }
-  end
 
-  it "should deep symbolise hash keys" do
-    HH.deep_symbolise_keys({
+    WITH_STRING_KEYS = {
       'a' => 1,
       'b' => {
-        'c' => 'a',
+        'c' => [:a, 'a'],
         'd' => {},
       },
-    }).should == {
-      :a => 1,
-      :b => {
-        :c => 'a',
-        :d => {},
-      },
     }
+
+    it 'should deep stringify hash keys' do
+      expect(HH.deep_stringify_keys(WITH_SYMBOL_KEYS)).to eq(WITH_STRING_KEYS)
+      expect(HH.deep_stringify_keys(WITH_STRING_KEYS)).to eq(WITH_STRING_KEYS)
+    end
+
+    it 'should deep symbolise hash keys' do
+      expect(HH.deep_symbolise_keys(WITH_STRING_KEYS)).to eq(WITH_SYMBOL_KEYS)
+      expect(HH.deep_symbolise_keys(WITH_SYMBOL_KEYS)).to eq(WITH_SYMBOL_KEYS)
+    end
   end
 
-  it "should deep merge hashes" do
-    HH.deep_merge({
+  it 'should deep merge hashes' do
+    merge_a = {
       :a => {
         :b => 1,
         :c => {
           :d => 2,
           :e => {
-            :f => true
+            :f => true,
           },
         },
       },
       :y => 10,
-    }, {
+    }
+
+    merge_b = {
       :a => {
         :b => 2,
         :c => {
@@ -57,8 +55,10 @@ describe ImageOptim::HashHelpers do
           :e => false,
         },
       },
-      :z => 20,
-    }).should == {
+      'z' => 20,
+    }
+
+    merge_result = {
       :a => {
         :b => 2,
         :c => {
@@ -67,8 +67,10 @@ describe ImageOptim::HashHelpers do
         },
       },
       :y => 10,
-      :z => 20,
+      'z' => 20,
     }
+
+    expect(HH.deep_merge(merge_a, merge_b)).to eq(merge_result)
   end
 
 end

data/spec/image_optim/image_path_spec.rb

@@ -1,39 +1,39 @@
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/image_path'
 
 describe ImageOptim::ImagePath do
   ImagePath = ImageOptim::ImagePath
 
-  describe "convert" do
-    it "should return ImagePath for string" do
+  describe 'convert' do
+    it 'should return ImagePath for string' do
       path = 'a'
 
-      ImagePath.convert(path).should be_a(ImageOptim::ImagePath)
-      ImagePath.convert(path).should eq(ImageOptim::ImagePath.new(path))
+      expect(ImagePath.convert(path)).to be_a(ImageOptim::ImagePath)
+      expect(ImagePath.convert(path)).to eq(ImageOptim::ImagePath.new(path))
 
-      ImagePath.convert(path).should_not eq(path)
-      ImagePath.convert(path).should_not be(path)
+      expect(ImagePath.convert(path)).not_to eq(path)
+      expect(ImagePath.convert(path)).not_to be(path)
     end
 
-    it "should return ImagePath for Pathname" do
+    it 'should return ImagePath for Pathname' do
       pathname = Pathname.new('a')
 
-      ImagePath.convert(pathname).should be_a(ImageOptim::ImagePath)
-      ImagePath.convert(pathname).should eq(ImageOptim::ImagePath.new(pathname))
+      expect(ImagePath.convert(pathname)).to be_a(ImageOptim::ImagePath)
+      expect(ImagePath.convert(pathname)).to eq(ImageOptim::ImagePath.new(pathname))
 
-      ImagePath.convert(pathname).should eq(pathname)
-      ImagePath.convert(pathname).should_not be(pathname)
+      expect(ImagePath.convert(pathname)).to eq(pathname)
+      expect(ImagePath.convert(pathname)).not_to be(pathname)
     end
 
-    it "should return same instance for ImagePath" do
+    it 'should return same instance for ImagePath' do
       image_path = ImageOptim::ImagePath.new('a')
 
-      ImagePath.convert(image_path).should be_a(ImageOptim::ImagePath)
-      ImagePath.convert(image_path).should eq(ImageOptim::ImagePath.new(image_path))
+      expect(ImagePath.convert(image_path)).to be_a(ImageOptim::ImagePath)
+      expect(ImagePath.convert(image_path)).to eq(ImageOptim::ImagePath.new(image_path))
 
-      ImagePath.convert(image_path).should eq(image_path)
-      ImagePath.convert(image_path).should be(image_path)
+      expect(ImagePath.convert(image_path)).to eq(image_path)
+      expect(ImagePath.convert(image_path)).to be(image_path)
     end
   end
 end

data/spec/image_optim/space_spec.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+require 'rspec'
+require 'image_optim/space'
+
+describe ImageOptim::Space do
+  Space = ImageOptim::Space
+
+  {
+    0           => '      ',
+    1           => '    1B',
+    10          => '   10B',
+    100         => '  100B',
+    1_000       => ' 1000B',
+    10_000      => '  9.8K',
+    100_000     => ' 97.7K',
+    1_000_000   => '976.6K',
+    10_000_000  => '  9.5M',
+    100_000_000 => ' 95.4M',
+  }.each do |size, space|
+    it "should convert #{size} to #{space}" do
+      expect(Space.space(size)).to eq(space)
+    end
+  end
+end

data/spec/image_optim/worker_spec.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+require 'rspec'
+require 'image_optim/worker'
+
+describe ImageOptim::Worker do
+  Worker = ImageOptim::Worker
+
+  describe 'optimize' do
+    it 'should raise NotImplementedError unless overriden' do
+      class Abc < ImageOptim::Worker; end
+
+      expect do
+        Abc.new({}).optimize(double, double)
+      end.to raise_error NotImplementedError
+    end
+  end
+
+end

data/spec/image_optim_spec.rb

@@ -1,4 +1,4 @@
-$:.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'rspec'
 require 'image_optim'
 require 'tempfile'
@@ -41,23 +41,61 @@ end
 
 describe ImageOptim do
   before do
-    ImageOptim::Config.stub(:global => {}, :local => {})
+    allow(ImageOptim::Config).to receive(:global).and_return({})
+    allow(ImageOptim::Config).to receive(:local).and_return({})
   end
 
-  describe "worker" do
-    options = Hash[ImageOptim::Worker.klasses.map{ |klass| [klass.bin_sym, false] }]
-    ImageOptim::Worker.klasses.reject{ |k| k.new({}).image_formats.empty? }.each do |worker_klass|
+  describe 'workers' do
+    it 'should be ordered by run_order' do
+      original_klasses = ImageOptim::Worker.klasses
+      formats = original_klasses.map do |klass|
+        klass.new({}).image_formats
+      end.flatten.uniq
+
+      [
+        original_klasses,
+        original_klasses.reverse,
+        original_klasses.shuffle,
+      ].each do |klasses|
+        expect(ImageOptim::Worker).to receive(:klasses).and_return(klasses)
+
+        image_optim = ImageOptim.new
+
+        formats.each do |format|
+          path = ImagePath.new("test.#{format}")
+          expect(path).to receive(:format).and_return(format)
+
+          workers = image_optim.workers_for_image(path)
+          expect(workers).to eq(workers.sort)
+        end
+      end
+    end
+  end
+
+  describe 'worker' do
+    base_options = Hash[ImageOptim::Worker.klasses.map do |klass|
+      [klass.bin_sym, false]
+    end]
+
+    real_workers = ImageOptim::Worker.klasses.reject do |klass|
+      klass.new({}).image_formats.empty?
+    end
+
+    real_workers.each do |worker_klass|
       describe worker_klass.bin_sym do
-        it "should optimize at least one test image" do
-          image_optim = ImageOptim.new(options.merge(worker_klass.bin_sym => true))
-          expect(TEST_IMAGES.any?{ |original| image_optim.optimize_image(original.temp_copy) }).to be_true
+        it 'should optimize at least one test image' do
+          options = base_options.merge(worker_klass.bin_sym => true)
+          image_optim = ImageOptim.new(options)
+          expect(TEST_IMAGES.any? do |original|
+            image_optim.optimize_image(original.temp_copy)
+          end).to be true
         end
       end
     end
   end
 
-  describe "isolated" do
-    describe "optimize" do
+  describe 'isolated' do
+    describe 'optimize' do
       TEST_IMAGES.each do |original|
         it "should optimize #{original}" do
           copy = original.temp_copy
@@ -66,53 +104,55 @@ describe ImageOptim do
           image_optim = ImageOptim.new
           optimized_image = image_optim.optimize_image(copy)
           expect(optimized_image).to be_a(ImageOptim::ImagePath::Optimized)
-          optimized_image.size.should be_in_range(1...original.size)
-          optimized_image.read.should_not == original.read
-          copy.read.should == original.read
+          expect(optimized_image.size).to be_in_range(1...original.size)
+          expect(optimized_image.read).not_to eq(original.read)
+          expect(copy.read).to eq(original.read)
 
           if image_optim.workers_for_image(original).length > 1
-            Tempfile.init_count.should be_in_range(1..2)
+            expect(Tempfile.init_count).to be_in_range(1..2)
           else
-            Tempfile.init_count.should === 1
+            expect(Tempfile.init_count).to eq(1)
           end
         end
       end
     end
 
-    describe "optimize in place" do
+    describe 'optimize in place' do
       TEST_IMAGES.each do |original|
         it "should optimize #{original}" do
           copy = original.temp_copy
 
           Tempfile.reset_init_count
           image_optim = ImageOptim.new
-          image_optim.optimize_image!(copy).should be_true
-          copy.size.should be_in_range(1...original.size)
-          copy.read.should_not == original.read
+          expect(image_optim.optimize_image!(copy)).to be_truthy
+          expect(copy.size).to be_in_range(1...original.size)
+          expect(copy.read).not_to eq(original.read)
 
           if image_optim.workers_for_image(original).length > 1
-            Tempfile.init_count.should be_in_range(2..3)
+            expect(Tempfile.init_count).to be_in_range(2..3)
           else
-            Tempfile.init_count.should === 2
+            expect(Tempfile.init_count).to eq(2)
           end
         end
       end
     end
 
-    describe "optimize image data" do
+    describe 'optimize image data' do
       TEST_IMAGES.each do |original|
         it "should optimize #{original}" do
           image_optim = ImageOptim.new
           optimized_data = image_optim.optimize_image_data(original.read)
-          optimized_data.should_not be_nil
-          optimized_data.should == image_optim.optimize_image(original.temp_copy).open('rb', &:read)
+          expect(optimized_data).not_to be_nil
+
+          expected_path = image_optim.optimize_image(original.temp_copy)
+          expect(optimized_data).to eq(expected_path.open('rb', &:read))
 
-          image_optim.optimize_image_data(optimized_data).should be_nil
+          expect(image_optim.optimize_image_data(optimized_data)).to be_nil
         end
       end
     end
 
-    describe "stop optimizing" do
+    describe 'stop optimizing' do
       TEST_IMAGES.each do |original|
         it "should stop optimizing #{original}" do
           copy = original.temp_copy
@@ -122,62 +162,65 @@ describe ImageOptim do
             tries += 1
             break unless ImageOptim.optimize_image!(copy)
           end
-          tries.should be_in_range(2...3)
+          expect(tries).to be_in_range(2...3)
         end
       end
     end
   end
 
-  describe "bunch" do
-    it "should optimize" do
+  describe 'bunch' do
+    it 'should optimize' do
       copies = TEST_IMAGES.map(&:temp_copy)
       optimized_images = ImageOptim.optimize_images(copies)
-      TEST_IMAGES.zip(copies, optimized_images).each do |original, copy, optimized_image|
+      zipped = TEST_IMAGES.zip(copies, optimized_images)
+      zipped.each do |original, copy, optimized_image|
         expect(optimized_image).to be_a(ImageOptim::ImagePath::Optimized)
-        optimized_image.size.should be_in_range(1...original.size)
-        optimized_image.read.should_not == original.read
-        copy.read.should == original.read
+        expect(optimized_image.size).to be_in_range(1...original.size)
+        expect(optimized_image.read).not_to eq(original.read)
+        expect(copy.read).to eq(original.read)
       end
     end
 
-    it "should optimize in place" do
+    it 'should optimize in place' do
       copies = TEST_IMAGES.map(&:temp_copy)
       ImageOptim.optimize_images!(copies)
       TEST_IMAGES.zip(copies).each do |original, copy|
-        copy.size.should be_in_range(1...original.size)
-        copy.read.should_not == original.read
+        expect(copy.size).to be_in_range(1...original.size)
+        expect(copy.read).not_to eq(original.read)
       end
     end
 
-    it "should optimize datas" do
-      optimized_images_datas = ImageOptim.optimize_images_data(TEST_IMAGES.map(&:read))
-      TEST_IMAGES.zip(optimized_images_datas).each do |original, optimized_image_data|
-        optimized_image_data.should_not be_nil
-        optimized_image_data.should == ImageOptim.optimize_image(original.temp_copy).open('rb', &:read)
+    it 'should optimize datas' do
+      optimized_datas = ImageOptim.optimize_images_data(TEST_IMAGES.map(&:read))
+      TEST_IMAGES.zip(optimized_datas).each do |original, optimized_data|
+        expect(optimized_data).not_to be_nil
+
+        expected_path = ImageOptim.optimize_image(original.temp_copy)
+        expect(optimized_data).to eq(expected_path.open('rb', &:read))
       end
     end
   end
 
-  describe "unsupported" do
+  describe 'unsupported' do
     let(:original){ ImageOptim::ImagePath.new(__FILE__) }
 
-    it "should ignore" do
+    it 'should ignore' do
       copy = original.temp_copy
 
       Tempfile.reset_init_count
       optimized_image = ImageOptim.optimize_image(copy)
-      Tempfile.init_count.should == 0
-      optimized_image.should be_nil
-      copy.read.should == original.read
+      expect(Tempfile.init_count).to eq(0)
+      expect(optimized_image).to be_nil
+      expect(copy.read).to eq(original.read)
     end
 
-    it "should ignore in place" do
+    it 'should ignore in place' do
       copy = original.temp_copy
 
       Tempfile.reset_init_count
-      ImageOptim.optimize_image!(copy).should_not be_true
-      Tempfile.init_count.should == 0
-      copy.read.should == original.read
+      expect(ImageOptim.optimize_image!(copy)).not_to be_truthy
+      expect(Tempfile.init_count).to eq(0)
+      expect(copy.read).to eq(original.read)
     end
 
     {
@@ -186,65 +229,74 @@ describe ImageOptim do
     }.each do |type, data|
       describe "broken #{type}" do
         before do
-          ImageOptim::ImageMeta.should_receive(:warn)
+          expect(ImageOptim::ImageMeta).to receive(:warn)
         end
 
-        it "should ignore path" do
+        it 'should ignore path' do
           path = FSPath.temp_file_path
           path.write(data)
-          ImageOptim.optimize_image(path).should be_nil
+          expect(ImageOptim.optimize_image(path)).to be_nil
         end
 
-        it "should ignore data" do
-          ImageOptim.optimize_image_data(data).should be_nil
+        it 'should ignore data' do
+          expect(ImageOptim.optimize_image_data(data)).to be_nil
         end
       end
     end
   end
 
-  describe "optimize multiple" do
+  describe 'optimize multiple' do
     let(:srcs){ ('a'..'z').to_a }
 
     %w[optimize_images optimize_images!].each do |list_method|
       describe list_method do
-        single_method = list_method.sub('images', 'image')
-        describe "without block" do
-          it "should optimize images and return array of results" do
+        method = list_method.sub('images', 'image')
+        describe 'without block' do
+          it 'should optimize images and return array of results' do
             image_optim = ImageOptim.new
             dsts = srcs.map do |src|
               dst = "#{src}_"
-              image_optim.should_receive(single_method).with(src).and_return(dst)
+              expect(image_optim).to receive(method).with(src).and_return(dst)
               dst
             end
-            image_optim.send(list_method, srcs).should == dsts
+            expect(image_optim.send(list_method, srcs)).to eq(dsts)
           end
         end
 
-        describe "given block" do
-          it "should optimize images, yield path and result for each and return array of yield results" do
+        describe 'given block' do
+          it 'should optimize images, yield path and result for each and '\
+              'return array of yield results' do
             image_optim = ImageOptim.new
             results = srcs.map do |src|
               dst = "#{src}_"
-              image_optim.should_receive(single_method).with(src).and_return(dst)
+              expect(image_optim).to receive(method).with(src).and_return(dst)
               "#{src} #{dst}"
             end
-            image_optim.send(list_method, srcs) do |src, dst|
+            expect(image_optim.send(list_method, srcs) do |src, dst|
               "#{src} #{dst}"
-            end.should == results
+            end).to eq(results)
           end
         end
       end
     end
   end
 
-  describe "losslessness" do
-    rotated = ImageOptim::ImagePath.new(__FILE__).dirname / 'images/orient/original.jpg'
-    rotate_images = ImageOptim::ImagePath.new(__FILE__).dirname.glob('images/orient/?.jpg')
+  describe 'losslessness' do
+    images_dir = ImageOptim::ImagePath.new(__FILE__).dirname / 'images'
+    rotated = images_dir / 'orient/original.jpg'
+    rotate_images = images_dir.glob('orient/?.jpg')
 
     def flatten_animation(image)
       if image.format == :gif
         flattened = image.temp_path
-        system("convert #{image.to_s.shellescape} -coalesce -append #{flattened.to_s.shellescape}").should be_true
+        flatten_command = %W[
+          convert
+          #{image.to_s.shellescape}
+          -coalesce
+          -append
+          #{flattened.to_s.shellescape}
+        ].join(' ')
+        expect(system(flatten_command)).to be_truthy
         flattened
       else
         image
@@ -252,12 +304,20 @@ describe ImageOptim do
     end
 
     def check_lossless_optimization(original, optimized)
-      optimized.should_not be_nil
+      expect(optimized).not_to be_nil
       original = flatten_animation(original)
       optimized = flatten_animation(optimized)
-      nrmse = `compare -metric RMSE #{original.to_s.shellescape} #{optimized.to_s.shellescape} /dev/null 2>&1`[/\((\d+(\.\d+)?)\)/, 1]
-      nrmse.should_not be_nil
-      nrmse.to_f.should == 0
+      nrmse_command = %W[
+        compare
+        -metric RMSE
+        #{original.to_s.shellescape}
+        #{optimized.to_s.shellescape}
+        /dev/null
+        2>&1
+      ].join(' ')
+      nrmse = `#{nrmse_command}`[/\((\d+(\.\d+)?)\)/, 1]
+      expect(nrmse).not_to be_nil
+      expect(nrmse.to_f).to eq(0)
     end
 
     rotate_images.each do |image|