openstreetmap-image_optim 0.21.0.1

data/lib/image_optim/bin_resolver.rb

@@ -0,0 +1,144 @@
+require 'thread'
+require 'fspath'
+require 'image_optim/bin_resolver/error'
+require 'image_optim/bin_resolver/bin'
+
+class ImageOptim
+  # Handles resolving binaries and checking versions
+  #
+  # If there is an environment variable XXX_BIN when resolving xxx, then a
+  # symlink to binary will be created in a temporary directory which will be
+  # added to PATH
+  class BinResolver
+    class BinNotFound < Error; end
+
+    # Directory for symlinks to bins if XXX_BIN was used
+    attr_reader :dir
+
+    # Path to pack from image_optim_pack if used
+    attr_reader :pack_path
+
+    def initialize(image_optim)
+      @image_optim = image_optim
+      @bins = {}
+      @lock = Mutex.new
+      init_pack
+    end
+
+    # Binary resolving: create symlink if there is XXX_BIN environment variable,
+    # build Bin with full path, check binary version
+    # Return Bin instance
+    def resolve!(name)
+      name = name.to_sym
+
+      resolving(name) do
+        path = symlink_custom_bin!(name) || full_path(name)
+        bin = Bin.new(name, path) if path
+
+        if bin && @image_optim.verbose
+          $stderr << "Resolved #{bin}\n"
+        end
+
+        @bins[name] = bin
+
+        bin.check! if bin
+      end
+
+      if @bins[name]
+        @bins[name].check_fail!
+      else
+        fail BinNotFound, "`#{name}` not found"
+      end
+
+      @bins[name]
+    end
+
+    # Path to vendor at root of image_optim
+    VENDOR_PATH = File.expand_path('../../../vendor', __FILE__)
+
+    # Prepand `dir` and append `VENDOR_PATH` to `PATH` from environment
+    def env_path
+      [
+        dir,
+        pack_path,
+        ENV['PATH'],
+        VENDOR_PATH,
+      ].compact.join(File::PATH_SEPARATOR)
+    end
+
+    # Collect resolving errors when running block over items of enumerable
+    def self.collect_errors(enumerable)
+      errors = []
+      enumerable.each do |item|
+        begin
+          yield item
+        rescue Error => e
+          errors << e
+        end
+      end
+      errors
+    end
+
+  private
+
+    def init_pack
+      return unless @image_optim.pack
+
+      @pack_path = if @image_optim.verbose
+        Pack.path do |message|
+          $stderr << "#{message}\n"
+        end
+      else
+        Pack.path
+      end
+      return if @pack_path
+
+      warn 'No pack for this OS and/or ARCH, check verbose output'
+    end
+
+    # Double-checked locking
+    def resolving(name)
+      return if @bins.include?(name)
+      @lock.synchronize do
+        yield unless @bins.include?(name)
+      end
+    end
+
+    # Check path in XXX_BIN to exist, be a file and be executable and symlink to
+    # dir as name
+    def symlink_custom_bin!(name)
+      env_name = "#{name}_bin".upcase
+      path = ENV[env_name]
+      return unless path
+      path = File.expand_path(path)
+      desc = "`#{path}` specified in #{env_name}"
+      fail "#{desc} doesn\'t exist" unless File.exist?(path)
+      fail "#{desc} is not a file" unless File.file?(path)
+      fail "#{desc} is not executable" unless File.executable?(path)
+      if @image_optim.verbose
+        $stderr << "Custom path for #{name} specified in #{env_name}: #{path}\n"
+      end
+      unless @dir
+        @dir = FSPath.temp_dir
+        at_exit{ FileUtils.remove_entry_secure @dir }
+      end
+      symlink = @dir / name
+      symlink.make_symlink(path)
+      path
+    end
+
+    # Return full path to bin or null
+    # based on http://stackoverflow.com/a/5471032/96823
+    def full_path(name)
+      # PATHEXT is needed only for windows
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      env_path.split(File::PATH_SEPARATOR).each do |dir|
+        exts.each do |ext|
+          path = File.expand_path("#{name}#{ext}", dir)
+          return path if File.file?(path) && File.executable?(path)
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/image_optim/bin_resolver/bin.rb

