image_optim 0.28.0 → 0.31.1

data/lib/image_optim/runner.rb

@@ -38,7 +38,7 @@ class ImageOptim
         if size_a == size_b
           "------ #{Space::EMPTY_SPACE}"
         else
-          percent = 100 - 100.0 * size_b / size_a
+          percent = 100 - (100.0 * size_b / size_a)
           space = Space.space(size_a - size_b)
           format('%5.2f%% %s', percent, space)
         end

data/lib/image_optim/timer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'image_optim/elapsed_time'
+
+class ImageOptim
+  # Hold start time and timeout
+  class Timer
+    include ElapsedTime
+
+    def initialize(seconds)
+      @start = now
+      @seconds = seconds
+    end
+
+    def elapsed
+      now - @start
+    end
+
+    def left
+      @seconds - elapsed
+    end
+
+    alias_method :to_f, :left
+  end
+end

data/lib/image_optim/worker/advpng.rb

@@ -9,11 +9,11 @@ class ImageOptim
     class Advpng < Worker
       LEVEL_OPTION =
       option(:level, 4, 'Compression level: '\
-          '`0` - don\'t compress, '\
-          '`1` - fast, '\
-          '`2` - normal, '\
-          '`3` - extra, '\
-          '`4` - extreme') do |v|
+                        '`0` - don\'t compress, '\
+                        '`1` - fast, '\
+                        '`2` - normal, '\
+                        '`3` - extra, '\
+                        '`4` - extreme') do |v|
         OptionHelpers.limit_with_range(v.to_i, 0..4)
       end
 
@@ -21,7 +21,7 @@ class ImageOptim
         4
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         src.copy(dst)
         args = %W[
           --recompress
@@ -30,7 +30,7 @@ class ImageOptim
           --
           #{dst}
         ]
-        execute(:advpng, *args) && optimized?(src, dst)
+        execute(:advpng, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/gifsicle.rb

@@ -12,32 +12,32 @@ class ImageOptim
         return super if options.key?(:interlace)
 
         [false, true].map do |interlace|
-          new(image_optim, options.merge(:interlace => interlace))
+          new(image_optim, options.merge(interlace: interlace))
         end
       end
 
       INTERLACE_OPTION =
       option(:interlace, false, TrueFalseNil, 'Interlace: '\
-          '`true` - interlace on, '\
-          '`false` - interlace off, '\
-          '`nil` - as is in original image '\
-          '(defaults to running two instances, one with interlace off and '\
-          'one with on)') do |v|
+                                              '`true` - interlace on, '\
+                                              '`false` - interlace off, '\
+                                              '`nil` - as is in original image '\
+                                              '(defaults to running two instances, one with interlace off and '\
+                                              'one with on)') do |v|
         TrueFalseNil.convert(v)
       end
 
       LEVEL_OPTION =
       option(:level, 3, 'Compression level: '\
-          '`1` - light and fast, '\
-          '`2` - normal, '\
-          '`3` - heavy (slower)') do |v|
+                        '`1` - light and fast, '\
+                        '`2` - normal, '\
+                        '`3` - heavy (slower)') do |v|
         OptionHelpers.limit_with_range(v.to_i, 1..3)
       end
 
       CAREFUL_OPTION =
       option(:careful, false, 'Avoid bugs with some software'){ |v| !!v }
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         args = %W[
           --output=#{dst}
           --no-comments
@@ -58,7 +58,7 @@ class ImageOptim
         end
         args.unshift '--careful' if careful
         args.unshift "--optimize=#{level}" if level
-        execute(:gifsicle, *args) && optimized?(src, dst)
+        execute(:gifsicle, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/jhead.rb

@@ -25,7 +25,7 @@ class ImageOptim
         [:jhead, :jpegtran]
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         return false unless oriented?(src)
 
         src.copy(dst)
@@ -34,7 +34,7 @@ class ImageOptim
           #{dst}
         ]
         resolve_bin!(:jpegtran)
-        execute(:jhead, *args) && dst.size?
+        execute(:jhead, args, options) && dst.size?
       end
 
     private

data/lib/image_optim/worker/jpegoptim.rb

@@ -12,13 +12,13 @@ class ImageOptim
 
       STRIP_OPTION =
       option(:strip, :all, Array, 'List of markers to strip: '\
-          '`:com`, '\
-          '`:exif`, '\
-          '`:iptc`, '\
-          '`:icc`, '\
-          '`:xmp`, '\
-          '`:none` or '\
-          '`:all`') do |v|
+                                  '`:com`, '\
+                                  '`:exif`, '\
+                                  '`:iptc`, '\
+                                  '`:icc`, '\
+                                  '`:xmp`, '\
+                                  '`:none` or '\
+                                  '`:all`') do |v|
         values = Array(v).map(&:to_s)
         known_values = %w[com exif iptc icc xmp none all]
         unknown_values = values - known_values
