image_optim 0.22.1 → 0.23.0

data/spec/image_optim/handler_spec.rb

@@ -9,15 +9,12 @@ describe ImageOptim::Handler do
   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
+    allow(original).to receive(:respond_to?).with(:temp_path).and_return(true)
 
     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)
-    expect(original).to receive(:temp_path).once.and_return(temp_b)
+    expect(original).to receive(:temp_path).and_return(temp_a, temp_b)
 
     # first unsuccessful run
     handler.process do |src, dst|
@@ -60,7 +57,7 @@ describe ImageOptim::Handler do
     handler.cleanup
   end
 
-  describe :open do
+  describe '.for' do
     it 'yields instance, runs cleanup and returns result' do
       original = double
       handler = double

data/spec/image_optim/image_meta_spec.rb

@@ -0,0 +1,61 @@
+require 'image_optim/image_meta'
+
+describe ImageOptim::ImageMeta do
+  let(:image_path){ 'spec/images/lena.jpg' }
+  let(:non_image_path){ __FILE__ }
+  let(:broken_image_path){ 'spec/images/broken_jpeg' }
+
+  describe '.format_for_path' do
+    context 'for an image' do
+      it 'returns format' do
+        expect(described_class.format_for_path(image_path)).
+          to eq(:jpeg)
+      end
+    end
+
+    context 'for broken image' do
+      it 'warns and returns nil' do
+        expect(described_class).to receive(:warn)
+
+        expect(described_class.format_for_path(broken_image_path)).
+          to eq(nil)
+      end
+    end
+
+    context 'for not an image' do
+      it 'does not warn and returns nil' do
+        expect(described_class).not_to receive(:warn)
+
+        expect(described_class.format_for_path(non_image_path)).
+          to eq(nil)
+      end
+    end
+  end
+
+  describe '.format_for_data' do
+    context 'for image data' do
+      it 'returns format' do
+        expect(described_class.format_for_data(File.read(image_path))).
+          to eq(:jpeg)
+      end
+    end
+
+    context 'for broken image data' do
+      it 'warns and returns nil' do
+        expect(described_class).to receive(:warn)
+
+        expect(described_class.format_for_data(File.read(broken_image_path))).
+          to eq(nil)
+      end
+    end
+
+    context 'for not an image data' do
+      it 'does not warn and returns nil' do
+        expect(described_class).not_to receive(:warn)
+
+        expect(described_class.format_for_data(File.read(non_image_path))).
+          to eq(nil)
+      end
+    end
+  end
+end

data/spec/image_optim/optimized_path_spec.rb

@@ -0,0 +1,58 @@
+require 'image_optim/optimized_path'
+
+describe ImageOptim::OptimizedPath do
+  describe '#initialize' do
+    context 'when second argument is original' do
+      subject{ described_class.new('a', 'b') }
+
+      before do
+        allow_any_instance_of(ImageOptim::Path).
+          to receive(:size).and_return(616)
+      end
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns original path as Path for original' do
+        expect(subject.original).to eq(ImageOptim::Path.new('b'))
+      end
+
+      it 'returns original size for original_size' do
+        expect(subject.original_size).to eq(616)
+      end
+    end
+
+    context 'when second argument is size' do
+      subject{ described_class.new('a', 616) }
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns optimized path as Path for original' do
+        expect(subject.original).to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns size for original_size' do
+        expect(subject.original_size).to eq(616)
+      end
+    end
+
+    context 'when no second argument' do
+      subject{ described_class.new('a') }
+
+      it 'delegates to optimized path as Path' do
+        is_expected.to eq(ImageOptim::Path.new('a'))
+      end
+
+      it 'returns nil for original' do
+        expect(subject.original).to eq(nil)
+      end
+
+      it 'returns nil for original_size' do
+        expect(subject.original_size).to eq(nil)
+      end
+    end
+  end
+end

data/spec/image_optim/option_helpers_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'image_optim/option_helpers'
+
+describe ImageOptim::OptionHelpers do
+  describe '.limit_with_range' do
+    {
+      2..4 => 'inclusive',
+      2...5 => 'exclusive',
+    }.each do |range, type|
+      context "for an end #{type} range" do
+        it 'returns number when it is in range' do
+          expect(described_class.limit_with_range(4, range)).to eq(4)
+        end
+
+        it 'returns begin when it is less than minimum' do
+          expect(described_class.limit_with_range(1, range)).to eq(2)
+        end
+
+        it 'returns end when it is more than maximum' do
+          expect(described_class.limit_with_range(10, range)).to eq(4)
+        end
+      end
+    end
+  end
+end

