image_optim 0.13.3 → 0.14.0

data/spec/image_optim/bin_resolver/comparable_condition_spec.rb

@@ -1,11 +1,11 @@
-$:.unshift File.expand_path('../../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/bin_resolver/comparable_condition'
 
 describe ImageOptim::BinResolver::ComparableCondition do
   is = ImageOptim::BinResolver::ComparableCondition.is
 
-  it "should build conditions" do
+  it 'should build conditions' do
     expect(is.between?(10, 20).method).to eq(:between?)
     expect(is.between?(10, 20).args).to eq([10, 20])
 
@@ -16,23 +16,23 @@ describe ImageOptim::BinResolver::ComparableCondition do
     expect((is < 30).args).to eq([30])
   end
 
-  it "should stringify conditions" do
+  it 'should stringify conditions' do
     expect(is.between?(10, 20).to_s).to eq('10..20')
     expect((is >= 15).to_s).to eq('>= 15')
     expect((is < 30).to_s).to eq('< 30')
   end
 
-  it "should match conditions" do
-    expect(is.between?(10, 20)).not_to be === 9
-    expect(is.between?(10, 20)).to be === 15
-    expect(is.between?(10, 20)).not_to be === 21
+  it 'should match conditions' do
+    expect(is.between?(10, 20)).not_to match 9
+    expect(is.between?(10, 20)).to match 15
+    expect(is.between?(10, 20)).not_to match 21
 
-    expect(is >= 15).not_to be === 14
-    expect(is >= 15).to be === 15
-    expect(is >= 15).to be === 16
+    expect(is >= 15).not_to match 14
+    expect(is >= 15).to match 15
+    expect(is >= 15).to match 16
 
-    expect(is < 30).to be === 29
-    expect(is < 30).not_to be === 30
-    expect(is < 30).not_to be === 31
+    expect(is < 30).to match 29
+    expect(is < 30).not_to match 30
+    expect(is < 30).not_to match 31
   end
 end

data/spec/image_optim/bin_resolver/simple_version_spec.rb

@@ -1,4 +1,4 @@
-$:.unshift File.expand_path('../../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/bin_resolver/simple_version'
 
@@ -7,7 +7,7 @@ describe ImageOptim::BinResolver::SimpleVersion do
     ImageOptim::BinResolver::SimpleVersion.new(str)
   end
 
-  it "should compare versions" do
+  it 'should compare versions' do
     expect(v '1.17').to be > '0'
     expect(v '1.17').to be > '0.1'
     expect(v '1.17').to be > '0.9'
@@ -17,7 +17,7 @@ describe ImageOptim::BinResolver::SimpleVersion do
     expect(v '1.17').to be < '2.1'
   end
 
-  it "should normalize versions" do
+  it 'should normalize versions' do
     variations = %w[1 01 1.0 1.00 1.0.0 1.0.0.0]
     variations.each do |a|
       variations.each do |b|
@@ -26,7 +26,7 @@ describe ImageOptim::BinResolver::SimpleVersion do
     end
   end
 
-  it "should convert objects" do
+  it 'should convert objects' do
     expect(v 1.17).to eq('1.17')
     expect(v '1.17').to eq('1.17')
     expect(v(v 1.17)).to eq('1.17')

data/spec/image_optim/bin_resolver_spec.rb

@@ -1,4 +1,4 @@
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/bin_resolver'
 
@@ -10,74 +10,93 @@ ensure
 end
 
 describe ImageOptim::BinResolver do
-  let(:image_optim){ double(:image_optim, :verbose? => false) }
+  let(:image_optim){ double(:image_optim, :verbose => false) }
   let(:resolver){ ImageOptim::BinResolver.new(image_optim) }
 
-  it "should resolve bin in path" do
+  it 'should resolve bin in path' do
     with_env 'LS_BIN', nil do
-      resolver.should_receive(:accessible?).with(:ls).once.and_return(true)
-      FSPath.should_not_receive(:temp_dir)
+      expect(resolver).to receive(:accessible?).with(:ls).once.and_return(true)
+      expect(FSPath).not_to receive(:temp_dir)
 
       5.times do
         resolver.resolve!(:ls)
       end
-      resolver.env_path.should == "#{ENV['PATH']}:#{ImageOptim::BinResolver::VENDOR_PATH}"
+      expect(resolver.env_path).to eq([
+        ENV['PATH'],
+        ImageOptim::BinResolver::VENDOR_PATH,
+      ].join(':'))
     end
   end
 
-  it "should resolve bin specified in ENV" do
-    path = (FSPath(__FILE__).dirname / '../bin/image_optim').relative_path_from(Dir.pwd).to_s
+  it 'should resolve bin specified in ENV' do
+    path = 'some/path/image_optim2.3.4'
     with_env 'IMAGE_OPTIM_BIN', path do
-      tmpdir = double(:tmpdir)
+      tmpdir = double(:tmpdir, :to_str => 'tmpdir')
       symlink = double(:symlink)
 
-      resolver.should_receive(:accessible?).with(:image_optim).once.and_return(true)
-      FSPath.should_receive(:temp_dir).once.and_return(tmpdir)
-      tmpdir.should_receive(:/).with(:image_optim).once.and_return(symlink)
-      symlink.should_receive(:make_symlink).with(File.expand_path(path)).once
+      expect(resolver).to receive(:accessible?).
+        with(:image_optim).once.and_return(true)
+      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
 
       at_exit_blocks = []
-      resolver.should_receive(:at_exit).once do |&block|
+      expect(resolver).to receive(:at_exit).once do |&block|
         at_exit_blocks.unshift(block)
       end
 
       5.times do
         resolver.resolve!(:image_optim)
       end
-      resolver.env_path.should == "#{tmpdir.to_str}:#{ENV['PATH']}:#{ImageOptim::BinResolver::VENDOR_PATH}"
+      expect(resolver.env_path).to eq([
+        tmpdir,
+        ENV['PATH'],
+        ImageOptim::BinResolver::VENDOR_PATH,
+      ].join(':'))
 
-      FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+      expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
       at_exit_blocks.each(&:call)
     end
   end
 
-  it "should raise on failure to resolve bin" do
+  it 'should raise on failure to resolve bin' do
     with_env 'SHOULD_NOT_EXIST_BIN', nil do
-      resolver.should_receive(:accessible?).with(:should_not_exist).once.and_return(false)
-      FSPath.should_not_receive(:temp_dir)
+      expect(resolver).to receive(:accessible?).
+        with(:should_not_exist).once.and_return(false)
+      expect(FSPath).not_to receive(:temp_dir)
 
       5.times do
         expect do
           resolver.resolve!(:should_not_exist)
         end.to raise_error ImageOptim::BinNotFoundError
       end
-      resolver.env_path.should == "#{ENV['PATH']}:#{ImageOptim::BinResolver::VENDOR_PATH}"
+      expect(resolver.env_path).to eq([
+        ENV['PATH'],
+        ImageOptim::BinResolver::VENDOR_PATH,
+      ].join(':'))
     end
   end
 
-  it "should raise on failure to resolve bin specified in ENV" do
-    path = (FSPath(__FILE__).dirname / '../bin/should_not_exist_bin').relative_path_from(Dir.pwd).to_s
+  it 'should raise on failure to resolve bin specified in ENV' do
+    path = 'some/path/should_not_exist_bin'
     with_env 'SHOULD_NOT_EXIST_BIN', path do
-      tmpdir = double(:tmpdir)
+      tmpdir = double(:tmpdir, :to_str => 'tmpdir')
       symlink = double(:symlink)
 
-      resolver.should_receive(:accessible?).with(:should_not_exist).once.and_return(false)
-      FSPath.should_receive(:temp_dir).once.and_return(tmpdir)
-      tmpdir.should_receive(:/).with(:should_not_exist).once.and_return(symlink)
-      symlink.should_receive(:make_symlink).with(File.expand_path(path)).once
+      expect(resolver).to receive(:accessible?).
+        with(:should_not_exist).once.and_return(false)
+      expect(FSPath).to receive(:temp_dir).
+        once.and_return(tmpdir)
+      expect(tmpdir).to receive(:/).
+        with(:should_not_exist).once.and_return(symlink)
+      expect(symlink).to receive(:make_symlink).
+        with(File.expand_path(path)).once
 
       at_exit_blocks = []
-      resolver.should_receive(:at_exit).once do |&block|
+      expect(resolver).to receive(:at_exit).once do |&block|
         at_exit_blocks.unshift(block)
       end
 
@@ -86,16 +105,20 @@ describe ImageOptim::BinResolver do
           resolver.resolve!(:should_not_exist)
         end.to raise_error ImageOptim::BinNotFoundError
       end
-      resolver.env_path.should == "#{tmpdir.to_str}:#{ENV['PATH']}:#{ImageOptim::BinResolver::VENDOR_PATH}"
+      expect(resolver.env_path).to eq([
+        tmpdir,
+        ENV['PATH'],
+        ImageOptim::BinResolver::VENDOR_PATH,
+      ].join(':'))
 
-      FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+      expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
       at_exit_blocks.each(&:call)
     end
   end
 
-  it "should resolve bin only once" do
+  it 'should resolve bin only once' do
     with_env 'LS_BIN', nil do
-      resolver.should_receive(:resolve?).once.with(:ls){ sleep 0.1; true }
+      expect(resolver).to receive(:resolve?).once.with(:ls){ sleep 0.1; true }
 
       10.times.map do
         Thread.new do
@@ -105,18 +128,23 @@ describe ImageOptim::BinResolver do
     end
   end
 
-  it "should raise on detection of problematic version" do
+  it 'should raise on detection of problematic version' do
     with_env 'PNGCRUSH_BIN', nil do
-      resolver.should_receive(:accessible?).with(:pngcrush).once.and_return(true)
-      resolver.should_receive(:version).with(:pngcrush).once.and_return('1.7.60')
-      FSPath.should_not_receive(:temp_dir)
+      expect(resolver).to receive(:accessible?).
+        with(:pngcrush).once.and_return(true)
+      expect(resolver).to receive(:version).
+        with(:pngcrush).once.and_return('1.7.60')
+      expect(FSPath).not_to receive(:temp_dir)
 
       5.times do
         expect do
           resolver.resolve!(:pngcrush)
         end.to raise_error ImageOptim::BadBinVersion
       end
-      resolver.env_path.should == "#{ENV['PATH']}:#{ImageOptim::BinResolver::VENDOR_PATH}"
+      expect(resolver.env_path).to eq([
+        ENV['PATH'],
+        ImageOptim::BinResolver::VENDOR_PATH,
+      ].join(':'))
     end
   end
 end

data/spec/image_optim/config_spec.rb

@@ -1,153 +1,164 @@
-$:.unshift File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'rspec'
 require 'image_optim/config'
 
-class ImageOptim
-  describe Config do
-    before do
-      Config.stub(:global => {}, :local => {})
+describe ImageOptim::Config do
+  Config = ImageOptim::Config
+
+  before do
+    allow(Config).to receive(:global).and_return({})
+    allow(Config).to receive(:local).and_return({})
+  end
+
+  describe 'assert_no_unused_options!' do
+    it 'should not raise when no unused options' do
+      config = Config.new({})
+      config.assert_no_unused_options!
     end
 
-    describe "assert_no_unused_options!" do
-      it "should not raise when no unused options" do
-        config = Config.new({})
+    it 'should raise when there are unused options' do
+      config = Config.new(:unused => true)
+      expect do
         config.assert_no_unused_options!
-      end
-
-      it "should raise when there are unused options" do
-        config = Config.new({:unused => true})
-        proc {
-          config.assert_no_unused_options!
-        }.should raise_error(ConfigurationError)
-      end
+      end.to raise_error(ImageOptim::ConfigurationError)
     end
+  end
 
-    describe "nice" do
-      it "should be 10 by default" do
-        config = Config.new({})
-        config.nice.should == 10
-      end
+  describe 'nice' do
+    it 'should be 10 by default' do
+      config = Config.new({})
+      expect(config.nice).to eq(10)
+    end
 
-      it "should be 0 if disabled" do
-        config = Config.new({:nice => false})
-        config.nice.should == 0
-      end
+    it 'should be 0 if disabled' do
+      config = Config.new(:nice => false)
+      expect(config.nice).to eq(0)
+    end
 
-      it "should convert value to number" do
-        config = Config.new({:nice => '13'})
-        config.nice.should == 13
-      end
+    it 'should convert value to number' do
+      config = Config.new(:nice => '13')
+      expect(config.nice).to eq(13)
     end
+  end
 
-    describe "threads" do
-      it "should be processor_count by default" do
-        config = Config.new({})
-        config.stub(:processor_count).and_return(13)
-        config.threads.should == 13
-      end
+  describe 'threads' do
+    it 'should be processor_count by default' do
+      config = Config.new({})
+      allow(config).to receive(:processor_count).and_return(13)
+      expect(config.threads).to eq(13)
+    end
 
-      it "should be 1 if disabled" do
-        config = Config.new({:threads => false})
-        config.threads.should == 1
-      end
+    it 'should be 1 if disabled' do
+      config = Config.new(:threads => false)
+      expect(config.threads).to eq(1)
+    end
 
-      it "should convert value to number" do
-        config = Config.new({:threads => '616'})
-        config.threads.should == 616
-      end
+    it 'should convert value to number' do
+      config = Config.new(:threads => '616')
+      expect(config.threads).to eq(616)
     end
+  end
 
-    describe "for_worker" do
-      class Abc < Worker
-        def image_formats; []; end
+  describe 'for_worker' do
+    Abc = Class.new(ImageOptim::Worker) do
+      def image_formats
+        []
       end
+    end
 
-      it "should return empty hash by default" do
-        config = Config.new({})
-        config.for_worker(Abc).should == {}
-      end
+    it 'should return empty hash by default' do
+      config = Config.new({})
+      expect(config.for_worker(Abc)).to eq({})
+    end
 
-      it "should return passed hash" do
-        config = Config.new({:abc => {:option => true}})
-        config.for_worker(Abc).should == {:option => true}
-      end
+    it 'should return passed hash' do
+      config = Config.new(:abc => {:option => true})
+      expect(config.for_worker(Abc)).to eq(:option => true)
+    end
 
-      it "should return passed false" do
-        config = Config.new({:abc => false})
-        config.for_worker(Abc).should == false
-      end
+    it 'should return passed false' do
+      config = Config.new(:abc => false)
+      expect(config.for_worker(Abc)).to eq(false)
+    end
 
-      it "should raise on unknown optino" do
-        config = Config.new({:abc => 13})
-        proc {
-          config.for_worker(Abc)
-        }.should raise_error(ConfigurationError)
-      end
+    it 'should raise on unknown optino' do
+      config = Config.new(:abc => 13)
+      expect do
+        config.for_worker(Abc)
+      end.to raise_error(ImageOptim::ConfigurationError)
     end
+  end
 
-    describe 'class methods' do
-      before do
-        Config.unstub(:global)
-        Config.unstub(:local)
-      end
+  describe 'class methods' do
+    before do
+      allow(Config).to receive(:global).and_call_original
+      allow(Config).to receive(:local).and_call_original
+    end
 
-      describe 'global' do
-        it "should return empty hash for global config if it does not exists" do
-          File.should_receive(:file?).with(Config::GLOBAL_CONFIG_PATH).and_return(false)
-          Config.should_not_receive(:read)
+    describe 'global' do
+      it 'should return empty hash for global config if it does not exists' do
+        expect(File).to receive(:file?).
+          with(Config::GLOBAL_CONFIG_PATH).and_return(false)
+        expect(Config).not_to receive(:read)
 
-          Config.global.should == {}
-        end
+        expect(Config.global).to eq({})
+      end
 
-        it "should read global config if it exists" do
-          File.should_receive(:file?).with(Config::GLOBAL_CONFIG_PATH).and_return(true)
-          Config.should_receive(:read).with(Config::GLOBAL_CONFIG_PATH).and_return({:config => true})
+      it 'should read global config if it exists' do
+        expect(File).to receive(:file?).
+          with(Config::GLOBAL_CONFIG_PATH).and_return(true)
+        expect(Config).to receive(:read).
+          with(Config::GLOBAL_CONFIG_PATH).and_return(:config => true)
 
-          Config.global.should == {:config => true}
-        end
+        expect(Config.global).to eq(:config => true)
       end
+    end
 
-      describe 'local' do
-        it "should return empty hash for local config if it does not exists" do
-          File.should_receive(:file?).with(Config::LOCAL_CONFIG_PATH).and_return(false)
-          Config.should_not_receive(:read)
+    describe 'local' do
+      it 'should return empty hash for local config if it does not exists' do
+        expect(File).to receive(:file?).
+          with(Config::LOCAL_CONFIG_PATH).and_return(false)
+        expect(Config).not_to receive(:read)
 
-          Config.local.should == {}
-        end
+        expect(Config.local).to eq({})
+      end
 
-        it "should read local config if it exists" do
-          File.should_receive(:file?).with(Config::LOCAL_CONFIG_PATH).and_return(true)
-          Config.should_receive(:read).with(Config::LOCAL_CONFIG_PATH).and_return({:config => true})
+      it 'should read local config if it exists' do
+        expect(File).to receive(:file?).
+          with(Config::LOCAL_CONFIG_PATH).and_return(true)
+        expect(Config).to receive(:read).
+          with(Config::LOCAL_CONFIG_PATH).and_return(:config => true)
 
-          Config.local.should == {:config => true}
-        end
+        expect(Config.local).to eq(:config => true)
       end
+    end
 
-      describe 'read' do
-        it "should return hash with deep symbolised keys from yaml file reader" do
-          path = double(:path)
-          YAML.should_receive(:load_file).with(path).and_return({'config' => {'this' => true}})
+    describe 'read' do
+      it 'should return hash with deep symbolised keys from reader' do
+        stringified = {'config' => {'this' => true}}
+        symbolized = {:config => {:this => true}}
 
-          Config.instance_eval{ read(path) }.should == {:config => {:this => true}}
-        end
+        path = double(:path)
+        expect(YAML).to receive(:load_file).with(path).and_return(stringified)
 
-        it "should warn and return an empty hash if yaml file reader returns non hash" do
-          path = double(:path)
-          YAML.should_receive(:load_file).with(path).and_return([:config])
-          Config.should_receive(:warn)
+        expect(Config.instance_eval{ read(path) }).to eq(symbolized)
+      end
 
-          Config.instance_eval{ read(path) }.should == {}
-        end
+      it 'should warn and return an empty hash if reader returns non hash' do
+        path = double(:path)
+        expect(YAML).to receive(:load_file).with(path).and_return([:config])
+        expect(Config).to receive(:warn)
 
-        it "should warn and return an empty hash if yaml file reader raises exception" do
-          path = double(:path)
-          YAML.should_receive(:load_file).with(path).and_raise
-          Config.should_receive(:warn)
+        expect(Config.instance_eval{ read(path) }).to eq({})
+      end
 
-          Config.instance_eval{ read(path) }.should == {}
-        end
+      it 'should warn and return an empty hash if reader raises exception' do
+        path = double(:path)
+        expect(YAML).to receive(:load_file).with(path).and_raise
+        expect(Config).to receive(:warn)
+
+        expect(Config.instance_eval{ read(path) }).to eq({})
       end
     end
-
   end
 end