@@ -30,13 +30,13 @@ class ImageOptim
 
       MAX_QUALITY_OPTION =
       option(:max_quality, 100, 'Maximum image quality factor '\
-          '`0`..`100`, ignored in default/lossless mode') do |v, opt_def|
+                                '`0`..`100`, ignored in default/lossless mode') do |v, opt_def|
         if allow_lossy
           OptionHelpers.limit_with_range(v.to_i, 0..100)
         else
           if v != opt_def.default
             warn "#{self.class.bin_sym} #{opt_def.name} #{v} ignored " \
-                'in lossless mode'
+                 'in lossless mode'
           end
           opt_def.default
         end
@@ -47,7 +47,7 @@ class ImageOptim
         max_quality < 100 ? -1 : 0
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         src.copy(dst)
         args = %W[
           --quiet
@@ -58,7 +58,7 @@ class ImageOptim
           args.unshift "--strip-#{strip_marker}"
         end
         args.unshift "--max=#{max_quality}" if max_quality < 100
-        execute(:jpegoptim, *args) && optimized?(src, dst)
+        execute(:jpegoptim, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/jpegrecompress.rb

@@ -28,10 +28,10 @@ class ImageOptim
 
       METHOD_OPTION =
       option(:method, 'ssim', 'Comparison Metric: '\
-          '`mpe` - Mean pixel error, '\
-          '`ssim` - Structural similarity, '\
-          '`ms-ssim` - Multi-scale structural similarity (slow!), '\
-          '`smallfry` - Linear-weighted BBCQ-like (may be patented)') do |v, opt_def|
+                              '`mpe` - Mean pixel error, '\
+                              '`ssim` - Structural similarity, '\
+                              '`ms-ssim` - Multi-scale structural similarity (slow!), '\
+                              '`smallfry` - Linear-weighted BBCQ-like (may be patented)') do |v, opt_def|
         if %w[mpe ssim ms-ssim smallfry].include? v
           v
         else
@@ -49,7 +49,7 @@ class ImageOptim
         -5
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         args = %W[
           --quality #{QUALITY_NAMES[quality]}
           --method #{method}
@@ -57,7 +57,7 @@ class ImageOptim
           #{src}
           #{dst}
         ]
-        execute(:'jpeg-recompress', *args) && optimized?(src, dst)
+        execute(:'jpeg-recompress', args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/jpegtran.rb

@@ -17,13 +17,13 @@ class ImageOptim
 
       JPEGRESCAN_OPTION =
       option(:jpegrescan, true, 'Use jpegtran through jpegrescan, '\
-          'ignore progressive option'){ |v| !!v }
+                                'ignore progressive option'){ |v| !!v }
 
       def used_bins
         jpegrescan ? [:jpegtran, :jpegrescan] : [:jpegtran]
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         if jpegrescan
           args = %W[
             #{src}
@@ -31,7 +31,7 @@ class ImageOptim
           ]
           args.unshift '-s' unless copy_chunks
           resolve_bin!(:jpegtran)
-          execute(:jpegrescan, *args) && optimized?(src, dst)
+          execute(:jpegrescan, args, options) && optimized?(src, dst)
         else
           args = %W[
             -optimize
@@ -40,7 +40,7 @@ class ImageOptim
           ]
           args.unshift '-copy', (copy_chunks ? 'all' : 'none')
           args.unshift '-progressive' if progressive
-          execute(:jpegtran, *args) && optimized?(src, dst)
+          execute(:jpegtran, args, options) && optimized?(src, dst)
         end
       end
     end

data/lib/image_optim/worker/optipng.rb

@@ -10,16 +10,16 @@ class ImageOptim
     class Optipng < Worker
       LEVEL_OPTION =
       option(:level, 6, 'Optimization level preset: '\
-          '`0` is least, '\
-          '`7` is best') do |v|
+                        '`0` is least, '\
+                        '`7` is best') do |v|
         OptionHelpers.limit_with_range(v.to_i, 0..7)
       end
 
       INTERLACE_OPTION =
       option(:interlace, false, TrueFalseNil, 'Interlace: '\
-          '`true` - interlace on, '\
-          '`false` - interlace off, '\
-          '`nil` - as is in original image') do |v|
+                                              '`true` - interlace on, '\
+                                              '`false` - interlace off, '\
+                                              '`nil` - as is in original image') do |v|
         TrueFalseNil.convert(v)
       end
 
