image_optim 0.22.1 → 0.23.0

data/spec/image_optim/bin_resolver/comparable_condition_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'image_optim/bin_resolver/comparable_condition'
 
 describe ImageOptim::BinResolver::ComparableCondition do
-  is = ImageOptim::BinResolver::ComparableCondition.is
+  let(:is){ ImageOptim::BinResolver::ComparableCondition.is }
 
   it 'builds conditions' do
     expect(is.between?(10, 20).method).to eq(:between?)

data/spec/image_optim/bin_resolver/simple_version_spec.rb

@@ -2,56 +2,64 @@ require 'spec_helper'
 require 'image_optim/bin_resolver/simple_version'
 
 describe ImageOptim::BinResolver::SimpleVersion do
-  helpers = Module.new do
-    def v(str)
-      ImageOptim::BinResolver::SimpleVersion.new(str)
-    end
-  end
-  include helpers
-  extend helpers
-
-  describe 'compares version 1.17' do
-    subject{ v '1.17' }
-
-    it{ is_expected.to be > '0' }
-    it{ is_expected.to be > '0.1' }
-    it{ is_expected.to be > '0.9' }
-    it{ is_expected.to be > '1.9' }
-    it{ is_expected.to be < '1.17.1' }
-    it{ is_expected.to be < '1.99' }
-    it{ is_expected.to be < '2.1' }
+  def v(str)
+    described_class.new(str)
   end
 
-  describe 'normalization' do
-    %w[
-      1
-      01
-      1.0
-      1.00
-      1.0.0
-      1.0.0.0
-    ].each do |variation|
-      it "normalizes #{variation}" do
-        expect(v(variation)).to eq(1)
+  describe '#initialize' do
+    describe 'conversion' do
+      it 'converts Integer' do
+        expect(v(117)).to eq('117')
       end
-    end
-  end
 
-  describe 'conversion' do
-    it 'converts Integer' do
-      expect(v(117)).to eq('117')
+      it 'converts Float' do
+        expect(v(1.17)).to eq('1.17')
+      end
+
+      it 'converts String' do
+        expect(v('1.17')).to eq('1.17')
+      end
+
+      it 'converts self' do
+        expect(v(v(1.17))).to eq('1.17')
+      end
     end
 
-    it 'converts Float' do
-      expect(v(1.17)).to eq('1.17')
+    describe 'normalization' do
+      %w[
+        1
+        01
+        1.0
+        1.00
+        1.0.0
+        1.0.0.0
+      ].each do |variation|
+        it "normalizes #{variation}" do
+          expect(v(variation)).to eq(1)
+        end
+      end
     end
+  end
 
-    it 'converts String' do
-      expect(v('1.17')).to eq('1.17')
+  describe '#to_s' do
+    it 'returns the original value converted to String' do
+      expect(v(117).to_s).to eq('117')
+      expect(v(1.17).to_s).to eq('1.17')
+      expect(v('0117').to_s).to eq('0117')
     end
+  end
+
+  describe '#<=>' do
+    describe 'comparing version 1.17' do
+      subject{ v '1.17' }
 
-    it 'converts self' do
-      expect(v(v(1.17))).to eq('1.17')
+      it{ is_expected.to be > '0' }
+      it{ is_expected.to be > '0.1' }
+      it{ is_expected.to be > '0.9' }
+      it{ is_expected.to be > '1.9' }
+      it{ is_expected.to be < '1.17.1' }
+      it{ is_expected.to be < '1.99' }
+      it{ is_expected.to be < '2.1' }
     end
   end
 end

data/spec/image_optim/bin_resolver_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 require 'image_optim/bin_resolver'
 require 'image_optim/cmd'
+require 'image_optim/path'
 
 describe ImageOptim::BinResolver do
-  def with_env(key, value)
-    saved, ENV[key] = ENV[key], value
-    yield
-  ensure
-    ENV[key] = saved
+  def stub_env(key, value)
+    allow(ENV).to receive(:[]).with(key).and_return(value)
   end
 
   before do
