openstreetmap-image_optim 0.21.0.1

data/README.markdown

@@ -0,0 +1,344 @@
+[![Gem Version](https://img.shields.io/gem/v/image_optim.svg?style=flat)](https://rubygems.org/gems/image_optim)
+[![Build Status](https://img.shields.io/travis/toy/image_optim/master.svg?style=flat)](https://travis-ci.org/toy/image_optim)
+[![Code Climate](https://img.shields.io/codeclimate/github/toy/image_optim.svg?style=flat)](https://codeclimate.com/github/toy/image_optim)
+[![Code Climate Coverage](https://img.shields.io/codeclimate/coverage/github/toy/image_optim.svg?style=flat)](https://codeclimate.com/github/toy/image_optim)
+[![Dependency Status](https://img.shields.io/gemnasium/toy/image_optim.svg?style=flat)](https://gemnasium.com/toy/image_optim)
+[![Inch CI](http://inch-ci.org/github/toy/image_optim.svg?branch=master&style=flat)](http://inch-ci.org/github/toy/image_optim)
+
+# image_optim
+
+Optimize (lossless compress, optionally lossy) images (jpeg, png, gif, svg) using external utilities:
+
+* [advpng](http://advancemame.sourceforge.net/doc-advpng.html) from [AdvanceCOMP](http://advancemame.sourceforge.net/comp-readme.html)
+(will use [zopfli](https://code.google.com/p/zopfli/) on default/maximum level 4)
+* [gifsicle](http://www.lcdf.org/gifsicle/)
+* [jhead](http://www.sentex.net/~mwandel/jhead/)
+* [jpegoptim](http://www.kokkonen.net/tjko/projects.html)
+* [jpeg-recompress](https://github.com/danielgtaylor/jpeg-archive#jpeg-recompress)
+* jpegtran from [Independent JPEG Group's JPEG library](http://www.ijg.org/)
+* [optipng](http://optipng.sourceforge.net/)
+* [pngcrush](http://pmt.sourceforge.net/pngcrush/)
+* [pngout](http://www.advsys.net/ken/util/pngout.htm)
+* [pngquant](http://pngquant.org/)
+* [svgo](https://github.com/svg/svgo)
+
+Based on [ImageOptim.app](http://imageoptim.com/).
+
+Documentation for [latest version](http://rubydoc.info/gems/image_optim/frames) and [master](http://rubydoc.info/github/toy/image_optim/master/frames).
+
+## Gem installation
+
+```sh
+gem install image_optim
+```
+
+You may also want to install [`image_optim_pack`](https://github.com/toy/image_optim_pack) (see [Binaries pack](#binaries-pack)).
+
+```sh
+gem install image_optim_pack
+```
+
+### Bundler
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'image_optim'
+```
+
+With `image_optim_pack`:
+
+```ruby
+gem 'image_optim'
+gem 'image_optim_pack'
+```
+
+With version:
+
+```ruby
+gem 'image_optim', '~> 0.11'
+```
+
+If you want to check latest changes:
+
+```ruby
+gem 'image_optim', :git => 'git://github.com/toy/image_optim.git'
+```
+
+## Binaries location
+
+Simplest way for `image_optim` to locate binaries is to install them in common location present in `PATH` (see [Binaries installation](#binaries-installation)).
+
+If you cannot install to common location, then install to custom one and add it to `PATH`.
+
+Specify custom bin location using `XXX_BIN` environment variable (`JPEGOPTIM_BIN`, `OPTIPNG_BIN`, …).
+
+Besides permanently setting environment variables in `~/.profile`, `~/.bash_profile`, `~/.bashrc`, `~/.zshrc`, … they can be set:
+
+* before command:
+
+  `PATH="/custom/location:$PATH" image_optim *.jpg`
+
+  for example:
+
+  `PATH="/Applications/ImageOptim.app/Contents/MacOS:$PATH" image_optim *.jpg`
+
+* inside script:
+
+  `ENV['PATH'] = "/custom/location:#{ENV['PATH']}"; ImageOptim.optimize_images([…])`
+
+  for example:
+
+  `ENV['PATH'] = "/Applications/ImageOptim.app/Contents/MacOS:#{ENV['PATH']}"; ImageOptim.optimize_images([…])`
+
+## Binaries installation
+
+### Binaries pack
+
+Easiest way to get latest versions of most binaries for `image_optim` for Linux and Mac OS X is by installing [`image_optim_pack`](https://github.com/toy/image_optim_pack) gem.
+
+Check installation instructions in [Gem installation](#gem-installation) section.
+
+Pack doesn't include `pngout` and `svgo` binaries, their installation instructions are provided below.
+
+### Linux - Debian/Ubuntu
+
+```bash
+sudo apt-get install -y advancecomp gifsicle jhead jpegoptim libjpeg-progs optipng pngcrush pngquant
+```
+
+If you get an old version of `pngquant`, please check how to install up-to-date version or compile from source at [http://pngquant.org/](http://pngquant.org/).
+
+### Linux - RHEL/Fedora/Centos
+
+```bash
+sudo yum install -y advancecomp gifsicle jhead libjpeg optipng pngquant
+```
+
+You may also need to install `libjpeg-turbo-utils` instead of `libjpeg`:
+
+```bash
+sudo yum install -y libjpeg-turbo-utils
+```
+
+You will also need to install `jpegoptim` and `pngcrush` from source:
+
+#### jpegoptim
+
+Replace `X.Y.Z` with latest version number from http://www.kokkonen.net/tjko/projects.html#jpegoptim.
+
+```bash
+JPEGOPTIM_VERSION=X.Y.Z
+cd /tmp
+curl -O http://www.kokkonen.net/tjko/src/jpegoptim-$JPEGOPTIM_VERSION.tar.gz
+tar zxf jpegoptim-$JPEGOPTIM_VERSION.tar.gz
+cd jpegoptim-$JPEGOPTIM_VERSION
+./configure && make && make install
+```
+
+#### pngcrush
+
+Replace `X.Y.Z` with latest version number from http://sourceforge.net/projects/pmt/files/pngcrush/.
+
+```bash
+PNGCRUSH_VERSION=X.Y.Z
+cd /tmp
+curl -O http://iweb.dl.sourceforge.net/project/pmt/pngcrush/$PNGCRUSH_VERSION/pngcrush-$PNGCRUSH_VERSION.tar.gz
+tar zxf pngcrush-$PNGCRUSH_VERSION.tar.gz
+cd pngcrush-$PNGCRUSH_VERSION
+make && cp -f pngcrush /usr/local/bin
+```
+
+### OS X: Macports
+
+```bash
+sudo port install advancecomp gifsicle jhead jpegoptim jpeg optipng pngcrush pngquant
+```
+
+### OS X: Brew
+
+```bash
+brew install advancecomp gifsicle jhead jpegoptim jpeg optipng pngcrush pngquant
+```
+
+### pngout installation (optional)
+
+You can install `pngout` by downloading and installing the [binary versions](http://www.jonof.id.au/kenutils).
+
+_Note: pngout is free to use even in commercial soft, but you can not redistribute, repackage or reuse it without consent and agreement of creator. [license](http://advsys.net/ken/utils.htm#pngoutkziplicense)_
+
+### svgo installation (optional)
+
+`svgo` is available from NPM.
+
+```bash
+npm install -g svgo
+```
+
+### jpeg-recompress installation (optional)
+
+Download and install the `jpeg-recompress` binary from the [JPEG-Archive Releases](https://github.com/danielgtaylor/jpeg-archive/releases) page,
+or follow the instructions to [build from source](https://github.com/danielgtaylor/jpeg-archive#building).
+
+## Usage
+
+### From shell
+
+```sh
+image_optim *.{jpg,png,gif,svg}
+
+image_optim -r .
+
+image_optim -h
+```
+
+### From ruby
+
+Initialize optimizer (or you can call optimization methods directly on `ImageOptim`):
+
+```ruby
+image_optim = ImageOptim.new
+
+image_optim = ImageOptim.new(:pngout => false)
+
+image_optim = ImageOptim.new(:nice => 20)
+```
+
+Optimize image getting temp path:
+
+```ruby
+image_optim.optimize_image('a.png')
+```
+
+Optimize image in place:
+
+```ruby
+image_optim.optimize_image!('b.jpg')
+```
+
+Optimize image data:
+
+```ruby
+image_optim.optimize_image_data(data)
+```
+
+Multiple images:
+
+```ruby
+image_optim.optimize_images(Dir['*.png']) do |unoptimized, optimized|
+  if optimized
+    puts "#{unoptimized} => #{optimized}"
+  end
+end
+
+image_optim.optimize_images!(Dir['*.*'])
+
+image_optim.optimize_images_data(datas)
+```
+
+### From rails
+
+`ImageOptim::Railtie` will automatically register sprockets preprocessor unless you set `config.assets.image_optim = false` or `config.assets.compress = false` (later for partial rails 3 compatibility).
+
+You can provide options for image_optim used for preprocessor through config `config.assets.image_optim = {nice: 20, svgo: false}` (ruby1.8 style: `{:nice => 20, :svgo => false}`).
+Check available options in [options section](#options).
+
+Image optimization can be time consuming, so depending on your deployment process you may prefer to optimize original asset files.
+
+## Configuration
+
+Configuration in YAML format will be read and prepended to options from two paths:
+
+* `$XDG_CONFIG_HOME/image_optim.yml` (by default `~/.config/image_optim.yml`)
+* `.image_optim.yml` in current working directory
+
+Paths can be changed using `:config_paths` option and `--config-paths` argument.
+
+Example configuration:
+
+```yaml
+nice: 20
+pngout: false # disable
+optipng:
+  level: 5
+```
+
+## Options
+
+* `:nice` — Nice level *(defaults to `10`)*
+* `:threads` — Number of threads or disable *(defaults to number of processors)*
+* `:verbose` — Verbose output *(defaults to `false`)*
+* `: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 *(defaults to `nil`)*
+* `:skip_missing_workers` — Skip workers with missing or problematic binaries *(defaults to `false`)*
+* `:allow_lossy` — Allow lossy workers and optimizations *(defaults to `false`)*
+
+Worker can be disabled by passing `false` instead of options hash or by setting option `:disable` to `true`.
+
+<!---<worker-options>-->
+<!-- markdown for worker options is generated by `script/update_worker_options_in_readme` -->
+
+### :advpng =>
+* `:level` — Compression level: `0` - don't compress, `1` - fast, `2` - normal, `3` - extra, `4` - extreme *(defaults to `4`)*
+
+### :gifsicle =>
+* `:interlace` — Interlace: `true` - interlace on, `false` - interlace off, `nil` - as is in original image (defaults to running two instances, one with interlace off and one with on)
+* `:level` — Compression level: `1` - light and fast, `2` - normal, `3` - heavy (slower) *(defaults to `3`)*
+* `:careful` — Avoid bugs with some software *(defaults to `false`)*
+
+### :jhead =>
+Worker has no options
+
+### :jpegoptim =>
+* `:strip` — List of extra markers to strip: `:comments`, `:exif`, `:iptc`, `:icc` or `:all` *(defaults to `:all`)*
+* `:max_quality` — Maximum image quality factor `0`..`100`, ignored in default/lossless mode *(defaults to `100`)*
+
+### :jpegrecompress =>
+* `:quality` — JPEG quality preset: `0` - low, `1` - medium, `2` - high, `3` - veryhigh *(defaults to `3`)*
+
+### :jpegtran =>
+* `:copy_chunks` — Copy all chunks *(defaults to `false`)*
+* `:progressive` — Create progressive JPEG file *(defaults to `true`)*
+* `:jpegrescan` — Use jpegtran through jpegrescan, ignore progressive option *(defaults to `false`)*
+
+### :optipng =>
+* `:level` — Optimization level preset: `0` is least, `7` is best *(defaults to `6`)*
+* `:interlace` — Interlace: `true` - interlace on, `false` - interlace off, `nil` - as is in original image *(defaults to `false`)*
+* `:strip` — Remove all auxiliary chunks *(defaults to `true`)*
+
+### :pngcrush =>
+* `:chunks` — List of chunks to remove or `:alla` - all except tRNS/transparency or `:allb` - all except tRNS and gAMA/gamma *(defaults to `:alla`)*
+* `:fix` — Fix otherwise fatal conditions such as bad CRCs *(defaults to `false`)*
+* `:brute` — Brute force try all methods, very time-consuming and generally not worthwhile *(defaults to `false`)*
+* `:blacken` — Blacken fully transparent pixels *(defaults to `true`)*
+
+### :pngout =>
+* `:copy_chunks` — Copy optional chunks *(defaults to `false`)*
+* `:strategy` — Strategy: `0` - xtreme, `1` - intense, `2` - longest Match, `3` - huffman Only, `4` - uncompressed *(defaults to `0`)*
+
+### :pngquant =>
+* `:quality` — min..max - don't save below min, use less colors below max (both in range `0..100`; in yaml - `!ruby/range 0..100`), ignored in default/lossless mode *(defaults to `100..100`)*
+* `:speed` — speed/quality trade-off: `1` - slow, `3` - default, `11` - fast & rough *(defaults to `3`)*
+
+### :svgo =>
+* `disable_plugins` - List of plugins to disable *(defaults to none)*
+* `enable_plugins` - List of plugins to enable *(defaults to none)*
+
+<!---</worker-options>-->
+
+## Contributing
+
+[List](https://github.com/toy/image_optim/graphs/contributors) of contributors to `image_optim`.
+
+If you would like to contribute - that is great and you are very welcome. Please check few notes in file [CONTRIBUTING.markdown](CONTRIBUTING.markdown).
+
+Financial contributions can be made via [gratipay](https://gratipay.com/toy/).
+
+[![Support via Gratipay](https://cdn.rawgit.com/gratipay/gratipay-badge/2.1.2/dist/gratipay.png)](https://gratipay.com/toy/)
+
+## ChangeLog
+
+In separate file [CHANGELOG.markdown](CHANGELOG.markdown).
+
+## Copyright
+
+Copyright (c) 2012-2015 Ivan Kuchin. See [LICENSE.txt](LICENSE.txt) for details.

data/Vagrantfile

@@ -0,0 +1,33 @@
+VAGRANTFILE_API_VERSION = '2'
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  config.vm.box = 'ubuntu/trusty64'
+
+  config.vm.provision 'shell', :inline => <<-SH
+    set -e
+
+    cd /vagrant
+
+    echo 'Install git, node, npm, imagemagick...'
+    apt-get install -y git npm nodejs-legacy imagemagick > /dev/null
+
+    echo 'Update rubygems...'
+    REALLY_GEM_UPDATE_SYSTEM=x gem update --system > /dev/null
+
+    echo 'Install bundler...'
+    gem install bundler > /dev/null
+
+    echo 'Install svgo...'
+    npm install -g -q svgo > /dev/null
+
+    echo 'Install pngout...'
+    curl -s \
+      'http://static.jonof.id.au/dl/kenutils/pngout-20130221-linux.tar.gz' | \
+      tar -xz -C /usr/local/bin --strip-components 2 \
+      --wildcards '*/x86_64/pngout'
+
+    echo 'Bundle...'
+    bundle install --jobs=3 --quiet
+    bundle list
+  SH
+end

data/bin/image_optim

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'image_optim/runner'
+require 'image_optim/runner/option_parser'
+
+args = ARGV.dup
+
+options = ImageOptim::Runner::OptionParser.parse!(args)
+
+begin
+  if options[:verbose]
+    $stderr.puts ImageOptim.full_version
+  end
+
+  only_info = options.delete(:only_info)
+  runner = ImageOptim::Runner.new(options)
+  unless only_info
+    abort 'specify paths to optimize' if args.empty?
+    abort unless runner.run!(args)
+  end
+rescue => e
+  if options[:verbose]
+    abort "#{e}\n#{e.backtrace.join("\n")}"
+  else
+    abort e.to_s
+  end
+end

data/image_optim.gemspec

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+Gem::Specification.new do |s|
+  s.name        = 'openstreetmap-image_optim'
+  s.version     = '0.21.0.1'
+  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.add_dependency 'fspath', '~> 2.1'
+  s.add_dependency 'image_size', '~> 1.3'
+  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'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9.3')
+    s.add_development_dependency 'rubocop', '~> 0.27', '!= 0.30.1'
+  end
+end

data/lib/image_optim.rb

@@ -0,0 +1,228 @@
+require 'image_optim/bin_resolver'
+require 'image_optim/config'
+require 'image_optim/handler'
+require 'image_optim/image_meta'
+require 'image_optim/image_path'
+require 'image_optim/railtie' if defined?(Rails)
+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
+
+  # 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
+    ].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
+
+    log_workers_by_format if verbose
+
+    config.assert_no_unused_options!
+  end
+
+  # Get workers for image
+  def workers_for_image(path)
+    @workers_by_format[ImagePath.convert(path).format]
+  end
+
+  # Optimize one file, return new path as OptimizedImagePath or nil if
+  # optimization failed
+  def optimize_image(original)
+    original = ImagePath.convert(original)
+    return unless (workers = workers_for_image(original))
+    result = Handler.for(original) do |handler|
+      workers.each do |worker|
+        handler.process do |src, dst|
+          worker.optimize(src, dst)
+        end
+      end
+    end
+    return unless result
+    ImagePath::Optimized.new(result, original)
+  end
+
+  # Optimize one file in place, return original as OptimizedImagePath or nil if
+  # optimization failed
+  def optimize_image!(original)
+    original = ImagePath.convert(original)
+    return unless (result = optimize_image(original))
+    result.replace(original)
+    ImagePath::Optimized.new(original, result.original_size)
+  end
+
+  # Optimize image data, return new data or nil if optimization failed
+  def optimize_image_data(original_data)
+    image_meta = ImageMeta.for_data(original_data)
+    return unless image_meta && image_meta.format
+    ImagePath.temp_file %W[image_optim .#{image_meta.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
+
+  # Optimization methods with default options
+  def self.method_missing(method, *args, &block)
+    if method_defined?(method) && method.to_s =~ /^optimize_image/
+      new.send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  # Version of image_optim gem spec loaded
+  def self.version
+    Gem.loaded_specs['image_optim'].version.to_s rescue 'DEV'
+  end
+
+  # Full version of image_optim
+  def self.full_version
+    "image_optim v#{version}"
+  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
+        block.call(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