@@ -30,7 +30,7 @@ class ImageOptim
         -4
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         src.copy(dst)
         args = %W[
           -o #{level}
@@ -42,7 +42,7 @@ class ImageOptim
         if strip && resolve_bin!(:optipng).version >= '0.7'
           args.unshift '-strip', 'all'
         end
-        execute(:optipng, *args) && optimized?(src, dst)
+        execute(:optipng, args, options) && optimized?(src, dst)
       end
 
       def optimized?(src, dst)

data/lib/image_optim/worker/oxipng.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'image_optim/worker'
+require 'image_optim/option_helpers'
+require 'image_optim/true_false_nil'
+
+class ImageOptim
+  class Worker
+    # https://github.com/shssoichiro/oxipng
+    class Oxipng < Worker
+      LEVEL_OPTION =
+      option(:level, 3, 'Optimization level preset: '\
+                        '`0` is least, '\
+                        '`6` is best') do |v|
+        OptionHelpers.limit_with_range(v.to_i, 0..6)
+      end
+
+      INTERLACE_OPTION =
+      option(:interlace, false, TrueFalseNil, 'Interlace: '\
+                                              '`true` - interlace on, '\
+                                              '`false` - interlace off, '\
+                                              '`nil` - as is in original image') do |v|
+        TrueFalseNil.convert(v)
+      end
+
+      STRIP_OPTION =
+      option(:strip, true, 'Remove all auxiliary chunks'){ |v| !!v }
+
+      def run_order
+        -4
+      end
+
+      def optimize(src, dst, options = {})
+        src.copy(dst)
+        args = %W[
+          -o #{level}
+          --quiet
+          --
+          #{dst}
+        ]
+        args.unshift "-i#{interlace ? 1 : 0}" unless interlace.nil?
+        if strip
+          args.unshift '--strip', 'all'
+        end
+        execute(:oxipng, args, options) && optimized?(src, dst)
+      end
+
+      def optimized?(src, dst)
+        interlace ? dst.size? : super
+      end
+    end
+  end
+end

data/lib/image_optim/worker/pngcrush.rb

@@ -8,18 +8,18 @@ class ImageOptim
     class Pngcrush < Worker
       CHUNKS_OPTION =
       option(:chunks, :alla, Array, 'List of chunks to remove or '\
-          '`:alla` - all except tRNS/transparency or '\
-          '`:allb` - all except tRNS and gAMA/gamma') do |v|
+                                    '`:alla` - all except tRNS/transparency or '\
+                                    '`:allb` - all except tRNS and gAMA/gamma') do |v|
         Array(v).map(&:to_s)
       end
 
       FIX_OPTION =
       option(:fix, false, 'Fix otherwise fatal conditions '\
-          'such as bad CRCs'){ |v| !!v }
+                          'such as bad CRCs'){ |v| !!v }
 
       BRUTE_OPTION =
       option(:brute, false, 'Brute force try all methods, '\
-          'very time-consuming and generally not worthwhile'){ |v| !!v }
+                            'very time-consuming and generally not worthwhile'){ |v| !!v }
 
       BLACKEN_OPTION =
       option(:blacken, true, 'Blacken fully transparent pixels'){ |v| !!v }
@@ -28,7 +28,7 @@ class ImageOptim
         -6
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         flags = %w[
           -reduce
           -cc
@@ -49,7 +49,7 @@ class ImageOptim
           #{dst}
         ]
 
-        execute(:pngcrush, *args) && optimized?(src, dst)
+        execute(:pngcrush, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/pngout.rb

@@ -12,11 +12,11 @@ class ImageOptim
 
       STRATEGY_OPTION =
       option(:strategy, 0, 'Strategy: '\
-          '`0` - xtreme, '\
-          '`1` - intense, '\
-          '`2` - longest Match, '\
-          '`3` - huffman Only, '\
-          '`4` - uncompressed') do |v|
+                           '`0` - xtreme, '\
+                           '`1` - intense, '\
+                           '`2` - longest Match, '\
+                           '`3` - huffman Only, '\
+                           '`4` - uncompressed') do |v|
         OptionHelpers.limit_with_range(v.to_i, 0..4)
       end
 
