image_optim 0.28.0 → 0.31.1

data/spec/image_optim/timer_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'image_optim/timer'
+
+describe ImageOptim::Timer do
+  let!(:timer){ described_class.new(1) }
+
+  describe '#elapsed' do
+    it 'returns elapsed time' do
+      sleep 0.01
+
+      expect(timer.elapsed).to be >= 0.01
+    end
+  end
+
+  describe '#left' do
+    it 'returns time left' do
+      sleep 0.01
+
+      expect(timer.left).to be <= 0.99
+    end
+  end
+
+  describe '#to_f' do
+    it 'returns time left' do
+      sleep 0.01
+
+      expect(timer.to_f).to be <= 0.99
+    end
+  end
+end

data/spec/image_optim/worker/jpegrecompress_spec.rb

@@ -14,7 +14,7 @@ describe ImageOptim::Worker::Jpegrecompress do
     end
 
     context 'uses default when invalid' do
-      let(:method){ {:method => 'invalid'} }
+      let(:method){ {method: 'invalid'} }
 
       it 'warns and keeps default' do
         expect_any_instance_of(described_class).
@@ -24,7 +24,7 @@ describe ImageOptim::Worker::Jpegrecompress do
     end
 
     context 'can use a valid option' do
-      let(:method){ {:method => 'smallfry'} }
+      let(:method){ {method: 'smallfry'} }
 
       it{ is_expected.to eq('smallfry') }
     end

data/spec/image_optim/worker/optipng_spec.rb

@@ -10,7 +10,7 @@ describe ImageOptim::Worker::Optipng do
 
     let(:options){ {} }
     let(:optipng_version){ '0.7' }
-    let(:src){ instance_double(ImageOptim::Path, :copy => nil) }
+    let(:src){ instance_double(ImageOptim::Path, copy: nil) }
     let(:dst){ instance_double(ImageOptim::Path) }
 
     before do
@@ -34,7 +34,7 @@ describe ImageOptim::Worker::Optipng do
     end
 
     context 'when strip is disabled' do
-      let(:options){ {:strip => false} }
+      let(:options){ {strip: false} }
 
       it 'should not add -strip all to arguments' do
         expect(subject).to receive(:execute) do |_bin, *args|
@@ -61,42 +61,42 @@ describe ImageOptim::Worker::Optipng do
   describe '#optimized?' do
     let(:src){ instance_double(ImageOptim::Path, src_options) }
     let(:dst){ instance_double(ImageOptim::Path, dst_options) }
-    let(:src_options){ {:size => 10} }
-    let(:dst_options){ {:size? => 9} }
+    let(:src_options){ {size: 10} }
+    let(:dst_options){ {size?: 9} }
     let(:instance){ described_class.new(ImageOptim.new, instance_options) }
     let(:instance_options){ {} }
 
     subject{ instance.optimized?(src, dst) }
 
     context 'when interlace option is enabled' do
-      let(:instance_options){ {:interlace => true} }
+      let(:instance_options){ {interlace: true} }
 
       context 'when dst is empty' do
-        let(:dst_options){ {:size? => nil} }
+        let(:dst_options){ {size?: nil} }
         it{ is_expected.to be_falsy }
       end
 
       context 'when dst is not empty' do
-        let(:dst_options){ {:size? => 20} }
+        let(:dst_options){ {size?: 20} }
         it{ is_expected.to be_truthy }
       end
     end
 
     context 'when interlace option is disabled' do
-      let(:instance_options){ {:interlace => false} }
+      let(:instance_options){ {interlace: false} }
 
       context 'when dst is empty' do
-        let(:dst_options){ {:size? => nil} }
+        let(:dst_options){ {size?: nil} }
         it{ is_expected.to be_falsy }
       end
 
       context 'when dst is greater than or equal to src' do
-        let(:dst_options){ {:size? => 10} }
+        let(:dst_options){ {size?: 10} }
         it{ is_expected.to be_falsy }
       end
 
       context 'when dst is less than src' do
