image_optim 0.22.1 → 0.23.0

data/spec/image_optim/cache_path_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'image_optim/cache_path'
+require 'tempfile'
+
+describe ImageOptim::CachePath do
+  include CapabilityCheckHelpers
+
+  before do
+    stub_const('CachePath', ImageOptim::CachePath)
+  end
+
+  describe '#replace' do
+    let(:src){ CachePath.temp_file_path }
+    let(:dst){ CachePath.temp_file_path }
+
+    it 'moves data to destination' do
+      src.write('src')
+
+      src.replace(dst)
+
+      expect(dst.read).to eq('src')
+    end
+
+    it 'does not remove original file' do
+      src.replace(dst)
+
+      expect(src).to exist
+    end
+
+    it 'preserves attributes of destination file' do
+      skip 'full file modes are not support' unless any_file_modes_allowed?
+      mode = 0o666
+
+      dst.chmod(mode)
+
+      src.replace(dst)
+
+      got = dst.stat.mode & 0o777
+      expect(got).to eq(mode), format('expected %04o, got %04o', mode, got)
+    end
+
+    it 'does not preserve mtime of destination file' do
+      time = src.mtime
+
+      dst.utime(time - 1000, time - 1000)
+
+      src.replace(dst)
+
+      expect(dst.mtime).to be >= time
+    end
+
+    it 'changes inode of destination' do
+      skip 'inodes are not supported' unless inodes_supported?
+      expect do
+        src.replace(dst)
+      end.to change{ dst.stat.ino }
+    end
+  end
+end

data/spec/image_optim/cache_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require 'fspath'
+require 'image_optim/cache'
+require 'image_optim/path'
+
+describe ImageOptim::Cache do
+  before do
+    stub_const('Cache', ImageOptim::Cache)
+    stub_const('CachePath', ImageOptim::CachePath)
+  end
+
+  let(:tmp_file){ double('/somewhere/tmp/foo/bar', :rename => 0) }
+
+  let(:cache_dir) do
+    dir = '/somewhere/cache'
+    allow(FileUtils).to receive(:mkpath).with(Regexp.new(Regexp.escape(dir)))
+    allow(FileUtils).to receive(:touch)
+    allow(FSPath).to receive(:temp_file_path) do
+      tmp_file
+    end
+    FSPath.new(dir)
+  end
+
+  let(:original) do
+    original = double('/somewhere/original', :image_format => :ext)
+    allow(Digest::SHA1).to receive(:file).with(original) do
+      Digest::SHA1.new << 'some content!'
+    end
+    original
+  end
+
+  let(:optimized) do
+    double('/somewhere/optimized', :format => :ext, :basename => 'optimized')
+  end
+
+  let(:cached) do
+    cached = cache_dir / digest
+    allow(Digest::SHA1).to receive(:file).with(cached) do
+      Digest::SHA1.new << 'some optimized content!'
+    end
+    CachePath.convert(cached)
+  end
+
+  context 'when cache is disabled (default)' do
+    let(:image_optim) do
+      double(:image_optim, :cache_dir => nil, :cache_worker_digests => false)
+    end
+    let(:cache){ Cache.new(image_optim, double) }
+
+    describe :fetch do
+      it 'always return block' do
+        expect(cache.fetch(original){ optimized }).to be optimized
+      end
+    end
+
+    describe :fetch do
+      it 'does not write to disk' do
+        expect(FileUtils).not_to receive(:mv)
+        expect(FileUtils).not_to receive(:touch)
+        expect(cache.fetch(original){ optimized })
+      end
+    end
+  end
+
+  shared_examples 'an enabled cache' do
+    context 'when cached file does not exist' do
+      describe :fetch do
+        it 'writes to cache when file is optimizable' do
+          cached_s = cached.to_s
+          expect(FileTest).to receive(:file?).with(cached_s).and_return(false)
+          expect(FileTest).not_to receive(:size?).with(cached_s)
+          expect(FileUtils).to receive(:mv).with(anything, tmp_file)
+          expect(tmp_file).to receive(:rename).with(cached)
+
+          expect(cache.fetch(original){ optimized }).to eq(cached)
+        end
+
+        it 'writes an empty file to cache when file is already optimized' do
+          cached_s = cached.to_s
+          expect(FileTest).to receive(:file?).with(cached_s).and_return(false)
+          expect(FileTest).not_to receive(:size?).with(cached_s)
+          expect(FileUtils).to receive(:mv).with(anything, tmp_file)
+          expect(tmp_file).to receive(:rename).with(cached)
+
+          expect(cache.fetch(original){ optimized }).to eq(cached)
+        end
+      end
+    end
+
+    context 'when cached file exists (options and/or workers match)' do
+      describe(:fetch) do
+        it 'returns cached file' do
+          cached_s = cached.to_s
+          allow(FileTest).to receive(:file?).with(cached_s).and_return(true)
+          allow(FileTest).to receive(:size?).with(cached_s).and_return(1234)
+          expect(FileUtils).not_to receive(:mv)
+          expect(File).not_to receive(:rename)
+
+          expect(cache.fetch(original){}).to eq(cached)
+        end
+
+        it 'returns nil when file is already optimized' do
+          cached_s = cached.to_s
+          allow(FileTest).to receive(:file?).with(cached_s).and_return(true)
+          allow(FileTest).to receive(:size?).with(cached_s).and_return(nil)
+          expect(FileUtils).not_to receive(:mv)
+          expect(File).not_to receive(:rename)
+
+          expect(cache.fetch(original){}).to eq(nil)
+        end
+      end
+    end
+  end
+
+  context 'when cache is enabled (without worker digests)' do
+    let(:image_optim) do
+      double(:image_optim,
+             :cache_dir => cache_dir, :cache_worker_digests => false)
+    end
+    let(:cache) do
+      cache = Cache.new(image_optim, {})
+      allow(cache).
+        to receive(:options_by_format).
+        with(original.image_format).
+        and_return('some options!')
+      allow(cache).
+        to receive(:bins_by_format).
+        with(original.image_format).
+        and_return('some bins!')
+      cache
+    end
+    let(:digest){ cache.send(:digest, original, original.image_format) }
+
+    it_behaves_like 'an enabled cache'
+  end
+
+  context 'when cache is enabled (with worker digests)' do
+    let(:image_optim) do
+      double(:image_optim,
+             :cache_dir => cache_dir,
+             :cache_worker_digests => true)
+    end
+    let(:cache) do
+      cache = Cache.new(image_optim, {})
+      allow(cache).
+        to receive(:options_by_format).
+        with(original.image_format).
+        and_return('some options!')
+      allow(cache).
+        to receive(:bins_by_format).
+        with(original.image_format).
+        and_return('some bins!')
+      cache
+    end
+    let(:digest){ cache.send(:digest, original, original.image_format) }
+
+    it_behaves_like 'an enabled cache'
+  end
+end

