image_optim 0.31.3 → 0.32.0

data/lib/image_optim/runner/option_parser.rb

@@ -34,8 +34,8 @@ class ImageOptim
       def help
         text = super
 
-        # reserve one column
-        columns = terminal_columns - 1
+        # reserve one column and limit to 120
+        columns = [terminal_columns - 1, 120].min
         # 1 for distance between summary and description
         # 2 for additional indent
         wrapped_indent = summary_indent + (' ' * (summary_width + 1 + 2))
@@ -43,20 +43,7 @@ class ImageOptim
         # don't try to wrap if there is too little space for description
         return text if wrapped_width < 20
 
-        wrapped = ''.dup
-        text.split("\n").each do |line|
-          if line.length <= columns
-            wrapped << line << "\n"
-          else
-            indented = line =~ /^\s/
-            wrapped << line.slice!(wrap_regex(columns)) << "\n"
-            line.scan(wrap_regex(wrapped_width)) do |part|
-              wrapped << wrapped_indent if indented
-              wrapped << part << "\n"
-            end
-          end
-        end
-        wrapped
+        wrapped_text(text, wrapped_width, wrapped_indent, columns)
       end
 
     private
@@ -66,6 +53,27 @@ class ImageOptim
         stty_columns ? stty_columns.to_i : `tput cols`.to_i
       end
 
+      def wrapped_text(text, wrapped_width, wrapped_indent, columns)
+        wrapped = []
+        text.split("\n").each do |line|
+          if line.length <= columns
+            wrapped << line << "\n"
+          else
+            wrapped << line.slice!(wrap_regex(columns)).rstrip << "\n"
+            if line =~ /^\s/
+              line.scan(wrap_regex(wrapped_width)) do |part|
+                wrapped << wrapped_indent << part.rstrip << "\n"
+              end
+            else
+              line.scan(wrap_regex(columns)) do |part|
+                wrapped << part.rstrip << "\n"
+              end
+            end
+          end
+        end
+        wrapped.join(nil)
+      end
+
       def wrap_regex(width)
         /.*?.{1,#{width}}(?:\s|\z)/
       end
@@ -96,30 +104,25 @@ ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
     |
   TEXT
 
-  op.on('--config-paths PATH1,PATH2', Array, 'Config paths to use instead of ' \
-                                             'default ones') do |paths|
+  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|
+  op.on('-r', '-R', '--recursive', 'Recursively scan directories for images') do |recursive|
     options[:recursive] = recursive
   end
 
-  op.on("--exclude-dir 'GLOB'", 'Glob for excluding directories ' \
-                                '(defaults to .*)') do |glob|
+  op.on("--exclude-dir 'GLOB'", 'Glob for excluding directories (defaults to .*)') do |glob|
     options[:exclude_dir_glob] = glob
   end
 
-  op.on("--exclude-file 'GLOB'", 'Glob for excluding files ' \
-                                 '(defaults to .*)') do |glob|
+  op.on("--exclude-file 'GLOB'", 'Glob for excluding files (defaults to .*)') do |glob|
     options[:exclude_file_glob] = glob
   end
 
-  op.on("--exclude 'GLOB'", 'Set glob for excluding both directories and ' \
-                            'files') do |glob|
+  op.on("--exclude 'GLOB'", 'Set glob for excluding both directories and files') do |glob|
     options[:exclude_file_glob] = options[:exclude_dir_glob] = glob
   end
 
@@ -129,41 +132,51 @@ ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
     options[:show_progress] = show_progress
   end
 
-  op.on('--[no-]threads N', Integer, 'Number of threads or disable ' \
-                                     '(defaults to number of processors)') do |threads|
+  op.on('--[no-]threads N', Integer, 'Number of threads or disable (defaults to number of processors)') do |threads|
     options[:threads] = threads
   end
 
-  op.on('--[no-]nice N', Integer, '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)') do |nice|
+  op.on(
+    '--[no-]nice N',
+    Integer,
+    '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)'
+  ) do |nice|
     options[:nice] = nice
   end
 
-  op.on('--[no-]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') do |pack|
+  op.on(
+    '--[no-]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'
+  ) do |pack|
     options[:pack] = pack
   end
 
+  op.separator nil
+  op.on(
+    '--benchmark TYPE',
+    [:isolated],
+    'Run benchmarks, to compare tools without modifying images. `isolated` is the only supported type so far.'
+  ) do |benchmark|
+    options[:benchmark] = benchmark
+  end
+
   op.separator nil
   op.separator '  Caching:'
 
-  op.on('--cache-dir DIR', 'Cache optimized images ' \
-                           'into the specified directory') do |cache_dir|
+  op.on('--cache-dir DIR', 'Cache optimized images into the specified directory') do |cache_dir|
     options[:cache_dir] = cache_dir
   end
 
-  op.on('--cache-worker-digests', 'Cache worker digests ' \
-                                  '(updating workers invalidates cache)') do |cache_worker_digests|
+  op.on('--cache-worker-digests', 'Cache worker digests (updating workers invalidates cache)') do |cache_worker_digests|
     options[:cache_worker_digests] = cache_worker_digests
   end
 
   op.separator nil
   op.separator '  Disabling workers:'
 
-  op.on('--[no-]skip-missing-workers', 'Skip workers with missing or ' \
-                                       'problematic binaries') do |skip|
+  op.on('--[no-]skip-missing-workers', 'Skip workers with missing or problematic binaries') do |skip|
     options[:skip_missing_workers] = skip
   end
 
@@ -177,8 +190,7 @@ ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
   op.separator nil
   op.separator '  Worker options:'
 
-  op.on('--allow-lossy', 'Allow lossy workers and ' \
-                         'optimizations') do |allow_lossy|
+  op.on('--allow-lossy', 'Allow lossy workers and optimizations') do |allow_lossy|
     options[:allow_lossy] = allow_lossy
   end
 
@@ -229,9 +241,12 @@ ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
   op.separator nil
   op.separator '  Common options:'
 
-  op.on_tail('-v', '--verbose', 'Verbose output (show global and worker ' \
-                                'config, binary resolution log, information about each tool invocation, ' \
-                                'backtrace of exception)') do
+  op.on_tail(
+    '-v',
+    '--verbose',
+    'Verbose output (show global and worker config, binary resolution log, information about each tool invocation, ' \
+    'backtrace of exception)'
+  ) do
     options[:verbose] = true
   end
 

data/lib/image_optim/runner.rb

@@ -45,6 +45,43 @@ class ImageOptim
       end
     end
 
+    # files, elapsed, kb saved, kb/s
+    class BenchmarkResults
+      def initialize
+        @all = []
+      end
+
+      def add(rows)
+        @all.concat(rows)
+      end
+
+      def print
+        if @all.empty?
+          puts 'nothing to report'
+          return
+        end
+
+        report = @all.group_by(&:worker).map do |name, results|
+          kb = (results.sum(&:bytes) / 1024.0)
+          elapsed = results.sum(&:elapsed)
+          {
+            'name' => name,
+            'files' => results.length,
+            'elapsed' => elapsed,
+            'kb saved' => kb,
+            'kb/s' => (kb / elapsed),
+          }
+        end
+
+        report = report.sort_by do |row|
+          [-row['kb/s'], row['name']]
+        end
+
+        puts "\nBENCHMARK RESULTS\n\n"
+        Table.new(report).write($stdout)
+      end
+    end
+
     def initialize(options)
       options = HashHelpers.deep_symbolise_keys(options)
       @recursive = options.delete(:recursive)
@@ -53,19 +90,40 @@ class ImageOptim
         glob = options.delete(:"exclude_#{type}_glob") || '.*'
         GlobHelpers.expand_braces(glob)
       end
+
+      # --benchmark
+      @benchmark = options.delete(:benchmark)
+      if @benchmark
+        unless options[:threads].nil?
+          warning '--benchmark ignores --threads'
+          options[:threads] = 1 # for consistency
+        end
+        if options[:timeout]
+          warning '--benchmark ignores --timeout'
+        end
+      end
+
       @image_optim = ImageOptim.new(options)
     end
 
-    def run!(args)
+    def run!(args) # rubocop:disable Naming/PredicateMethod
       to_optimize = find_to_optimize(args)
       unless to_optimize.empty?
-        results = Results.new
+        if @benchmark
+          benchmark_results = BenchmarkResults.new
+          benchmark_images(to_optimize).each do |_original, rows| # rubocop:disable Style/HashEachMethods
+            benchmark_results.add(rows)
+          end
+          benchmark_results.print
+        else
+          results = Results.new
 
-        optimize_images!(to_optimize).each do |original, optimized|
-          results.add(original, optimized)
-        end
+          optimize_images!(to_optimize).each do |original, optimized|
+            results.add(original, optimized)
+          end
 
-        results.print
+          results.print
+        end
       end
 
       !@warnings
@@ -73,6 +131,11 @@ class ImageOptim
 
   private
 
+    def benchmark_images(to_optimize, &block)
+      to_optimize = to_optimize.with_progress('benchmarking') if @progress
+      @image_optim.benchmark_images(to_optimize, &block)
+    end
+
     def optimize_images!(to_optimize, &block)
       to_optimize = to_optimize.with_progress('optimizing') if @progress
       @image_optim.optimize_images!(to_optimize, &block)

data/lib/image_optim/table.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class ImageOptim
+  # Handy class for pretty printing a table in the terminal. This is very simple, switch to Terminal
+  # Table, Table Tennis or similar if we need more.
+  class Table
+    attr_reader :rows
+
+    def initialize(rows)
+      @rows = rows
+    end
+
+    def write(io)
+      io.puts render_row(columns)
+      io.puts render_sep
+      rows.each do |row|
+        io.puts render_row(row.values)
+      end
+    end
+
+  protected
+
+    # array of column names
+    def columns
+      @columns ||= rows.first.keys
+    end
+
+    # should columns be justified left or right?
+    def justs
+      @justs ||= columns.map do |col|
+        rows.first[col].is_a?(Numeric) ? :rjust : :ljust
+      end
+    end
+
+    # max width of each column
+    def widths
+      @widths ||= columns.map do |col|
+        values = rows.map{ |row| fmt(row[col]) }
+        ([col] + values).map(&:length).max
+      end
+    end
+
+    # render an array of row values
+    def render_row(values)
+      values.zip(justs, widths).map do |value, just, width|
+        fmt(value).send(just, width)
+      end.join('  ')
+    end
+
+    # render a separator line
+    def render_sep
+      render_row(widths.map{ |width| '-' * width })
+    end
+
+    # format one cell value
+    def fmt(value)
+      if value.is_a?(Float)
+        format('%0.3f', value)
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/image_optim/worker/svgo.rb

@@ -1,19 +1,41 @@
 # frozen_string_literal: true
 
+require 'image_optim/option_helpers'
 require 'image_optim/worker'
+require 'fspath'
 
 class ImageOptim
   class Worker
     # https://github.com/svg/svgo
     class Svgo < Worker
+      PLUGIN_NAME_R = /\A[a-zA-Z]+\z/.freeze
+
       DISABLE_PLUGINS_OPTION =
       option(:disable_plugins, [], 'List of plugins to disable') do |v|
-        Array(v).map(&:to_s)
+        parse_plugin_names(v)
       end
 
       ENABLE_PLUGINS_OPTION =
       option(:enable_plugins, [], 'List of plugins to enable') do |v|
-        Array(v).map(&:to_s)
+        parse_plugin_names(v)
+      end
+
+      ALLOW_LOSSY_OPTION =
+      option(:allow_lossy, false, 'Allow precision option'){ |v| !!v }
+
+      PRECISION_OPTION =
+      option(:precision, 3, 'Number of digits in the fractional part ' \
+                            '`0`..`20`, ignored in default/lossless mode') \
+                            do |v, opt_def|
+        if allow_lossy
+          OptionHelpers.limit_with_range(v.to_i, 0..20)
+        else
+          if v != opt_def.default
+            warn "#{self.class.bin_sym} #{opt_def.name} #{v} ignored " \
+                 'in default/lossless mode'
+          end
+          opt_def.default
+        end
       end
 
       def optimize(src, dst, options = {})
@@ -21,14 +43,57 @@ class ImageOptim
           --input #{src}
           --output #{dst}
         ]
-        disable_plugins.each do |plugin_name|
-          args.unshift "--disable=#{plugin_name}"
-        end
-        enable_plugins.each do |plugin_name|
-          args.unshift "--enable=#{plugin_name}"
+        if resolve_bin!(:svgo).version >= '2.0.0'
+          unless disable_plugins.empty? && enable_plugins.empty?
+            config_file = plugins_config_file
+            args.unshift "--config=#{config_file.path}"
+          end
+        else
+          disable_plugins.each do |plugin_name|
+            args.unshift "--disable=#{plugin_name}"
+          end
+          enable_plugins.each do |plugin_name|
+            args.unshift "--enable=#{plugin_name}"
+          end
         end
+        args.unshift "--precision=#{precision}" if allow_lossy
         execute(:svgo, args, options) && optimized?(src, dst)
       end
+
+    private
+
+      def parse_plugin_names(value)
+        Array(value).map(&:to_s).select do |name|
+          if name =~ PLUGIN_NAME_R
+            true
+          else
+            warn "Doesn't look like svgo plugin name: #{name}"
+          end
+        end
+      end
+
+      def plugins_config_file
+        @plugins_config_file ||= FSPath.temp_file(%w[image_optim .js]).tap do |config_file|
+          config_file.puts 'export default {'
+          config_file.puts '  plugins: ['
+          config_file.puts '    {'
+          config_file.puts '      name: \'preset-default\','
+          config_file.puts '      params: {'
+          config_file.puts '        overrides: {'
+          disable_plugins.each do |plugin_name|
+            config_file.puts "          #{plugin_name}: false,"
+          end
+          config_file.puts '        }'
+          config_file.puts '      }'
+          config_file.puts '    },'
+          enable_plugins.each do |plugin_name|
+            config_file.puts "  '#{plugin_name}',"
+          end
+          config_file.puts '  ]'
+          config_file.puts '};'
+          config_file.close
+        end
+      end
     end
   end
 end

data/lib/image_optim.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'image_optim/benchmark_result'
 require 'image_optim/bin_resolver'
 require 'image_optim/cache'
 require 'image_optim/config'
@@ -8,6 +9,7 @@ require 'image_optim/handler'
 require 'image_optim/image_meta'
 require 'image_optim/optimized_path'
 require 'image_optim/path'
+require 'image_optim/table'
 require 'image_optim/timer'
 require 'image_optim/worker'
 require 'in_threads'
@@ -162,6 +164,22 @@ class ImageOptim
     end
   end
 
+  def benchmark_image(original)
+    src = Path.convert(original)
+    return unless (workers = workers_for_image(src))
+
+    dst = src.temp_path
+    begin
+      workers.map do |worker|
+        start = ElapsedTime.now
+        worker.optimize(src, dst)
+        BenchmarkResult.new(src, dst, ElapsedTime.now - start, worker)
+      end
+    ensure
+      dst.unlink
+    end
+  end
+
   # Optimize multiple images
   # if block given yields path and result for each image and returns array of
   # yield results
@@ -186,6 +204,10 @@ class ImageOptim
     run_method_for(datas, :optimize_image_data, &block)
   end
 
+  def benchmark_images(paths, &block)
+    run_method_for(paths, :benchmark_image, &block)
+  end
+
   class << self
     # Optimization methods with default options
     def method_missing(method, *args, &block)

data/script/update-rubygems-n-bundler

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+ruby <<'RUBY'
+  short_version = RUBY_VERSION.to_f
+
+  gemrc_path = File.expand_path('~/.gemrc')
+  unless File.exist?(gemrc_path)
+    File.open(gemrc_path, 'w') do |f|
+      if short_version < 2.0
+        f.puts 'gem: --no-ri --no-rdoc'
+      else
+        f.puts 'gem: --no-document'
+      end
+    end
+  end
+
+  def sh(*args)
+    abort unless system(*args)
+  end
+
+  case
+  when short_version < 2.3
+    sh 'curl --output rubygems-update.gem https://rubygems.org/downloads/rubygems-update-2.7.11.gem'
+    sh 'gem install --local rubygems-update.gem'
+    sh 'update_rubygems'
+    File.unlink(`which bundle`.strip)
+    sh 'curl --output bundler.gem https://rubygems.org/downloads/bundler-1.17.3.gem'
+    sh 'gem install --local bundler.gem'
+  when short_version < 2.6
+    sh 'gem update --system 3.3.27'
+    sh 'gem install bundler --version 2.3.27'
+  when short_version < 3.0
+    sh 'gem update --system 3.4.22'
+    sh 'gem install bundler --version 2.4.22'
+  when short_version < 3.1
+    sh 'gem update --system 3.5.23'
+    sh 'gem install bundler --version 2.5.23'
+  when short_version < 3.2
+    sh 'gem update --system 3.6.9'
+    sh 'gem install bundler --version 2.6.9'
+  else
+    sh 'gem update --system'
+    sh 'gem install bundler'
+  end
+RUBY
+
+gem -v
+bundle -v

