image_optim 0.17.1 → 0.18.0

data/spec/image_optim/config_spec.rb

@@ -1,21 +1,22 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/config'
 
 describe ImageOptim::Config do
-  IOConfig = ImageOptim::Config
+  before 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
 
-    it 'should not raise when no unused options' do
+    it 'does not raise when no unused options' do
       config = IOConfig.new({})
       config.assert_no_unused_options!
     end
 
-    it 'should raise when there are unused options' do
+    it 'raises when there are unused options' do
       config = IOConfig.new(:unused => true)
       expect do
         config.assert_no_unused_options!
@@ -23,80 +24,79 @@ describe ImageOptim::Config do
     end
   end
 
-  describe 'nice' do
+  describe :nice do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
     end
 
-    it 'should be 10 by default' do
+    it 'is 10 by default' do
       config = IOConfig.new({})
       expect(config.nice).to eq(10)
     end
 
-    it 'should be 0 if disabled' do
+    it 'is 0 if disabled' do
       config = IOConfig.new(:nice => false)
       expect(config.nice).to eq(0)
     end
 
-    it 'should convert value to number' do
+    it 'converts value to number' do
       config = IOConfig.new(:nice => '13')
       expect(config.nice).to eq(13)
     end
   end
 
-  describe 'threads' do
+  describe :threads do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
     end
 
-    it 'should be processor_count by default' do
+    it 'is processor_count by default' do
       config = IOConfig.new({})
       allow(config).to receive(:processor_count).and_return(13)
       expect(config.threads).to eq(13)
     end
 
-    it 'should be 1 if disabled' do
+    it 'is 1 if disabled' do
       config = IOConfig.new(:threads => false)
       expect(config.threads).to eq(1)
     end
 
-    it 'should convert value to number' do
+    it 'converts value to number' do
       config = IOConfig.new(:threads => '616')
       expect(config.threads).to eq(616)
     end
   end
 
-  describe 'for_worker' do
+  describe :for_worker do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
-    end
+      stub_const('Abc', Class.new do
+        def self.bin_sym
+          :abc
+        end
 
-    Abc = Class.new do
-      def self.bin_sym
-        :abc
-      end
-
-      def image_formats
-        []
-      end
+        def image_formats
+          []
+        end
+      end)
     end
 
-    it 'should return empty hash by default' do
+    it 'returns empty hash by default' do
       config = IOConfig.new({})
       expect(config.for_worker(Abc)).to eq({})
     end
 
-    it 'should return passed hash' do
+    it 'returns passed hash' do
       config = IOConfig.new(:abc => {:option => true})
       expect(config.for_worker(Abc)).to eq(:option => true)
     end
 
-    it 'should return passed false' do
+    it 'returns passed false' do
       config = IOConfig.new(:abc => false)
       expect(config.for_worker(Abc)).to eq(false)
     end
 
-    it 'should raise on unknown option' do
+    it 'raises on unknown option' do
       config = IOConfig.new(:abc => 13)
       expect do
         config.for_worker(Abc)
@@ -105,7 +105,7 @@ describe ImageOptim::Config do
   end
 
   describe 'config' do
-    it 'should read options from default locations' 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)
       expect(IOConfig).to receive(:read_options).
@@ -118,14 +118,14 @@ describe ImageOptim::Config do
       config.assert_no_unused_options!
     end
 
-    it 'should not read options with empty config_paths' do
+    it 'does not read options with empty config_paths' do
       expect(IOConfig).not_to receive(:read_options)
 
       config = IOConfig.new(:config_paths => [])
       config.assert_no_unused_options!
     end
 
-    it 'should read options from specified paths' do
+    it 'reads options from specified paths' do
       expect(IOConfig).to receive(:read_options).
         with('/etc/image_optim.yml').and_return(:a => 1, :b => 2, :c => 3)
       expect(IOConfig).to receive(:read_options).
@@ -141,7 +141,7 @@ describe ImageOptim::Config do
       config.assert_no_unused_options!
     end
 
