image_optim 0.16.0 → 0.17.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDE1MjA4Yzc2MDkwZWM5YjgwNmJhZDVmMzM5MzI5NTU2ZjY3YWViZA==
+    NDA2ZGQwMGNiYTI1OTgxN2IyYWY1MmEyNDg0OTgwYzQ1YmY2ODk2MQ==
   data.tar.gz: !binary |-
-    NTMxMjc5YTI1ZmEzYzA1YTYwMWYwNWU4YzM3ODA0YTMwNDAyZDc3MQ==
-!binary "U0hBNTEy":
+    ZTdmNTAzMDYwMzRmM2ZlZmM5YTg4MDk5ZTgzNWJjZTUxZjY4OTA2YQ==
+SHA512:
   metadata.gz: !binary |-
-    YWM3ZmNmMzk0NWE4YTI0NTQxNDI1YzEyM2YxNzM3ZjlhMmM3NWIwMTQwYjE5
-    NGIwYzJiZDk3MzhlMGJkOWQ5Y2NkYzc3OWEyMGMyZGQ5YzEyNzJkOGRhODgy
-    NmRkNzBkMTQ0N2M3YTc3YWU2OTI0MzAxM2MyMDZmMzliMjljNDM=
+    NjM2NTMyODYxNDU2ZjNiOWQxYTE3NmY0NjgyMDY3ZGRmYjEzZDQzMTUwNmYy
+    N2IyZTdhODAxYmI0YjRjMmM5YWY5MWFlNGI0MGU3M2FmZjMzYTc1ZWQzMzhl
+    OWNjNGFlNzEyY2NjNDY1ODhmZTU1Mzk5MWQ5OTM4ZDQ0MmM3MWU=
   data.tar.gz: !binary |-
-    MjEyYWRhNDA3OTZkMTM2NWNiYTc5MzI2MDEyYzQ4ZDBlYzcyNzU4MjkxODY0
-    MTVjZjdjYjIyMWRhYTIzY2ZiMTA0ZDM3N2U2YzAyZDllM2M5Y2NkNWI5YWQw
-    OGRhYmFmZGU5ZWVlNWIzZjYzMmJkNDI3ODM1NTg0NWY3NDdhODM=
+    Y2NmZjlmODI1NDAyODk0NjAwYzRmYjUzNDU0ZTllMTNhYmM4NWRkYjQ3YmMz
+    NDFkNDc2ZTIwNTBhOWZlNmQyYTQ2YTc0NDViYmY3NDg4Yzc0ZGNlN2JjMDA2
+    MjRmOGNlNjdiNTE2YWQxMGE5Mjc5NDdkYTk1YTkzNWNlZDI0MjI=

data/.rubocop.yml

@@ -12,7 +12,7 @@ Metrics/CyclomaticComplexity:
   Max: 10
 
 Metrics/MethodLength:
-  Max: 20
+  Max: 25
 
 Metrics/PerceivedComplexity:
   Max: 8

data/.travis.yml

@@ -40,6 +40,7 @@ before_install:
 env:
   - PATH=~/bin:$PATH
 matrix:
+  fast_finish: true
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head

data/CHANGELOG.markdown

@@ -2,6 +2,14 @@
 
 ## unreleased
 
