discourse_image_optim 0.24.4

data/image_optim.gemspec

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+Gem::Specification.new do |s|
+  s.name        = 'discourse_image_optim'
+  s.version     = '0.24.4'
+  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']
+  s.license     = 'MIT'
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w[lib]
+
+  s.post_install_message = <<-EOF
+Rails image assets optimization is extracted into image_optim_rails gem
+You can safely remove `config.assets.image_optim = false` if you are not going to use that gem
+EOF
+
+  s.add_dependency 'fspath', '~> 3.0'
+  s.add_dependency 'image_size', '~> 1.5'
+  s.add_dependency 'exifr', '~> 1.2', '>= 1.2.2'
+  s.add_dependency 'progress', '~> 3.0', '>= 3.0.1'
+  s.add_dependency 'in_threads', '~> 1.3'
+
+  s.add_development_dependency 'image_optim_pack', '~> 0.2', '>= 0.2.2'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  if RUBY_VERSION >= '2.0'
+    s.add_development_dependency 'rubocop', '~> 0.47'
+  end
+end

data/lib/image_optim.rb

@@ -0,0 +1,267 @@
+require 'image_optim/bin_resolver'
+require 'image_optim/cache'
+require 'image_optim/config'
+require 'image_optim/handler'
+require 'image_optim/image_meta'
+require 'image_optim/optimized_path'
+require 'image_optim/path'
+require 'image_optim/worker'
+require 'in_threads'
+require 'shellwords'
+
+%w[
+  pngcrush pngout advpng optipng pngquant
+  jhead jpegoptim jpegrecompress jpegtran
+  gifsicle
+  svgo
+].each do |worker|
+  require "image_optim/worker/#{worker}"
+end
+
+# Main interface
+class ImageOptim
+  # Nice level
+  attr_reader :nice
+
+  # Number of threads to run with
+  attr_reader :threads
+
+  # Verbose output?
+  attr_reader :verbose
+
+  # Use image_optim_pack
+  attr_reader :pack
+
+  # Skip workers with missing or problematic binaries
+  attr_reader :skip_missing_workers
+
+  # Allow lossy workers and optimizations
+  attr_reader :allow_lossy
+
+  # Cache directory
+  attr_reader :cache_dir
+
+  # Cache worker digests
+  attr_reader :cache_worker_digests
+
+  # Timeout
+  attr_reader :timeout
+
+  # Initialize workers, specify options using worker underscored name:
+  #
+  # pass false to disable worker
+  #
+  #     ImageOptim.new(:pngcrush => false)
+  #
+  # or hash with options to worker
+  #
+  #     ImageOptim.new(:advpng => {:level => 3}, :optipng => {:level => 2})
+  #
+  # use :threads to set number of parallel optimizers to run (passing true or
+  # nil determines number of processors, false disables parallel processing)
+  #
+  #     ImageOptim.new(:threads => 8)
+  #
+  # use :nice to specify optimizers nice level (true or nil makes it 10, false
+  # makes it 0)
+  #
+  #     ImageOptim.new(:nice => 20)
+  def initialize(options = {})
+    config = Config.new(options)
+    @verbose = config.verbose
+    $stderr << "config:\n#{config.to_s.gsub(/^/, '  ')}" if verbose
+
+    %w[
+      nice
+      threads
+      pack
+      skip_missing_workers
+      allow_lossy
+      cache_dir
+      cache_worker_digests
+      timeout
+    ].each do |name|
+      instance_variable_set(:"@#{name}", config.send(name))
+      $stderr << "#{name}: #{send(name)}\n" if verbose
+    end
+
+    @bin_resolver = BinResolver.new(self)
+
+    @workers_by_format = Worker.create_all_by_format(self) do |klass|
+      config.for_worker(klass)
+    end
+
+    @cache = Cache.new(self, @workers_by_format)
+
+    log_workers_by_format if verbose
+
+    config.assert_no_unused_options!
+  end
+
+  # Get workers for image
+  def workers_for_image(path)
+    @workers_by_format[Path.convert(path).image_format]
+  end
+
+  # Optimize one file, return new path as OptimizedPath or nil if
+  # optimization failed
+  def optimize_image(original)
+    original = Path.convert(original)
+    return unless (workers = workers_for_image(original))
+
+    optimized = @cache.fetch(original) do
+      Handler.for(original) do |handler|
+        workers.each do |worker|
+          handler.process do |src, dst|
+            worker.optimize(src, dst)
+          end
+        end
+      end
+    end
+
+    return unless optimized
+    OptimizedPath.new(optimized, original)
+  end
+
+  # Optimize one file in place, return original as OptimizedPath or nil if
+  # optimization failed
+  def optimize_image!(original)
+    original = Path.convert(original)
+    return unless (result = optimize_image(original))
+    result.replace(original)
+    OptimizedPath.new(original, result.original_size)
+  end
+
+  # Optimize image data, return new data or nil if optimization failed
+  def optimize_image_data(original_data)
+    format = ImageMeta.format_for_data(original_data)
+    return unless format
+    Path.temp_file %W[image_optim .#{format}] do |temp|
+      temp.binmode
+      temp.write(original_data)
+      temp.close
+
+      if (result = optimize_image(temp.path))
+        result.binread
+      end
+    end
+  end
+
+  # Optimize multiple images
+  # if block given yields path and result for each image and returns array of
+  # yield results
+  # else return array of path and result pairs
+  def optimize_images(paths, &block)
+    run_method_for(paths, :optimize_image, &block)
+  end
+
+  # Optimize multiple images in place
+  # if block given yields path and result for each image and returns array of
+  # yield results
+  # else return array of path and result pairs
+  def optimize_images!(paths, &block)
+    run_method_for(paths, :optimize_image!, &block)
+  end
+
+  # Optimize multiple image datas
+  # if block given yields original and result for each image data and returns
+  # array of yield results
+  # else return array of path and result pairs
+  def optimize_images_data(datas, &block)
+    run_method_for(datas, :optimize_image_data, &block)
+  end
+
+  class << self
+    # Optimization methods with default options
+    def method_missing(method, *args, &block)
+      if optimize_image_method?(method)
+        new.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      optimize_image_method?(method) || super
+    end
+
+    if RUBY_VERSION < '1.9'
+      def respond_to?(method, include_private = false)
+        optimize_image_method?(method) || super
+      end
+    end
+
+    # Version of image_optim gem spec loaded
+    def version
+      Gem.loaded_specs['image_optim'].version.to_s
+    rescue
+      'DEV'
+    end
+
+    # Full version of image_optim
+    def full_version
+      "image_optim v#{version}"
+    end
+
+  private
+
+    def optimize_image_method?(method)
+      method_defined?(method) && method.to_s =~ /^optimize_image/
+    end
+  end
+
+  # Are there workers for file at path?
+  def optimizable?(path)
+    !!workers_for_image(path)
+  end
+
+  # Check existance of binary, create symlink if ENV contains path for key
+  # XXX_BIN where XXX is upper case bin name
+  def resolve_bin!(bin)
+    @bin_resolver.resolve!(bin)
+  end
+
+  # Join resolve_dir, default path and vendor path for PATH environment variable
+  def env_path
+    @bin_resolver.env_path
+  end
+
+private
+
+  def log_workers_by_format
+    $stderr << "Workers by format:\n"
+    @workers_by_format.each do |format, workers|
+      $stderr << "#{format}:\n"
+      workers.each do |worker|
+        $stderr << "  #{worker.class.bin_sym}:\n"
+        worker.options.each do |name, value|
+          $stderr << "    #{name}: #{value.inspect}\n"
+        end
+      end
+    end
+  end
+
+  # Run method for each item in list
+  # if block given yields item and result for item and returns array of yield
+  # results
+  # else return array of item and result pairs
+  def run_method_for(list, method_name, &block)
+    apply_threading(list).map do |item|
+      result = send(method_name, item)
+      if block
+        yield item, result
+      else
+        [item, result]
+      end
+    end
+  end
+
+  # Apply threading if threading is allowed
+  def apply_threading(enum)
+    if threads > 1
+      enum.in_threads(threads)
+    else
+      enum
+    end
+  end
+end

data/lib/image_optim/bin_resolver.rb

@@ -0,0 +1,142 @@
+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
+
+      fail BinNotFound, "`#{name}` not found" unless @bins[name]
+
+      @bins[name].check_fail!
+
+      @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,115 @@
+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 'image_optim/path'
+require 'shellwords'
+require 'digest/sha1'
+
+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 digest
+        return @digest if defined?(@digest)
+        @digest = File.exist?(@path) && Digest::SHA1.file(@path).hexdigest
+      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'],
+      ].freeze
+
+      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-`'],
+        [:optipng, is < '0.7', 'does not support -strip option'],
+      ].freeze
+
+      # Fail if version will not work properly
+      def check_fail!
+        unless version
+          fail UnknownVersion, "could not get version of #{name} at #{path}"
+        end
+
+        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
+          capture("#{escaped_path} --version 2> #{Path::NULL}")[/\d+(\.\d+)+/]
+        when :svgo, :pngquant
+          capture("#{escaped_path} --version 2>&1")[/\d+(\.\d+)+/]
+        when :jhead, :'jpeg-recompress'
+          capture("#{escaped_path} -V 2> #{Path::NULL}")[/\d+(\.\d+)+/]
+        when :jpegtran
+          capture("#{escaped_path} -v - 2>&1")[/version (\d+\S*)/, 1]
+        when :pngcrush
+          capture("#{escaped_path} -version 2>&1")[/pngcrush (\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 use first 8 characters of sha1 hex
+          Digest::SHA1.file(path).hexdigest[0, 8] if 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