discourse_image_optim 0.26.1 → 0.26.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4cc5e84e0c8dff3c8fd0af654608b8ee958b3283463f7f945076964ae9d3eae
-  data.tar.gz: ca77fd28eac0fb79493ed19600eaae18fdb7ea244f9025fdc909e7791a32133e
+  metadata.gz: 79257562b4927a5ec9d03fbbbc649b45dd060a3567897b0b0c10e29fbb759561
+  data.tar.gz: 524acbb993b15449b795f1aaa1c49bd477dbf18f102c2c516f3eafbb1a9dc194
 SHA512:
-  metadata.gz: fcbd37ef3c8899889ebcf1912f0200f7bab98399779e32658b39d55af99da87f452dfec263e91d15a177e1700d566705891f455191758ebc23f9c68d47b96cfa
-  data.tar.gz: 0b1379b801324ee93c546c4672abec97385cd7e5c50624e8657c9049d4f4e06135d167783d46901385209aab8b0ae364dfaf40887a67f8931c8a3b6f36255352
+  metadata.gz: 3aa22f9ea0ee4fb7a2aaaca83a577a842105b77fbe9f8399239d051a687b5c181a99f4d8cd4208b1dba8a6eb84d996a0980cd9b3182c11a4963bddf5979ed99c
+  data.tar.gz: 7e74d060fc2d3977441a99dbb971a5961f9d414cf286de48702bec28ae259230540994497b95a8d45ba5e129a554f8393032bbbbb1ba6952d0e64762045bdfde

data/.rubocop.yml

@@ -56,7 +56,7 @@ Metrics/BlockLength:
     - 'spec/**/*.rb'
 
 Metrics/ClassLength:
-  Max: 150
+  Max: 200
 
 Metrics/CyclomaticComplexity:
   Max: 10

data/CHANGELOG.markdown

@@ -2,13 +2,12 @@
 
 ## unreleased
 