@@ -15,71 +13,67 @@ describe ImageOptim::BinResolver do
     stub_const('Bin', BinResolver::Bin)
     stub_const('SimpleVersion', BinResolver::SimpleVersion)
     stub_const('Cmd', ImageOptim::Cmd)
+
+    allow(ENV).to receive(:[]).and_call_original
   end
 
   let(:image_optim){ double(:image_optim, :verbose => false, :pack => false) }
   let(:resolver){ BinResolver.new(image_optim) }
 
-  describe :full_path do
+  describe '#full_path' do
     def full_path(name)
       resolver.instance_eval{ full_path(name) }
     end
 
-    def command_v(name)
-      path = Cmd.capture("sh -c 'command -v #{name}' 2> /dev/null").strip
-      path unless path.empty?
-    end
-
-    it 'finds binary in path' do
-      with_env 'PATH', 'bin' do
-        expect(full_path('image_optim')).
-          to eq(File.expand_path('bin/image_optim'))
-      end
-    end
+    context 'when PATHEXT is not set' do
+      it 'finds binary without ext in combined path' do
+        stub_env 'PATH', %w[/a /b /c /d].join(File::PATH_SEPARATOR)
+        stub_env 'PATHEXT', nil
+
+        [
+          [:file?,        '/a/abc', false],
+          [:file?,        '/b/abc', true],
+          [:executable?,  '/b/abc', false],
+          [:file?,        '/c/abc', true],
+          [:executable?,  '/c/abc', true],
+        ].each do |method, path, result|
+          allow(File).to receive(method).
+            with(File.expand_path(path)).and_return(result)
+        end
 
-    it 'finds bin in vendor' do
-      with_env 'PATH', nil do
-        expect(full_path('jpegrescan')).
-          to eq(File.expand_path('vendor/jpegrescan'))
+        expect(full_path('abc')).
+          to eq(File.expand_path('/c/abc'))
       end
     end
 
-    it 'finds bin in pack' do
-      allow(image_optim).to receive(:pack).and_return(true)
-      stub_const('ImageOptim::Pack', Class.new do
-        def self.path
-          'script'
+    context 'when PATHEXT is set' do
+      it 'finds binary with ext in combined path' do
+        stub_env 'PATH', %w[/a /b].join(File::PATH_SEPARATOR)
+        stub_env 'PATHEXT', '.com;.bat'
+
+        [
+          [:file?,        '/a/abc.com', false],
+          [:file?,        '/a/abc.bat', true],
+          [:executable?,  '/a/abc.bat', false],
+          [:file?,        '/b/abc.com', true],
+          [:executable?,  '/b/abc.com', true],
+        ].each do |method, path, result|
+          allow(File).to receive(method).
+            with(File.expand_path(path)).and_return(result)
         end
-      end)
 
-      with_env 'PATH', nil do
-        expect(full_path('update_worker_options_in_readme')).
-          to eq(File.expand_path('script/update_worker_options_in_readme'))
-      end
-    end
-
-    it 'works with different path separator' do
-      stub_const('File::PATH_SEPARATOR', 'O_o')
-      with_env 'PATH', 'bin' do
-        expect(full_path('image_optim')).
-          to eq(File.expand_path('bin/image_optim'))
+        expect(full_path('abc')).
+          to eq(File.expand_path('/b/abc.com'))
       end
     end
 
     it 'returns nil on failure' do
-      with_env 'PATH', 'lib' do
-        expect(full_path('image_optim')).to be_nil
-      end
-    end
-
-    %w[ls sh which bash image_optim does_not_exist].each do |name|
-      it "returns same path as `command -v` for #{name}" do
-        expect(full_path(name)).to eq(command_v(name))
-      end
+      stub_env 'PATH', ''
+      expect(full_path('image_optim')).to be_nil
     end
   end
 
