discourse_image_optim 0.24.4

data/spec/image_optim/path_spec.rb

@@ -0,0 +1,103 @@
+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{ src.replace(dst) }.to change{ dst.stat.ino }
+    end
+  end
+end

data/spec/image_optim/runner/glob_helpers_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'image_optim/runner/glob_helpers'
+
+describe ImageOptim::Runner::GlobHelpers do
+  describe '.expand_braces' do
+    {
+      'hello.world' => %w[hello.world],
+      '{hello,.world}' => %w[hello .world],
+      'hello{.,!}world' => %w[hello.world hello!world],
+      '{a,b},{c,d}' => %w[a,c b,c a,d b,d],
+      '{{a,b},{c,d}}' => %w[a b c d],
+      '{a,b,{c,d}}' => %w[a b c d],
+      '{\{a,b\},\{c,d\}}' => %w[\\{a b\\} \\{c d\\}],
+      'test{ing,}' => %w[testing test],
+    }.each do |glob, expected|
+      it "expands #{glob}" do
+        expect(described_class.expand_braces(glob)).to match_array(expected)
+      end
+    end
+  end
+end

data/spec/image_optim/runner/option_parser_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'image_optim/runner/option_parser'
+
+describe ImageOptim::Runner::OptionParser do
+  before do
+    stub_const('OptionParser', ImageOptim::Runner::OptionParser)
+  end
+
+  def exit_with_status(status)
+    raise_error(SystemExit) do |e|
+      expect(e.status).to eq(status)
+    end
+  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 options 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 exit_with_status(0) &
+               output("#{help}\n").to_stdout
+      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 exit_with_status(1) &
+               output("invalid option: --unknown-option\n\n#{help}\n").to_stderr
+      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

