image_optim 0.18.0 → 0.19.0

data/spec/image_optim/worker_spec.rb

@@ -1,9 +1,11 @@
 require 'spec_helper'
 require 'image_optim/worker'
+require 'image_optim/bin_resolver'
 
 describe ImageOptim::Worker do
   before do
     stub_const('Worker', ImageOptim::Worker)
+    stub_const('BinResolver', ImageOptim::BinResolver)
   end
 
   describe :optimize do
@@ -17,4 +19,141 @@ describe ImageOptim::Worker do
     end
   end
 
+  describe :create_all_by_format do
+    it 'passes arguments to create_all' do
+      image_optim = double
+      options_proc = proc{ true }
+
+      expect(Worker).to receive(:create_all) do |arg, &block|
+        expect(arg).to eq(image_optim)
+        expect(block).to eq(options_proc)
+        []
+      end
+
+      Worker.create_all_by_format(image_optim, &options_proc)
+    end
+
+    it 'create hash by format' do
+      workers = [
+        double(:image_formats => [:a]),
+        double(:image_formats => [:a, :b]),
+        double(:image_formats => [:b, :c]),
+      ]
+
+      expect(Worker).to receive(:create_all).and_return(workers)
+
+      worker_by_format = {
+        :a => [workers[0], workers[1]],
+        :b => [workers[1], workers[2]],
+        :c => [workers[2]],
+      }
+
+      expect(Worker.create_all_by_format(double)).to eq(worker_by_format)
+    end
+  end
+
+  describe :create_all do
+    def worker_double(override = {})
+      stubs = {:resolve_used_bins! => nil, :run_order => 0}.merge(override)
+      instance_double(Worker, stubs)
+    end
+
+    let(:image_optim){ double(:allow_lossy => false) }
+
+    it 'creates all workers for which options_proc returns true' do
+      workers = Array.new(3){ worker_double }
+      klasses = workers.map{ |worker| double(:init => worker) }
+      options_proc = proc{ |klass| klass != klasses[1] ? {} : false }
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim, &options_proc)).
+        to eq([workers[0], workers[2]])
+    end
+
+    it 'handles workers initializing multiple instances' do
+      workers = [
+        worker_double,
+        [worker_double, worker_double, worker_double],
+        worker_double,
+      ]
+      klasses = workers.map{ |worker| double(:init => worker) }
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim){ {} }).
+        to eq(workers.flatten)
+    end
+
+    describe 'with missing workers' do
+      let(:workers) do
+        Array.new(3) do |i|
+          worker = worker_double
+          unless i == 1
+            allow(worker).to receive(:resolve_used_bins!).
+              and_raise(BinResolver::BinNotFound, "not found #{i}")
+          end
+          worker
+        end
+      end
+      let(:klasses){ workers.map{ |worker| double(:init => worker) } }
+
+      before do
+        allow(Worker).to receive(:klasses).and_return(klasses)
+      end
+
+      describe 'if skip_missing_workers is true' do
+        define :bin_not_found do |message|
+          match do |error|
+            error.is_a?(BinResolver::BinNotFound) && error.message == message
+          end
+        end
+
+        it 'shows warnings and returns resolved workers ' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(true)
+
+          expect(Worker).to receive(:warn).
+            once.with(bin_not_found('not found 0'))
+          expect(Worker).to receive(:warn).
+            once.with(bin_not_found('not found 2'))
+
+          expect(Worker.create_all(image_optim){ {} }).
+            to eq([workers[1]])
+        end
+      end
+
+      describe 'if skip_missing_workers is false' do
+        it 'fails with a joint exception' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(false)
+
+          expect do
+            Worker.create_all(image_optim){ {} }
+          end.to raise_error(BinResolver::Error, /not found 0\nnot found 2/)
+        end
+      end
+    end
+
+    it 'orders workers by run_order' do
+      image_optim = double(:allow_lossy => false)
+      run_orders = [10, -10, 0, 0, 0, 10, -10]
+      workers = run_orders.map do |run_order|
+        worker_double(:run_order => run_order)
+      end
+      klasses_list = workers.map{ |worker| double(:init => worker) }
+
+      [
+        klasses_list,
+        klasses_list.reverse,
+        klasses_list.shuffle,
+      ].each do |klasses|
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        expected_order = klasses.map(&:init).sort_by.with_index do |worker, i|
+          [worker.run_order, i]
+        end
+
+        expect(Worker.create_all(image_optim){ {} }).to eq(expected_order)
+      end
+    end
+  end
 end

data/spec/image_optim_spec.rb