@@ -24,7 +24,7 @@ class ImageOptim
         2
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         args = %W[
           -k#{copy_chunks ? 1 : 0}
           -s#{strategy}
@@ -33,7 +33,7 @@ class ImageOptim
           #{src}
           #{dst}
         ]
-        execute(:pngout, *args) && optimized?(src, dst)
+        execute(:pngout, args, options) && optimized?(src, dst)
       rescue SignalException => e
         raise unless Signal.list.key(e.signo) == 'SEGV'
         raise unless resolve_bin!(:pngout).version <= '20150920'

data/lib/image_optim/worker/pngquant.rb

@@ -19,9 +19,9 @@ class ImageOptim
       QUALITY_OPTION =
       option(:quality, '`100..100`, `0..100` in lossy mode',
              NonNegativeIntegerRange, 'min..max - don\'t '\
-         'save below min, use less colors below max (both in range `0..100`; '\
-         'in yaml - `!ruby/range 0..100`), ignored in default/lossless '\
-         'mode') do |v, opt_def|
+                                      'save below min, use less colors below max (both in range `0..100`; '\
+                                      'in yaml - `!ruby/range 0..100`), ignored in default/lossless '\
+                                      'mode') do |v, opt_def|
         if allow_lossy
           if v == opt_def.default
             0..100
@@ -32,7 +32,7 @@ class ImageOptim
         else
           if v != opt_def.default
             warn "#{self.class.bin_sym} #{opt_def.name} #{v} ignored " \
-                'in lossless mode'
+                 'in lossless mode'
           end
           100..100
         end
@@ -40,9 +40,9 @@ class ImageOptim
 
       SPEED_OPTION =
       option(:speed, 3, 'speed/quality trade-off: '\
-          '`1` - slow, '\
-          '`3` - default, '\
-          '`11` - fast & rough') do |v|
+                        '`1` - slow, '\
+                        '`3` - default, '\
+                        '`11` - fast & rough') do |v|
         OptionHelpers.limit_with_range(v.to_i, 1..11)
       end
 
@@ -50,7 +50,7 @@ class ImageOptim
         -2
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         args = %W[
           --quality=#{quality.begin}-#{quality.end}
           --speed=#{speed}
@@ -61,7 +61,7 @@ class ImageOptim
           --
           #{src}
         ]
