image_optim_pack 0.1.0

data/image_optim_pack.gemspec

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+Gem::Specification.new do |s|
+  s.name        = 'image_optim_pack'
+  s.version     = '0.1.0'
+  s.summary     = %q{Precompiled binaries for image_optim: advpng, gifsicle, jhead, jpegoptim, jpegtran, optipng, pngcrush, pngquant}
+  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 'image_optim', '~> 0.18'
+  s.add_dependency 'fspath', '~> 2.1'
+
+  s.add_development_dependency 'versionomy', '~> 0.4.4'
+  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.26.0'
+  end
+end

data/lib/image_optim/pack.rb

@@ -0,0 +1,110 @@
+require 'fspath'
+require 'image_optim/bin_resolver/bin'
+
+class ImageOptim
+  # Handle selection of directory with binaries most suitable for current
+  # operating system and architecture
+  module Pack
+    # Path to binary, last two parts are expect to be os/arch
+    class Path
+      # Path provided to initialize as FSPath
+      attr_reader :path
+
+      # Intended os
+      attr_reader :os
+
+      # Inteded architecture
+      attr_reader :arch
+
+      # Receive path, use last part for arch and last but one part for os
+      def initialize(path)
+        @path = FSPath(path)
+        @os = @path.dirname.basename.to_s
+        @arch = @path.basename.to_s
+      end
+
+      # Return path converted to string
+      def to_s
+        path.to_s
+      end
+
+      # Cached array of BinResolver::Bin instances for each bin
+      def bins
+        @bins ||= bin_paths.map do |bin_path|
+          BinResolver::Bin.new(bin_path.basename.to_s, bin_path.to_s)
+        end
+      end
+
+      # Return true if all bins can execute and return version
+      def all_bins_working?
+        bins.all?(&:version)
+      end
+
+      # Return true if all bins can't execute and return version
+      def all_bins_failing?
+        bins.none?(&:version)
+      end
+
+      # List of bins which can execute and return version
+      def working_bins
+        bins.select(&:version)
+      end
+
+      # List of bins which can't execute and return version
+      def failing_bins
+        bins.reject(&:version)
+      end
+
+    private
+
+      # All children except those starting with 'lib'
+      def bin_paths
+        path.children.reject{ |child| child.basename.to_s =~ /^lib/ }
+      end
+    end
+
+    # downcased `uname -s`
+    OS = `uname -s`.strip.downcase
+
+    # downcased `uname -m`
+    ARCH = `uname -m`.strip.downcase
+
+    # Path to vendor at root of image_optim_pack
+    VENDOR_PATH = FSPath('../../../vendor').expand_path(__FILE__)
+
+    # List of paths
+    PATHS = VENDOR_PATH.glob('*/*').map{ |path| Path.new(path) }
+
+    class << self
+      # Return path to directory with binaries
+      # Yields debug messages if block given
+      def path
+        ordered_by_os_arch_match.find do |path|
+          yield "image_optim_pack: #{debug_message(path)}" if block_given?
+          path.all_bins_working?
+        end
+      end
+
+    private
+
+      # Order by match of os and architecture
+      def ordered_by_os_arch_match
+        PATHS.sort_by do |path|
+          [path.os == OS ? 0 : 1, path.arch == ARCH ? 0 : 1]
+        end
+      end
+
+      # Messages based on success of getting versions of bins
+      def debug_message(path)
+        case
+        when path.all_bins_working?
+          "all bins from #{path} worked"
+        when path.all_bins_failing?
+          "all bins from #{path} failed"
+        else
+          "#{path.failing_bins.map(&:name).join(', ')} from #{path} failed"
+        end
+      end
+    end
+  end
+end

data/lib/image_optim_pack.rb

@@ -0,0 +1 @@
+require 'image_optim/pack'

data/script/livecheck

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'uri'
+require 'net/http'
+require 'versionomy'
+
+bare = ARGV.delete('--bare')
+
+unless [1, 2].include?(ARGV.length)
+  abort 'expected project name and optional current version'
+end
+
+def version(string)
+  Versionomy.parse(string)
+end
+
+name = ARGV[0].downcase
+config = YAML.load(DATA)[name]
+abort "Livecheck for #{name} was not defined" unless config
+
+uri = URI(config['url'])
+version_regex = Regexp.new(config['regexp'])
+current_version = ARGV[1] && version(ARGV[1])
+
+data = Net::HTTP.get(uri)
+versions = data.scan(version_regex).uniq.map{ |match| version(match[0]) }
+abort 'No versions found' if versions.empty?
+
+latest_version = versions.max
+case
+when bare
+  print latest_version
+when current_version
+  if latest_version > current_version
+    puts "#{name} #{latest_version} > #{current_version}"
+  end
+else
+  puts "#{name} #{latest_version}"
+end
+
+__END__
+advancecomp:
+  url: http://sourceforge.net/projects/advancemame/rss?path=/advancecomp
+  regexp: /advancecomp/(\d+(?:\.\d+)*)/
+gifsicle:
+  url: http://www.lcdf.org/gifsicle/
+  regexp: gifsicle-(\d+(?:\.\d+)*)\.tar\.gz
+jhead:
+  url: http://www.sentex.net/~mwandel/jhead/
+  regexp: jhead-(\d+(?:\.\d+)*)
+jpegoptim:
+  url: http://www.kokkonen.net/tjko/src/
+  regexp: jpegoptim-(\d+(?:\.\d+)*)
+libjpeg:
+  url: http://www.ijg.org/files/
+  regexp: jpegsrc.v(.*?).tar.gz
+libpng:
+  url: http://sourceforge.net/projects/libpng/rss
+  regexp: /libpng\d*/(\d+(?:\.\d+)*)/
+libz:
+  url: http://sourceforge.net/projects/libpng/rss?path=/zlib
+  regexp: /zlib/(\d+(?:\.\d+)*)/
+optipng:
+  url: http://sourceforge.net/projects/optipng/rss
+  regexp: /OptiPNG/optipng-(\d+(?:\.\d+)*)/
+pngcrush:
+  url: http://sourceforge.net/projects/pmt/rss?path=/pngcrush
+  regexp: /pngcrush/(\d+(?:\.\d+)*)/
+pngquant:
+  url: http://pngquant.org/releases.html
+  regexp: pngquant-([0-9.]+)-src.tar.bz2