-        let(:dst_options){ {:size? => 9} }
+        let(:dst_options){ {size?: 9} }
         it{ is_expected.to be_truthy }
       end
     end

data/spec/image_optim/worker/oxipng_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'image_optim/worker/oxipng'
+require 'image_optim/path'
+
+describe ImageOptim::Worker::Oxipng do
+  describe 'strip option' do
+    subject{ described_class.new(ImageOptim.new, options) }
+
+    let(:options){ {} }
+    let(:src){ instance_double(ImageOptim::Path, copy: nil) }
+    let(:dst){ instance_double(ImageOptim::Path) }
+
+    before do
+      oxipng_bin = instance_double(ImageOptim::BinResolver::Bin)
+      allow(subject).to receive(:resolve_bin!).
+        with(:oxipng).and_return(oxipng_bin)
+
+      allow(subject).to receive(:optimized?)
+    end
+
+    context 'by default' do
+      it 'should add --strip all to arguments' do
+        expect(subject).to receive(:execute) do |_bin, *args|
+          expect(args.join(' ')).to match(/(^| )--strip all($| )/)
+        end
+
+        subject.optimize(src, dst)
+      end
+    end
+
+    context 'when strip is disabled' do
+      let(:options){ {strip: false} }
+
+      it 'should not add --strip all to arguments' do
+        expect(subject).to receive(:execute) do |_bin, *args|
+          expect(args.join(' ')).not_to match(/(^| )--strip all($| )/)
+        end
+
+        subject.optimize(src, dst)
+      end
+    end
+  end
+
+  describe '#optimized?' do
+    let(:src){ instance_double(ImageOptim::Path, src_options) }
+    let(:dst){ instance_double(ImageOptim::Path, dst_options) }
+    let(:src_options){ {size: 10} }
+    let(:dst_options){ {size?: 9} }
+    let(:instance){ described_class.new(ImageOptim.new, instance_options) }
+    let(:instance_options){ {} }
+
+    subject{ instance.optimized?(src, dst) }
+
+    context 'when interlace option is enabled' do
+      let(:instance_options){ {interlace: true} }
+
+      context 'when dst is empty' do
+        let(:dst_options){ {size?: nil} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is not empty' do
+        let(:dst_options){ {size?: 20} }
+        it{ is_expected.to be_truthy }
+      end
+    end
+
+    context 'when interlace option is disabled' do
+      let(:instance_options){ {interlace: false} }
+
+      context 'when dst is empty' do
+        let(:dst_options){ {size?: nil} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is greater than or equal to src' do
+        let(:dst_options){ {size?: 10} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is less than src' do
+        let(:dst_options){ {size?: 9} }
+        it{ is_expected.to be_truthy }
+      end
+    end
+  end
+end

data/spec/image_optim/worker/pngquant_spec.rb

@@ -22,7 +22,7 @@ describe ImageOptim::Worker::Pngquant do
         end
 
         context 'when value is passed through options' do
-          let(:options){ {:quality => 10..90} }
+          let(:options){ {quality: 10..90} }
 
           it 'warns and keeps default' do
             expect_any_instance_of(described_class).
@@ -34,13 +34,13 @@ describe ImageOptim::Worker::Pngquant do
 
       context 'when lossy allowed' do
         context 'by default' do
-          let(:options){ {:allow_lossy => true} }
+          let(:options){ {allow_lossy: true} }
 
           it{ is_expected.to eq(0..100) }
         end
 
         context 'when value is passed through options' do
-          let(:options){ {:allow_lossy => true, :quality => 10..90} }
+          let(:options){ {allow_lossy: true, quality: 10..90} }
 
           it 'sets the value without warning' do
             expect_any_instance_of(described_class).not_to receive(:warn)
@@ -49,7 +49,7 @@ describe ImageOptim::Worker::Pngquant do
         end
 
         context 'when passed range begin is less than 0' do
-          let(:options){ {:allow_lossy => true, :quality => -50..50} }
+          let(:options){ {allow_lossy: true, quality: -50..50} }
 
           it 'sets begin to 0' do
             is_expected.to eq(0..50)
@@ -57,7 +57,7 @@ describe ImageOptim::Worker::Pngquant do
         end
 
         context 'when passed range end is more than 100' do
-          let(:options){ {:allow_lossy => true, :quality => 50..150} }
+          let(:options){ {allow_lossy: true, quality: 50..150} }
 
           it 'sets end to 100' do
             is_expected.to eq(50..100)

data/spec/image_optim/worker_spec.rb

@@ -29,9 +29,9 @@ describe ImageOptim::Worker do
         option(:three, 3, 'Three')
       end
 
-      worker = worker_class.new(ImageOptim.new, :three => '...')
+      worker = worker_class.new(ImageOptim.new, three: '...')
 
-      expect(worker.options).to eq(:one => 1, :two => 2, :three => '...')
+      expect(worker.options).to eq(one: 1, two: 2, three: '...')
     end
   end
 
@@ -72,7 +72,7 @@ describe ImageOptim::Worker do
         option(:three, 3, 'Three')
       end)
 
-      worker = DefOptim.new(ImageOptim.new, :three => '...')
+      worker = DefOptim.new(ImageOptim.new, three: '...')
 
       expect(worker.inspect).to eq('#<DefOptim @one=1, @two=2, @three="...">')
     end
@@ -104,17 +104,17 @@ describe ImageOptim::Worker do
 
     it 'create hash by format' do
       workers = [
-        double(:image_formats => [:a]),
-        double(:image_formats => [:a, :b]),
-        double(:image_formats => [:b, :c]),
+        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]],
+        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)
@@ -123,21 +123,21 @@ describe ImageOptim::Worker do
 
   describe '.create_all' do
     def worker_double(override = {})
