image_optim 0.22.1 → 0.23.0

data/spec/image_optim/worker_spec.rb

@@ -6,12 +6,36 @@ describe ImageOptim::Worker do
   before do
     stub_const('Worker', ImageOptim::Worker)
     stub_const('BinResolver', ImageOptim::BinResolver)
+
+    # don't add to list of wokers
+    allow(ImageOptim::Worker).to receive(:inherited)
+  end
+
+  describe '#initialize' do
+    it 'expects first argument to be an instanace of ImageOptim' do
+      expect do
+        Worker.new(double)
+      end.to raise_error ArgumentError
+    end
+  end
+
+  describe '#options' do
+    it 'returns a Hash with options' do
+      worker_class = Class.new(Worker) do
+        option(:one, 1, 'One')
+        option(:two, 2, 'Two')
+        option(:three, 3, 'Three')
+      end
+
+      worker = worker_class.new(ImageOptim.new, :three => '...')
+
+      expect(worker.options).to eq(:one => 1, :two => 2, :three => '...')
+    end
   end
 
-  describe :optimize do
+  describe '#optimize' do
     it 'raises NotImplementedError' do
-      image_optim = ImageOptim.new
-      worker = Worker.new(image_optim, {})
+      worker = Worker.new(ImageOptim.new, {})
 
       expect do
         worker.optimize(double, double)
@@ -19,7 +43,50 @@ describe ImageOptim::Worker do
     end
   end
 
-  describe :create_all_by_format do
+  describe '#image_formats' do
+    {
+      'GifOptim' => :gif,
+      'JpegOptim' => :jpeg,
+      'PngOptim' => :png,
+      'SvgOptim' => :svg,
+    }.each do |class_name, image_format|
+      it "detects if class name contains #{image_format}" do
+        worker = stub_const(class_name, Class.new(Worker)).new(ImageOptim.new)
+        expect(worker.image_formats).to eq([image_format])
+      end
+    end
+
+    it 'fails if class name does not contain known type' do
+      worker = stub_const('TiffOptim', Class.new(Worker)).new(ImageOptim.new)
+      expect{ worker.image_formats }.to raise_error(/can't guess/)
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns inspect String containing options' do
+      stub_const('DefOptim', Class.new(Worker) do
+        option(:one, 1, 'One')
+        option(:two, 2, 'Two')
+        option(:three, 3, 'Three')
+      end)
+
+      worker = DefOptim.new(ImageOptim.new, :three => '...')
+
+      expect(worker.inspect).to eq('#<DefOptim @one=1, @two=2, @three="...">')
+    end
+  end
+
+  describe '.inherited' do
+    it 'adds subclasses to klasses' do
+      base_class = Class.new{ extend ImageOptim::Worker::ClassMethods }
+      expect(base_class.klasses.to_a).to eq([])
+
+      worker_class = Class.new(base_class)
+      expect(base_class.klasses.to_a).to eq([worker_class])
+    end
+  end
+
+  describe '.create_all_by_format' do
     it 'passes arguments to create_all' do
       image_optim = double
       options_proc = proc{ true }
@@ -52,17 +119,21 @@ describe ImageOptim::Worker do
     end
   end
 
-  describe :create_all do
+  describe '.create_all' do
     def worker_double(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) }
+    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) }
+      klasses = worker_class_doubles(workers)
       options_proc = proc do |klass|
         klass == klasses[1] ? {:disable => true} : {}
       end
@@ -79,7 +150,7 @@ describe ImageOptim::Worker do
         [worker_double, worker_double, worker_double],
         worker_double,
       ]
-      klasses = workers.map{ |worker| double(:init => worker) }
+      klasses = worker_class_doubles(workers)
 
       allow(Worker).to receive(:klasses).and_return(klasses)
 
@@ -98,7 +169,7 @@ describe ImageOptim::Worker do
           worker
         end
       end
-      let(:klasses){ workers.map{ |worker| double(:init => worker) } }
+      let(:klasses){ worker_class_doubles(workers) }
 
       before do
         allow(Worker).to receive(:klasses).and_return(klasses)
@@ -136,12 +207,11 @@ describe ImageOptim::Worker do
     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 = worker_class_doubles(workers)
 
       [
         klasses_list,
@@ -157,13 +227,43 @@ describe ImageOptim::Worker do
         expect(Worker.create_all(image_optim){ {} }).to eq(expected_order)
       end
     end
+
+    describe 'passing allow_lossy' do
+      it 'passes allow_lossy if worker has such attribute' do
+        klasses = worker_class_doubles([worker_double, worker_double])
+
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        klasses[0].send(:attr_reader, :allow_lossy)
+        expect(klasses[0]).to receive(:init).
+          with(image_optim, hash_including(:allow_lossy))
+        expect(klasses[1]).to receive(:init).
+          with(image_optim, hash_not_including(:allow_lossy))
+
+        Worker.create_all(image_optim){ {} }
+      end
+
+      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} : {}
+        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))
+        expect(klasses[1]).to receive(:init).
+          with(image_optim, hash_including(:allow_lossy => :b))
+
+        Worker.create_all(image_optim, &options_proc)
+      end
+    end
   end
 