+## v0.17.0 (2014-10-04)
+
+* Use pure ruby detection of bin path [@toy](https://github.com/toy)
+* Fail if version of bin can't be detected [#39](https://github.com/toy/image_optim/issues/39) [@toy](https://github.com/toy)
+* Check path in `XXX_BIN` to exist, be a file and be executable [@toy](https://github.com/toy)
+* `image_optim --info` to perform initialization with verbose output without running optimizations [@toy](https://github.com/toy)
+* Changeable config paths [@toy](https://github.com/toy)
+
 ## v0.16.0 (2014-09-12)
 
 * Wrote this ChangeLog [#62](https://github.com/toy/image_optim/issues/62) [@toy](https://github.com/toy)

data/README.markdown

@@ -220,11 +220,13 @@ Image optimization can be time consuming, so depending on your deployment proces
 
 ## Configuration
 
-Configuration in YAML format will be read and prepanded to options from two paths:
+Configuration in YAML format will be read and prepended to options from two paths:
 
 * `$XDG_CONFIG_HOME/image_optim.yml` (by default `~/.config/image_optim.yml`)
 * `.image_optim.yml` in current working directory
 
+Paths can be changed using `:config_paths` option and `--config-paths` argument.
+
 Example configuration:
 
 ```yaml

data/bin/image_optim

@@ -18,11 +18,18 @@ option_parser = OptionParser.new do |op|
     |  #{op.program_name} [options] image_path …
     |
     |Configuration will be read and prepanded to options from two paths:
-    |  #{ImageOptim::Config::GLOBAL_CONFIG_PATH}
-    |  #{ImageOptim::Config::LOCAL_CONFIG_PATH}
+    |  #{ImageOptim::Config::GLOBAL_PATH}
+    |  #{ImageOptim::Config::LOCAL_PATH}
     |
   TEXT
 
+  op.on('--config-paths PATH1,PATH2', Array, 'Config paths to use instead of '\
+      'default ones') do |paths|
+    options[:config_paths] = paths
+  end
+
+  op.separator nil
+
   op.on('-r', '-R', '--recursive', 'Recursively scan directories '\
       'for images') do |recursive|
     options[:recursive] = recursive
@@ -107,33 +114,42 @@ option_parser = OptionParser.new do |op|
   op.separator nil
   op.separator '  Common options:'
 
-  op.on('-v', '--verbose', 'Verbose output') do |verbose|
-    options[:verbose] = verbose
+  op.on('-v', '--verbose', 'Verbose output') do
+    options[:verbose] = true
   end
 
-  op.on_tail('-h', '--help', 'Show full help') do
+  op.on_tail('-h', '--help', 'Show help and exit') do
     puts op.help
     exit
   end
 
-  op.on_tail('--version', 'Show version') do
+  op.on_tail('--version', 'Show version and exit') do
     puts ImageOptim.version
     exit
   end
+
+  op.on_tail('--info', 'Show environment info and exit') do
+    options[:verbose] = true
+    options[:only_info] = true
+  end
 end
 
 begin
   args = ARGV.dup
 
-  # assume -v to be request to print version if it is the only argument
+  # assume -v to be a request to print version if it is the only argument
   args = %w[--version] if args == %w[-v]
 
   option_parser.parse!(args)
   if options[:verbose]
     $stderr.puts ImageOptim.full_version
   end
-  unless ImageOptim::Runner.run!(args, options)
-    abort
+
+  only_info = options.delete(:only_info)
+  runner = ImageOptim::Runner.new(options)
+  unless only_info
+    abort 'specify paths to optimize' if args.empty?
+    abort unless runner.run!(args)
   end
 rescue OptionParser::ParseError => e
   abort "#{e}\n\n#{option_parser.help}"

data/image_optim.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'image_optim'
-  s.version     = '0.16.0'
+  s.version     = '0.17.0'
   s.summary     = %q{Optimize (lossless compress) images (jpeg, png, gif, svg) using external utilities (advpng, gifsicle, jpegoptim, jpegtran, optipng, pngcrush, pngout, pngquant, svgo)}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']

data/lib/image_optim/bin_resolver.rb

@@ -1,59 +1,53 @@
 require 'thread'
 require 'fspath'
-require 'image_optim/bin_resolver/simple_version'
-require 'image_optim/bin_resolver/comparable_condition'
+require 'image_optim/bin_resolver/error'
+require 'image_optim/bin_resolver/bin'
 
 class ImageOptim
   # Handles resolving binaries and checking versions
   #
-  # If there is an environment variable XXX_BIN when resolbing xxx, then a
+  # If there is an environment variable XXX_BIN when resolving xxx, then a
   # symlink to binary will be created in a temporary directory which will be
   # added to PATH
   class BinResolver
-    class Error < StandardError; end
     class BinNotFound < Error; end
-    class BadBinVersion < Error; end
-
-    # Holds name and version of an executable
-    class Bin
-      attr_reader :name, :version
-      def initialize(name, version)
-        @name = name
-        @version = version && SimpleVersion.new(version)
-      end
-
-      def to_s
-        "#{@name} #{@version || '-'}"
-      end
-    end
 
+    # Directory for symlinks to bins if XXX_BIN was used
     attr_reader :dir
+
     def initialize(image_optim)
       @image_optim = image_optim
       @bins = {}
       @lock = Mutex.new
     end
 
+    # Binary resolving: create symlink if there is XXX_BIN environment variable,
+    # build Bin with full path, check binary version
     def resolve!(name)
       name = name.to_sym
 
       resolving(name) do
-        bin = Bin.new(name, version(name)) if resolve?(name)
+        path = symlink_custom_bin!(name) || full_path(name)
+        bin = Bin.new(name, path) if path
+
         if bin && @image_optim.verbose
           $stderr << "Resolved #{bin}\n"
         end
+
         @bins[name] = bin
       end
 
       if @bins[name]
-        check!(@bins[name])
+        @bins[name].check!
       else
         fail BinNotFound, "`#{name}` not found"
       end
     end
 
+    # Path to vendor at root of image_optim
     VENDOR_PATH = File.expand_path('../../../vendor', __FILE__)
 
+    # Prepand `dir` and append `VENDOR_PATH` to `PATH` from environment
     def env_path
       [dir, ENV['PATH'], VENDOR_PATH].compact.join(':')
     end
@@ -73,6 +67,7 @@ class ImageOptim
 
   private
 
+    # Double-checked locking
     def resolving(name)
       return if @bins.include?(name)
       @lock.synchronize do
@@ -80,71 +75,41 @@ class ImageOptim
       end
     end
 
-    def resolve?(name)
-      if (path = ENV["#{name}_bin".upcase])
-        unless @dir
-          @dir = FSPath.temp_dir
-          at_exit{ FileUtils.remove_entry_secure @dir }
-        end
-        symlink = @dir / name
-        symlink.make_symlink(File.expand_path(path))
+    # Check path in XXX_BIN to exist, be a file and be executable and symlink to
+    # dir as name
+    def symlink_custom_bin!(name)
+      env_name = "#{name}_bin".upcase
+      path = ENV[env_name]
+      return unless path
+      path = File.expand_path(path)
+      desc = "`#{path}` specified in #{env_name}"
+      fail "#{desc} doesn\'t exist" unless File.exist?(path)
+      fail "#{desc} is not a file" unless File.file?(path)
+      fail "#{desc} is not executable" unless File.executable?(path)
+      if @image_optim.verbose
+        $stderr << "Custom path for #{name} specified in #{env_name}: #{path}\n"
       end
-      accessible?(name)
-    end
-
-    def accessible?(name)
-      !!version(name)
-    end
-
-    def version(name)
-      case name.to_sym
-      when :advpng, :gifsicle, :jpegoptim, :optipng, :pngquant
-        capture_output("#{name} --version 2> /dev/null")[/\d+(\.\d+){1,}/]
-      when :svgo
-        capture_output("#{name} --version 2>&1")[/\d+(\.\d+){1,}/]
-      when :jhead
-        capture_output("#{name} -V 2> /dev/null")[/\d+(\.\d+){1,}/]
-      when :jpegtran
-        capture_output("#{name} -v - 2>&1")[/version (\d+\S*)/, 1]
-      when :pngcrush
-        capture_output("#{name} -version 2>&1")[/\d+(\.\d+){1,}/]
-      when :pngout
-        date_regexp = /[A-Z][a-z]{2} (?: |\d)\d \d{4}/
-        date_str = capture_output("#{name} 2>&1")[date_regexp]
-        Date.parse(date_str).strftime('%Y%m%d') if date_str
-      when :jpegrescan
-        # jpegrescan has no version so just check presence
-        capture_output("command -v #{name}")['jpegrescan']
-      else
-        fail "getting `#{name}` version is not defined"
+      unless @dir
+        @dir = FSPath.temp_dir
+        at_exit{ FileUtils.remove_entry_secure @dir }
       end
+      symlink = @dir / name
+      symlink.make_symlink(path)
+      path
     end
 
-    def check!(bin)
-      is = ComparableCondition.is
-      case bin.name
-      when :pngcrush
-        case bin.version
-        when c = is.between?('1.7.60', '1.7.65')
-          fail BadBinVersion, "`#{bin}` (#{c}) is known to produce broken pngs"
-        end
-      when :advpng
-        case bin.version
-        when c = is < '1.17'
-          warn "Note that `#{bin}` (#{c}) does not use zopfli"
-        end
-      when :pngquant
-        case bin.version
-        when c = is < '2.0'
-          fail BadBinVersion, "`#{bin}` (#{c}) is not supported"
-        when c = is < '2.1'
-          warn "Note that `#{bin}` (#{c}) may be lossy even with quality `100-`"
+    # Return full path to bin or null
+    # based on http://stackoverflow.com/a/5471032/96823
+    def full_path(name)
+      # PATHEXT is needed only for windows
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].to_s.split(File::PATH_SEPARATOR).each do |dir|
+        exts.each do |ext|
+          path = File.expand_path("#{name}#{ext}", dir)
+          return path if File.file?(path) && File.executable?(path)
         end
       end
-    end
-
-    def capture_output(command)
-      `env PATH=#{env_path.shellescape} #{command}`
+      nil
     end
   end
 end

data/lib/image_optim/bin_resolver/bin.rb

@@ -0,0 +1,84 @@
+require 'image_optim/bin_resolver/error'
+require 'image_optim/bin_resolver/simple_version'
+require 'image_optim/bin_resolver/comparable_condition'
+
+class ImageOptim
+  class BinResolver
+    # Holds bin name and path, gets version
+    class Bin
+      class BadVersion < Error; end
+
+      attr_reader :name, :path, :version
+      def initialize(name, path)
+        @name = name.to_sym
+        @path = path
+        @version = detect_version
+      end
+
+      def to_s
+        "#{name} #{version || '?'} at #{path}"
+      end
+
+      # Fail or warn if version is known to misbehave depending on severity
+      def check!
+        unless version
+          fail BadVersion, "didn't get version of #{name} at #{path}"
+        end
+
+        is = ComparableCondition.is
+        case name
+        when :pngcrush
+          case version
+          when c = is.between?('1.7.60', '1.7.65')
+            fail BadVersion, "#{self} (#{c}) is known to produce broken pngs"
+          end
+        when :advpng
+          case version
+          when c = is < '1.17'
+            warn "WARN: #{self} (#{c}) does not use zopfli"
+          end
+        when :pngquant
+          case version
+          when c = is < '2.0'
+            fail BadVersion, "#{self} (#{c}) is not supported"
+          when c = is < '2.1'
+            warn "WARN: #{self} (#{c}) may be lossy even with quality `100-`"
+          end
+        end
+      end
+
+    private
+
+      # Wrap version_string with SimpleVersion
+      def detect_version
+        str = version_string
+        str && SimpleVersion.new(str)
+      end
+
+      # Getting version of bin, will fail for an unknown name
+      def version_string
+        case name
+        when :advpng, :gifsicle, :jpegoptim, :optipng, :pngquant
+          `#{path.shellescape} --version 2> /dev/null`[/\d+(\.\d+){1,}/]
+        when :svgo
+          `#{path.shellescape} --version 2>&1`[/\d+(\.\d+){1,}/]
+        when :jhead
+          `#{path.shellescape} -V 2> /dev/null`[/\d+(\.\d+){1,}/]
+        when :jpegtran
+          `#{path.shellescape} -v - 2>&1`[/version (\d+\S*)/, 1]
+        when :pngcrush
+          `#{path.shellescape} -version 2>&1`[/\d+(\.\d+){1,}/]
+        when :pngout
+          date_regexp = /[A-Z][a-z]{2} (?: |\d)\d \d{4}/
+          date_str = `#{path.shellescape} 2>&1`[date_regexp]
+          Date.parse(date_str).strftime('%Y%m%d') if date_str
+        when :jpegrescan
+          # jpegrescan has no version so just check presence
+          path && '-'
+        else
+          fail "getting `#{name}` version is not defined"
+        end
+      end
+    end
+  end
+end

data/lib/image_optim/bin_resolver/error.rb

@@ -0,0 +1,6 @@
+class ImageOptim
+  class BinResolver
+    # Base error during bin resolving
+    class Error < StandardError; end
+  end
+end

data/lib/image_optim/config.rb

@@ -10,26 +10,15 @@ class ImageOptim
   class Config
     include OptionHelpers
 
-    CONFIG_HOME = ENV['XDG_CONFIG_HOME'] || '~/.config'
-    GLOBAL_CONFIG_PATH = File.join(CONFIG_HOME, 'image_optim.yml')
-    LOCAL_CONFIG_PATH = './.image_optim.yml'
+    GLOBAL_PATH = begin
+      File.join(ENV['XDG_CONFIG_HOME'] || '~/.config', 'image_optim.yml')
+    end
+    LOCAL_PATH = './.image_optim.yml'
 
     class << self
-      # Read config at GLOBAL_CONFIG_PATH if it exists, warn if anything is
-      # wrong
-      def global
-        read(GLOBAL_CONFIG_PATH)
-      end
-
-      # Read config at LOCAL_CONFIG_PATH if it exists, warn if anything is
-      # wrong
-      def local
-        read(LOCAL_CONFIG_PATH)
-      end
-
-    private
-
-      def read(path)
+      # Read options at path: expand path (warn on failure), return {} if file
+      # does not exist, read yaml, check if it is a Hash, deep symbolise keys
+      def read_options(path)
         begin
           full_path = File.expand_path(path)
         rescue ArgumentError => e
@@ -49,11 +38,13 @@ class ImageOptim
     end
 
     def initialize(options)
-      @options = [
-        Config.global,
-        Config.local,
-        HashHelpers.deep_symbolise_keys(options),
-      ].reduce do |memo, hash|
+      config_paths = options.delete(:config_paths) || [GLOBAL_PATH, LOCAL_PATH]
+      config_paths = Array(config_paths)
+
+      to_merge = config_paths.map{ |path| self.class.read_options(path) }
+      to_merge << HashHelpers.deep_symbolise_keys(options)
+
+      @options = to_merge.reduce do |memo, hash|
         HashHelpers.deep_merge(memo, hash)
       end
       @used = Set.new

data/lib/image_optim/runner.rb

@@ -44,8 +44,7 @@ class ImageOptim
       end
     end
 
-    def initialize(args, options)
-      fail 'specify paths to optimize' if args.empty?
+    def initialize(options)
       options = HashHelpers.deep_symbolise_keys(options)
       @recursive = options.delete(:recursive)
       @exclude_dir_globs, @exclude_file_globs = %w[dir file].map do |type|
@@ -53,14 +52,14 @@ class ImageOptim
         GlobHelpers.expand_braces(glob)
       end
       @image_optim = ImageOptim.new(options)
-      @to_optimize = find_to_optimize(args)
     end
 
-    def run!
-      unless @to_optimize.empty?
+    def run!(args)
+      to_optimize = find_to_optimize(args)
+      unless to_optimize.empty?
         results = Results.new
 
-        optimize_images!.each do |original, optimized|
+        optimize_images!(to_optimize).each do |original, optimized|
           results.add(original, optimized)
         end
 
@@ -70,15 +69,11 @@ class ImageOptim
       !@warnings
     end
 
-    def self.run!(args, options)
-      new(args, options).run!
-    end
-
   private
 
-    def optimize_images!(&block)
+    def optimize_images!(to_optimize, &block)
       @image_optim.
-        optimize_images!(@to_optimize.with_progress('optimizing'), &block)
+        optimize_images!(to_optimize.with_progress('optimizing'), &block)
     end
 
     def find_to_optimize(paths)

data/lib/image_optim/worker.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
+require 'image_optim/bin_resolver/error'
 require 'image_optim/configuration_error'
 require 'image_optim/option_definition'
 require 'image_optim/option_helpers'

data/spec/image_optim/bin_resolver_spec.rb

@@ -10,50 +10,85 @@ ensure
 end
 
 describe ImageOptim::BinResolver do
+  BinResolver = ImageOptim::BinResolver
+  Bin = BinResolver::Bin
+  SimpleVersion = BinResolver::SimpleVersion
+
   let(:image_optim){ double(:image_optim, :verbose => false) }
-  let(:resolver){ ImageOptim::BinResolver.new(image_optim) }
+  let(:resolver){ BinResolver.new(image_optim) }
+
+  describe :full_path do
+    def full_path(name)
+      resolver.instance_eval{ full_path(name) }
+    end
+
+    def command_v(name)
+      path = `sh -c 'command -v #{name}' 2> /dev/null`.strip
+      path unless path.empty?
+    end
+
+    it 'should find binary in path' do
+      with_env 'PATH', 'bin' do
+        expect(full_path('image_optim')).
+          to eq(File.expand_path('bin/image_optim'))
+      end
+    end
+
+    it 'should return nil on failure' do
+      with_env 'PATH', 'lib' do
+        expect(full_path('image_optim')).to be_nil
+      end
+    end
+
+    %w[ls sh which bash image_optim should_not_exist].each do |name|
+      it "should return same path as `command -v` for #{name}" do
+        expect(full_path(name)).to eq(command_v(name))
+      end
+    end
+  end
 
   it 'should resolve bin in path' do
     with_env 'LS_BIN', nil do
-      allow(resolver).to receive(:version).with(:ls).and_return('xxx')
-      expect(resolver).to receive(:accessible?).with(:ls).once.and_return(true)
       expect(FSPath).not_to receive(:temp_dir)
+      expect(resolver).to receive(:full_path).with(:ls).and_return('/bin/ls')
+      bin = double
+      expect(Bin).to receive(:new).with(:ls, '/bin/ls').and_return(bin)
+      expect(bin).to receive(:check!).exactly(5).times
 
       5.times do
         resolver.resolve!(:ls)
       end
       expect(resolver.env_path).to eq([
         ENV['PATH'],
-        ImageOptim::BinResolver::VENDOR_PATH,
+        BinResolver::VENDOR_PATH,
       ].join(':'))
     end
   end
 
-  it 'should fail to resolve unknown bin' do
+  it 'should raise on failure to resolve bin' do
     with_env 'LS_BIN', nil do
       expect(FSPath).not_to receive(:temp_dir)
+      expect(resolver).to receive(:full_path).with(:ls).and_return(nil)
+      expect(Bin).not_to receive(:new)
 
       5.times do
         expect do
           resolver.resolve!(:ls)
-        end.to raise_error RuntimeError
+        end.to raise_error BinResolver::BinNotFound
       end
       expect(resolver.env_path).to eq([
         ENV['PATH'],
-        ImageOptim::BinResolver::VENDOR_PATH,
+        BinResolver::VENDOR_PATH,
       ].join(':'))
     end
   end
 
   it 'should resolve bin specified in ENV' do
-    path = 'some/path/image_optim2.3.4'
+    path = 'bin/image_optim'
     with_env 'IMAGE_OPTIM_BIN', path do
       tmpdir = double(:tmpdir, :to_str => 'tmpdir')
       symlink = double(:symlink)
 
-      allow(resolver).to receive(:version).with(:image_optim).and_return('xxx')
-      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(:/).
@@ -61,6 +96,12 @@ describe ImageOptim::BinResolver do
       expect(symlink).to receive(:make_symlink).
         with(File.expand_path(path)).once
 
+      expect(resolver).not_to receive(:full_path)
+      bin = double
+      expect(Bin).to receive(:new).
+        with(:image_optim, File.expand_path(path)).and_return(bin)
+      expect(bin).to receive(:check!).exactly(5).times
+
       at_exit_blocks = []
       expect(resolver).to receive(:at_exit).once do |&block|
         at_exit_blocks.unshift(block)
@@ -72,7 +113,7 @@ describe ImageOptim::BinResolver do
       expect(resolver.env_path).to eq([
         tmpdir,
         ENV['PATH'],
-        ImageOptim::BinResolver::VENDOR_PATH,
+        BinResolver::VENDOR_PATH,
       ].join(':'))
 
       expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
@@ -80,85 +121,71 @@ describe ImageOptim::BinResolver do
     end
   end
 
-  it 'should raise on failure to resolve bin' do
-    with_env 'PATH', nil do
-      expect(FSPath).not_to receive(:temp_dir)
-
-      5.times do
-        expect do
-          resolver.resolve!(:jpegtran)
-        end.to raise_error ImageOptim::BinResolver::BinNotFound
+  {
+    'some/path/should_not_exist_bin' => 'doesn\'t exist',
+    '.' => 'is not a file',
+    __FILE__ => 'is not executable',
+  }.each do |path, error_message|
+    it "should raise when bin specified in ENV #{error_message}" do
+      with_env 'IMAGE_OPTIM_BIN', path do
+        expect(FSPath).not_to receive(:temp_dir)
+        expect(resolver).not_to receive(:at_exit)
+
+        5.times do
+          expect do
+            resolver.resolve!(:image_optim)
+          end.to raise_error RuntimeError, /#{Regexp.escape(error_message)}/
+        end
+        expect(resolver.env_path).to eq([
+          ENV['PATH'],
+          BinResolver::VENDOR_PATH,
+        ].join(':'))
       end
-      expect(resolver.env_path).to eq(ImageOptim::BinResolver::VENDOR_PATH)
     end
   end
 
-  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, :to_str => 'tmpdir')
-      symlink = double(:symlink)
-
-      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 = []
-      expect(resolver).to receive(:at_exit).once do |&block|
-        at_exit_blocks.unshift(block)
+  it 'should resolve bin only once, but check every time' do
+    with_env 'LS_BIN', nil do
+      expect(resolver).to receive(:full_path).once.with(:ls) do
+        sleep 0.1
+        '/bin/ls'
       end
+      bin = double
+      expect(Bin).to receive(:new).once.with(:ls, '/bin/ls').and_return(bin)
 
-      5.times do
-        expect do
-          resolver.resolve!(:should_not_exist)
-        end.to raise_error ImageOptim::BinResolver::BinNotFound
-      end
-      expect(resolver.env_path).to eq([
-        tmpdir,
-        ENV['PATH'],
-        ImageOptim::BinResolver::VENDOR_PATH,
-      ].join(':'))
-
-      expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir)
-      at_exit_blocks.each(&:call)
-    end
-  end
-
-  it 'should resolve bin only once' do
-    with_env 'LS_BIN', nil do
-      allow(resolver).to receive(:version).with(:ls).and_return('xxx')
-      expect(resolver).to receive(:resolve?).once.with(:ls){ sleep 0.1; true }
+      check_count = 0
+      mutex = Mutex.new
+      allow(bin).to receive(:check!){ mutex.synchronize{ check_count += 1 } }
 
       10.times.map do
         Thread.new do
           resolver.resolve!(:ls)
         end
       end.each(&:join)
+
+      expect(check_count).to eq(10)
+    end
+  end
+
+  it 'should raise if did not got bin version' do
+    bin = Bin.new(:pngcrush, '/bin/pngcrush')
+    allow(bin).to receive(:version).and_return(nil)
+
+    5.times do
+      expect do
+        bin.check!
+      end.to raise_error Bin::BadVersion
     end
   end
 
   it 'should raise on detection of problematic version' do
-    with_env 'PNGCRUSH_BIN', nil do
-      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)
+    bin = Bin.new(:pngcrush, '/bin/pngcrush')
+    allow(bin).to receive(:version).and_return(SimpleVersion.new('1.7.60'))
 
-      5.times do
-        expect do
-          resolver.resolve!(:pngcrush)
-        end.to raise_error ImageOptim::BinResolver::BadBinVersion
-      end
-      expect(resolver.env_path).to eq([
-        ENV['PATH'],
-        ImageOptim::BinResolver::VENDOR_PATH,
-      ].join(':'))
+    5.times do
+      expect do
+        bin.check!
+      end.to raise_error Bin::BadVersion
     end
   end
 end

data/spec/image_optim/config_spec.rb

@@ -3,21 +3,20 @@ require 'rspec'
 require 'image_optim/config'
 
 describe ImageOptim::Config do
-  Config = ImageOptim::Config
-
-  before do
-    allow(Config).to receive(:global).and_return({})
-    allow(Config).to receive(:local).and_return({})
-  end
+  IOConfig = ImageOptim::Config
 
   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
-      config = Config.new({})
+      config = IOConfig.new({})
       config.assert_no_unused_options!
     end
 
     it 'should raise when there are unused options' do
-      config = Config.new(:unused => true)
+      config = IOConfig.new(:unused => true)
       expect do
         config.assert_no_unused_options!
       end.to raise_error(ImageOptim::ConfigurationError)
@@ -25,41 +24,53 @@ describe ImageOptim::Config do
   end
 
   describe 'nice' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
     it 'should be 10 by default' do
-      config = Config.new({})
+      config = IOConfig.new({})
       expect(config.nice).to eq(10)
     end
 
     it 'should be 0 if disabled' do
-      config = Config.new(:nice => false)
+      config = IOConfig.new(:nice => false)
       expect(config.nice).to eq(0)
     end
 
     it 'should convert value to number' do
-      config = Config.new(:nice => '13')
+      config = IOConfig.new(:nice => '13')
       expect(config.nice).to eq(13)
     end
   end
 
   describe 'threads' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
     it 'should be processor_count by default' do
-      config = Config.new({})
+      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
-      config = Config.new(:threads => false)
+      config = IOConfig.new(:threads => false)
       expect(config.threads).to eq(1)
     end
 
     it 'should convert value to number' do
-      config = Config.new(:threads => '616')
+      config = IOConfig.new(:threads => '616')
       expect(config.threads).to eq(616)
     end
   end
 
   describe 'for_worker' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
     Abc = Class.new do
       def self.bin_sym
         :abc
@@ -71,80 +82,103 @@ describe ImageOptim::Config do
     end
 
     it 'should return empty hash by default' do
-      config = Config.new({})
+      config = IOConfig.new({})
       expect(config.for_worker(Abc)).to eq({})
     end
 
     it 'should return passed hash' do
-      config = Config.new(:abc => {:option => true})
+      config = IOConfig.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 = IOConfig.new(:abc => false)
       expect(config.for_worker(Abc)).to eq(false)
     end
 
-    it 'should raise on unknown optino' do
-      config = Config.new(:abc => 13)
+    it 'should raise on unknown option' do
+      config = IOConfig.new(:abc => 13)
       expect do
         config.for_worker(Abc)
       end.to raise_error(ImageOptim::ConfigurationError)
     end
   end
 
-  describe 'class methods' do
-    before do
-      allow(Config).to receive(:global).and_call_original
-      allow(Config).to receive(:local).and_call_original
+  describe 'config' do
+    it 'should read 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).
+        with(IOConfig::LOCAL_PATH).and_return(:a => 10, :b => 20)
+
+      config = IOConfig.new(:a => 100)
+      expect(config.get!(:a)).to eq(100)
+      expect(config.get!(:b)).to eq(20)
+      expect(config.get!(:c)).to eq(3)
+      config.assert_no_unused_options!
     end
 
-    describe 'global' do
-      it 'should call read with GLOBAL_CONFIG_PATH' do
-        expect(Config).to receive(:read).
-          with(Config::GLOBAL_CONFIG_PATH).and_return(:config => true)
+    it 'should not read options with empty config_paths' do
+      expect(IOConfig).not_to receive(:read_options)
 
-        expect(Config.global).to eq(:config => true)
-      end
+      config = IOConfig.new(:config_paths => [])
+      config.assert_no_unused_options!
     end
 
-    describe 'local' do
-      it 'should call read with LOCAL_CONFIG_PATH' do
-        expect(Config).to receive(:read).
-          with(Config::LOCAL_CONFIG_PATH).and_return(:config => true)
+    it 'should read 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).
+        with('config/image_optim.yml').and_return(:a => 10, :b => 20)
 
-        expect(Config.local).to eq(:config => true)
-      end
+      config = IOConfig.new(:a => 100, :config_paths => %w[
+        /etc/image_optim.yml
+        config/image_optim.yml
+      ])
+      expect(config.get!(:a)).to eq(100)
+      expect(config.get!(:b)).to eq(20)
+      expect(config.get!(:c)).to eq(3)
+      config.assert_no_unused_options!
     end
 
-    describe 'read' do
+    it 'should convert config_paths to array' do
+      expect(IOConfig).to receive(:read_options).
+        with('config/image_optim.yml').and_return({})
+
+      config = IOConfig.new(:config_paths => 'config/image_optim.yml')
+      config.assert_no_unused_options!
+    end
+  end
+
+  describe 'class methods' do
+    describe 'read_options' do
       let(:path){ double(:path) }
       let(:full_path){ double(:full_path) }
 
       it 'should warn if expand path fails' do
-        expect(Config).to receive(:warn)
+        expect(IOConfig).to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_raise(ArgumentError)
         expect(File).not_to receive(:file?)
 
-        expect(Config.send(:read, path)).to eq({})
+        expect(IOConfig.read_options(path)).to eq({})
       end
 
       it 'should return empty hash if path is not a file' do
-        expect(Config).not_to receive(:warn)
+        expect(IOConfig).not_to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_return(full_path)
         expect(File).to receive(:file?).
           with(full_path).and_return(false)
 
-        expect(Config.send(:read, path)).to eq({})
+        expect(IOConfig.read_options(path)).to eq({})
       end
 
       it 'should return hash with deep symbolised keys from reader' do
         stringified = {'config' => {'this' => true}}
         symbolized = {:config => {:this => true}}
 
-        expect(Config).not_to receive(:warn)
+        expect(IOConfig).not_to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_return(full_path)
         expect(File).to receive(:file?).
@@ -152,11 +186,11 @@ describe ImageOptim::Config do
         expect(YAML).to receive(:load_file).
           with(full_path).and_return(stringified)
 
-        expect(Config.send(:read, path)).to eq(symbolized)
+        expect(IOConfig.read_options(path)).to eq(symbolized)
       end
 
       it 'should warn and return an empty hash if reader returns non hash' do
-        expect(Config).to receive(:warn)
+        expect(IOConfig).to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_return(full_path)
         expect(File).to receive(:file?).
@@ -164,11 +198,11 @@ describe ImageOptim::Config do
         expect(YAML).to receive(:load_file).
           with(full_path).and_return([:config])
 
-        expect(Config.send(:read, path)).to eq({})
+        expect(IOConfig.read_options(path)).to eq({})
       end
 
       it 'should warn and return an empty hash if reader raises exception' do
-        expect(Config).to receive(:warn)
+        expect(IOConfig).to receive(:warn)
         expect(File).to receive(:expand_path).
           with(path).and_return(full_path)
         expect(File).to receive(:file?).
@@ -176,7 +210,7 @@ describe ImageOptim::Config do
         expect(YAML).to receive(:load_file).
           with(full_path).and_raise
 
-        expect(Config.send(:read, path)).to eq({})
+        expect(IOConfig.read_options(path)).to eq({})
       end
     end
   end

data/spec/image_optim/image_path_spec.rb

@@ -9,8 +9,8 @@ describe ImageOptim::ImagePath do
     it 'should return ImagePath for string' do
       path = 'a'
 
-      expect(ImagePath.convert(path)).to be_a(ImageOptim::ImagePath)
-      expect(ImagePath.convert(path)).to eq(ImageOptim::ImagePath.new(path))
+      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)
@@ -19,18 +19,18 @@ describe ImageOptim::ImagePath do
     it 'should return ImagePath for Pathname' do
       pathname = Pathname.new('a')
 
