openstreetmap-image_optim 0.21.0.1

data/spec/image_optim/handler_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'image_optim/handler'
+
+describe ImageOptim::Handler do
+  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 = 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)
+
+    # first unsuccessful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([original, temp_a]); false
+    end
+    expect(handler.result).to be_nil
+
+    # first successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([original, temp_a]); true
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # second unsuccessful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); false
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # second successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); true
+    end
+    expect(handler.result).to eq(temp_b)
+
+    # third successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_b, temp_a]); true
+    end
+    expect(handler.result).to eq(temp_a)
+
+    # forth successful run
+    handler.process do |src, dst|
+      expect([src, dst]).to eq([temp_a, temp_b]); true
+    end
+    expect(handler.result).to eq(temp_b)
+
+    expect(temp_a).to receive(:unlink).once
+    handler.cleanup
+    handler.cleanup
+  end
+
+  describe :open do
+    it 'yields instance, runs cleanup and returns result' do
+      original = double
+      handler = double
+      result = double
+
+      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(Handler.for(original) do |h|
+        h.process
+      end).to eq(result)
+    end
+
+    it 'cleans up if exception is raised' do
+      original = double
+      handler = double
+
+      expect(Handler).to receive(:new).
+        with(original).and_return(handler)
+      expect(handler).to receive(:cleanup)
+
+      expect do
+        Handler.for(original) do
+          fail 'hello'
+        end
+      end.to raise_error 'hello'
+    end
+  end
+end

data/spec/image_optim/hash_helpers_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'image_optim/hash_helpers'
+
+describe ImageOptim::HashHelpers do
+  before do
+    stub_const('HashHelpers', ImageOptim::HashHelpers)
+  end
+
+  context 'stringify/simbolyze' do
+    symbol_keys = {
+      :a => 1,
+      :b => {
+        :c => [:a, 'a'],
+        :d => {},
+      },
+    }
+
+    string_keys = {
+      'a' => 1,
+      'b' => {
+        'c' => [:a, 'a'],
+        'd' => {},
+      },
+    }
+
+    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 '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 'deep merges hashes' do
+    merge_a = {
+      :a => {
+        :b => 1,
+        :c => {
+          :d => 2,
+          :e => {
+            :f => true,
+          },
+        },
+      },
+      :y => 10,
+    }
+
+    merge_b = {
+      :a => {
+        :b => 2,
+        :c => {
+          :d => 3,
+          :e => false,
+        },
+      },
+      'z' => 20,
+    }
+
+    merge_result = {
+      :a => {
+        :b => 2,
+        :c => {
+          :d => 3,
+          :e => false,
+        },
+      },
+      :y => 10,
+      'z' => 20,
+    }
+
+    expect(HashHelpers.deep_merge(merge_a, merge_b)).to eq(merge_result)
+  end
+end

data/spec/image_optim/image_path_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'image_optim/image_path'
+
+describe ImageOptim::ImagePath do
+  before do
+    stub_const('ImagePath', ImageOptim::ImagePath)
+  end
+
+  describe :convert do
+    it 'returns ImagePath for string' do
+      path = 'a'
+
+      expect(ImagePath.convert(path)).to be_a(ImagePath)
+      expect(ImagePath.convert(path)).to eq(ImagePath.new(path))
+
+      expect(ImagePath.convert(path)).not_to eq(path)
+      expect(ImagePath.convert(path)).not_to be(path)
+    end
+
+    it 'returns ImagePath for Pathname' do
+      pathname = Pathname.new('a')
+
+      expect(ImagePath.convert(pathname)).to be_a(ImagePath)
+      expect(ImagePath.convert(pathname)).to eq(ImagePath.new(pathname))
+
+      expect(ImagePath.convert(pathname)).to eq(pathname)
+      expect(ImagePath.convert(pathname)).not_to be(pathname)
+    end
+
+    it 'returns same instance for ImagePath' do
+      image_path = ImagePath.new('a')
+
+      expect(ImagePath.convert(image_path)).to be_a(ImagePath)
+      expect(ImagePath.convert(image_path)).to eq(ImagePath.new(image_path))
+
+      expect(ImagePath.convert(image_path)).to eq(image_path)
+      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/railtie_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe 'ImageOptim::Railtie' do
+  require 'rails/all'
+  require 'image_optim/railtie'
+
+  def init_rails_app
+    Class.new(Rails::Application) do
+      # Rails 4 requires application class to have name
+      def self.name
+        'Dummy'
+      end
+
+      config.active_support.deprecation = :stderr
+      config.eager_load = false
+
+      config.logger = Logger.new('/dev/null')
+
+      config.assets.tap do |assets|
+        assets.enabled = true
+        assets.version = '1.0'
+        assets.cache_store = :null_store
+        assets.paths = %w[spec/images]
+
+        assets.delete(:compress)
+        assets.delete(:image_optim)
+      end
+
+      yield config if block_given?
+    end.initialize!
+  end
+
+  after do
+    Rails.application = nil
+  end
+
+  describe :initialization do
+    it 'initializes by default' do
+      expect(ImageOptim).to receive(:new)
+      init_rails_app
+    end
+
+    it 'initializes if config.assets.image_optim is nil' do
+      expect(ImageOptim).to receive(:new)
+      init_rails_app do |config|
+        config.assets.image_optim = nil
+      end
+    end
+
+    it 'does not initialize if config.assets.image_optim is false' do
+      expect(ImageOptim).not_to receive(:new)
+      init_rails_app do |config|
+        config.assets.image_optim = false
+      end
+    end
+
+    it 'does not initialize if config.assets.compress is false' do
+      expect(ImageOptim).not_to receive(:new)
+      init_rails_app do |config|
+        config.assets.compress = false
+      end
+    end
+
+    describe 'options' do
+      it 'initializes with empty hash by default' do
+        expect(ImageOptim).to receive(:new).with({})
+        init_rails_app
+      end
+
+      it 'initializes with empty hash if config.assets.image_optim is true' do
+        expect(ImageOptim).to receive(:new).with({}).and_call_original
+        init_rails_app do |config|
+          config.assets.image_optim = true
+        end
+      end
+
+      it 'initializes with empty hash if config.assets.image_optim is nil' do
+        expect(ImageOptim).to receive(:new).with({}).and_call_original
+        init_rails_app do |config|
+          config.assets.image_optim = nil
+        end
+      end
+
+      it 'initializes with hash assigned to config.assets.image_optim' do
+        hash = double
+        expect(ImageOptim).to receive(:new).with(hash)
+        init_rails_app do |config|
+          config.assets.image_optim = hash
+        end
+      end
+    end
+  end
+
+  describe :assets do
+    before do
+      stub_const('ImagePath', ImageOptim::ImagePath)
+    end
+
+    %w[
+      icecream.gif
+      lena.jpg
+      rails.png
+      test.svg
+    ].each do |asset_name|
+      it "optimizes #{asset_name}" do
+        asset = init_rails_app.assets.find_asset(asset_name)
+
+        asset_data = asset.source
+        original = ImagePath.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)
+
+          expect(temp).to be_similar_to(original, 0)
+        end
+      end
+    end
+  end
+end if ENV['RAILS_VERSION']

data/spec/image_optim/runner/glob_helpers_spec.rb

@@ -0,0 +1,25 @@
+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
+    {
+      '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(GlobHelpers.expand_braces(glob)).to match_array(expected)
+      end
+    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