-  describe :option do
+  describe '.option' do
     it 'runs option block in context of worker' do
-      # don't add Abc to list of wokers
-      allow(ImageOptim::Worker).to receive(:inherited)
-
       stub_const('Abc', Class.new(Worker) do
         option(:test, 1, 'Test context') do |_v|
           some_instance_method
@@ -176,9 +276,6 @@ describe ImageOptim::Worker do
     end
 
     it 'returns instance of OptionDefinition' do
-      # don't add Abc to list of wokers
-      allow(ImageOptim::Worker).to receive(:inherited)
-
       definition = nil
       Class.new(Worker) do
         definition = option(:test, 1, 'Test'){ |v| v }

data/spec/image_optim_spec.rb

@@ -5,7 +5,7 @@ require 'tempfile'
 require 'English'
 
 describe ImageOptim do
-  root_dir = ImageOptim::ImagePath.new(__FILE__).dirname.dirname
+  root_dir = ImageOptim::Path.new(__FILE__).dirname.dirname
   images_dir = root_dir / 'spec/images'
   test_images = images_dir.glob('**/*.*').freeze
 
@@ -17,15 +17,8 @@ describe ImageOptim do
   include helpers
   extend helpers
 
-  matcher :be_in_range do |expected|
-    match{ |actual| expected.include?(actual) }
-  end
-
   before do
     stub_const('Cmd', ImageOptim::Cmd)
-
-    allow(ImageOptim::Config).to receive(:global).and_return({})
-    allow(ImageOptim::Config).to receive(:local).and_return({})
   end
 
   isolated_options_base = {:skip_missing_workers => false}
@@ -50,7 +43,7 @@ describe ImageOptim do
     end
   end
 
-  describe :optimize_image do
+  describe '#optimize_image' do
     define :have_same_data_as do |expected|
       match{ |actual| actual.binread == expected.binread }
     end
@@ -68,30 +61,28 @@ describe ImageOptim do
         ['lossless', base_options, 0],
         ['lossy', base_options.merge(:allow_lossy => true), 0.001],
       ].each do |type, options, max_difference|
-        image_optim = ImageOptim.new(options)
-        describe type do
+        it "does it #{type}" do
+          image_optim = ImageOptim.new(options)
           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
+            expect(copy).to have_same_data_as(original)
+
+            expect(optimized).not_to be_nil
+            expect(optimized).to be_a(ImageOptim::OptimizedPath)
+            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
 
     it 'ignores text file' do
-      original = ImageOptim::ImagePath.new(__FILE__)
+      original = ImageOptim::Path.new(__FILE__)
       copy = temp_copy(original)
 
       expect(Tempfile).not_to receive(:new)
@@ -106,27 +97,27 @@ describe ImageOptim do
     }.each do |type, data|
       it "ingores broken #{type}" do
         path = FSPath.temp_file_path
-        path.write(data)
+        path.binwrite(data)
         expect(ImageOptim::ImageMeta).to receive(:warn)
         expect(ImageOptim.optimize_image(path)).to be_nil
       end
     end
   end
 
-  describe :optimize_image! do
+  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
 
-      allow(ImageOptim::ImagePath).to receive(:convert).
+      allow(ImageOptim::Path).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).
+      expect(ImageOptim::OptimizedPath).to receive(:new).
         with(original, 12_345).and_return(optimized_wrap)
 
       expect(image_optim.optimize_image!(original)).to eq(optimized_wrap)
@@ -136,18 +127,18 @@ describe ImageOptim do
       original = double
       image_optim = ImageOptim.new
 
-      allow(ImageOptim::ImagePath).to receive(:convert).
+      allow(ImageOptim::Path).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(ImageOptim::OptimizedPath).not_to receive(:new)
 
       expect(image_optim.optimize_image!(original)).to eq(nil)
     end
   end
 
-  describe :optimize_image_data do
+  describe '#optimize_image_data' do
     it 'create temp file, optimizes image and returns data' do
       data = double
       temp = double(:path => double)
@@ -155,10 +146,10 @@ describe ImageOptim do
       optimized_data = double
       image_optim = ImageOptim.new
 
-      allow(ImageOptim::ImageMeta).to receive(:for_data).
-        with(data).and_return(double(:format => 'xxx'))
+      allow(ImageOptim::ImageMeta).to receive(:format_for_data).
+        with(data).and_return('xxx')
 
-      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(ImageOptim::Path).to receive(:temp_file).and_yield(temp)
       expect(temp).to receive(:binmode)
       expect(temp).to receive(:write).with(data)
       expect(temp).to receive(:close)
@@ -174,10 +165,10 @@ describe ImageOptim do
       temp = double(:path => double)
       image_optim = ImageOptim.new
 