-        execute(:pngquant, *args) && optimized?(src, dst)
+        execute(:pngquant, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker/svgo.rb

@@ -16,7 +16,7 @@ class ImageOptim
         Array(v).map(&:to_s)
       end
 
-      def optimize(src, dst)
+      def optimize(src, dst, options = {})
         args = %W[
           --input #{src}
           --output #{dst}
@@ -27,7 +27,7 @@ class ImageOptim
         enable_plugins.each do |plugin_name|
           args.unshift "--enable=#{plugin_name}"
         end
-        execute(:svgo, *args) && optimized?(src, dst)
+        execute(:svgo, args, options) && optimized?(src, dst)
       end
     end
   end

data/lib/image_optim/worker.rb

@@ -3,6 +3,7 @@
 
 require 'image_optim/cmd'
 require 'image_optim/configuration_error'
+require 'image_optim/elapsed_time'
 require 'image_optim/path'
 require 'image_optim/worker/class_methods'
 require 'shellwords'
@@ -41,7 +42,7 @@ class ImageOptim
 
     # Optimize image at src, output at dst, must be overriden in subclass
     # return true on success
-    def optimize(_src, _dst)
+    def optimize(_src, _dst, options = {})
       fail NotImplementedError, "implement method optimize in #{self.class}"
     end
 
@@ -104,7 +105,7 @@ class ImageOptim
       return if unknown_options.empty?
 
       fail ConfigurationError, "unknown options #{unknown_options.inspect} "\
-          "for #{self}"
+                               "for #{self}"
     end
 
     # Forward bin resolving to image_optim
@@ -117,47 +118,49 @@ class ImageOptim
     def wrap_resolver_error_message(message)
       name = self.class.bin_sym
       "#{name} worker: #{message}; please provide proper binary or "\
-          "disable this worker (--no-#{name} argument or "\
-          "`:#{name} => false` through options)"
+        "disable this worker (--no-#{name} argument or "\
+        "`:#{name} => false` through options)"
     end
 
     # Run command setting priority and hiding output
-    def execute(bin, *arguments)
+    def execute(bin, arguments, options)
       resolve_bin!(bin)
 
       cmd_args = [bin, *arguments].map(&:to_s)
 
-      start = Time.now
-
-      success = run_command(cmd_args)
-
       if @image_optim.verbose
-        seconds = Time.now - start
-        $stderr << "#{success ? '✓' : '✗'} #{seconds}s #{cmd_args.shelljoin}\n"
+        run_command_verbose(cmd_args, options)
+      else
+        run_command(cmd_args, options)
       end
-
-      success
     end
 
     # Run command defining environment, setting nice level, removing output and
     # reraising signal exception
-    def run_command(cmd_args)
-      args = if RUBY_VERSION < '1.9' || defined?(JRUBY_VERSION)
-        %W[
-          env PATH=#{@image_optim.env_path.shellescape}
-          nice -n #{@image_optim.nice}
-          #{cmd_args.shelljoin}
-          > #{Path::NULL} 2>&1
-        ].join(' ')
-      else
-        [
-          {'PATH' => @image_optim.env_path},
-          %W[nice -n #{@image_optim.nice}],
-          cmd_args,
-          {:out => Path::NULL, :err => Path::NULL},
-        ].flatten
-      end
+    def run_command(cmd_args, options)
+      args = [
+        {'PATH' => @image_optim.env_path},
+        *%W[nice -n #{@image_optim.nice}],
+        *cmd_args,
+        options.merge(out: Path::NULL, err: Path::NULL),
+      ]
       Cmd.run(*args)
     end
+
+    # Wrap run_command and output status, elapsed time and command
+    def run_command_verbose(cmd_args, options)
+      start = ElapsedTime.now
+
+      begin
+        success = run_command(cmd_args, options)
+        status = success ? '✓' : '✗'
+        success
+      rescue Errors::TimeoutExceeded
+        status = 'timeout'
+        raise
+      ensure
+        $stderr << format("%s %.1fs %s\n", status, ElapsedTime.now - start, cmd_args.shelljoin)
+      end
+    end
   end
 end

data/lib/image_optim.rb

@@ -3,16 +3,18 @@
 require 'image_optim/bin_resolver'
 require 'image_optim/cache'
 require 'image_optim/config'
+require 'image_optim/errors'
 require 'image_optim/handler'
 require 'image_optim/image_meta'
 require 'image_optim/optimized_path'
 require 'image_optim/path'
+require 'image_optim/timer'
 require 'image_optim/worker'
 require 'in_threads'
 require 'shellwords'
 
 %w[
-  pngcrush pngout advpng optipng pngquant
+  pngcrush pngout advpng optipng pngquant oxipng
   jhead jpegoptim jpegrecompress jpegtran
   gifsicle
   svgo
@@ -46,6 +48,9 @@ class ImageOptim
   # Cache worker digests
   attr_reader :cache_worker_digests
 
+  # Timeout in seconds for each image
+  attr_reader :timeout
+
   # Initialize workers, specify options using worker underscored name:
   #
   # pass false to disable worker
@@ -78,6 +83,7 @@ class ImageOptim
       allow_lossy
       cache_dir
       cache_worker_digests
+      timeout
     ].each do |name|
       instance_variable_set(:"@#{name}", config.send(name))
       $stderr << "#{name}: #{send(name)}\n" if verbose
@@ -110,11 +116,17 @@ class ImageOptim
     return unless (workers = workers_for_image(original))
 
     optimized = @cache.fetch(original) do
+      timer = timeout && Timer.new(timeout)
+
       Handler.for(original) do |handler|
-        workers.each do |worker|
-          handler.process do |src, dst|
-            worker.optimize(src, dst)
+        begin
+          workers.each do |worker|
+            handler.process do |src, dst|
+              worker.optimize(src, dst, timeout: timer)
+            end
           end
+        rescue Errors::TimeoutExceeded
+          handler.result
         end
       end
     end
@@ -188,12 +200,6 @@ class ImageOptim
       optimize_image_method?(method) || super
     end
 
-    if RUBY_VERSION < '1.9'
-      def respond_to?(method, include_private = false)
-        optimize_image_method?(method) || super
-      end
-    end
-
     # Version of image_optim gem spec loaded
     def version
       Gem.loaded_specs['image_optim'].version.to_s