data/script/run

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+set -xe
+
+MAKE_COMMAND='make all -j'
+
+for arg in "$@"; do
+  if [[ "$arg" =~ ^([A-Z_]+)=(.*)$ ]]; then
+    eval "$(printf %q=%q "${BASH_REMATCH[1]}" "${BASH_REMATCH[2]}")"
+  fi
+done
+
+if [ "$(uname -s | tr A-Z a-z)" != 'darwin' ]; then
+  echo 'expected to run on Mac OS X'
+  exit 1
+fi
+
+for arch in i386 x86_64; do
+  $MAKE_COMMAND ARCH=$arch
+done
+
+for vm in linux_{i686,x86_64}; do
+  vagrant up $vm
+  vagrant ssh $vm -c "cd /vagrant; $MAKE_COMMAND"
+  [ -n "$NO_HALT" ] || vagrant halt
+done

data/script/update_versions

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'English'
+
+tty = $stdout.tty?
+
+ARGF.each do |line|
+  if (name = line[/^([A-Z]+)_VER *:= *.*/, 1])
+    $stderr << name << ' := ' unless tty
+    latest_version = `script/livecheck --bare #{name}`.strip
+    abort unless $CHILD_STATUS.success?
+    $stderr << latest_version << "\n" unless tty
+    $stdout << "#{name}_VER := #{latest_version}\n"
+  else
+    $stdout << line
+  end
+end

data/script/vm_init

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+present(){
+  local missing=0
+  for name in "$@"; do
+    if command -v "$name" >/dev/null 2>&1; then
+      echo "got $name"
+    else
+      echo "no $name"
+      missing=1
+    fi
+  done
+  [ $missing -eq 0 ] || return 127
+}
+
+if ! present make wget gcc g++ chrpath perl pkg-config automake; then
+  if present apt-get; then
+    apt-get -y install make wget gcc g++ chrpath perl pkg-config automake
+  elif present yum; then
+    yum -y install make wget gcc gcc-c++ chrpath perl pkg-config automake
+  else
+    echo 'unknown package manager'
+    exit 1
+  fi
+fi
+
+if ! make --version 2>&1 | grep -q 'GNU Make'; then
+  echo 'non gnu make'
+  exit 1
+fi