@@ -0,0 +1,105 @@
+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
+    # Holds bin name and path, gets version
+    class Bin
+      class UnknownVersion < Error; end
+      class BadVersion < Error; end
+
+      attr_reader :name, :path, :version
+      def initialize(name, path)
+        @name = name.to_sym
+        @path = path.to_s
+        @version = detect_version
+      end
+
+      def to_s
+        "#{name} #{version || '?'} at #{path}"
+      end
+
+      is = ComparableCondition.is
+
+      FAIL_CHECKS = [
+        [:pngcrush, is.between?('1.7.60', '1.7.65'), 'is known to produce '\
+              'broken pngs'],
+        [:pngcrush, is == '1.7.80', 'loses one color in indexed images'],
+        [:pngquant, is < '2.0', 'is not supported'],
+      ]
+
+      WARN_CHECKS = [
+        [:advpng, is < '1.17', 'does not use zopfli'],
+        [:gifsicle, is < '1.85', 'does not support removing extension blocks'],
+        [:pngcrush, is < '1.7.38', 'does not have blacken flag'],
+        [:pngquant, is < '2.1', 'may be lossy even with quality `100-`'],
+      ]
+
+      # Fail if version will not work properly
+      def check_fail!
+        fail UnknownVersion, "didn't get version of #{self}" unless version
+
+        FAIL_CHECKS.each do |bin_name, matcher, message|
+          next unless bin_name == name
+          next unless matcher.match(version)
+          fail BadVersion, "#{self} (#{matcher}) #{message}"
+        end
+      end
+
+      # Run check_fail!, otherwise warn if version is known to misbehave
+      def check!
+        check_fail!
+
+        WARN_CHECKS.each do |bin_name, matcher, message|
+          next unless bin_name == name
+          next unless matcher.match(version)
+          warn "WARN: #{self} (#{matcher}) #{message}"
+        end
+      end
+
+    private
+
+      # Wrap version_string with SimpleVersion
+      def detect_version
+        str = version_string
+        str && SimpleVersion.new(str)
+      end
+
+      # Getting version of bin, will fail for an unknown name
+      def version_string
+        case name
+        when :advpng, :gifsicle, :jpegoptim, :optipng, :pngquant
+          capture("#{escaped_path} --version 2> /dev/null")[/\d+(\.\d+){1,}/]
+        when :svgo
+          capture("#{escaped_path} --version 2>&1")[/\d+(\.\d+){1,}/]
+        when :jhead, :'jpeg-recompress'
+          capture("#{escaped_path} -V 2> /dev/null")[/\d+(\.\d+){1,}/]
+        when :jpegtran
+          capture("#{escaped_path} -v - 2>&1")[/version (\d+\S*)/, 1]
+        when :pngcrush
+          capture("#{escaped_path} -version 2>&1")[/\d+(\.\d+){1,}/]
+        when :pngout
+          date_regexp = /[A-Z][a-z]{2} (?: |\d)\d \d{4}/
+          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
+          path && '-'
+        else
+          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/bin_resolver/comparable_condition.rb

@@ -0,0 +1,60 @@
+class ImageOptim
+  class BinResolver
+    # Allows to externalize conditions for an instance of Comparable to use in
+    # case statemens
+    #
+    #     is = ComparableCondition.is
+    #     case rand(100)
+    #     when is < 10 then # ...
+    #     when is.between?(13, 23) then # ...
+    #     when is >= 90 then # ...
+    #     end
+    class ComparableCondition
+      # Helper class for creating conditions using ComparableCondition.is
+      class Builder
+        Comparable.instance_methods.each do |method|
+          define_method method do |*args|
+            ComparableCondition.new(method, *args)
+          end
+        end
+      end
+
+      def self.is
+        Builder.new
+      end
+
+      attr_reader :method, :args
+      def initialize(method, *args)
+        @method, @args = method.to_sym, args
+
+        case @method
+        when :between?
+          @args.length == 2 || argument_error!("`between?' expects 2 arguments")
+        when :<, :<=, :==, :>, :>=
+          @args.length == 1 || argument_error!("`#{method}' expects 1 argument")
+        else
+          argument_error! "Unknown method `#{method}'"
+        end
+      end
+
+      def ===(other)
+        other.send(@method, *@args)
+      end
+      alias_method :match, :===
+
+      def to_s
+        if @method == :between?
+          @args.join('..')
+        else
+          "#{@method} #{@args.first}"
+        end
+      end
+
+    private
+
+      def argument_error!(message)
+        fail ArgumentError, message
+      end
+    end
+  end
+end