@@ -28,36 +28,6 @@ describe ImageOptim do
     allow(ImageOptim::Config).to receive(:local).and_return({})
   end
 
-  describe 'workers' do
-    they 'are ordered by run_order' do
-      image_optim = ImageOptim.new
-      original_klasses = ImageOptim::Worker.klasses
-      formats = original_klasses.map do |klass|
-        klass.new(image_optim, {}).image_formats
-      end.flatten.uniq
-
-      [
-        original_klasses,
-        original_klasses.to_a.reverse,
-        original_klasses.to_a.shuffle,
-      ].each do |klasses|
-        expect(ImageOptim::Worker).to receive(:klasses).and_return(klasses)
-
-        image_optim = ImageOptim.new
-
-        formats.each do |format|
-          path = ImageOptim::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_by.with_index do |worker, i|
-            [worker.run_order, i]
-          end)
-        end
-      end
-    end
-  end
-
   disable_all_workers = Hash[ImageOptim::Worker.klasses.map do |klass|
     [klass.bin_sym, false]
   end]
@@ -65,8 +35,15 @@ describe ImageOptim do
   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)
+        options = disable_all_workers.dup
+        options.merge!(worker_klass.bin_sym => true)
+        options.merge!(:skip_missing_workers => false)
+
         image_optim = ImageOptim.new(options)
+        if Array(worker_klass.init(image_optim)).empty?
+          image_optim = ImageOptim.new(options.merge(:allow_lossy => true))
+        end
+
         expect(test_images.any? do |original|
           image_optim.optimize_image(temp_copy(original))
         end).to be true
@@ -123,14 +100,14 @@ describe ImageOptim do
       match{ |actual| actual.size < expected.size }
     end
 
-    define :be_pixel_identical_to do |expected|
+    define :be_similar_to do |expected, max_difference|
       match do |actual|
         @diff = nrmse(actual, expected)
-        @diff == 0
+        @diff <= max_difference
       end
       failure_message do |actual|
-        "expected #{actual} to be pixel identical to #{expected}, got "\
-            "normalized root-mean-square error of #{@diff}"
+        "expected #{actual} to have at most #{max_difference} difference from "\
+            "#{expected}, got normalized root-mean-square error of #{@diff}"
       end
     end
 
@@ -138,24 +115,29 @@ describe ImageOptim do
       rotated = images_dir / 'orient/original.jpg'
       rotate_images = images_dir.glob('orient/?.jpg')
 
-      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)
+      base_options = {:skip_missing_workers => false}
+      [
+        ['lossless', base_options, 0],
+        ['lossy', base_options.merge(:allow_lossy => true), 0.01],
+      ].each do |type, options, max_difference|
+        image_optim = ImageOptim.new(options)
+        describe type do
+          copies = test_images.map{ |image| temp_copy(image) }
+          pairs = image_optim.optimize_images(copies)
+          test_images.zip(*pairs.transpose).each do |original, copy, optimized|
+            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_similar_to(compare_to, max_difference)
+            end
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_optim
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-01 00:00:00.000000000 Z
+date: 2014-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fspath
@@ -98,14 +98,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -189,9 +189,11 @@ files:
 - lib/image_optim/true_false_nil.rb
 - lib/image_optim/worker.rb
 - lib/image_optim/worker/advpng.rb
+- lib/image_optim/worker/class_methods.rb
 - lib/image_optim/worker/gifsicle.rb
 - lib/image_optim/worker/jhead.rb
 - lib/image_optim/worker/jpegoptim.rb
+- lib/image_optim/worker/jpegrecompress.rb
 - lib/image_optim/worker/jpegtran.rb
 - lib/image_optim/worker/optipng.rb
 - lib/image_optim/worker/pngcrush.rb
@@ -261,9 +263,9 @@ rubyforge_project: image_optim
 rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
-summary: Optimize (lossless compress) images (jpeg, png, gif, svg) using external
-  utilities (advpng, gifsicle, jhead, jpegoptim, jpegrescan, jpegtran, optipng, pngcrush,
-  pngout, pngquant, svgo)
+summary: Optimize (lossless compress, optionally lossy) images (jpeg, png, gif, svg)
+  using external utilities (advpng, gifsicle, jhead, jpeg-recompress, jpegoptim, jpegrescan,
+  jpegtran, optipng, pngcrush, pngout, pngquant, svgo)
 test_files:
 - spec/image_optim/bin_resolver/comparable_condition_spec.rb
 - spec/image_optim/bin_resolver/simple_version_spec.rb