-  it 'combines path in order dir:pack:path:vendor' do
+  it 'combines path in order dir, pack, path, vendor' do
     allow(image_optim).to receive(:pack).and_return(true)
     stub_const('ImageOptim::Pack', Class.new do
       def self.path
@@ -93,130 +87,157 @@ describe ImageOptim::BinResolver do
       'pack_path',
       ENV['PATH'],
       BinResolver::VENDOR_PATH,
-    ].join(':'))
+    ].join(File::PATH_SEPARATOR))
   end
 
   it 'resolves bin in path and returns instance of Bin' do
-    with_env 'LS_BIN', nil do
-      expect(FSPath).not_to receive(:temp_dir)
-      expect(resolver).to receive(:full_path).with(:ls).and_return('/bin/ls')
-      bin = double
-      expect(Bin).to receive(:new).with(:ls, '/bin/ls').and_return(bin)
-      expect(bin).to receive(:check!).once
-      expect(bin).to receive(:check_fail!).exactly(5).times
-
-      5.times do
-        expect(resolver.resolve!(:ls)).to eq(bin)
-      end
-      expect(resolver.env_path).to eq([
-        ENV['PATH'],
-        BinResolver::VENDOR_PATH,
-      ].join(':'))
+    stub_env 'LS_BIN', nil
+    expect(FSPath).not_to receive(:temp_dir)
+    expect(resolver).to receive(:full_path).with(:ls).and_return('/bin/ls')
+    bin = double
+    expect(Bin).to receive(:new).with(:ls, '/bin/ls').and_return(bin)
+    expect(bin).to receive(:check!).once
+    expect(bin).to receive(:check_fail!).exactly(5).times
+
+    5.times do
+      expect(resolver.resolve!(:ls)).to eq(bin)
     end
+    expect(resolver.env_path).to eq([
+      ENV['PATH'],
+      BinResolver::VENDOR_PATH,
+    ].join(File::PATH_SEPARATOR))
   end
 
   it 'raises on failure to resolve bin' do
-    with_env 'LS_BIN', nil do
+    stub_env 'LS_BIN', nil
+    expect(FSPath).not_to receive(:temp_dir)
+    expect(resolver).to receive(:full_path).with(:ls).and_return(nil)
+    expect(Bin).not_to receive(:new)
+
+    5.times do
+      expect do
+        resolver.resolve!(:ls)
+      end.to raise_error BinResolver::BinNotFound
+    end
+    expect(resolver.env_path).to eq([
+      ENV['PATH'],
+      BinResolver::VENDOR_PATH,
+    ].join(File::PATH_SEPARATOR))
+  end
+
+  it 'resolves bin specified in ENV' do
+    path = 'bin/the_optimizer'
+    stub_env 'THE_OPTIMIZER_BIN', path
+    tmpdir = double(:tmpdir, :to_str => 'tmpdir')
+    symlink = double(:symlink)
+
+    full_path = File.expand_path(path)
+    allow(File).to receive(:exist?).with(full_path).and_return(true)
+    allow(File).to receive(:file?).with(full_path).and_return(true)
+    allow(File).to receive(:executable?).with(full_path).and_return(true)
+
+    expect(FSPath).to receive(:temp_dir).
+      once.and_return(tmpdir)
+    expect(tmpdir).to receive(:/).
+      with(:the_optimizer).once.and_return(symlink)
+    expect(symlink).to receive(:make_symlink).
+      with(File.expand_path(path)).once
+
+    expect(resolver).not_to receive(:full_path)
+    bin = double
+    expect(Bin).to receive(:new).
+      with(:the_optimizer, File.expand_path(path)).and_return(bin)
+    expect(bin).to receive(:check!).once
+    expect(bin).to receive(:check_fail!).exactly(5).times
+
+    at_exit_blocks = []
+    expect(resolver).to receive(:at_exit).once do |&block|
+      at_exit_blocks.unshift(block)
+    end
+
+    5.times do
+      resolver.resolve!(:the_optimizer)
+    end
+    expect(resolver.env_path).to eq([
+      tmpdir,
+      ENV['PATH'],
+      BinResolver::VENDOR_PATH,
+    ].join(File::PATH_SEPARATOR))
+
+    expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
+    at_exit_blocks.each(&:call)
+  end
+
+  describe 'checking bin' do
+    let(:path){ 'the_optimizer' }
+    let(:exist?){ true }
+    let(:file?){ true }
+    let(:executable?){ true }
+
+    before do
+      stub_env 'THE_OPTIMIZER_BIN', path
       expect(FSPath).not_to receive(:temp_dir)