-    it 'should convert config_paths to array' do
+    it 'converts config_paths to array' do
       expect(IOConfig).to receive(:read_options).
         with('config/image_optim.yml').and_return({})
 
@@ -151,11 +151,11 @@ describe ImageOptim::Config do
   end
 
   describe 'class methods' do
-    describe 'read_options' do
+    describe :read_options do
       let(:path){ double(:path) }
       let(:full_path){ double(:full_path) }
 
-      it 'should warn if expand path fails' do
+      it 'warns if expand path fails' do
         expect(IOConfig).to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_raise(ArgumentError)
@@ -164,7 +164,7 @@ describe ImageOptim::Config do
         expect(IOConfig.read_options(path)).to eq({})
       end
 
-      it 'should return empty hash if path is not a file' do
+      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)
@@ -174,7 +174,7 @@ describe ImageOptim::Config do
         expect(IOConfig.read_options(path)).to eq({})
       end
 
-      it 'should return hash with deep symbolised keys from reader' do
+      it 'returns hash with deep symbolised keys from reader' do
         stringified = {'config' => {'this' => true}}
         symbolized = {:config => {:this => true}}
 
@@ -189,7 +189,7 @@ describe ImageOptim::Config do
         expect(IOConfig.read_options(path)).to eq(symbolized)
       end
 
-      it 'should warn and return an empty hash if reader returns non hash' do
+      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)
@@ -201,7 +201,7 @@ describe ImageOptim::Config do
         expect(IOConfig.read_options(path)).to eq({})
       end
 
-      it 'should warn and return an empty hash if reader raises exception' do
+      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)

data/spec/image_optim/handler_spec.rb

@@ -1,16 +1,19 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/handler'
 
 describe ImageOptim::Handler do
-  it 'should use original as source for first conversion '\
+  before do
+    stub_const('Handler', ImageOptim::Handler)
+  end
+
+  it 'uses original as source for first conversion '\
       'and two temp files for further conversions' do
     original = double(:original)
     allow(original).to receive(:temp_path) do
       fail 'temp_path called unexpectedly'
     end
 
-    handler = ImageOptim::Handler.new(original)
+    handler = Handler.new(original)
     temp_a = double(:temp_a)
     temp_b = double(:temp_b)
     expect(original).to receive(:temp_path).once.and_return(temp_a)
@@ -58,32 +61,32 @@ describe ImageOptim::Handler do
   end
 
   describe :open do
-    it 'should yield instance, run cleanup and return result' do
+    it 'yields instance, runs cleanup and returns result' do
       original = double
       handler = double
       result = double
 
-      expect(ImageOptim::Handler).to receive(:new).
-          with(original).and_return(handler)
+      expect(Handler).to receive(:new).
+        with(original).and_return(handler)
       expect(handler).to receive(:process)
       expect(handler).to receive(:cleanup)
       expect(handler).to receive(:result).and_return(result)
 