data/spec/image_optim/path_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'image_optim/path'
+require 'tempfile'
+
+describe ImageOptim::Path do
+  include CapabilityCheckHelpers
+
+  before do
+    stub_const('Path', ImageOptim::Path)
+  end
+
+  describe '.convert' do
+    it 'returns Path for string' do
+      path = 'a'
+
+      expect(Path.convert(path)).to be_a(Path)
+      expect(Path.convert(path)).to eq(Path.new(path))
+
+      expect(Path.convert(path)).not_to eq(path)
+      expect(Path.convert(path)).not_to be(path)
+    end
+
+    it 'returns Path for Pathname' do
+      pathname = Pathname.new('a')
+
+      expect(Path.convert(pathname)).to be_a(Path)
+      expect(Path.convert(pathname)).to eq(Path.new(pathname))
+
+      expect(Path.convert(pathname)).to eq(pathname)
+      expect(Path.convert(pathname)).not_to be(pathname)
+    end
+
+    it 'returns same instance for Path' do
+      image_path = Path.new('a')
+
+      expect(Path.convert(image_path)).to be_a(Path)
+      expect(Path.convert(image_path)).to eq(Path.new(image_path))
+
+      expect(Path.convert(image_path)).to eq(image_path)
+      expect(Path.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 = Path.temp_file_path
+      path.binwrite(data)
+
+      expect(path.binread).to eq(data)
+      if ''.respond_to?(:encoding)
+        expect(path.binread.encoding).to eq(Encoding.find('ASCII-8BIT'))
+      end
+    end
+  end
+
+  describe '#replace' do
+    let(:src){ Path.temp_file_path }
+    let(:dst){ Path.temp_file_path }
+
+    it 'moves data to destination' do
+      src.write('src')
+
+      src.replace(dst)
+
+      expect(dst.read).to eq('src')
+    end
+
+    it 'removes original file' do
+      src.replace(dst)
+
+      expect(src).to_not 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/railtie_spec.rb

@@ -33,7 +33,7 @@ describe 'ImageOptim::Railtie' do
     Rails.application = nil
   end
 
-  describe :initialization do
+  describe 'initialization' do
     it 'initializes by default' do
       expect(ImageOptim).to receive(:new)
       init_rails_app
@@ -117,9 +117,9 @@ describe 'ImageOptim::Railtie' do
     end
   end
 
-  describe :assets do
+  describe 'optimizing assets' do
     before do
-      stub_const('ImagePath', ImageOptim::ImagePath)
+      stub_const('Path', ImageOptim::Path)
     end
 
     %w[
@@ -132,12 +132,12 @@ describe 'ImageOptim::Railtie' do
         asset = init_rails_app.assets.find_asset(asset_name)
 
         asset_data = asset.source
-        original = ImagePath.convert(asset.pathname)
+        original = Path.convert(asset.pathname)
 
         expect(asset_data).to be_smaller_than(original)
 
-        ImagePath.temp_file_path %W[spec .#{original.format}] do |temp|
-          temp.write(asset_data)
+        Path.temp_file_path %W[spec .#{original.image_format}] do |temp|
+          temp.binwrite(asset_data)
 
           expect(temp).to be_similar_to(original, 0)
         end

data/spec/image_optim/runner/glob_helpers_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 require 'image_optim/runner/glob_helpers'
 
 describe ImageOptim::Runner::GlobHelpers do
-  before do
-    stub_const('GlobHelpers', ImageOptim::Runner::GlobHelpers)
-  end
-
-  describe :expand_braces do
+  describe '.expand_braces' do
     {
       'hello.world' => %w[hello.world],
       '{hello,.world}' => %w[hello .world],
@@ -18,7 +14,7 @@ describe ImageOptim::Runner::GlobHelpers do
       'test{ing,}' => %w[testing test],
     }.each do |glob, expected|
       it "expands #{glob}" do
-        expect(GlobHelpers.expand_braces(glob)).to match_array(expected)
+        expect(described_class.expand_braces(glob)).to match_array(expected)
       end
     end
   end

data/spec/image_optim/runner/option_parser_spec.rb

@@ -12,7 +12,7 @@ describe ImageOptim::Runner::OptionParser do
     end
   end
 
-  describe :parse! do
+  describe '.parse!' do
     it 'returns empty hash for arguments without options' do
       args = %w[foo bar]
       expect(OptionParser.parse!(args)).to eq({})
@@ -25,7 +25,7 @@ describe ImageOptim::Runner::OptionParser do
       expect(args).to eq(%w[foo bar])
     end
 
-    it 'stops parsing optiosn after --' do
+    it 'stops parsing options after --' do
       args = %w[-- -r foo bar]
       OptionParser.parse!(args)
       expect(args).to eq(%w[-r foo bar])
@@ -92,7 +92,7 @@ describe ImageOptim::Runner::OptionParser do
     end
   end
 
-  describe :help do
+  describe '#help' do
     it 'returns wrapped text' do
       parser = OptionParser.new({})
 

data/spec/image_optim/space_spec.rb

@@ -2,24 +2,22 @@ require 'spec_helper'
 require 'image_optim/space'
 
 describe ImageOptim::Space do
-  before do
-    stub_const('Space', ImageOptim::Space)
-  end
-
-  {
-    0           => '      ',
-    1           => '    1B',
-    10          => '   10B',
-    100         => '  100B',
-    1_000       => ' 1000B',
-    10_000      => '  9.8K',
-    100_000     => ' 97.7K',
-    1_000_000   => '976.6K',
-    10_000_000  => '  9.5M',
-    100_000_000 => ' 95.4M',
-  }.each do |size, space|
-    it "converts #{size} to #{space}" do
-      expect(Space.space(size)).to eq(space)
+  describe '.space' do
+    {
+      0           => '      ',
+      1           => '    1B',
+      10          => '   10B',
+      100         => '  100B',
+      1_000       => ' 1000B',
+      10_000      => '  9.8K',
+      100_000     => ' 97.7K',
+      1_000_000   => '976.6K',
+      10_000_000  => '  9.5M',
+      100_000_000 => ' 95.4M',
+    }.each do |size, space|
+      it "converts #{size} to #{space}" do
+        expect(described_class.space(size)).to eq(space)
+      end
     end
   end
 end

data/spec/image_optim/worker/optipng_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'image_optim/worker/optipng'
-require 'image_optim/image_path'
+require 'image_optim/path'
 
 describe ImageOptim::Worker::Optipng do
   describe 'strip option' do
@@ -8,8 +8,8 @@ describe ImageOptim::Worker::Optipng do
 
     let(:options){ {} }
     let(:optipng_version){ '0.7' }
-    let(:src){ instance_double(ImageOptim::ImagePath, :copy => nil) }
-    let(:dst){ instance_double(ImageOptim::ImagePath) }
+    let(:src){ instance_double(ImageOptim::Path, :copy => nil) }
+    let(:dst){ instance_double(ImageOptim::Path) }
 
     before do
       optipng_bin = instance_double(ImageOptim::BinResolver::Bin)

data/spec/image_optim/worker/pngquant_spec.rb

@@ -10,17 +10,57 @@ describe ImageOptim::Worker::Pngquant do
     end
 
     describe 'value' do
-      let(:options){ {} }
-      subject{ described_class.new(ImageOptim.new, options).quality }
+      let(:subject){ described_class.new(ImageOptim.new, options).quality }
 
-      context 'by default' do
-        it{ is_expected.to eq(100..100) }
+      context 'when lossy not allowed' do
+        context 'by default' do
+          let(:options){ {} }
+
+          it{ is_expected.to eq(100..100) }
+        end
+
+        context 'when value is passed through options' do
+          let(:options){ {:quality => 10..90} }
+
+          it 'warns and keeps default' do
+            expect_any_instance_of(described_class).
+              to receive(:warn).with(/ignored in lossless mode/)
+            is_expected.to eq(100..100)
+          end
+        end
       end
 
-      context 'when lossy allowed by default' do
-        let(:options){ {:allow_lossy => true} }
+      context 'when lossy allowed' do
+        context 'by default' do
+          let(:options){ {:allow_lossy => true} }
+
+          it{ is_expected.to eq(0..100) }
+        end
+
+        context 'when value is passed through options' do
+          let(:options){ {:allow_lossy => true, :quality => 10..90} }
+
+          it 'sets the value without warning' do
+            expect_any_instance_of(described_class).not_to receive(:warn)
+            is_expected.to eq(10..90)
+          end
+        end
+
+        context 'when passed range begin is less than 0' do
+          let(:options){ {:allow_lossy => true, :quality => -50..50} }
+
+          it 'sets begin to 0' do
+            is_expected.to eq(0..50)
+          end
+        end
+
+        context 'when passed range end is more than 100' do
+          let(:options){ {:allow_lossy => true, :quality => 50..150} }
 
-        it{ is_expected.to eq(0..100) }
+          it 'sets end to 100' do
+            is_expected.to eq(50..100)
+          end
+        end
       end
     end
   end