-      stubs = {:resolve_used_bins! => nil, :run_order => 0}.merge(override)
+      stubs = {resolve_used_bins!: nil, run_order: 0}.merge(override)
       instance_double(Worker, stubs)
     end
 
     def worker_class_doubles(workers)
-      workers.map{ |worker| class_double(Worker, :init => worker) }
+      workers.map{ |worker| class_double(Worker, init: worker) }
     end
 
-    let(:image_optim){ double(:allow_lossy => false) }
+    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 = worker_class_doubles(workers)
       options_proc = proc do |klass|
-        klass == klasses[1] ? {:disable => true} : {}
+        klass == klasses[1] ? {disable: true} : {}
       end
 
       allow(Worker).to receive(:klasses).and_return(klasses)
@@ -206,7 +206,7 @@ describe ImageOptim::Worker do
     it 'orders workers by run_order' do
       run_orders = [10, -10, 0, 0, 0, 10, -10]
       workers = run_orders.map do |run_order|
-        worker_double(:run_order => run_order)
+        worker_double(run_order: run_order)
       end
       klasses_list = worker_class_doubles(workers)
 
@@ -243,16 +243,16 @@ describe ImageOptim::Worker do
       it 'allows overriding per worker' do
         klasses = worker_class_doubles([worker_double, worker_double])
         options_proc = proc do |klass|
-          klass == klasses[1] ? {:allow_lossy => :b} : {}
+          klass == klasses[1] ? {allow_lossy: :b} : {}
         end
 
         allow(Worker).to receive(:klasses).and_return(klasses)
 
         klasses.each{ |klass| klass.send(:attr_reader, :allow_lossy) }
         expect(klasses[0]).to receive(:init).
-          with(image_optim, hash_including(:allow_lossy => false))
+          with(image_optim, hash_including(allow_lossy: false))
         expect(klasses[1]).to receive(:init).
-          with(image_optim, hash_including(:allow_lossy => :b))
+          with(image_optim, hash_including(allow_lossy: :b))
 
         Worker.create_all(image_optim, &options_proc)
       end

data/spec/image_optim_spec.rb

@@ -27,7 +27,7 @@ describe ImageOptim do
     ImageOptim::Worker.klasses.map do |klass|
       [klass.bin_sym, false]
     end
