discourse_image_optim 0.24.4

data/lib/image_optim/runner/option_parser.rb

@@ -0,0 +1,246 @@
+# 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}
+    |
+    |Usage:
+    |  #{op.program_name} [options] image_path …
+    |
+    |Configuration will be read and prepended 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-progress', 'Disable showing progress') do |show_progress|
+    options[:show_progress] = show_progress
+  end
+
+  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|
+    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 '  Caching:'
+
+  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|
+    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|
+    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:'
+
+  op.on('--allow-lossy', 'Allow lossy workers and '\
+      'optimizations') do |allow_lossy|
+    options[:allow_lossy] = allow_lossy
+  end
+
+  op.on('--timeout N', 'Sets a timeout for workers') do |timeout|
+    options[:timeout] = timeout.to_i
+  end
+
+  op.separator nil
+
+  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.tr('_', '-')
+      default = option_definition.default_description
+      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 = option_definition.description.gsub(' - ', ' - ')
+      unless description['(defaults']
+        description << " (defaults to #{default})"
+      end
+
+      op.on("--#{bin}-#{name} #{marking}", type, description) 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

data/lib/image_optim/space.rb

@@ -0,0 +1,29 @@
+class ImageOptim
+  # Present size in readable form as fixed length string
+  module Space
+    SIZE_SYMBOLS = %w[B K M G T P E].freeze
+    BASE = 1024.0
+    PRECISION = 1
+    LENGTH = 4 + PRECISION + 1
+
+    EMPTY_SPACE = ' ' * LENGTH
+
+    def self.space(size)
+      case size
+      when 0, nil
+        EMPTY_SPACE
+      else
+        log_denominator = Math.log(size.abs) / Math.log(BASE)
+        degree = [log_denominator.floor, SIZE_SYMBOLS.length - 1].min
+        number_string = if degree.zero?
+          size.to_s
+        else
+          denominator = BASE**degree
+          number = size / denominator
+          format("%.#{PRECISION}f", number)
+        end
+        "#{number_string}#{SIZE_SYMBOLS[degree]}".rjust(LENGTH)
+      end
+    end
+  end
+end

data/lib/image_optim/true_false_nil.rb

@@ -0,0 +1,16 @@
+class ImageOptim
+  # Denote ternary value (`true`/`false`/`nil`) for worker option
+  class TrueFalseNil
+    # Add handling of ternary value in OptionParser instance, maps `nil` and
+    # `'nil'` to `nil`
+    def self.add_to_option_parser(option_parser)
+      completing = OptionParser.top.atype[TrueClass][0].merge('nil' => nil)
+      option_parser.accept(self, completing){ |_arg, val| val }
+    end
+
+    # Convert everything truthy to `true`, leave `false` and `nil` as is
+    def self.convert(v)
+      v && true
+    end
+  end
+end

data/lib/image_optim/worker.rb

@@ -0,0 +1,170 @@
+# encoding: UTF-8
+
+require 'image_optim/cmd'
+require 'image_optim/configuration_error'
+require 'image_optim/path'
+require 'image_optim/worker/class_methods'
+require 'shellwords'
+require 'English'
+
+class ImageOptim
+  # Base class for all workers
+  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
+
+    # Configure (raises on extra options)
+    def initialize(image_optim, options = {})
+      unless image_optim.is_a?(ImageOptim)
+        fail ArgumentError, 'first parameter should be an ImageOptim instance'
+      end
+      @image_optim = image_optim
+      parse_options(options)
+      assert_no_unknown_options!(options)
+    end
+
+    # Return hash with worker options
+    def options
+      hash = {}
+      self.class.option_definitions.each do |option|
+        hash[option.name] = send(option.name)
+      end
+      hash
+    end
+
+    # Optimize image at src, output at dst, must be overriden in subclass
+    # return true on success
+    def optimize(_src, _dst)
+      fail NotImplementedError, "implement method optimize in #{self.class}"
+    end
+
+    # List of formats which worker can optimize
+    def image_formats
+      format_from_name = self.class.name.downcase[/gif|jpeg|png|svg/]
+      unless format_from_name
+        fail "#{self.class}: can't guess applicable format from worker name"
+      end
+      [format_from_name.to_sym]
+    end
+
+    # Ordering in list of workers, 0 by default
+    def run_order
+      0
+    end
+
+    # List of bins used by worker
+    def used_bins
+      [self.class.bin_sym]
+    end
+
+    # Resolve used bins, raise exception concatenating all messages
+    def resolve_used_bins!
+      errors = BinResolver.collect_errors(used_bins) do |bin|
+        @image_optim.resolve_bin!(bin)
+      end
+      return if errors.empty?
+      fail BinResolver::Error, wrap_resolver_error_message(errors.join(', '))
+    end
+
+    # Check if operation resulted in optimized file
+    def optimized?(src, dst)
+      dst_size = dst.size?
+      dst_size && dst_size < src.size
+    end
+
+    # Short inspect
+    def inspect
+      options_string = self.class.option_definitions.map do |option|
+        " @#{option.name}=#{send(option.name).inspect}"
+      end.join(',')
+      "#<#{self.class}#{options_string}>"
+    end
+
+  private
+
+    def parse_options(options)
+      self.class.option_definitions.each do |option_definition|
+        value = option_definition.value(self, options)
+        instance_variable_set("@#{option_definition.name}", value)
+      end
+    end
+
+    def assert_no_unknown_options!(options)
+      known_keys = self.class.option_definitions.map(&:name)
+      unknown_options = options.reject{ |key, _value| known_keys.include?(key) }
+      return if unknown_options.empty?
+      fail ConfigurationError, "unknown options #{unknown_options.inspect} "\
+          "for #{self}"
+    end
+
+    # Forward bin resolving to image_optim
+    def resolve_bin!(bin)
+      @image_optim.resolve_bin!(bin)
+    rescue BinResolver::Error => e
+      raise e, wrap_resolver_error_message(e.message), e.backtrace
+    end
+
+    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)"
+    end
+
+    # Run command setting priority and hiding output
+    def execute(bin, *arguments)
+      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"
+      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
+
+      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
+    end
+  end
+end