+* Add `timeout` option to ImageOptim [#21](https://github.com/toy/image_optim/issues/21) [@tgxworld](http://github.com/tgxworld)
+
 ## v0.26.1 (2017-12-14)
 
 * Require `'date'` which is used in parsing pngout version [toy/image_optim_pack#14](https://github.com/toy/image_optim_pack/issues/14) [@toy](https://github.com/toy)
 
-* Add `timeout` option to workers [#21](https://github.com/toy/image_optim/issues/21)
-  [@tgxworld](http://github.com/tgxworld)
-
 ## v0.26.0 (2017-11-13)
 
 * Enable `jpegrescan` by default after removing its dependency on `File::Slurp` and fixing for windows [#153](https://github.com/toy/image_optim/issues/153) [@toy](https://github.com/toy)
@@ -36,7 +35,7 @@
 
 ## v0.24.0 (2016-08-14)
 
-* Rails image assets optimization is extracted into [image_optim_rails gem](https://github.com/toy/image_optim_rails) [#127](https://github.com/toy/image_optim/issues/127) [@toy](https://github.com/toy)
+* Rails image assets optimization is extracted into [image\_optim\_rails gem](https://github.com/toy/image_optim_rails) [#127](https://github.com/toy/image_optim/issues/127) [@toy](https://github.com/toy)
 * Add proper handling of `ImageOptim.respond_to?` [@toy](https://github.com/toy)
 * Fix an issue not working OptiPNG `interlace` option [#136](https://github.com/toy/image_optim/pull/136) [@mrk21](https://github.com/mrk21)
 * Minimize number of file system calls in default implementation of `optimized?` [#137](https://github.com/toy/image_optim/issues/137) [@toy](https://github.com/toy)
@@ -283,7 +282,7 @@
 
 * Warn if directly added files are not images or are not optimizable [@toy](https://github.com/toy)
 * Recursively scan directories for images [#4](https://github.com/toy/image_optim/issues/4) [@toy](https://github.com/toy)
-* Typo in bin/image_optim [#3](https://github.com/toy/image_optim/issues/3) [@fabiomcosta](https://github.com/fabiomcosta)
+* Typo in bin/image_optim  [#3](https://github.com/toy/image_optim/issues/3) [@fabiomcosta](https://github.com/fabiomcosta)
 
 ## v0.5.1 (2012-08-07)
 

data/README.markdown

@@ -11,7 +11,7 @@
 Optimize (lossless compress, optionally lossy) images (jpeg, png, gif, svg) using external utilities:
 
 * [advpng](http://advancemame.sourceforge.net/doc-advpng.html) from [AdvanceCOMP](http://advancemame.sourceforge.net/comp-readme.html)
-  (will use [zopfli](https://code.google.com/p/zopfli/) on default/maximum level 4)
+(will use [zopfli](https://code.google.com/p/zopfli/) on default/maximum level 4)
 * [gifsicle](http://www.lcdf.org/gifsicle/)
 * [jhead](http://www.sentex.net/~mwandel/jhead/)
 * [jpegoptim](http://www.kokkonen.net/tjko/projects.html)
@@ -57,11 +57,9 @@ gem 'image_optim_pack'
 With version:
 
 <!---<update-version>-->
-
 ```ruby
 gem 'image_optim', '~> 0.26'
 ```
-
 <!---</update-version>-->
 
 If you want to check latest changes:
@@ -243,7 +241,7 @@ image_optim.optimize_images_data(datas)
 
 ### From rails
 
-Rails image assets optimization is extracted into [image_optim_rails gem](https://github.com/toy/image_optim_rails).
+Rails image assets optimization is extracted into [image\_optim\_rails gem](https://github.com/toy/image_optim_rails).
 
 ## Configuration
 
@@ -265,92 +263,70 @@ optipng:
 
 ## Options
 
-* `:nice` — Nice level, priority of all used tools with higher value meaning lower priority, in range `-20..19`, negative values can be set only if run by root user _(defaults to `10`)_
-* `:threads` — Number of threads or disable _(defaults to number of processors)_
-* `:verbose` — Verbose output _(defaults to `false`)_
-* `:pack` — Require image_optim_pack or disable it, by default image_optim_pack will be used if available, will turn on `:skip-missing-workers` unless explicitly disabled _(defaults to `nil`)_
-* `:skip_missing_workers` — Skip workers with missing or problematic binaries _(defaults to `false`)_
-* `:allow_lossy` — Allow lossy workers and optimizations _(defaults to `false`)_
+* `:nice` — Nice level, priority of all used tools with higher value meaning lower priority, in range `-20..19`, negative values can be set only if run by root user *(defaults to `10`)*
+* `:threads` — Number of threads or disable *(defaults to number of processors)*
+* `:verbose` — Verbose output *(defaults to `false`)*
+* `:pack` — Require image\_optim\_pack or disable it, by default image\_optim\_pack will be used if available, will turn on `:skip-missing-workers` unless explicitly disabled *(defaults to `nil`)*
+* `:skip_missing_workers` — Skip workers with missing or problematic binaries *(defaults to `false`)*
+* `:allow_lossy` — Allow lossy workers and optimizations *(defaults to `false`)*
 * `:cache_dir` — Configure cache directory
 * `:cache_worker_digests` - Also cache worker digests along with original file digest and worker options: updating workers invalidates cache
-* `:timeout` — Number of seconds before workers are timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:timeout` - Number of seconds before ImageOptim is timed out.
 
 Worker can be disabled by passing `false` instead of options hash or by setting option `:disable` to `true`.
 
 <!---<worker-options>-->
-
 <!-- markdown for worker options is generated by `script/update_worker_options_in_readme` -->
 
 ### advpng:
-
-* `:level` — Compression level: `0` - don't compress, `1` - fast, `2` - normal, `3` - extra, `4` - extreme _(defaults to `4`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:level` — Compression level: `0` - don't compress, `1` - fast, `2` - normal, `3` - extra, `4` - extreme *(defaults to `4`)*
 
 ### gifsicle:
-
 * `:interlace` — 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)
-* `:level` — Compression level: `1` - light and fast, `2` - normal, `3` - heavy (slower) _(defaults to `3`)_
-* `:careful` — Avoid bugs with some software _(defaults to `false`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:level` — Compression level: `1` - light and fast, `2` - normal, `3` - heavy (slower) *(defaults to `3`)*
+* `:careful` — Avoid bugs with some software *(defaults to `false`)*
 
 ### jhead:
-
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+Worker has no options
 
 ### jpegoptim:
-
-* `:allow_lossy` — Allow limiting maximum quality _(defaults to `false`)_
-* `:strip` — List of extra markers to strip: `:comments`, `:exif`, `:iptc`, `:icc` or `:all` _(defaults to `:all`)_
-* `:max_quality` — Maximum image quality factor `0`..`100`, ignored in default/lossless mode _(defaults to `100`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:allow_lossy` — Allow limiting maximum quality *(defaults to `false`)*
+* `:strip` — List of extra markers to strip: `:comments`, `:exif`, `:iptc`, `:icc` or `:all` *(defaults to `:all`)*
+* `:max_quality` — Maximum image quality factor `0`..`100`, ignored in default/lossless mode *(defaults to `100`)*
 
 ### jpegrecompress:
-
-* `:allow_lossy` — Allow worker, it is always lossy _(defaults to `false`)_
-* `:quality` — JPEG quality preset: `0` - low, `1` - medium, `2` - high, `3` - veryhigh _(defaults to `3`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:allow_lossy` — Allow worker, it is always lossy *(defaults to `false`)*
+* `:quality` — JPEG quality preset: `0` - low, `1` - medium, `2` - high, `3` - veryhigh *(defaults to `3`)*
 
 ### jpegtran:
-
-* `:copy_chunks` — Copy all chunks _(defaults to `false`)_
-* `:progressive` — Create progressive JPEG file _(defaults to `true`)_
-* `:jpegrescan` — Use jpegtran through jpegrescan, ignore progressive option _(defaults to `false`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:copy_chunks` — Copy all chunks *(defaults to `false`)*
+* `:progressive` — Create progressive JPEG file *(defaults to `true`)*
+* `:jpegrescan` — Use jpegtran through jpegrescan, ignore progressive option *(defaults to `true`)*
 
 ### optipng:
-
-* `:level` — Optimization level preset: `0` is least, `7` is best _(defaults to `6`)_
-* `:interlace` — Interlace: `true` - interlace on, `false` - interlace off, `nil` - as is in original image _(defaults to `false`)_
-* `:strip` — Remove all auxiliary chunks _(defaults to `true`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:level` — Optimization level preset: `0` is least, `7` is best *(defaults to `6`)*
+* `:interlace` — Interlace: `true` - interlace on, `false` - interlace off, `nil` - as is in original image *(defaults to `false`)*
+* `:strip` — Remove all auxiliary chunks *(defaults to `true`)*
 
 ### pngcrush:
-
-* `:chunks` — List of chunks to remove or `:alla` - all except tRNS/transparency or `:allb` - all except tRNS and gAMA/gamma _(defaults to `:alla`)_
-* `:fix` — Fix otherwise fatal conditions such as bad CRCs _(defaults to `false`)_
-* `:brute` — Brute force try all methods, very time-consuming and generally not worthwhile _(defaults to `false`)_
-* `:blacken` — Blacken fully transparent pixels _(defaults to `true`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:chunks` — List of chunks to remove or `:alla` - all except tRNS/transparency or `:allb` - all except tRNS and gAMA/gamma *(defaults to `:alla`)*
+* `:fix` — Fix otherwise fatal conditions such as bad CRCs *(defaults to `false`)*
+* `:brute` — Brute force try all methods, very time-consuming and generally not worthwhile *(defaults to `false`)*
+* `:blacken` — Blacken fully transparent pixels *(defaults to `true`)*
 
 ### pngout:
-
-* `:copy_chunks` — Copy optional chunks _(defaults to `false`)_
-* `:strategy` — Strategy: `0` - xtreme, `1` - intense, `2` - longest Match, `3` - huffman Only, `4` - uncompressed _(defaults to `0`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:copy_chunks` — Copy optional chunks *(defaults to `false`)*
+* `:strategy` — Strategy: `0` - xtreme, `1` - intense, `2` - longest Match, `3` - huffman Only, `4` - uncompressed *(defaults to `0`)*
 
 ### pngquant:
-
-* `:allow_lossy` — Allow quality option _(defaults to `false`)_
-* `:max_colors` — Maximum number of colors to use _(defaults to `256`)_
-* `:quality` — 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 _(defaults to `100..100`, `0..100` in lossy mode)_
-* `:speed` — speed/quality trade-off: `1` - slow, `3` - default, `11` - fast & rough _(defaults to `3`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:allow_lossy` — Allow quality option *(defaults to `false`)*
+* `:max_colors` — Maximum number of colors to use *(defaults to `256`)*
+* `:quality` — 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 *(defaults to `100..100`, `0..100` in lossy mode)*
+* `:speed` — speed/quality trade-off: `1` - slow, `3` - default, `11` - fast & rough *(defaults to `3`)*
 
 ### svgo:
-
-* `:disable_plugins` — List of plugins to disable _(defaults to `[]`)_
-* `:enable_plugins` — List of plugins to enable _(defaults to `[]`)_
-* `:timeout` — Number of seconds before worker is timed out. Must be greater than 0 to enable timeout. _(defaults to `0`)_
+* `:disable_plugins` — List of plugins to disable *(defaults to `[]`)*
+* `:enable_plugins` — List of plugins to enable *(defaults to `[]`)*
 
 <!---</worker-options>-->
 

data/image_optim.gemspec

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

data/lib/image_optim.rb

@@ -20,6 +20,8 @@ end
 
 # Main interface
 class ImageOptim
+  class TimeoutExceeded < StandardError; end
+
   # Nice level
   attr_reader :nice
 
@@ -111,10 +113,22 @@ class ImageOptim
 
     optimized = @cache.fetch(original) do
       Handler.for(original) do |handler|
-        workers.each do |worker|
-          handler.process do |src, dst|
-            worker.optimize(src, dst)
+        current_worker = nil
+
+        begin
+          with_timeout(@timeout) do
+            workers.each do |worker|
+              current_worker = worker
+              handler.process{ |src, dst| worker.optimize(src, dst) }
+            end
+          end
+        rescue TimeoutExceeded => e
+          if current_worker && current_worker.pid
+            pid = current_worker.pid
+            cleanup_process(pid)
           end
+
+          raise e
         end
       end
     end
@@ -228,6 +242,37 @@ class ImageOptim
 
 private
 
+  def with_timeout(timeout)
+    if timeout && timeout >= 0
+      thread = Thread.new{ yield if block_given? }
+      if thread.respond_to?(:report_on_exception)
+        thread.report_on_exception = false
+      end
+      fail TimeoutExceeded if thread.join(timeout).nil?
+    elsif block_given?
+      yield
+    end
+  end
+
+  def cleanup_process(pid)
+    Process.detach(pid)
+    Process.kill('-TERM', pid)
+    now = Time.now
+
+    while Time.now - now < 10
+      begin
+        Process.getpgid(pid)
+        sleep 0.1
+      rescue Errno::ESRCH
+        break
+      end
+    end
+
+    Process.kill('-KILL', pid) if Process.getpgid(pid)
+  rescue Errno::ESRCH
+    pid
+  end
+
   def log_workers_by_format
     $stderr << "Workers by format:\n"
     @workers_by_format.each do |format, workers|

data/lib/image_optim/cmd.rb

@@ -1,60 +1,39 @@
 require 'English'
-require 'open3'
 
 class ImageOptim
   # Helper for running commands
   module Cmd
-    class TimeoutExceeded < StandardError; end
-
     class << self
       # Run using `system`
       # Return success status
       # Will raise SignalException if process was interrupted
       def run(*args)
-        success = system(*args)
+        if Process.respond_to?(:spawn)
+          if args.last.is_a?(Hash)
+            args.last[Gem.win_platform? ? :new_pgroup : :pgroup] = true
+          end
 
-        check_status!
+          begin
+            pid = Process.spawn(*args)
+          ensure
+            yield pid if block_given?
+          end
 
-        success
-      end
+          begin
+            Process.waitpid(pid)
+          rescue Errno::ECHILD
+            return
+          end
 
-      def support_timeout?
-        if defined?(JRUBY_VERSION)
-          JRUBY_VERSION >= '9.0.0.0'
+          check_status!
+          $CHILD_STATUS.success?
         else
-          RUBY_VERSION >= '1.9'
-        end
-      end
-
-      # Run the specified command, and kill it off if it runs longer
-      # than `timeout` seconds.
-      #
-      # Return success status
-      # Will raise an error when command timeouts
-      def run_with_timeout(timeout, *args)
-        return run(*args) unless timeout > 0 && support_timeout?
+          success = system(*args)
 
-        success = false
-        init_options!(args)
+          check_status!
 
-        begin
-          stdin, stdout, thread = Open3.popen2(*args)
-          stdin.close
-          stdout.close
-
-          pid = thread[:pid]
-
-          if thread.join(timeout).nil?
-            cleanup_process(pid)
-            thread.kill
-            fail TimeoutExceeded
-          else
-            status = thread.value.exitstatus
-            success = status.zero? if status
-          end
+          success
         end
-
-        success
       end
 
       # Run using backtick
@@ -86,38 +65,6 @@ class ImageOptim
 
         fail SignalException, status.termsig
       end
-
-      def init_options!(args)
-        pgroup_opt = Gem.win_platform? ? :new_pgroup : :pgroup
-
-        if args.last.is_a?(Hash)
-          args.last[pgroup_opt] = true
-        else
-          args.push(pgroup_opt => true)
-        end
-      end
-
-      def cleanup_process(pid)
-        Thread.new do
-          Process.kill('-TERM', pid)
-          Process.detach(pid)
-          now = Time.now
-
-          while Time.now - now < 10
-            begin
-              Process.kill(0, pid)
-              sleep 0.001
-              next
-            rescue Errno::ESRCH
-              break
-            end
-          end
-
-          if Process.getpgid(pid)
-            Process.kill('-KILL', pid)
-          end
-        end
-      end
     end
   end
 end

data/lib/image_optim/config.rb

@@ -114,6 +114,11 @@ class ImageOptim
       end
     end
 
+    def timeout
+      timeout = get!(:timeout)
+      timeout ? timeout.to_f : nil
+    end
+
     # Verbose mode, converted to boolean
     def verbose
       !!get!(:verbose)
@@ -157,11 +162,6 @@ class ImageOptim
       !!get!(:cache_worker_digests)
     end
 
-    def timeout
-      timeout = get!(:timeout)
-      timeout ? timeout.to_i : 0
-    end
-
     # Options for worker class by its `bin_sym`:
     # * `Hash` passed as is
     # * `{}` for `true` or `nil`

data/lib/image_optim/runner/option_parser.rb

@@ -181,8 +181,8 @@ ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
     options[:allow_lossy] = allow_lossy
   end
 
-  op.on('--timeout N', 'Sets a timeout for workers') do |timeout|
-    options[:timeout] = timeout.to_i
+  op.on('--timeout N', Integer, 'Sets a timeout for optimization') do |timeout|
+    options[:timeout] = timeout
   end
 
   op.separator nil

data/lib/image_optim/worker.rb

@@ -12,14 +12,14 @@ class ImageOptim
   class Worker
     extend ClassMethods
 
-    class TimeoutExceeded < StandardError; end
-
     class << self
       # Default init for worker is new
       # Check example of override in gifsicle worker
       alias_method :init, :new
     end
 
+    attr_accessor :pid
+
     # Configure (raises on extra options)
     def initialize(image_optim, options = {})
       unless image_optim.is_a?(ImageOptim)
@@ -155,17 +155,7 @@ class ImageOptim
         ].flatten
       end
 
-      seconds_to_timeout = timeout || @image_optim.timeout
-
-      if seconds_to_timeout > 0
-        begin
-          Cmd.run_with_timeout(seconds_to_timeout, *args)
-        rescue Cmd::TimeoutExceeded
-          raise ImageOptim::Worker::TimeoutExceeded
-        end
-      else
-        Cmd.run(*args)
-      end
+      Cmd.run(*args){ |pid| self.pid = pid }
     end
   end
 end

data/lib/image_optim/worker/advpng.rb

@@ -15,8 +15,6 @@ class ImageOptim
         OptionHelpers.limit_with_range(v.to_i, 0..4)
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       def run_order
         4
       end

data/lib/image_optim/worker/class_methods.rb

@@ -32,15 +32,6 @@ class ImageOptim
         @option_definitions ||= []
       end
 
-      def timeout_option
-        option(
-          :timeout,
-          0,
-          'Number of seconds before worker is timed out. Must be greater than' \
-          '0 to enable timeout.'
-        ){ |v| v }
-      end
-
       def option(name, default, type, description = nil, &proc)
         attr_reader name
         OptionDefinition.new(name, default, type, description, &proc).
@@ -92,13 +83,9 @@ class ImageOptim
         klasses.map do |klass|
           options = options_proc[klass]
           next if options[:disable]
-
-          [:allow_lossy, :timeout].each do |option_key|
-            if !options.key?(option_key) && klass.method_defined?(option_key)
-              options[option_key] = image_optim.send(option_key)
-            end
+          if !options.key?(:allow_lossy) && klass.method_defined?(:allow_lossy)
+            options[:allow_lossy] = image_optim.allow_lossy
           end
-
           klass.init(image_optim, options)
         end.compact.flatten
       end

data/lib/image_optim/worker/gifsicle.rb

@@ -35,8 +35,6 @@ class ImageOptim
       CAREFUL_OPTION =
       option(:careful, false, 'Avoid bugs with some software'){ |v| !!v }
 
-      TIMEOUT_OPTION = timeout_option
-
       def optimize(src, dst)
         args = %W[
           --output=#{dst}

data/lib/image_optim/worker/jhead.rb

@@ -7,8 +7,6 @@ class ImageOptim
     #
     # Jhead internally uses jpegtran which should be on path
     class Jhead < Worker
-      TIMEOUT_OPTION = timeout_option
-
       ORIENTED = 2..8 # not top-left
 
       # Works on jpegs

data/lib/image_optim/worker/jpegoptim.rb

@@ -38,8 +38,6 @@ class ImageOptim
         end
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       # Run earlier if max_quality is less than 100
       def run_order
         max_quality < 100 ? -1 : 0

data/lib/image_optim/worker/jpegrecompress.rb

@@ -24,8 +24,6 @@ class ImageOptim
         OptionHelpers.limit_with_range(v.to_i, 0...QUALITY_NAMES.length)
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       def used_bins
         [:'jpeg-recompress']
       end

data/lib/image_optim/worker/jpegtran.rb

@@ -17,8 +17,6 @@ class ImageOptim
       option(:jpegrescan, true, 'Use jpegtran through jpegrescan, '\
           'ignore progressive option'){ |v| !!v }
 
-      TIMEOUT_OPTION = timeout_option
-
       def used_bins
         jpegrescan ? [:jpegtran, :jpegrescan] : [:jpegtran]
       end

data/lib/image_optim/worker/optipng.rb

@@ -24,8 +24,6 @@ class ImageOptim
       STRIP_OPTION =
       option(:strip, true, 'Remove all auxiliary chunks'){ |v| !!v }
 
-      TIMEOUT_OPTION = timeout_option
-
       def run_order
         -4
       end

data/lib/image_optim/worker/pngcrush.rb

@@ -22,8 +22,6 @@ class ImageOptim
       BLACKEN_OPTION =
       option(:blacken, true, 'Blacken fully transparent pixels'){ |v| !!v }
 
-      TIMEOUT_OPTION = timeout_option
-
       def run_order
         -6
       end

data/lib/image_optim/worker/pngout.rb

@@ -18,8 +18,6 @@ class ImageOptim
         OptionHelpers.limit_with_range(v.to_i, 0..4)
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       def run_order
         2
       end

data/lib/image_optim/worker/pngquant.rb

@@ -44,8 +44,6 @@ class ImageOptim
         OptionHelpers.limit_with_range(v.to_i, 1..11)
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       def run_order
         -2
       end

data/lib/image_optim/worker/svgo.rb

@@ -14,8 +14,6 @@ class ImageOptim
         Array(v).map(&:to_s)
       end
 
-      TIMEOUT_OPTION = timeout_option
-
       def optimize(src, dst)
         args = %W[
           --input #{src}

data/spec/image_optim/cmd_spec.rb

@@ -15,13 +15,6 @@ describe ImageOptim::Cmd do
   end
 
   describe '.run' do
-    it 'calls system and returns result' do
-      status = double
-      expect(Cmd).to receive(:system).with('cmd', 'arg').and_return(status)
-      allow(Cmd).to receive(:check_status!)
-      expect(Cmd.run('cmd', 'arg')).to eq(status)
-    end
-
     it 'returns process success status' do
       expect(Cmd.run('sh -c "exit 0"')).to eq(true)
       expect($CHILD_STATUS.exitstatus).to eq(0)
@@ -33,6 +26,14 @@ describe ImageOptim::Cmd do
       expect($CHILD_STATUS.exitstatus).to eq(66)
     end
 
+    it 'accepts a block that yields the pid' do
+      expect(
+        Cmd.run('sh -c "exit 66"') do |pid|
+          expect(pid.is_a?(Integer)).to eq(true)
+        end
+      ).to eq(false)
+    end
+
     it 'raises SignalException if process terminates after signal' do
       skip 'signals are not supported' unless signals_supported?
       expect_int_exception do
@@ -41,29 +42,6 @@ describe ImageOptim::Cmd do
     end
   end
 
-  describe '.run_with_timeout', :if => ImageOptim::Cmd.support_timeout? do
-    it 'spawns a process in a thread and returns status' do
-      expect(Cmd.run_with_timeout(20, 'sh -c "exit 0"')).to eq(true)
-
-      [1, 66].each do |status|
-        expect(Cmd.run_with_timeout(20, "sh -c \"exit #{status}\"")).
-          to eq(false)
-      end
-    end
-
-    it 'raises Timeout::Error if process timeout' do
-      expect{ Cmd.run_with_timeout(0.001, 'sleep 1') }.
-        to raise_error(Cmd::TimeoutExceeded)
-    end
-
-    it 'calls system if timeout is <= zero' do
-      expect(Cmd.run_with_timeout(0, 'sh -c "sleep 0.001; exit 0"')).to eq(true)
-
-      expect(Cmd.run_with_timeout(-1, 'sh -c "sleep 0.001; exit 1"')).
-        to eq(false)
-    end
-  end
-
   describe '.capture' do
     it 'calls ` and returns result' do
       output = double

data/spec/image_optim/config_spec.rb

@@ -94,22 +94,6 @@ describe ImageOptim::Config do
     end
   end
 
-  describe '#timeout' do
-    before do
-      allow(IOConfig).to receive(:read_options).and_return({})
-    end
-
-    it 'is 0 by default' do
-      config = IOConfig.new({})
-      expect(config.timeout).to eq(0)
-    end
-
-    it 'converts value to number' do
-      config = IOConfig.new(:timeout => '15')
-      expect(config.timeout).to eq(15)
-    end
-  end
-
   describe '#for_worker' do
     before do
       allow(IOConfig).to receive(:read_options).and_return({})
@@ -251,4 +235,20 @@ describe ImageOptim::Config do
       expect(IOConfig.read_options(path)).to eq({})
     end
   end
+
+  describe '#timeout' do
+    before do
+      allow(IOConfig).to receive(:read_options).and_return({})
+    end
+
+    it 'is nil by default' do
+      config = IOConfig.new({})
+      expect(config.timeout).to eq(nil)
+    end
+
+    it 'converts value to a float' do
+      config = IOConfig.new(:timeout => '15.1')
+      expect(config.timeout).to eq(15.1)
+    end
+  end
 end

data/spec/image_optim/worker_spec.rb

@@ -129,7 +129,7 @@ describe ImageOptim::Worker do
       workers.map{ |worker| class_double(Worker, :init => worker) }
     end
 
-    let(:image_optim){ double(:allow_lossy => false, :timeout => 30) }
+    let(:image_optim){ double(:allow_lossy => false) }
 
     it 'creates all workers for which options_proc returns true' do
       workers = Array.new(3){ worker_double }
@@ -223,53 +223,34 @@ describe ImageOptim::Worker do
       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
+    describe 'passing allow_lossy' do
+      it 'passes allow_lossy if worker has such attribute' 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) }
+        klasses[0].send(:attr_reader, :allow_lossy)
         expect(klasses[0]).to receive(:init).
-          with(image_optim, hash_including(:allow_lossy => false))
+          with(image_optim, hash_including(:allow_lossy))
         expect(klasses[1]).to receive(:init).
-          with(image_optim, hash_including(:allow_lossy => :b))
+          with(image_optim, hash_not_including(:allow_lossy))
 
-        Worker.create_all(image_optim, &options_proc)
+        Worker.create_all(image_optim){ {} }
       end
 
-      it 'allows overriding timeout per worker' do
+      it 'allows overriding per worker' do
         klasses = worker_class_doubles([worker_double, worker_double])
         options_proc = proc do |klass|
-          klass == klasses[1] ? {:timeout => 50} : {}
+          klass == klasses[1] ? {:allow_lossy => :b} : {}
         end
 
         allow(Worker).to receive(:klasses).and_return(klasses)
 
-        klasses.each{ |klass| klass.send(:attr_reader, :timeout) }
+        klasses.each{ |klass| klass.send(:attr_reader, :allow_lossy) }
         expect(klasses[0]).to receive(:init).
-          with(image_optim, hash_including(:timeout => 30))
+          with(image_optim, hash_including(:allow_lossy => false))
         expect(klasses[1]).to receive(:init).
-          with(image_optim, hash_including(:timeout => 50))
+          with(image_optim, hash_including(:allow_lossy => :b))
 
         Worker.create_all(image_optim, &options_proc)
       end

data/spec/image_optim_spec.rb

@@ -102,6 +102,21 @@ describe ImageOptim do
         expect(ImageOptim.optimize_image(path)).to be_nil
       end
     end
+
+    it 'allows timeout to be configured' do
+      base_options = {:timeout => 0.001}
+      image_optim = ImageOptim.new(base_options)
+
+      original_threads = Thread.list
+
+      expect do
+        image_optim.optimize_image(test_images.first)
+      end.to raise_error(ImageOptim::TimeoutExceeded)
+
+      # Ensure we don't leak any threads
+      (Thread.list - original_threads).each(&:join)
+      expect(Thread.list.count).to eq(original_threads.count)
+    end
   end
 
   describe '#optimize_image!' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discourse_image_optim
 version: !ruby/object:Gem::Version
-  version: 0.26.1
+  version: 0.26.2
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fspath