data/lib/image_optim/bin_resolver/error.rb

@@ -0,0 +1,6 @@
+class ImageOptim
+  class BinResolver
+    # Base error during bin resolving
+    class Error < StandardError; end
+  end
+end

data/lib/image_optim/bin_resolver/simple_version.rb

@@ -0,0 +1,31 @@
+class ImageOptim
+  class BinResolver
+    # Allows comparision of simple versions, only numbers separated by dots are
+    # taken into account
+    class SimpleVersion
+      include Comparable
+
+      # Numbers extracted from version string
+      attr_reader :parts
+
+      # Initialize with a string or an object convertible to string
+      #
+      #    SimpleVersion.new('2.0.1') <=> SimpleVersion.new(2)
+      def initialize(str)
+        @str = String(str)
+        @parts = @str.split('.').map(&:to_i).reverse.drop_while(&:zero?).reverse
+      end
+
+      # Returns original version string
+      def to_s
+        @str
+      end
+
+      # Compare version parts of self with other
+      def <=>(other)
+        other = self.class.new(other) unless other.is_a?(self.class)
+        parts <=> other.parts
+      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

@@ -0,0 +1,205 @@
+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'
+
+class ImageOptim
+  # Read, merge and parse configuration
+  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
+      # Read options at path: expand path (warn on failure), return {} if file
+      # does not exist, read yaml, check if it is a Hash, deep symbolise keys
+      def read_options(path)
+        begin
+          full_path = File.expand_path(path)
+        rescue ArgumentError => e
+          warn "Can't expand path #{path}: #{e}"
+          return {}
+        end
+        return {} unless File.file?(full_path)
+        config = YAML.load_file(full_path)
+        unless config.is_a?(Hash)
+          fail "expected hash, got #{config.inspect}"
+        end
+        HashHelpers.deep_symbolise_keys(config)
+      rescue => e
+        warn "exception when reading #{full_path}: #{e}"
+        {}
+      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)
+
+      to_merge = config_paths.map{ |path| self.class.read_options(path) }
+      to_merge << HashHelpers.deep_symbolise_keys(options)
+
+      @options = to_merge.reduce do |memo, hash|
+        HashHelpers.deep_merge(memo, hash)
+      end
+      @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)
+
+      case nice
+      when true, nil
+        10
+      when false
+        0
+      else
+        nice.to_i
+      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)
+
+      case threads
+      when true, nil
+        processor_count
+      when false
+        1
+      else
+        threads.to_i
+      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
+
+    # Allow lossy workers and optimizations, converted to boolean
+    def allow_lossy
+      !!get!(:allow_lossy)
+    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)
+
+      case worker_options
+      when Hash
+        worker_options
+      when true, nil
+        {}
+      when false
+        {:disable => true}
+      else
+        fail ConfigurationError, "Got #{worker_options.inspect} for "\
+            "#{klass.name} options"
+      end
+    end
+
+    # yaml dump without document beginning prefix `---`
+    def to_s
+      YAML.dump(HashHelpers.deep_stringify_keys(@options)).sub(/\A---\n/, '')
+    end
+
+  private
+
+    # http://stackoverflow.com/a/6420817
+    def processor_count
+      @processor_count ||= case host_os = RbConfig::CONFIG['host_os']
+      when /darwin9/
+        Cmd.capture 'hwprefs cpu_count'
+      when /darwin/
+        if (Cmd.capture 'which hwprefs') != ''
+          Cmd.capture 'hwprefs thread_count'
+        else
+          Cmd.capture 'sysctl -n hw.ncpu'
+        end
+      when /linux/
+        Cmd.capture 'grep -c processor /proc/cpuinfo'
+      when /freebsd/
+        Cmd.capture 'sysctl -n hw.ncpu'
+      when /mswin|mingw/
+        require 'win32ole'
+        WIN32OLE.
+        connect('winmgmts://').
+        ExecQuery('select NumberOfLogicalProcessors from Win32_Processor').
+        to_enum.first.NumberOfLogicalProcessors
+      else
+        warn "Unknown architecture (#{host_os}) assuming one processor."
+        1
+      end.to_i
+    end
+  end
+end