image_optim 0.17.1 → 0.18.0

data/spec/image_optim/space_spec.rb

@@ -1,9 +1,10 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/space'
 
 describe ImageOptim::Space do
-  Space = ImageOptim::Space
+  before do
+    stub_const('Space', ImageOptim::Space)
+  end
 
   {
     0           => '      ',
@@ -17,7 +18,7 @@ describe ImageOptim::Space do
     10_000_000  => '  9.5M',
     100_000_000 => ' 95.4M',
   }.each do |size, space|
-    it "should convert #{size} to #{space}" do
+    it "converts #{size} to #{space}" do
       expect(Space.space(size)).to eq(space)
     end
   end

data/spec/image_optim/worker_spec.rb

@@ -1,12 +1,13 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/worker'
 
 describe ImageOptim::Worker do
-  Worker = ImageOptim::Worker
+  before do
+    stub_const('Worker', ImageOptim::Worker)
+  end
 
-  describe 'optimize' do
-    it 'should raise NotImplementedError' do
+  describe :optimize do
+    it 'raises NotImplementedError' do
       image_optim = ImageOptim.new
       worker = Worker.new(image_optim, {})
 

data/spec/image_optim_spec.rb

@@ -1,52 +1,35 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim'
+require 'image_optim/cmd'
 require 'tempfile'
+require 'English'
 
-TEST_IMAGES = ImageOptim::ImagePath.new(__FILE__).dirname.glob('images/**/*.*')
-
-Fixnum.class_eval do
-  def in_range?(range)
-    range.include?(self)
-  end
-end
-
-Tempfile.class_eval do
-  def self.init_count
-    class_variable_get(:@@init_count)
-  end
-
-  def self.init_count=(value)
-    class_variable_set(:@@init_count, value)
-  end
-
-  def self.reset_init_count
-    self.init_count = 0
-  end
-
-  reset_init_count
+describe ImageOptim do
+  root_dir = ImageOptim::ImagePath.new(__FILE__).dirname.dirname
+  images_dir = root_dir / 'spec/images'
+  test_images = images_dir.glob('**/*.*').freeze
 
-  alias_method :initialize_orig, :initialize
-  def initialize(*args, &block)
-    self.class.init_count += 1
-    initialize_orig(*args, &block)
+  helpers = Module.new do
+    def temp_copy(image)
+      image.temp_path.tap{ |path| image.copy(path) }
+    end
   end
-end
+  include helpers
+  extend helpers
 
-ImageOptim::ImagePath.class_eval do
-  def temp_copy
-    temp_path.tap{ |path| copy(path) }
+  matcher :be_in_range do |expected|
+    match{ |actual| expected.include?(actual) }
   end
-end
 
-describe ImageOptim do
   before do
+    stub_const('Cmd', ImageOptim::Cmd)
+
     allow(ImageOptim::Config).to receive(:global).and_return({})
     allow(ImageOptim::Config).to receive(:local).and_return({})
   end
 
   describe 'workers' do
-    it 'should be ordered by run_order' do
+    they 'are ordered by run_order' do
       image_optim = ImageOptim.new
       original_klasses = ImageOptim::Worker.klasses
       formats = original_klasses.map do |klass|
@@ -55,8 +38,8 @@ describe ImageOptim do
 
       [
         original_klasses,
-        original_klasses.reverse,
-        original_klasses.shuffle,
+        original_klasses.to_a.reverse,
+        original_klasses.to_a.shuffle,
       ].each do |klasses|
         expect(ImageOptim::Worker).to receive(:klasses).and_return(klasses)
 
@@ -75,265 +58,254 @@ describe ImageOptim do
     end
   end
 
-  describe 'worker' do
-    base_options = Hash[ImageOptim::Worker.klasses.map do |klass|
-      [klass.bin_sym, false]
-    end]
-
-    ImageOptim::Worker.klasses.each do |worker_klass|
-      describe worker_klass.bin_sym do
-        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
+  disable_all_workers = Hash[ImageOptim::Worker.klasses.map do |klass|
+    [klass.bin_sym, false]
+  end]
+
+  ImageOptim::Worker.klasses.each do |worker_klass|
+    describe "#{worker_klass.bin_sym} worker" do
+      it 'optimizes at least one test image' do
+        options = disable_all_workers.merge(worker_klass.bin_sym => true)
+        image_optim = ImageOptim.new(options)
+        expect(test_images.any? do |original|
+          image_optim.optimize_image(temp_copy(original))
+        end).to be true
       end
     end
   end
 