-      allow(ImageOptim::ImageMeta).to receive(:for_data).
-        with(data).and_return(double(:format => 'xxx'))
+      allow(ImageOptim::ImageMeta).to receive(:format_for_data).
+        with(data).and_return('xxx')
 
-      expect(ImageOptim::ImagePath).to receive(:temp_file).and_yield(temp)
+      expect(ImageOptim::Path).to receive(:temp_file).and_yield(temp)
       expect(temp).to receive(:binmode)
       expect(temp).to receive(:write).with(data)
       expect(temp).to receive(:close)
@@ -191,49 +182,47 @@ describe ImageOptim do
       data = double
       image_optim = ImageOptim.new
 
-      allow(ImageOptim::ImageMeta).to receive(:for_data).
-        with(data).and_return(double(:format => nil))
+      allow(ImageOptim::ImageMeta).to receive(:format_for_data).
+        with(data).and_return(nil)
 
-      expect(ImageOptim::ImagePath).not_to receive(:temp_file)
+      expect(ImageOptim::Path).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
-    %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 'optimizes images and returns array of results' do
-            image_optim = ImageOptim.new
-            results = test_images.map do |src|
-              dst = double
-              expect(image_optim).to receive(method).with(src).and_return(dst)
-              [src, dst]
-            end
-            expect(image_optim.send(list_method, test_images)).to eq(results)
+  %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 'optimizes images and returns array of results' do
+          image_optim = ImageOptim.new
+          results = test_images.map do |src|
+            dst = double
+            expect(image_optim).to receive(method).with(src).and_return(dst)
+            [src, dst]
           end
+          expect(image_optim.send(list_method, test_images)).to eq(results)
         end
+      end
 
-        describe 'given block' do
-          it 'optimizes images, yields path and result for each and '\
-              'returns array of yield results' do
-            image_optim = ImageOptim.new
-            results = test_images.map do |src|
-              dst = double
-              expect(image_optim).to receive(method).with(src).and_return(dst)
-              [src, dst, :test]
-            end
-            expect(image_optim.send(list_method, test_images) do |src, dst|
-              [src, dst, :test]
-            end).to eq(results)
+      describe 'given block' do
+        it 'optimizes images, yields path and result for each and '\
+            'returns array of yield results' do
+          image_optim = ImageOptim.new
+          results = test_images.map do |src|
+            dst = double
+            expect(image_optim).to receive(method).with(src).and_return(dst)
+            [src, dst, :test]
           end
+          expect(image_optim.send(list_method, test_images) do |src, dst|
+            [src, dst, :test]
+          end).to eq(results)
         end
       end
     end

data/spec/images/broken_jpeg

@@ -0,0 +1 @@
+��

data/spec/spec_helper.rb

@@ -1,18 +1,28 @@
-if ENV['CODECLIMATE_REPO_TOKEN']
-  begin
-    require 'codeclimate-test-reporter'
-    CodeClimate::TestReporter.start
-  rescue LoadError => e
-    $stderr.puts "Got following while loading codeclimate-test-reporter: #{e}"
-  end
+if ENV['CODECLIMATE'] && ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
 end
 
+require 'image_optim/pack'
+require 'image_optim/path'
+
+ENV['PATH'] = [
+  ImageOptim::Pack.path,
+  ENV['PATH'],
+].compact.join File::PATH_SEPARATOR
+
 RSpec.configure do |c|
-  c.alias_example_to :they
+  c.before do
+    stub_const('ImageOptim::Config::GLOBAL_PATH', ImageOptim::Path::NULL)
+    stub_const('ImageOptim::Config::LOCAL_PATH', ImageOptim::Path::NULL)
+    ImageOptim.class_eval{ def pack; end }
+  end
+
+  c.order = :random
 end
 
 def flatten_animation(image)
-  if image.format == :gif
+  if image.image_format == :gif
     flattened = image.temp_path
     command = %W[
       convert
@@ -37,7 +47,7 @@ def mepp(image_a, image_b)
     -alpha Background
     #{coalesce_a.to_s.shellescape}
     #{coalesce_b.to_s.shellescape}
-    /dev/null
+    #{ImageOptim::Path::NULL}
     2>&1
   ].join(' ')
   output = ImageOptim::Cmd.capture(command)
@@ -63,3 +73,23 @@ RSpec::Matchers.define :be_similar_to do |expected, max_difference|
         "#{expected}, got normalized root-mean-square error of #{@diff}"
   end
 end
+
+module CapabilityCheckHelpers
+  def any_file_modes_allowed?
+    Tempfile.open 'posix' do |f|
+      File.chmod(0, f.path)
+      File.stat(f.path).mode & 0o777 == 0
+    end
+  end
+
+  def inodes_supported?
+    File.stat(__FILE__).ino != 0
+  end
+
+  def signals_supported?
+    Process.kill(0, 0)
+    true
+  rescue
+    false
+  end
+end