data/spec/image_optim/cmd_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'image_optim/cmd'
 
 describe ImageOptim::Cmd do
+  include CapabilityCheckHelpers
+
   before do
     stub_const('Cmd', ImageOptim::Cmd)
   end
@@ -12,7 +14,7 @@ describe ImageOptim::Cmd do
     end
   end
 
-  describe :run do
+  describe '.run' do
     it 'calls system and returns result' do
       status = double
       expect(Cmd).to receive(:system).with('cmd', 'arg').and_return(status)
@@ -21,24 +23,25 @@ describe ImageOptim::Cmd do
     end
 
     it 'returns process success status' do
-      expect(Cmd.run('sh -c exit\ 0')).to eq(true)
+      expect(Cmd.run('sh -c "exit 0"')).to eq(true)
       expect($CHILD_STATUS.exitstatus).to eq(0)
 
-      expect(Cmd.run('sh -c exit\ 1')).to eq(false)
+      expect(Cmd.run('sh -c "exit 1"')).to eq(false)
       expect($CHILD_STATUS.exitstatus).to eq(1)
 
-      expect(Cmd.run('sh -c exit\ 66')).to eq(false)
+      expect(Cmd.run('sh -c "exit 66"')).to eq(false)
       expect($CHILD_STATUS.exitstatus).to eq(66)
     end
 
     it 'raises SignalException if process terminates after signal' do
+      skip 'signals are not supported' unless signals_supported?
       expect_int_exception do
         Cmd.run('kill -s INT $$')
       end
     end
   end
 