-      expect(ImageOptim::Handler.for(original) do |h|
+      expect(Handler.for(original) do |h|
         h.process
       end).to eq(result)
     end
 
-    it 'should cleanup if exception is raised' do
+    it 'cleans up if exception is raised' do
       original = double
       handler = double
 
-      expect(ImageOptim::Handler).to receive(:new).
-          with(original).and_return(handler)
+      expect(Handler).to receive(:new).
+        with(original).and_return(handler)
       expect(handler).to receive(:cleanup)
 
       expect do
-        ImageOptim::Handler.for(original) do
+        Handler.for(original) do
           fail 'hello'
         end
       end.to raise_error 'hello'

data/spec/image_optim/hash_helpers_spec.rb

@@ -1,12 +1,13 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/hash_helpers'
 
 describe ImageOptim::HashHelpers do
-  HH = ImageOptim::HashHelpers
+  before do
+    stub_const('HashHelpers', ImageOptim::HashHelpers)
+  end
 
   context 'stringify/simbolyze' do
-    WITH_SYMBOL_KEYS = {
+    symbol_keys = {
       :a => 1,
       :b => {
         :c => [:a, 'a'],
@@ -14,7 +15,7 @@ describe ImageOptim::HashHelpers do
       },
     }
 
-    WITH_STRING_KEYS = {
+    string_keys = {
       'a' => 1,
       'b' => {
         'c' => [:a, 'a'],
@@ -22,18 +23,18 @@ describe ImageOptim::HashHelpers do
       },
     }
 
-    it 'should deep stringify hash keys' do
-      expect(HH.deep_stringify_keys(WITH_SYMBOL_KEYS)).to eq(WITH_STRING_KEYS)
-      expect(HH.deep_stringify_keys(WITH_STRING_KEYS)).to eq(WITH_STRING_KEYS)
+    it 'deep stringifies hash keys' do
+      expect(HashHelpers.deep_stringify_keys(symbol_keys)).to eq(string_keys)
+      expect(HashHelpers.deep_stringify_keys(string_keys)).to eq(string_keys)
     end
 
-    it 'should deep symbolise hash keys' do
-      expect(HH.deep_symbolise_keys(WITH_STRING_KEYS)).to eq(WITH_SYMBOL_KEYS)
-      expect(HH.deep_symbolise_keys(WITH_SYMBOL_KEYS)).to eq(WITH_SYMBOL_KEYS)
+    it 'deep symbolises hash keys' do
+      expect(HashHelpers.deep_symbolise_keys(string_keys)).to eq(symbol_keys)
+      expect(HashHelpers.deep_symbolise_keys(symbol_keys)).to eq(symbol_keys)
     end
   end
 
-  it 'should deep merge hashes' do
+  it 'deep merges hashes' do
     merge_a = {
       :a => {
         :b => 1,
@@ -70,7 +71,7 @@ describe ImageOptim::HashHelpers do
       'z' => 20,
     }
 
-    expect(HH.deep_merge(merge_a, merge_b)).to eq(merge_result)
+    expect(HashHelpers.deep_merge(merge_a, merge_b)).to eq(merge_result)
   end
 
 end

data/spec/image_optim/image_path_spec.rb

@@ -1,12 +1,13 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/image_path'
 
 describe ImageOptim::ImagePath do
-  ImagePath = ImageOptim::ImagePath
+  before do
+    stub_const('ImagePath', ImageOptim::ImagePath)
+  end
 
-  describe 'convert' do
-    it 'should return ImagePath for string' do
+  describe :convert do
+    it 'returns ImagePath for string' do
       path = 'a'
 
       expect(ImagePath.convert(path)).to be_a(ImagePath)
@@ -16,7 +17,7 @@ describe ImageOptim::ImagePath do
       expect(ImagePath.convert(path)).not_to be(path)
     end
 
-    it 'should return ImagePath for Pathname' do
+    it 'returns ImagePath for Pathname' do
       pathname = Pathname.new('a')
 
       expect(ImagePath.convert(pathname)).to be_a(ImagePath)
@@ -26,7 +27,7 @@ describe ImageOptim::ImagePath do
       expect(ImagePath.convert(pathname)).not_to be(pathname)
     end
 
-    it 'should return same instance for ImagePath' do
+    it 'returns same instance for ImagePath' do
       image_path = ImagePath.new('a')
 
       expect(ImagePath.convert(image_path)).to be_a(ImagePath)
@@ -36,4 +37,18 @@ describe ImageOptim::ImagePath do
       expect(ImagePath.convert(image_path)).to be(image_path)
     end
   end
+
+  describe :binread do
+    it 'reads binary data' do
+      data = (0..255).to_a.pack('c*')
+
+      path = ImagePath.temp_file_path
+      path.write(data)
+
+      expect(path.binread).to eq(data)
+      if ''.respond_to?(:encoding)
+        expect(path.binread.encoding).to eq(Encoding.find('ASCII-8BIT'))
+      end
+    end
+  end
 end

data/spec/image_optim/runner/glob_helpers_spec.rb

@@ -1,9 +1,10 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'rspec'
+require 'spec_helper'
 require 'image_optim/runner/glob_helpers'
 
 describe ImageOptim::Runner::GlobHelpers do
-  GH = ImageOptim::Runner::GlobHelpers
+  before do
+    stub_const('GlobHelpers', ImageOptim::Runner::GlobHelpers)
+  end
 
   describe :expand_braces do
     {
@@ -16,8 +17,8 @@ describe ImageOptim::Runner::GlobHelpers do
       '{\{a,b\},\{c,d\}}' => %w[\\{a b\\} \\{c d\\}],
       'test{ing,}' => %w[testing test],
     }.each do |glob, expected|
-      it "should expand #{glob}" do
-        expect(GH.expand_braces(glob)).to match_array(expected)
+      it "expands #{glob}" do
+        expect(GlobHelpers.expand_braces(glob)).to match_array(expected)
       end
     end
   end

data/spec/image_optim/runner/option_parser_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'image_optim/runner/option_parser'
+
+describe ImageOptim::Runner::OptionParser do
+  before do
+    stub_const('OptionParser', ImageOptim::Runner::OptionParser)
+  end
+
+  describe :parse! do
+    it 'returns empty hash for arguments without options' do
+      args = %w[foo bar]
+      expect(OptionParser.parse!(args)).to eq({})
+      expect(args).to eq(%w[foo bar])
+    end
+
+    it 'removes options from arguments' do
+      args = %w[-r foo bar]
+      OptionParser.parse!(args)
+      expect(args).to eq(%w[foo bar])
+    end
+
+    it 'stops parsing optiosn after --' do
+      args = %w[-- -r foo bar]
+      OptionParser.parse!(args)
+      expect(args).to eq(%w[-r foo bar])
+    end
+
+    describe 'boolean option recursive' do
+      %w[-r -R --recursive].each do |flag|
+        it "is parsed from #{flag}" do
+          args = %W[#{flag} foo bar]
+          expect(OptionParser.parse!(args)).to eq(:recursive => true)
+          expect(args).to eq(%w[foo bar])
+        end
+      end
+    end
+
+    describe 'numeric option threads' do
+      it 'is parsed with space separator' do
+        args = %w[--threads 616 foo bar]
+        expect(OptionParser.parse!(args)).to eq(:threads => 616)
+        expect(args).to eq(%w[foo bar])
+      end
+
+      it 'is parsed with equal separator' do
+        args = %w[--threads=616 foo bar]
+        expect(OptionParser.parse!(args)).to eq(:threads => 616)
+        expect(args).to eq(%w[foo bar])
+      end
+
+      it 'is parsed with no- prefix' do
+        args = %w[--no-threads 616 foo bar]
+        expect(OptionParser.parse!(args)).to eq(:threads => false)
+        expect(args).to eq(%w[616 foo bar])
+      end
+    end
+
+    describe 'help option' do
+      it 'prints help text to stdout and exits' do
+        parser = OptionParser.new({})
+        expect(OptionParser).to receive(:new).and_return(parser)
+
+        help = double
+        expect(parser).to receive(:help).and_return(help)
+
+        expect do
+          OptionParser.parse!(%w[--help])
+        end.to output("#{help}\n").to_stdout &
+          raise_error(SystemExit){ |e| expect(e.status).to eq(0) }
+      end
+    end
+
+    describe 'wrong option' do
+      it 'prints help text to stdout and exits' do
+        parser = OptionParser.new({})
+        expect(OptionParser).to receive(:new).and_return(parser)
+
+        help = double
+        expect(parser).to receive(:help).and_return(help)
+
+        expect do
+          OptionParser.parse!(%w[--unknown-option])
+        end.to output("invalid option: --unknown-option\n\n#{help}\n").
+          to_stderr & raise_error(SystemExit){ |e| expect(e.status).to eq(1) }
+      end
+    end
+  end
+
+  describe :help do
+    it 'returns wrapped text' do
+      parser = OptionParser.new({})
+
+      allow(parser).to receive(:terminal_columns).and_return(80)
+
+      expect(parser.help.split("\n")).
+        to all(satisfy{ |line| line.length <= 80 })
+    end
+  end
+end