-      expect(resolver).to receive(:full_path).with(:ls).and_return(nil)
-      expect(Bin).not_to receive(:new)
+      expect(resolver).not_to receive(:at_exit)
+      allow(File).to receive_messages(:exist? => exist?,
+                                      :file? => file?,
+                                      :executable? => executable?)
+    end
 
-      5.times do
-        expect do
-          resolver.resolve!(:ls)
-        end.to raise_error BinResolver::BinNotFound
-      end
+    after do
       expect(resolver.env_path).to eq([
         ENV['PATH'],
         BinResolver::VENDOR_PATH,
-      ].join(':'))
+      ].join(File::PATH_SEPARATOR))
     end
-  end
-
-  it 'resolves bin specified in ENV' do
-    path = 'bin/image_optim'
-    with_env 'IMAGE_OPTIM_BIN', path do
-      tmpdir = double(:tmpdir, :to_str => 'tmpdir')
-      symlink = double(:symlink)
-
-      expect(FSPath).to receive(:temp_dir).
-        once.and_return(tmpdir)
-      expect(tmpdir).to receive(:/).
-        with(:image_optim).once.and_return(symlink)
-      expect(symlink).to receive(:make_symlink).
-        with(File.expand_path(path)).once
-
-      expect(resolver).not_to receive(:full_path)
-      bin = double
-      expect(Bin).to receive(:new).
-        with(:image_optim, File.expand_path(path)).and_return(bin)
-      expect(bin).to receive(:check!).once
-      expect(bin).to receive(:check_fail!).exactly(5).times
-
-      at_exit_blocks = []
-      expect(resolver).to receive(:at_exit).once do |&block|
-        at_exit_blocks.unshift(block)
-      end
 
+    def raises_error(error_message)
       5.times do
-        resolver.resolve!(:image_optim)
+        expect do
+          resolver.resolve!(:the_optimizer)
+        end.to raise_error RuntimeError, /#{Regexp.escape(error_message)}/
       end
-      expect(resolver.env_path).to eq([
-        tmpdir,
-        ENV['PATH'],
-        BinResolver::VENDOR_PATH,
-      ].join(':'))
+    end
 
-      expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
-      at_exit_blocks.each(&:call)
+    context 'presence' do
+      let(:exist?){ false }
+
+      it{ raises_error('doesn\'t exist') }
     end
-  end
 
-  {
-    'some/path/does/not/exist' => 'doesn\'t exist',
-    '.' => 'is not a file',
-    __FILE__ => 'is not executable',
-  }.each do |path, error_message|
-    it "raises when bin specified in ENV #{error_message}" do
-      with_env 'IMAGE_OPTIM_BIN', path do
-        expect(FSPath).not_to receive(:temp_dir)
-        expect(resolver).not_to receive(:at_exit)
-
-        5.times do
-          expect do
-            resolver.resolve!(:image_optim)
-          end.to raise_error RuntimeError, /#{Regexp.escape(error_message)}/
-        end
-        expect(resolver.env_path).to eq([
-          ENV['PATH'],
-          BinResolver::VENDOR_PATH,
-        ].join(':'))
-      end
+    context 'been a file' do
+      let(:file?){ false }
+
+      it{ raises_error('is not a file') }
+    end
+
+    context 'been a file' do
+      let(:executable?){ false }
+
+      it{ raises_error('is not executable') }
     end
   end
 
   it 'resolves bin only once, but checks every time' do