-      expect(ImagePath.convert(pathname)).to be_a(ImageOptim::ImagePath)
-      expect(ImagePath.convert(pathname)).to eq(ImageOptim::ImagePath.new(pathname))
+      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 'should return same instance for ImagePath' do
-      image_path = ImageOptim::ImagePath.new('a')
+      image_path = ImagePath.new('a')
 
-      expect(ImagePath.convert(image_path)).to be_a(ImageOptim::ImagePath)
-      expect(ImagePath.convert(image_path)).to eq(ImageOptim::ImagePath.new(image_path))
+      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)

data/spec/image_optim_spec.rb

@@ -76,17 +76,11 @@ describe ImageOptim do
   end
 
   describe 'worker' do
-    image_optim = ImageOptim.new
-
     base_options = Hash[ImageOptim::Worker.klasses.map do |klass|
       [klass.bin_sym, false]
     end]
 
-    real_workers = ImageOptim::Worker.klasses.reject do |klass|
-      klass.new(image_optim, {}).image_formats.empty?
-    end
-
-    real_workers.each do |worker_klass|
+    ImageOptim::Worker.klasses.each do |worker_klass|
       describe worker_klass.bin_sym do
         it 'should optimize at least one test image' do
           options = base_options.merge(worker_klass.bin_sym => true)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: image_optim
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-12 00:00:00.000000000 Z
+date: 2014-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fspath
@@ -145,7 +145,9 @@ files:
 - image_optim.gemspec
 - lib/image_optim.rb
 - lib/image_optim/bin_resolver.rb
+- lib/image_optim/bin_resolver/bin.rb
 - lib/image_optim/bin_resolver/comparable_condition.rb
+- lib/image_optim/bin_resolver/error.rb
 - lib/image_optim/bin_resolver/simple_version.rb
 - lib/image_optim/config.rb
 - lib/image_optim/configuration_error.rb
@@ -227,7 +229,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: image_optim
-rubygems_version: 2.0.3
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Optimize (lossless compress) images (jpeg, png, gif, svg) using external
@@ -267,4 +269,3 @@ test_files:
 - spec/images/transparency1.png
 - spec/images/transparency2.png
 - spec/images/vergroessert.jpg
-has_rdoc: