image_optim 0.17.1 → 0.18.0

data/lib/image_optim/bin_resolver/bin.rb

@@ -1,6 +1,8 @@
 require 'image_optim/bin_resolver/error'
 require 'image_optim/bin_resolver/simple_version'
 require 'image_optim/bin_resolver/comparable_condition'
+require 'image_optim/cmd'
+require 'shellwords'
 
 class ImageOptim
   class BinResolver
@@ -11,7 +13,7 @@ class ImageOptim
       attr_reader :name, :path, :version
       def initialize(name, path)
         @name = name.to_sym
-        @path = path
+        @path = path.to_s
         @version = detect_version
       end
 
@@ -59,18 +61,18 @@ class ImageOptim
       def version_string
         case name
         when :advpng, :gifsicle, :jpegoptim, :optipng, :pngquant
-          `#{path.shellescape} --version 2> /dev/null`[/\d+(\.\d+){1,}/]
+          capture("#{escaped_path} --version 2> /dev/null")[/\d+(\.\d+){1,}/]
         when :svgo
-          `#{path.shellescape} --version 2>&1`[/\d+(\.\d+){1,}/]
+          capture("#{escaped_path} --version 2>&1")[/\d+(\.\d+){1,}/]
         when :jhead
-          `#{path.shellescape} -V 2> /dev/null`[/\d+(\.\d+){1,}/]
+          capture("#{escaped_path} -V 2> /dev/null")[/\d+(\.\d+){1,}/]
         when :jpegtran
-          `#{path.shellescape} -v - 2>&1`[/version (\d+\S*)/, 1]
+          capture("#{escaped_path} -v - 2>&1")[/version (\d+\S*)/, 1]
         when :pngcrush
-          `#{path.shellescape} -version 2>&1`[/\d+(\.\d+){1,}/]
+          capture("#{escaped_path} -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_str = capture("#{escaped_path} 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
@@ -79,6 +81,14 @@ class ImageOptim
           fail "getting `#{name}` version is not defined"
         end
       end
+
+      def capture(cmd)
+        Cmd.capture(cmd)
+      end
+
+      def escaped_path
+        path.shellescape
+      end
     end
   end
 end

data/lib/image_optim/cmd.rb

@@ -0,0 +1,49 @@
+require 'English'
+
+class ImageOptim
+  # Helper for running commands
+  module Cmd
+    class << self
+      # Run using `system`
+      # Return success status
+      # Will raise SignalException if process was interrupted
+      def run(*args)
+        success = system(*args)
+
+        check_status!
+
+        success
+      end
+
+      # Run using backtick
+      # Return captured output
+      # Will raise SignalException if process was interrupted
+      def capture(cmd)
+        output = `#{cmd}`
+
+        check_status!
+
+        output
+      end
+
+    private
+
+      def check_status!
+        status = $CHILD_STATUS
+
+        return unless status.signaled?
+
+        # jruby incorrectly returns true for `signaled?` if process exits with
+        # non zero status. For following code
+        #
+        #     `sh -c 'exit 66'`
+        #     p [$?.signaled?, $?.exitstatus, $?.termsig]
+        #
+        # jruby outputs `[true, 66, 66]` instead of expected `[false, 66, nil]`
+        return if defined?(JRUBY_VERSION) && status.exitstatus == status.termsig
+
+        fail SignalException, status.termsig
+      end
+    end
+  end
+end

data/lib/image_optim/config.rb

@@ -2,6 +2,7 @@ require 'image_optim/option_helpers'
 require 'image_optim/configuration_error'
 require 'image_optim/hash_helpers'
 require 'image_optim/worker'
+require 'image_optim/cmd'
 require 'set'
 require 'yaml'
 
@@ -10,9 +11,13 @@ class ImageOptim
   class Config
     include OptionHelpers
 
+    # Global config path at `$XDG_CONFIG_HOME/image_optim.yml` (by default
+    # `~/.config/image_optim.yml`)
     GLOBAL_PATH = begin
       File.join(ENV['XDG_CONFIG_HOME'] || '~/.config', 'image_optim.yml')
     end
+
+    # Local config path at `./.image_optim.yml`
     LOCAL_PATH = './.image_optim.yml'
 
     class << self
@@ -37,6 +42,9 @@ class ImageOptim
       end
     end
 
+    # Merge config from files with passed options
+    # Config files are checked at `GLOBAL_PATH` and `LOCAL_PATH` unless
+    # overriden using `:config_paths`
     def initialize(options)
       config_paths = options.delete(:config_paths) || [GLOBAL_PATH, LOCAL_PATH]
       config_paths = Array(config_paths)
@@ -50,18 +58,31 @@ class ImageOptim
       @used = Set.new
     end
 
+    # Gets value for key converted to symbol and mark option as used
     def get!(key)
       key = key.to_sym
       @used << key
       @options[key]
     end
 
+    # Check if key is present
+    def key?(key)
+      key = key.to_sym
+      @options.key?(key)
+    end
+
+    # Fail unless all options were marked as used (directly or indirectly
+    # accessed using `get!`)
     def assert_no_unused_options!
       unknown_options = @options.reject{ |key, _value| @used.include?(key) }
       return if unknown_options.empty?
       fail ConfigurationError, "unknown options #{unknown_options.inspect}"
     end
 
+    # Nice level:
+    # * `10` by default and for `nil` or `true`
+    # * `0` for `false`
+    # * otherwise convert to integer
     def nice
       nice = get!(:nice)
 
@@ -75,6 +96,10 @@ class ImageOptim
       end
     end
 
+    # Number of parallel threads:
+    # * `processor_count` by default and for `nil` or `true`
+    # * `1` for `false`
+    # * otherwise convert to integer
     def threads
       threads = get!(:threads)
 
@@ -88,10 +113,40 @@ class ImageOptim
       end
     end
 
+    # Verbose mode, converted to boolean
     def verbose
       !!get!(:verbose)
     end
 
+    # Using image_optim_pack:
+    # * `false` to disable
+    # * `nil` to use if available
+    # * everything else to require
+    def pack
+      pack = get!(:pack)
+      return false if pack == false
+
+      require 'image_optim/pack'
+      true
+    rescue LoadError => e
+      raise "Cannot load image_optim_pack: #{e}" if pack
+      false
+    end
+
+    # Skip missing workers, converted to boolean
+    def skip_missing_workers
+      if key?(:skip_missing_workers)
+        !!get!(:skip_missing_workers)
+      else
+        pack
+      end
+    end
+
+    # Options for worker class by its `bin_sym`:
+    # * `Hash` passed as is
+    # * `{}` for `true` or `nil`
+    # * `false` for `false`
+    # * otherwise fail with `ConfigurationError`
     def for_worker(klass)
       worker_options = get!(klass.bin_sym)
 
@@ -108,6 +163,7 @@ class ImageOptim
       end
     end
 
+    # yaml dump without document beginning prefix `---`
     def to_s
       YAML.dump(HashHelpers.deep_stringify_keys(@options)).sub(/\A---\n/, '')
     end
@@ -118,13 +174,17 @@ class ImageOptim
     def processor_count
       @processor_count ||= case host_os = RbConfig::CONFIG['host_os']
       when /darwin9/
-        `hwprefs cpu_count`
+        Cmd.capture 'hwprefs cpu_count'
       when /darwin/
-        (`which hwprefs` != '') ? `hwprefs thread_count` : `sysctl -n hw.ncpu`
+        if (Cmd.capture 'which hwprefs') != ''
+          Cmd.capture 'hwprefs thread_count'
+        else
+          Cmd.capture 'sysctl -n hw.ncpu'
+        end
       when /linux/
-        `grep -c processor /proc/cpuinfo`
+        Cmd.capture 'grep -c processor /proc/cpuinfo'
       when /freebsd/
-        `sysctl -n hw.ncpu`
+        Cmd.capture 'sysctl -n hw.ncpu'
       when /mswin|mingw/
         require 'win32ole'
         WIN32OLE.

data/lib/image_optim/image_path.rb

@@ -54,6 +54,11 @@ class ImageOptim
       image_meta && image_meta.format
     end
 
+    # Read binary data
+    def binread
+      open('rb', &:read)
+    end
+
     # Returns path if it is already an instance of this class otherwise new
     # instance
     def self.convert(path)

data/lib/image_optim/option_definition.rb

@@ -3,9 +3,11 @@ class ImageOptim
   class OptionDefinition
     attr_reader :name, :default, :type, :description, :proc
 
-    def initialize(name, default, type, description, &proc)
-      if type.is_a?(String)
-        type, description = default.class, type
+    def initialize(name, default, type_or_description, description = nil, &proc)
+      if type_or_description.is_a?(Class)
+        type = type_or_description
+      else
+        type, description = default.class, type_or_description
       end
 
       @name = name.to_sym

data/lib/image_optim/runner.rb

@@ -3,7 +3,6 @@ require 'image_optim/hash_helpers'
 require 'image_optim/runner/glob_helpers'
 require 'image_optim/space'
 require 'progress'
-require 'optparse'
 require 'find'
 require 'yaml'
 
@@ -127,7 +126,7 @@ class ImageOptim
       basename = File.basename(path)
       globs.any? do |glob|
         File.fnmatch(glob, relative_path, File::FNM_PATHNAME) ||
-        File.fnmatch(glob, basename, File::FNM_PATHNAME)
+          File.fnmatch(glob, basename, File::FNM_PATHNAME)
       end
     end
 

data/lib/image_optim/runner/option_parser.rb

@@ -0,0 +1,216 @@
+# encoding: UTF-8
+
+require 'image_optim'
+require 'image_optim/true_false_nil'
+require 'image_optim/non_negative_integer_range'
+require 'optparse'
+
+class ImageOptim
+  class Runner
+    # Parse options from arguments to image_optim binary
+    class OptionParser < ::OptionParser
+      # Parse and remove options from args, return options Hash
+      # Calls abort in case of parse error
+      def self.parse!(args)
+        # assume -v to be a request to print version if it is the only argument
+        args = %w[--version] if args == %w[-v]
+
+        options = {}
+        parser = new(options)
+        parser.parse!(args)
+        options
+      rescue OptionParser::ParseError => e
+        abort "#{e}\n\n#{parser.help}"
+      end
+
+      # After initialization passes self and options to DEFINE
+      def initialize(options)
+        super
+        DEFINE.call(self, options)
+      end
+
+      # Wraps and indents lines of overriden method
+      def help
+        text = super
+
+        # reserve one column
+        columns = terminal_columns - 1
+        # 1 for distance between summary and description
+        # 2 for additional indent
+        wrapped_indent = summary_indent + ' ' * (summary_width + 1 + 2)
+        wrapped_width = columns - wrapped_indent.length
+        # don't try to wrap if there is too little space for description
+        return text if wrapped_width < 20
+
+        wrapped = ''
+        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
+      end
+
+    private
+
+      def terminal_columns
+        stty_columns = `stty size 2> /dev/null`[/^\d+ (\d+)$/, 1]
+        stty_columns ? stty_columns.to_i : `tput cols`.to_i
+      end
+
+      def wrap_regex(width)
+        /.*?.{1,#{width}}(?:\s|\z)/
+      end
+    end
+  end
+end
+
+ImageOptim::Runner::OptionParser::DEFINE = proc do |op, options|
+  unless op.is_a?(OptionParser)
+    fail ArgumentError, "expected instance of OptionParser, got #{op.inspect}"
+  end
+  unless options.is_a?(Hash)
+    fail ArgumentError, "expected instance of Hash, got #{options.inspect}"
+  end
+
+  ImageOptim::TrueFalseNil.add_to_option_parser(op)
+  ImageOptim::NonNegativeIntegerRange.add_to_option_parser(op)
+
+  op.banner = <<-TEXT.gsub(/^\s*\|/, '')
+    |#{ImageOptim.full_version}
+    |
+    |Usege:
+    |  #{op.program_name} [options] image_path …
+    |
+    |Configuration will be read and prepanded to options from two paths:
+    |  #{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
+  end
+
+  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|
+    options[:exclude_file_glob] = glob
+  end
+
+  op.on("--exclude 'GLOB'", 'Set glob for excluding both directories and '\
+      'files') do |glob|
+    options[:exclude_file_glob] = options[:exclude_dir_glob] = glob
+  end
+
+  op.separator nil
+
+  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 (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|
+    options[:pack] = pack
+  end
+
+  op.separator nil
+  op.separator '  Disabling workers:'
+
+  op.on('--[no-]skip-missing-workers', 'Skip workers with missing or '\
+      'problematic binaries') do |skip|
+    options[:skip_missing_workers] = skip
+  end
+
+  ImageOptim::Worker.klasses.each do |klass|
+    bin = klass.bin_sym
+    op.on("--no-#{bin}", "disable #{bin} worker") do |enable|
+      options[bin] = enable
+    end
+  end
+
+  op.separator nil
+  op.separator '  Worker options:'
+
+  ImageOptim::Worker.klasses.each_with_index do |klass, i|
+    next if klass.option_definitions.empty?
+    op.separator nil unless i.zero?
+
+    bin = klass.bin_sym
+    klass.option_definitions.each do |option_definition|
+      name = option_definition.name.to_s.gsub('_', '-')
+      default = option_definition.default
+      type = option_definition.type
+
+      type, marking = case
+      when [TrueClass, FalseClass, ImageOptim::TrueFalseNil].include?(type)
+        [type, 'B']
+      when Integer >= type
+        [Integer, 'N']
+      when Array >= type
+        [Array, 'a,b,c']
+      when ImageOptim::NonNegativeIntegerRange == type
+        [type, 'M-N']
+      else
+        fail "Unknown type #{type}"
+      end
+
+      description_lines = %W[
+        #{option_definition.description.gsub(' - ', ' - ')}
+        (defaults to #{default})
+      ].join(' ')
+
+      op.on("--#{bin}-#{name} #{marking}", type, *description_lines) do |value|
+        options[bin] = {} unless options[bin].is_a?(Hash)
+        options[bin][option_definition.name.to_sym] = value
+      end
+    end
+  end
+
+  op.separator nil
+  op.separator '  Common options:'
+
+  op.on_tail('-v', '--verbose', 'Verbose output') do
+    options[:verbose] = true
+  end
+
+  op.on_tail('-h', '--help', 'Show help and exit') do
+    puts op.help
+    exit
+  end
+
+  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