-  describe 'isolated' do
-    describe 'optimize' do
-      TEST_IMAGES.each do |original|
-        it "should optimize #{original}" do
-          copy = original.temp_copy
-
-          Tempfile.reset_init_count
-          image_optim = ImageOptim.new
-          optimized_image = image_optim.optimize_image(copy)
-          expect(optimized_image).to be_a(ImageOptim::ImagePath::Optimized)
-          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
-            expect(Tempfile.init_count).to be_in_range(1..2)
-          else
-            expect(Tempfile.init_count).to eq(1)
-          end
-        end
+  describe :optimize_image do
+    def flatten_animation(image)
+      if image.format == :gif
+        flattened = image.temp_path
+        flatten_command = %W[
+          convert
+          #{image.to_s.shellescape}
+          -coalesce
+          -append
+          #{flattened.to_s.shellescape}
+        ].join(' ')
+        expect(Cmd.run(flatten_command)).to be_truthy
+        flattened
+      else
+        image
       end
     end
 
-    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
-          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
-            expect(Tempfile.init_count).to be_in_range(2..3)
-          else
-            expect(Tempfile.init_count).to eq(2)
-          end
-        end
+    def nrmse(image_a, image_b)
+      coalesce_a = flatten_animation(image_a)
+      coalesce_b = flatten_animation(image_b)
+      nrmse_command = %W[
+        compare
+        -metric RMSE
+        #{coalesce_a.to_s.shellescape}
+        #{coalesce_b.to_s.shellescape}
+        /dev/null
+        2>&1
+      ].join(' ')
+      output = Cmd.capture(nrmse_command)
+      if [0, 1].include?($CHILD_STATUS.exitstatus)
+        output[/\((\d+(\.\d+)?)\)/, 1].to_f
+      else
+        fail "compare #{image_a} with #{image_b} failed with `#{output}`"
       end
     end
 
-    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)
-          expect(optimized_data).not_to be_nil
+    define :have_same_data_as do |expected|
+      match{ |actual| actual.binread == expected.binread }
+    end
 
-          expected_path = image_optim.optimize_image(original.temp_copy)
-          expect(optimized_data).to eq(expected_path.open('rb', &:read))
+    define :have_size do
+      match(&:size?)
+    end
 
-          expect(image_optim.optimize_image_data(optimized_data)).to be_nil
-        end
+    define :be_smaller_than do |expected|
+      match{ |actual| actual.size < expected.size }
+    end
+
+    define :be_pixel_identical_to do |expected|
+      match do |actual|
+        @diff = nrmse(actual, expected)
+        @diff == 0
+      end
+      failure_message do |actual|
+        "expected #{actual} to be pixel identical to #{expected}, got "\
+            "normalized root-mean-square error of #{@diff}"
       end
     end
 
-    describe 'stop optimizing' do
-      TEST_IMAGES.each do |original|
-        it "should stop optimizing #{original}" do
-          copy = original.temp_copy
+    describe 'optimizing images' do
+      rotated = images_dir / 'orient/original.jpg'
+      rotate_images = images_dir.glob('orient/?.jpg')
 
-          tries = 0
-          10.times do
-            tries += 1
-            break unless ImageOptim.optimize_image!(copy)
-          end
-          expect(tries).to be_in_range(2...3)
+      copies = test_images.map{ |image| temp_copy(image) }
+      original_by_copy = Hash[copies.zip(test_images)]
+
+      ImageOptim.optimize_images(copies) do |copy, optimized|
+        fail 'expected copy to not be nil' if copy.nil?
+        original = original_by_copy[copy]
+
+        it "optimizes #{original.relative_path_from(root_dir)}" do
+          expect(copy).to have_same_data_as(original)
+
+          expect(optimized).not_to be_nil
+          expect(optimized).to be_a(ImageOptim::ImagePath::Optimized)
+          expect(optimized).to have_size
+          expect(optimized).to be_smaller_than(original)
+          expect(optimized).not_to have_same_data_as(original)
+
+          compare_to = rotate_images.include?(original) ? rotated : original
+          expect(optimized).to be_pixel_identical_to(compare_to)
         end
       end
     end
-  end
 