data/spec/image_optim/pack_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'image_optim/pack'
+
+describe ImageOptim::Pack do
+  before do
+    stub_const('Pack', ImageOptim::Pack)
+    stub_const('Path', Pack::Path)
+  end
+
+  describe :path do
+    it 'returns path' do
+      expect(Pack.path).to be
+    end
+
+    it 'returns instance of Path' do
+      expect(Pack.path).to be_an(Path)
+    end
+
+    it 'yields debug messages' do
+      expect{ |block| Pack.path(&block) }.
+        to yield_with_args(/^image_optim_pack: all bins .* worked$/)
+    end
+  end
+
+  describe ImageOptim::Pack::Path do
+    describe :path do
+      it 'returns FSPath with path' do
+        expect(Path.new('path').path).to eq(FSPath('path'))
+      end
+    end
+
+    describe :to_s do
+      it 'returns stringified path' do
+        expect(Path.new(Pathname('path')).to_s).to eq('path')
+      end
+    end
+
+    describe :os do
+      it 'returns last but one part of path' do
+        expect(Path.new('path/futureos/Kqbit').os).to eq('futureos')
+      end
+    end
+
+    describe :arch do
+      it 'returns last but one part of path' do
+        expect(Path.new('path/futureos/Kqbit').arch).to eq('Kqbit')
+      end
+    end
+
+    describe :bins do
+      subject{ Pack.path.bins }
+
+      define :be_non_libraries do
+        match do |bin|
+          bin.name !~ /^lib/
+        end
+      end
+
+      it{ should be_an(Array) }
+
+      it{ should_not be_empty }
+
+      it{ should all(be_an(ImageOptim::BinResolver::Bin)) }
+
+      it{ should all(have_attributes(:version => be)) }
+
+      it{ should all(be_non_libraries) }
+    end
+
+    describe 'bin helpers' do
+      def bins_with_versions(*versions)
+        versions.map do |version|
+          double(:version => version, :inspect => version ? 'good' : 'bad')
+        end
+      end
+
+      def path_with_bins(*bins)
+        path = Path.new('path')
+        allow(path).to receive(:bins).and_return(bins)
+        path
+      end
+
+      describe 'all good bins' do
+        let(:bins){ bins_with_versions('1.3', '6.1.6') }
+        subject{ path_with_bins(*bins) }
+
+        it{ should be_all_bins_working }
+        it{ should_not be_all_bins_failing }
+        it{ should have_attributes(:working_bins => eq(bins)) }
+        it{ should have_attributes(:failing_bins => be_empty) }
+      end
+
+      describe 'mixed good/bad bins' do
+        let(:bins){ bins_with_versions('1.3', nil, '6.1.6', nil) }
+        subject{ path_with_bins(*bins) }
+
+        it{ should_not be_all_bins_working }
+        it{ should_not be_all_bins_failing }
+        it{ should have_attributes(:working_bins => bins.select(&:version)) }
+        it{ should have_attributes(:failing_bins => bins.reject(&:version)) }
+      end
+
+      describe 'all bad bins' do
+        let(:bins){ bins_with_versions(nil, nil) }
+        subject{ path_with_bins(*bins) }
+
+        it{ should_not be_all_bins_working }
+        it{ should be_all_bins_failing }
+        it{ should have_attributes(:working_bins => be_empty) }
+        it{ should have_attributes(:failing_bins => eq(bins)) }
+      end
+    end
+  end
+end

data/spec/image_optim_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'image_optim'
+require 'image_optim/cmd'
+require 'tempfile'
+require 'English'
+
+describe ImageOptim do
+  def self.temp_copy(image)
+    image.temp_path.tap{ |path| image.copy(path) }
+  end
+
+  before do
+    stub_const('Cmd', ImageOptim::Cmd)
+  end
+
+  def flatten_animation(image)
+    if image.format == :gif
+      flattened = image.temp_path
+      flatten_command = %W[
+        convert
+        #{image.to_s.shellescape}
+        -coalesce
+        -append
+        #{flattened.to_s.shellescape}
+      ].join(' ')
+      expect(Cmd.run(flatten_command)).to be_truthy
+      flattened
+    else
+      image
+    end
+  end
+
+  def nrmse(image_a, image_b)
+    coalesce_a = flatten_animation(image_a)
+    coalesce_b = flatten_animation(image_b)
+    nrmse_command = %W[
+      compare
+      -metric RMSE
+      #{coalesce_a.to_s.shellescape}
+      #{coalesce_b.to_s.shellescape}
+      /dev/null
+      2>&1
+    ].join(' ')
+    output = Cmd.capture(nrmse_command)
+    if [0, 1].include?($CHILD_STATUS.exitstatus)
+      output[/\((\d+(\.\d+)?)\)/, 1].to_f
+    else
+      fail "compare #{image_a} with #{image_b} failed with `#{output}`"
+    end
+  end
+
+  define :have_same_data_as do |expected|
+    match{ |actual| actual.binread == expected.binread }
+  end
+
+  define :have_size do
+    match(&:size?)
+  end
+
+  define :be_smaller_than do |expected|
+    match{ |actual| actual.size < expected.size }
+  end
+
+  define :be_pixel_identical_to do |expected|
+    match do |actual|
+      @diff = nrmse(actual, expected)
+      @diff == 0
+    end
+    failure_message do |actual|
+      "expected #{actual} to be pixel identical to #{expected}, got "\
+          "normalized root-mean-square error of #{@diff}"
+    end
+  end
+
+  image_optim = ImageOptim.new
+
+  # grab images from image_optim gem
+  image_optim_root = Gem.loaded_specs['image_optim'].gem_dir
+  images_dir = ImageOptim::ImagePath.new(image_optim_root) / 'spec/images'
+  test_images = images_dir.glob('**/*.*')
+
+  # select images which for which there are workers
+  test_images = test_images.select do |image|
+    image_optim.workers_for_image(image)
+  end
+
+  rotated = images_dir / 'orient/original.jpg'
+  rotate_images = images_dir.glob('orient/?.jpg')
+
+  copies = test_images.map{ |image| temp_copy(image) }
+  original_by_copy = Hash[copies.zip(test_images)]
+
+  image_optim.optimize_images(copies) do |copy, optimized|
+    fail 'expected copy to not be nil' if copy.nil?
+    original = original_by_copy[copy]
+
+    it "optimizes #{original}" do
+      expect(copy).to have_same_data_as(original)
+
+      expect(optimized).not_to be_nil
+      expect(optimized).to have_size
+      expect(optimized).to be_smaller_than(original)
+      expect(optimized).not_to have_same_data_as(original)
+
+      compare_to = rotate_images.include?(original) ? rotated : original
+      expect(optimized).to be_pixel_identical_to(compare_to)
+    end
+  end
+end