data/script/update_worker_options_in_readme

@@ -51,8 +51,21 @@ def update_readme(text)
 end
 
 readme = File.read(README_FILE)
-if (readme = update_readme(readme))
-  File.write(README_FILE, readme)
+program_name = File.basename($PROGRAM_NAME, '.*')
+case ARGV
+when []
+  if (readme = update_readme(readme))
+    File.write(README_FILE, readme)
+  else
+    abort 'Did not update worker options'
+  end
+when %w[-n]
+  updated = update_readme(readme)
+  unless updated == readme
+    puts "Run #{program_name} to update work options in readme"
+    IO.popen('diff -u README.markdown -', 'w'){ |f| f << updated }
+    exit 1
+  end
 else
-  abort 'Did not update worker options'
+  abort "#{program_name} [-n] (-n to change exit code instead of updating)"
 end

data/spec/image_optim/bin_resolver_spec.rb

@@ -143,14 +143,14 @@ describe ImageOptim::BinResolver do
     expect(FSPath).to receive(:temp_dir).
       once.and_return(tmpdir)
     expect(tmpdir).to receive(:/).
-      with(:the_optimizer).once.and_return(symlink)
+      with(:'the-optimizer').once.and_return(symlink)
     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(:the_optimizer, File.expand_path(path)).and_return(bin)
+      with(:'the-optimizer', File.expand_path(path)).and_return(bin)
     expect(bin).to receive(:check!).once
     expect(bin).to receive(:check_fail!).exactly(5).times
 
@@ -160,7 +160,7 @@ describe ImageOptim::BinResolver do
     end
 
     5.times do
-      resolver.resolve!(:the_optimizer)
+      resolver.resolve!(:'the-optimizer')
     end
     expect(resolver.env_path).to eq([
       tmpdir,

data/spec/image_optim/cache_spec.rb

@@ -15,7 +15,9 @@ describe ImageOptim::Cache do
 
   let(:cache_dir) do
     dir = '/somewhere/cache'
-    allow(FileUtils).to receive(:mkpath).with(Regexp.new(Regexp.escape(dir)), any_args)
+    allow(Dir).to receive(:mkdir).with(File.dirname(dir))
+    allow(Dir).to receive(:mkdir).with(dir)
+    allow(Dir).to receive(:mkdir).with(%r{\A#{Regexp.escape(dir)}/[^/]+\z})
     allow(FileUtils).to receive(:touch)
     allow(FSPath).to receive(:temp_file_path) do
       tmp_file

data/spec/image_optim/option_definition_spec.rb

@@ -71,9 +71,7 @@ describe ImageOptim::OptionDefinition do
 
     context 'when proc given' do
       subject do
-        # not using &:inspect due to ruby Bug #13087
-        # to_s is just to calm rubocop
-        described_class.new('abc', :def, 'desc'){ |o| o.inspect.to_s }
+        described_class.new('abc', :def, 'desc', &:inspect)
       end
 
       context 'when option not provided' do

data/spec/image_optim/runner/option_parser_spec.rb

@@ -101,7 +101,16 @@ describe ImageOptim::Runner::OptionParser do
       allow(parser).to receive(:terminal_columns).and_return(80)
 
       expect(parser.help.split("\n")).
-        to all(satisfy{ |line| line.length <= 80 })
+        to all(satisfy{ |line| line.length < 80 })
+    end
+
+    it 'wraps texts even for too wide terminals' do
+      parser = OptionParser.new({})
+
+      allow(parser).to receive(:terminal_columns).and_return(1000)
+
+      expect(parser.help.split("\n")).
+        to all(satisfy{ |line| line.length <= 120 })
     end
   end
 end

data/spec/image_optim/true_false_nil_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'image_optim/true_false_nil'
+
+describe ImageOptim::TrueFalseNil do
+  describe '.convert' do
+    it 'keeps true' do
+      expect(described_class.convert(true)).to eq(true)
+    end
+
+    it 'keeps false' do
+      expect(described_class.convert(false)).to eq(false)
+    end
+
+    it 'keeps nil' do
+      expect(described_class.convert(nil)).to eq(nil)
+    end
+
+    it 'converts truthy to true' do
+      expect(described_class.convert(1)).to eq(true)
+    end
+  end
+end