-  describe 'bunch' do
-    it 'should optimize' do
-      copies = TEST_IMAGES.map(&:temp_copy)
-      results = ImageOptim.optimize_images(copies)
-      zipped = TEST_IMAGES.zip(copies, results)
-      zipped.each do |original, copy, result|
-        expect(result[0]).to eq(copy)
-        expect(result[1]).to be_a(ImageOptim::ImagePath::Optimized)
-        expect(result[1].size).to be_in_range(1...original.size)
-        expect(copy.read).to eq(original.read)
-      end
+    it 'ignores text file' do
+      original = ImageOptim::ImagePath.new(__FILE__)
+      copy = temp_copy(original)
+
+      expect(Tempfile).not_to receive(:new)
+      optimized_image = ImageOptim.optimize_image(copy)
+      expect(optimized_image).to be_nil
+      expect(copy.read).to eq(original.read)
     end
 
-    it 'should optimize in place' do
-      copies = TEST_IMAGES.map(&:temp_copy)
-      results = ImageOptim.optimize_images!(copies)
-      zipped = TEST_IMAGES.zip(copies, results)
-      zipped.each do |original, copy, result|
-        expect(result[0]).to eq(copy)
-        expect(result[1]).to be_a(ImageOptim::ImagePath::Optimized)
-        expect(copy.size).to be_in_range(1...original.size)
+    {
+      :png => "\211PNG\r\n\032\n",
+      :jpeg => "\377\330",
+    }.each do |type, data|
+      it "ingores broken #{type}" do
+        path = FSPath.temp_file_path
+        path.write(data)
+        expect(ImageOptim::ImageMeta).to receive(:warn)
+        expect(ImageOptim.optimize_image(path)).to be_nil
       end
     end
+  end
 
-    it 'should optimize datas' do
-      results = ImageOptim.optimize_images_data(TEST_IMAGES.map(&:read))
-      zipped = TEST_IMAGES.zip(results)
-      zipped.each do |original, result|
-        expect(result[0]).to eq(original.read)
-        expect(result[1]).to be_a(String)
-        expect(result[1].size).to be_in_range(1...original.size)
+  describe :optimize_image! do
+    it 'optimizes image and replaces original' do
+      original = double
+      optimized = double(:original_size => 12_345)
+      optimized_wrap = double
+      image_optim = ImageOptim.new
 
-        expected_path = ImageOptim.optimize_image(original.temp_copy)
-        expect(result[1]).to eq(expected_path.open('rb', &:read))
-      end
+      allow(ImageOptim::ImagePath).to receive(:convert).
+        with(original).and_return(original)
+
+      expect(image_optim).to receive(:optimize_image).
+        with(original).and_return(optimized)
+      expect(optimized).to receive(:replace).with(original)
+      expect(ImageOptim::ImagePath::Optimized).to receive(:new).
+        with(original, 12_345).and_return(optimized_wrap)
+
+      expect(image_optim.optimize_image!(original)).to eq(optimized_wrap)
+    end
+
+    it 'returns nil if optimization fails' do
+      original = double
+      image_optim = ImageOptim.new
+
+      allow(ImageOptim::ImagePath).to receive(:convert).
+        with(original).and_return(original)
+
+      expect(image_optim).to receive(:optimize_image).
+        with(original).and_return(nil)
+      expect(ImageOptim::ImagePath::Optimized).not_to receive(:new)
+
+      expect(image_optim.optimize_image!(original)).to eq(nil)
     end
   end
 
-  describe 'unsupported' do
-    let(:original){ ImageOptim::ImagePath.new(__FILE__) }
+  describe :optimize_image_data do
+    it 'create temp file, optimizes image and returns data' do
+      data = double
+      temp = double(:path => double)
+      optimized = double
+      optimized_data = double
+      image_optim = ImageOptim.new
 
-    it 'should ignore' do
-      copy = original.temp_copy
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => 'xxx'))
 
-      Tempfile.reset_init_count
-      optimized_image = ImageOptim.optimize_image(copy)
-      expect(Tempfile.init_count).to eq(0)
-      expect(optimized_image).to be_nil
-      expect(copy.read).to eq(original.read)
+      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(temp).to receive(:binmode)
+      expect(temp).to receive(:write).with(data)
+      expect(temp).to receive(:close)
+      expect(image_optim).to receive(:optimize_image).
+        with(temp.path).and_return(optimized)
+      expect(optimized).to receive(:binread).and_return(optimized_data)
+
+      expect(image_optim.optimize_image_data(data)).to eq(optimized_data)
     end
 