-    with_env 'LS_BIN', nil do
-      expect(resolver).to receive(:full_path).once.with(:ls) do
-        sleep 0.1
-        '/bin/ls'
-      end
-      bin = double
-      expect(Bin).to receive(:new).once.with(:ls, '/bin/ls').and_return(bin)
+    stub_env 'LS_BIN', nil
+    expect(resolver).to receive(:full_path).once.with(:ls) do
+      sleep 0.1
+      '/bin/ls'
+    end
+    bin = double
+    expect(Bin).to receive(:new).once.with(:ls, '/bin/ls').and_return(bin)
 
-      count = 0
-      mutex = Mutex.new
-      allow(bin).to receive(:check!).once
-      allow(bin).to receive(:check_fail!){ mutex.synchronize{ count += 1 } }
+    count = 0
+    mutex = Mutex.new
+    allow(bin).to receive(:check!).once
+    allow(bin).to receive(:check_fail!){ mutex.synchronize{ count += 1 } }
 
-      Array.new(10) do
-        Thread.new do
-          resolver.resolve!(:ls)
-        end
-      end.each(&:join)
+    Array.new(10) do
+      Thread.new do
+        resolver.resolve!(:ls)
+      end
+    end.each(&:join)
 
-      expect(count).to eq(10)
-    end
+    expect(count).to eq(10)
   end
 
   describe 'checking version' do
@@ -225,47 +246,44 @@ describe ImageOptim::BinResolver do
     end
 
     it 'raises every time if did not get bin version' do
-      with_env 'PNGCRUSH_BIN', nil do
-        bin = Bin.new(:pngcrush, '/bin/pngcrush')
+      stub_env 'PNGCRUSH_BIN', nil
+      bin = Bin.new(:pngcrush, '/bin/pngcrush')
 
-        expect(Bin).to receive(:new).and_return(bin)
-        allow(bin).to receive(:version).and_return(nil)
+      expect(Bin).to receive(:new).and_return(bin)
+      allow(bin).to receive(:version).and_return(nil)
 
-        5.times do
-          expect do
-            resolver.resolve!(:pngcrush)
-          end.to raise_error Bin::UnknownVersion
-        end
+      5.times do
+        expect do
+          resolver.resolve!(:pngcrush)
+        end.to raise_error Bin::UnknownVersion
       end
     end
 
     it 'raises every time on detection of misbehaving version' do
-      with_env 'PNGCRUSH_BIN', nil do
-        bin = Bin.new(:pngcrush, '/bin/pngcrush')
+      stub_env 'PNGCRUSH_BIN', nil
+      bin = Bin.new(:pngcrush, '/bin/pngcrush')
 
-        expect(Bin).to receive(:new).and_return(bin)
-        allow(bin).to receive(:version).and_return(SimpleVersion.new('1.7.60'))
+      expect(Bin).to receive(:new).and_return(bin)
+      allow(bin).to receive(:version).and_return(SimpleVersion.new('1.7.60'))
 
-        5.times do
-          expect do
-            resolver.resolve!(:pngcrush)
-          end.to raise_error Bin::BadVersion
-        end
+      5.times do
+        expect do
+          resolver.resolve!(:pngcrush)
+        end.to raise_error Bin::BadVersion
       end
     end
 
     it 'warns once on detection of problematic version' do
-      with_env 'ADVPNG_BIN', nil do
-        bin = Bin.new(:advpng, '/bin/advpng')
+      stub_env 'ADVPNG_BIN', nil
+      bin = Bin.new(:advpng, '/bin/advpng')
 
-        expect(Bin).to receive(:new).and_return(bin)
-        allow(bin).to receive(:version).and_return(SimpleVersion.new('1.15'))
+      expect(Bin).to receive(:new).and_return(bin)
+      allow(bin).to receive(:version).and_return(SimpleVersion.new('1.15'))
 
-        expect(bin).to receive(:warn).once
+      expect(bin).to receive(:warn).once
 
-        5.times do
-          resolver.resolve!(:pngcrush)
-        end
+      5.times do
+        resolver.resolve!(:pngcrush)
       end
     end
   end