-  ].merge(:skip_missing_workers => false)
+  ].merge(skip_missing_workers: false)
 
   ImageOptim::Worker.klasses.each do |worker_klass|
     describe "#{worker_klass.bin_sym} worker" do
@@ -36,7 +36,7 @@ describe ImageOptim do
 
         image_optim = ImageOptim.new(options)
         if Array(worker_klass.init(image_optim)).empty?
-          image_optim = ImageOptim.new(options.merge(:allow_lossy => true))
+          image_optim = ImageOptim.new(options.merge(allow_lossy: true))
         end
 
         expect(test_images.any? do |original|
@@ -59,10 +59,10 @@ describe ImageOptim do
       rotated = images_dir / 'orient/original.jpg'
       rotate_images = images_dir.glob('orient/?.jpg')
 
-      base_options = {:skip_missing_workers => false}
+      base_options = {skip_missing_workers: false}
       [
         ['lossless', base_options, 0],
-        ['lossy', base_options.merge(:allow_lossy => true), 0.001],
+        ['lossy', base_options.merge(allow_lossy: true), 0.001],
       ].each do |type, options, max_difference|
         it "does it #{type}" do
           image_optim = ImageOptim.new(options)
@@ -95,8 +95,8 @@ describe ImageOptim do
     end
 
     {
-      :png => "\211PNG\r\n\032\n",
-      :jpeg => "\377\330",
+      png: "\211PNG\r\n\032\n",
+      jpeg: "\377\330",
     }.each do |type, data|
       it "ingores broken #{type}" do
         path = FSPath.temp_file_path
@@ -105,12 +105,49 @@ describe ImageOptim do
         expect(ImageOptim.optimize_image(path)).to be_nil
       end
     end
+
+    context 'using timeout' do
+      let(:timeout){ 123 }
+      let(:image_optim){ ImageOptim.new(isolated_options_base.merge(timeout: timeout)) }
+      let(:timer){ instance_double(ImageOptim::Timer) }
+      let(:workers){ Array.new(3){ instance_double(ImageOptim::Worker) } }
+      let(:path){ test_images.first }
+
+      before do
+        allow(ImageOptim::Timer).to receive(:new).with(timeout).and_return(timer)
+        allow(image_optim).to receive(:workers_for_image).and_return(workers)
+      end
+
+      it 'sends timeout to every worker' do
+        some_path = instance_of(ImageOptim::Path)
+
+        expect(workers[0]).to receive(:optimize).with(some_path, some_path, timeout: timer)
+        expect(workers[1]).to receive(:optimize).with(some_path, some_path, timeout: timer)
+        expect(workers[2]).to receive(:optimize).with(some_path, some_path, timeout: timer)
+
+        image_optim.optimize_image(path)
+      end
+
+      it 'returns nil if there was no success before worker times out' do
+        allow(workers[0]).to receive(:optimize).and_return(false)
+        allow(workers[1]).to receive(:optimize).and_raise(ImageOptim::Errors::TimeoutExceeded)
+
+        expect(image_optim.optimize_image(path)).to be_nil
+      end
+
+      it 'returns result if there was success before worker times out' do
+        allow(workers[0]).to receive(:optimize).and_return(true)
+        allow(workers[1]).to receive(:optimize).and_raise(ImageOptim::Errors::TimeoutExceeded)
+
+        expect(image_optim.optimize_image(path)).to be_an(ImageOptim::OptimizedPath)
+      end
+    end
   end
 
   describe '#optimize_image!' do
     it 'optimizes image and replaces original' do
       original = double
-      optimized = double(:original_size => 12_345)
+      optimized = double(original_size: 12_345)
       optimized_wrap = double
       image_optim = ImageOptim.new
 
@@ -144,7 +181,7 @@ describe ImageOptim do
   describe '#optimize_image_data' do
     it 'create temp file, optimizes image and returns data' do
       data = double
-      temp = double(:path => double)
+      temp = double(path: double)
       optimized = double
       optimized_data = double
       image_optim = ImageOptim.new
@@ -165,7 +202,7 @@ describe ImageOptim do
 
     it 'returns nil if optimization fails' do
       data = double
-      temp = double(:path => double)
+      temp = double(path: double)
       image_optim = ImageOptim.new
 
       allow(ImageOptim::ImageMeta).to receive(:format_for_data).
@@ -216,7 +253,7 @@ describe ImageOptim do
 
       describe 'given block' do
         it 'optimizes images, yields path and result for each and '\
-            'returns array of yield results' do
+           'returns array of yield results' do
           image_optim = ImageOptim.new
           results = test_images.map do |src|
             dst = double

data/spec/images/invisiblepixels/generate

@@ -17,7 +17,7 @@ IO.popen(%W[
 ].shelljoin, 'w') do |f|
   side.times do |a|
     side.times do |b|
-      alpha = [0, 1, 0x7f, 0xff][(a / 8 + b / 8) % 4]
+      alpha = [0, 1, 0x7f, 0xff][((a / 8) + (b / 8)) % 4]
       f << [rand(256), rand(256), rand(256), alpha].pack('C*')
     end
   end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-if ENV['CODECLIMATE']
+if ENV['CC_TEST_REPORTER_ID']
   require 'simplecov'
   SimpleCov.start
 end
@@ -23,16 +23,18 @@ RSpec.configure do |c|
   c.order = :random
 end
 
+IMAGEMAGICK_PREFIX = ImageOptim::Cmd.capture('which magick').empty? ? [] : %w[magick]
+
 def flatten_animation(image)
   if image.image_format == :gif
     flattened = image.temp_path
-    command = %W[
+    command = (IMAGEMAGICK_PREFIX + %W[
       convert
       #{image}
       -coalesce
       -append
       #{flattened}
-    ].shelljoin
+    ]).shelljoin
     expect(ImageOptim::Cmd.run(command)).to be_truthy
     flattened
   else
@@ -43,7 +45,7 @@ end
 def mepp(image_a, image_b)
   coalesce_a = flatten_animation(image_a)
   coalesce_b = flatten_animation(image_b)
-  output = ImageOptim::Cmd.capture(%W[
+  output = ImageOptim::Cmd.capture((IMAGEMAGICK_PREFIX + %W[
     compare
     -metric MEPP
     -alpha Background
@@ -51,7 +53,7 @@ def mepp(image_a, image_b)
     #{coalesce_b.to_s.shellescape}
     #{ImageOptim::Path::NULL}
     2>&1
-  ].join(' '))
+  ]).join(' '))
   unless [0, 1].include?($CHILD_STATUS.exitstatus)
     fail "compare #{image_a} with #{image_b} failed with `#{output}`"
   end
@@ -71,26 +73,27 @@ RSpec::Matchers.define :be_similar_to do |expected, max_difference|
   end
   failure_message do |actual|
     "expected #{actual} to have at most #{max_difference} difference from "\
-        "#{expected}, got normalized root-mean-square error of #{@diff}"
+      "#{expected}, got mean error per pixel of #{@diff}"
   end
 end
 
-module CapabilityCheckHelpers
-  def any_file_modes_allowed?
-    Tempfile.open 'posix' do |f|
+SkipConditions = Hash.new do |cache, name|
+  cache[name] = case name
+  when :any_file_mode_allowed
+    Tempfile.open('posix') do |f|
       File.chmod(0, f.path)
-      return (File.stat(f.path).mode & 0o777).zero?
+      'full file modes are not support' unless (File.stat(f.path).mode & 0o777).zero?
     end
-  end
-
-  def inodes_supported?
-    !File.stat(__FILE__).ino.zero?
-  end
-
-  def signals_supported?
-    Process.kill(0, 0)
-    true
-  rescue
-    false
+  when :inodes_support
+    'inodes are not supported' if File.stat(__FILE__).ino.zero?
+  when :signals_support
+    begin
+      Process.kill(0, 0)
+      nil
+    rescue
+      'signals are not supported'
+    end
+  else
+    fail "Unknown check #{name}"
   end
 end