-  describe :capture do
+  describe '.capture' do
     it 'calls ` and returns result' do
       output = double
       expect(Cmd).to receive(:`).with('cmd arg arg+').and_return(output)
@@ -50,14 +53,15 @@ describe ImageOptim::Cmd do
       expect(Cmd.capture('echo test')).to eq("test\n")
       expect($CHILD_STATUS.exitstatus).to eq(0)
 
-      expect(Cmd.capture('printf more; sh -c exit\ 1')).to eq('more')
+      expect(Cmd.capture('printf more && sh -c "exit 1"')).to eq('more')
       expect($CHILD_STATUS.exitstatus).to eq(1)
 
-      expect(Cmd.capture('sh -c exit\ 66')).to eq('')
+      expect(Cmd.capture('sh -c "exit 66"')).to eq('')
       expect($CHILD_STATUS.exitstatus).to eq(66)
     end
 
     it 'raises SignalException if process terminates after signal' do
+      skip 'signals are not supported' unless signals_supported?
       expect_int_exception do
         Cmd.capture('kill -s INT $$')
       end

data/spec/image_optim/config_spec.rb

@@ -6,7 +6,7 @@ describe ImageOptim::Config do
     stub_const('IOConfig', ImageOptim::Config)
   end
 
-  describe :assert_no_unused_options! do
+  describe '#assert_no_unused_options!' do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
     end
@@ -24,7 +24,7 @@ describe ImageOptim::Config do
     end
   end
 
-  describe :nice do
+  describe '#nice' do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
     end
@@ -45,7 +45,7 @@ describe ImageOptim::Config do
     end
   end
 
-  describe :threads do
+  describe '#threads' do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
     end
@@ -67,17 +67,40 @@ describe ImageOptim::Config do
     end
   end
 
-  describe :for_worker do
+  describe '#cache_dir' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is nil by default' do
+      config = IOConfig.new({})
+      expect(config.cache_dir).to be nil
+    end
+
+    it 'is nil if set to the empty string' do
+      config = IOConfig.new(:cache_dir => '')
+      expect(config.cache_dir).to be nil
+    end
+  end
+
+  describe '#cache_worker_digests' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is false by default' do
+      config = IOConfig.new({})
+      expect(config.cache_worker_digests).to be false
+    end
+  end
+
+  describe '#for_worker' do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
       stub_const('Abc', Class.new do
         def self.bin_sym
           :abc
         end
-
-        def image_formats
-          []
-        end
       end)
     end
 
@@ -104,7 +127,7 @@ describe ImageOptim::Config do
     end
   end
 
-  describe 'config' do
+  describe '#initialize' do
     it 'reads options from default locations' do
       expect(IOConfig).to receive(:read_options).
         with(IOConfig::GLOBAL_PATH).and_return(:a => 1, :b => 2, :c => 3)
@@ -150,68 +173,66 @@ describe ImageOptim::Config do
     end
   end
 
-  describe 'class methods' do
-    describe :read_options do
-      let(:path){ double(:path) }
-      let(:full_path){ double(:full_path) }
-
-      it 'warns if expand path fails' do
-        expect(IOConfig).to receive(:warn)
-        expect(File).to receive(:expand_path).
-          with(path).and_raise(ArgumentError)
-        expect(File).not_to receive(:file?)
-
-        expect(IOConfig.read_options(path)).to eq({})
-      end
-
-      it 'returns empty hash if path is not a file' do
-        expect(IOConfig).not_to receive(:warn)
-        expect(File).to receive(:expand_path).
-          with(path).and_return(full_path)
-        expect(File).to receive(:file?).
-          with(full_path).and_return(false)
-
-        expect(IOConfig.read_options(path)).to eq({})
-      end
-
-      it 'returns hash with deep symbolised keys from reader' do
-        stringified = {'config' => {'this' => true}}
-        symbolized = {:config => {:this => true}}
-
-        expect(IOConfig).not_to receive(:warn)
-        expect(File).to receive(:expand_path).
-          with(path).and_return(full_path)
-        expect(File).to receive(:file?).
-          with(full_path).and_return(true)
-        expect(YAML).to receive(:load_file).
-          with(full_path).and_return(stringified)
-
-        expect(IOConfig.read_options(path)).to eq(symbolized)
-      end
-
-      it 'warns and returns an empty hash if reader returns non hash' do
-        expect(IOConfig).to receive(:warn)
-        expect(File).to receive(:expand_path).
-          with(path).and_return(full_path)
-        expect(File).to receive(:file?).
-          with(full_path).and_return(true)
-        expect(YAML).to receive(:load_file).
-          with(full_path).and_return([:config])
-
-        expect(IOConfig.read_options(path)).to eq({})
-      end
-
-      it 'warns and returns an empty hash if reader raises exception' do
-        expect(IOConfig).to receive(:warn)
-        expect(File).to receive(:expand_path).
-          with(path).and_return(full_path)
-        expect(File).to receive(:file?).
-          with(full_path).and_return(true)
-        expect(YAML).to receive(:load_file).
-          with(full_path).and_raise
-
-        expect(IOConfig.read_options(path)).to eq({})
-      end
+  describe '.read_options' do
+    let(:path){ double(:path) }
+    let(:full_path){ double(:full_path) }
+
+    it 'warns if expand path fails' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_raise(ArgumentError)
+      expect(File).not_to receive(:size?)
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'returns empty hash if path is not a file or is an empty file' do
+      expect(IOConfig).not_to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(false)
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'returns hash with deep symbolised keys from reader' do
+      stringified = {'config' => {'this' => true}}
+      symbolized = {:config => {:this => true}}
+
+      expect(IOConfig).not_to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_return(stringified)
+
+      expect(IOConfig.read_options(path)).to eq(symbolized)
+    end
+
+    it 'warns and returns an empty hash if reader returns non hash' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_return([:config])
+
+      expect(IOConfig.read_options(path)).to eq({})
+    end
+
+    it 'warns and returns an empty hash if reader raises exception' do
+      expect(IOConfig).to receive(:warn)
+      expect(File).to receive(:expand_path).
+        with(path).and_return(full_path)
+      expect(File).to receive(:size?).
+        with(full_path).and_return(true)
+      expect(YAML).to receive(:load_file).
+        with(full_path).and_raise
+
+      expect(IOConfig.read_options(path)).to eq({})
     end
   end
 end