data/spec/image_optim/space_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'image_optim/space'
+
+describe ImageOptim::Space do
+  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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'image_optim/worker/optipng'
+require 'image_optim/path'
+
+describe ImageOptim::Worker::Optipng do
+  describe 'strip option' do
+    subject{ described_class.new(ImageOptim.new, options) }
+
+    let(:options){ {} }
+    let(:optipng_version){ '0.7' }
+    let(:src){ instance_double(ImageOptim::Path, :copy => nil) }
+    let(:dst){ instance_double(ImageOptim::Path) }
+
+    before do
+      optipng_bin = instance_double(ImageOptim::BinResolver::Bin)
+      allow(subject).to receive(:resolve_bin!).
+        with(:optipng).and_return(optipng_bin)
+      allow(optipng_bin).to receive(:version).
+        and_return(ImageOptim::BinResolver::SimpleVersion.new(optipng_version))
+
+      allow(subject).to receive(:optimized?)
+    end
+
+    context 'by default' do
+      it 'should add -strip all to arguments' do
+        expect(subject).to receive(:execute) do |_bin, *args|
+          expect(args.join(' ')).to match(/(^| )-strip all($| )/)
+        end
+
+        subject.optimize(src, dst)
+      end
+    end
+
+    context 'when strip is disabled' do
+      let(:options){ {:strip => false} }
+
+      it 'should not add -strip all to arguments' do
+        expect(subject).to receive(:execute) do |_bin, *args|
+          expect(args.join(' ')).not_to match(/(^| )-strip all($| )/)
+        end
+
+        subject.optimize(src, dst)
+      end
+    end
+
+    context 'when optipng version is < 0.7' do
+      let(:optipng_version){ '0.6.999' }
+
+      it 'should not add -strip all to arguments' do
+        expect(subject).to receive(:execute) do |_bin, *args|
+          expect(args.join(' ')).not_to match(/(^| )-strip all($| )/)
+        end
+
+        subject.optimize(src, dst)
+      end
+    end
+  end
+
+  describe '#optimized?' do
+    let(:src){ instance_double(ImageOptim::Path, src_options) }
+    let(:dst){ instance_double(ImageOptim::Path, dst_options) }
+    let(:src_options){ {:size => 10} }
+    let(:dst_options){ {:size? => 9} }
+    let(:instance){ described_class.new(ImageOptim.new, instance_options) }
+    let(:instance_options){ {} }
+
+    subject{ instance.optimized?(src, dst) }
+
+    context 'when interlace option is enabled' do
+      let(:instance_options){ {:interlace => true} }
+
+      context 'when dst is empty' do
+        let(:dst_options){ {:size? => nil} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is not empty' do
+        let(:dst_options){ {:size? => 20} }
+        it{ is_expected.to be_truthy }
+      end
+    end
+
+    context 'when interlace option is disabled' do
+      let(:instance_options){ {:interlace => false} }
+
+      context 'when dst is empty' do
+        let(:dst_options){ {:size? => nil} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is greater than or equal to src' do
+        let(:dst_options){ {:size? => 10} }
+        it{ is_expected.to be_falsy }
+      end
+
+      context 'when dst is less than src' do
+        let(:dst_options){ {:size? => 9} }
+        it{ is_expected.to be_truthy }
+      end
+    end
+  end
+end

data/spec/image_optim/worker/pngquant_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'image_optim/worker/pngquant'
+
+describe ImageOptim::Worker::Pngquant do
+  describe 'quality option' do
+    describe 'default' do
+      subject{ described_class::QUALITY_OPTION.default }
+
+      it{ is_expected.to match(/100\.\.100.*0\.\.100/) }
+    end
+
+    describe 'value' do
+      let(:subject){ described_class.new(ImageOptim.new, options).quality }
+
+      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' 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 'sets end to 100' do
+            is_expected.to eq(50..100)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/image_optim/worker_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+require 'image_optim/worker'
+require 'image_optim/bin_resolver'
+
+describe ImageOptim::Worker do
+  before do
+    stub_const('Worker', ImageOptim::Worker)
+    stub_const('BinResolver', ImageOptim::BinResolver)
+
+    # don't add to list of wokers
+    allow(ImageOptim::Worker).to receive(:inherited)
+  end
+
+  describe '#initialize' do
+    it 'expects first argument to be an instanace of ImageOptim' do
+      expect do
+        Worker.new(double)
+      end.to raise_error ArgumentError
+    end
+  end
+
+  describe '#options' do
+    it 'returns a Hash with options' do
+      worker_class = Class.new(Worker) do
+        option(:one, 1, 'One')
+        option(:two, 2, 'Two')
+        option(:three, 3, 'Three')
+      end
+
+      worker = worker_class.new(ImageOptim.new, :three => '...')
+
+      expect(worker.options).to eq(:one => 1, :two => 2, :three => '...')
+    end
+  end
+
+  describe '#optimize' do
+    it 'raises NotImplementedError' do
+      worker = Worker.new(ImageOptim.new, {})
+
+      expect do
+        worker.optimize(double, double)
+      end.to raise_error NotImplementedError
+    end
+  end
+
+  describe '#image_formats' do
+    {
+      'GifOptim' => :gif,
+      'JpegOptim' => :jpeg,
+      'PngOptim' => :png,
+      'SvgOptim' => :svg,
+    }.each do |class_name, image_format|
+      it "detects if class name contains #{image_format}" do
+        worker = stub_const(class_name, Class.new(Worker)).new(ImageOptim.new)
+        expect(worker.image_formats).to eq([image_format])
+      end
+    end
+
+    it 'fails if class name does not contain known type' do
+      worker = stub_const('TiffOptim', Class.new(Worker)).new(ImageOptim.new)
+      expect{ worker.image_formats }.to raise_error(/can't guess/)
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns inspect String containing options' do
+      stub_const('DefOptim', Class.new(Worker) do
+        option(:one, 1, 'One')
+        option(:two, 2, 'Two')
+        option(:three, 3, 'Three')
+      end)
+
+      worker = DefOptim.new(ImageOptim.new, :three => '...')
+
+      expect(worker.inspect).to eq('#<DefOptim @one=1, @two=2, @three="...">')
+    end
+  end
+
+  describe '.inherited' do
+    it 'adds subclasses to klasses' do
+      base_class = Class.new{ extend ImageOptim::Worker::ClassMethods }
+      expect(base_class.klasses.to_a).to eq([])
+
+      worker_class = Class.new(base_class)
+      expect(base_class.klasses.to_a).to eq([worker_class])
+    end
+  end
+
+  describe '.create_all_by_format' do
+    it 'passes arguments to create_all' do
+      image_optim = double
+      options_proc = proc{ true }
+
+      expect(Worker).to receive(:create_all) do |arg, &block|
+        expect(arg).to eq(image_optim)
+        expect(block).to eq(options_proc)
+        []
+      end
+
+      Worker.create_all_by_format(image_optim, &options_proc)
+    end
+
+    it 'create hash by format' do
+      workers = [
+        double(:image_formats => [:a]),
+        double(:image_formats => [:a, :b]),
+        double(:image_formats => [:b, :c]),
+      ]
+
+      expect(Worker).to receive(:create_all).and_return(workers)
+
+      worker_by_format = {
+        :a => [workers[0], workers[1]],
+        :b => [workers[1], workers[2]],
+        :c => [workers[2]],
+      }
+
+      expect(Worker.create_all_by_format(double)).to eq(worker_by_format)
+    end
+  end
+
+  describe '.create_all' do
+    def worker_double(override = {})
+      stubs = {:resolve_used_bins! => nil, :run_order => 0}.merge(override)
+      instance_double(Worker, stubs)
+    end
+
+    def worker_class_doubles(workers)
+      workers.map{ |worker| class_double(Worker, :init => worker) }
+    end
+
+    let(:image_optim){ double(:allow_lossy => false, :timeout => 30) }
+
+    it 'creates all workers for which options_proc returns true' do
+      workers = Array.new(3){ worker_double }
+      klasses = worker_class_doubles(workers)
+      options_proc = proc do |klass|
+        klass == klasses[1] ? {:disable => true} : {}
+      end
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim, &options_proc)).
+        to eq([workers[0], workers[2]])
+    end
+
+    it 'handles workers initializing multiple instances' do
+      workers = [
+        worker_double,
+        [worker_double, worker_double, worker_double],
+        worker_double,
+      ]
+      klasses = worker_class_doubles(workers)
+
+      allow(Worker).to receive(:klasses).and_return(klasses)
+
+      expect(Worker.create_all(image_optim){ {} }).
+        to eq(workers.flatten)
+    end
+
+    describe 'with missing workers' do
+      let(:workers) do
+        %w[a b c c].map do |bin|
+          worker = worker_double
+          unless bin == 'b'
+            allow(worker).to receive(:resolve_used_bins!).
+              and_raise(BinResolver::BinNotFound, "not found #{bin}")
+          end
+          worker
+        end
+      end
+      let(:klasses){ worker_class_doubles(workers) }
+
+      before do
+        allow(Worker).to receive(:klasses).and_return(klasses)
+      end
+
+      describe 'if skip_missing_workers is true' do
+        it 'shows deduplicated warnings and returns resolved workers ' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(true)
+
+          expect(Worker).to receive(:warn).once.with('not found a')
+          expect(Worker).to receive(:warn).once.with('not found c')
+
+          expect(Worker.create_all(image_optim){ {} }).to eq([workers[1]])
+        end
+      end
+
+      describe 'if skip_missing_workers is false' do
+        it 'fails with a joint exception of deduplicated messages' do
+          allow(image_optim).to receive(:skip_missing_workers).and_return(false)
+
+          expect do
+            Worker.create_all(image_optim){ {} }
+          end.to raise_error(BinResolver::Error, [
+            'Bin resolving errors:',
+            'not found a',
+            'not found c',
+          ].join("\n"))
+        end
+      end
+    end
+
+    it 'orders workers by run_order' do
+      run_orders = [10, -10, 0, 0, 0, 10, -10]
+      workers = run_orders.map do |run_order|
+        worker_double(:run_order => run_order)
+      end
+      klasses_list = worker_class_doubles(workers)
+
+      [
+        klasses_list,
+        klasses_list.reverse,
+        klasses_list.shuffle,
+      ].each do |klasses|
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        expected_order = klasses.map(&:init).sort_by.with_index do |worker, i|
+          [worker.run_order, i]
+        end
+
+        expect(Worker.create_all(image_optim){ {} }).to eq(expected_order)
+      end
+    end
+
+    describe 'configuring workers' do
+      [:allow_lossy, :timeout].each do |option|
+        it "passes #{option} if worker has such attribute" do
+          klasses = worker_class_doubles([worker_double, worker_double])
+
+          allow(Worker).to receive(:klasses).and_return(klasses)
+
+          klasses[0].send(:attr_reader, option)
+          expect(klasses[0]).to receive(:init).
+            with(image_optim, hash_including(option))
+          expect(klasses[1]).to receive(:init).
+            with(image_optim, hash_not_including(option))
+
+          Worker.create_all(image_optim){ {} }
+        end
+      end
+
+      it 'allows overriding allow_lossy per worker' do
+        klasses = worker_class_doubles([worker_double, worker_double])
+        options_proc = proc do |klass|
+          klass == klasses[1] ? {:allow_lossy => :b} : {}
+        end
+
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        klasses.each{ |klass| klass.send(:attr_reader, :allow_lossy) }
+        expect(klasses[0]).to receive(:init).
+          with(image_optim, hash_including(:allow_lossy => false))
+        expect(klasses[1]).to receive(:init).
+          with(image_optim, hash_including(:allow_lossy => :b))
+
+        Worker.create_all(image_optim, &options_proc)
+      end
+
+      it 'allows overriding timeout per worker' do
+        klasses = worker_class_doubles([worker_double, worker_double])
+        options_proc = proc do |klass|
+          klass == klasses[1] ? {:timeout => 50} : {}
+        end
+
+        allow(Worker).to receive(:klasses).and_return(klasses)
+
+        klasses.each{ |klass| klass.send(:attr_reader, :timeout) }
+        expect(klasses[0]).to receive(:init).
+          with(image_optim, hash_including(:timeout => 30))
+        expect(klasses[1]).to receive(:init).
+          with(image_optim, hash_including(:timeout => 50))
+
+        Worker.create_all(image_optim, &options_proc)
+      end
+    end
+  end
+
+  describe '.option' do
+    it 'runs option block in context of worker' do
+      stub_const('Abc', Class.new(Worker) do
+        option(:test, 1, 'Test context') do |_v|
+          some_instance_method
+        end
+      end)
+
+      expect_any_instance_of(Abc).
+        to receive(:some_instance_method).and_return(20)
+      expect(Abc.new(ImageOptim.new).test).to eq(20)
+    end
+
+    it 'returns instance of OptionDefinition' do
+      definition = nil
+      Class.new(Worker) do
+        definition = option(:test, 1, 'Test'){ |v| v }
+      end
+
+      expect(definition).to be_an(ImageOptim::OptionDefinition)
+      expect(definition.name).to eq(:test)
+      expect(definition.default).to eq(1)
+    end
+  end
+end