-    it 'should ignore in place' do
-      copy = original.temp_copy
+    it 'returns nil if optimization fails' do
+      data = double
+      temp = double(:path => double)
+      image_optim = ImageOptim.new
 
-      Tempfile.reset_init_count
-      expect(ImageOptim.optimize_image!(copy)).not_to be_truthy
-      expect(Tempfile.init_count).to eq(0)
-      expect(copy.read).to eq(original.read)
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => 'xxx'))
+
+      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(temp).to receive(:binmode)
+      expect(temp).to receive(:write).with(data)
+      expect(temp).to receive(:close)
+      expect(image_optim).to receive(:optimize_image).
+        with(temp.path).and_return(nil)
+
+      expect(image_optim.optimize_image_data(data)).to eq(nil)
     end
 
-    {
-      :png => "\211PNG\r\n\032\n",
-      :jpeg => "\377\330",
-    }.each do |type, data|
-      describe "broken #{type}" do
-        before do
-          expect(ImageOptim::ImageMeta).to receive(:warn)
-        end
+    it 'returns nil if format can\'t be detected' do
+      data = double
+      image_optim = ImageOptim.new
 
-        it 'should ignore path' do
-          path = FSPath.temp_file_path
-          path.write(data)
-          expect(ImageOptim.optimize_image(path)).to be_nil
-        end
+      allow(ImageOptim::ImageMeta).to receive(:for_data).
+        with(data).and_return(double(:format => nil))
 
-        it 'should ignore data' do
-          expect(ImageOptim.optimize_image_data(data)).to be_nil
-        end
-      end
+      expect(ImageOptim::ImagePath).not_to receive(:temp_file)
+      expect(image_optim).not_to receive(:optimize_image)
+
+      expect(image_optim.optimize_image_data(data)).to eq(nil)
     end
   end
 
   describe 'optimize multiple' do
-    let(:srcs){ ('a'..'z').to_a }
-
-    %w[optimize_images optimize_images!].each do |list_method|
+    %w[
+      optimize_images
+      optimize_images!
+      optimize_images_data
+    ].each do |list_method|
       describe list_method do
         method = list_method.sub('images', 'image')
         describe 'without block' do
-          it 'should optimize images and return array of results' do
+          it 'optimizes images and returns array of results' do
             image_optim = ImageOptim.new
-            dsts = srcs.map do |src|
-              dst = "#{src}_"
+            results = test_images.map do |src|
+              dst = double
               expect(image_optim).to receive(method).with(src).and_return(dst)
-              dst
+              [src, dst]
             end
-            expect(image_optim.send(list_method, srcs)).to eq(srcs.zip(dsts))
+            expect(image_optim.send(list_method, test_images)).to eq(results)
           end
         end
 
         describe 'given block' do
-          it 'should optimize images, yield path and result for each and '\
-              'return array of yield results' do
+          it 'optimizes images, yields path and result for each and '\
+              'returns array of yield results' do
             image_optim = ImageOptim.new
-            results = srcs.map do |src|
-              dst = "#{src}_"
+            results = test_images.map do |src|
+              dst = double
               expect(image_optim).to receive(method).with(src).and_return(dst)
-              "#{src} #{dst}"
+              [src, dst, :test]
             end
-            expect(image_optim.send(list_method, srcs) do |src, dst|
-              "#{src} #{dst}"
+            expect(image_optim.send(list_method, test_images) do |src, dst|
+              [src, dst, :test]
             end).to eq(results)
           end
         end
       end
     end
   end
-
-  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
-        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
-      end
-    end
-
-    def check_lossless_optimization(original, optimized)
-      expect(optimized).not_to be_nil
-      original = flatten_animation(original)
-      optimized = flatten_animation(optimized)
-      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|
-      it "should rotate and optimize #{image} losslessly" do
-        check_lossless_optimization(rotated, ImageOptim.optimize_image(image))
-      end
-    end
-
-    (TEST_IMAGES - rotate_images).each do |image|
-      it "should optimize #{image} losslessly" do
-        check_lossless_optimization(image, ImageOptim.optimize_image(image))
-      end
-    end
-  end
 end