image_optim 0.6.0 → 0.7.0

data/lib/image_optim/worker.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 
 require 'shellwords'
+
 require 'image_optim'
 
 class ImageOptim
@@ -16,12 +17,6 @@ class ImageOptim
         klasses << base
       end
 
-      # List of formats which worker can optimize
-      def image_formats
-        format_from_name = name.downcase[/gif|jpeg|png/]
-        format_from_name ? [format_from_name.to_sym] : []
-      end
-
       # Undercored class name
       def underscored_name
         @underscored_name ||= name.split('::').last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
@@ -30,59 +25,51 @@ class ImageOptim
 
     include OptionHelpers
 
-    # Binary name or path
-    attr_reader :bin
-
-    # Binary name or path
-    attr_reader :nice
-
-    # Be verbose
-    attr_reader :verbose
-
-    # Configure (raises on extra options), find binary (raises if not found)
-    def initialize(options = {})
-      get_option!(options, :bin, default_bin)
-      get_option!(options, :nice, 10){ |v| v.to_i }
-      get_option!(options, :verbose, false)
+    # Configure (raises on extra options)
+    def initialize(image_optim, options = {})
+      @image_optim = image_optim
       parse_options(options)
-      raise BinaryNotFoundError, "`#{bin}` not found" if `which #{bin.to_s.shellescape}`.empty?
       assert_options_empty!(options)
     end
 
-    # Put first in list of workers
-    def run_first?
+    # List of formats which worker can optimize
+    def image_formats
+      format_from_name = self.class.name.downcase[/gif|jpeg|png/]
+      format_from_name ? [format_from_name.to_sym] : []
     end
 
-    # Priority in list of workers
-    def run_priority
-      run_first? ? 0 : 1
+    # Ordering in list of workers
+    def run_order
+      0
     end
 
-    # Optimize file from src to dst, return boolean representing success status
-    def optimize(src, dst)
-      command = [bin, *command_args(src, dst)].map(&:to_s).shelljoin
-      start = Time.now
-      pid = fork do
-        $stdout.reopen('/dev/null', 'w')
-        $stderr.reopen('/dev/null', 'w')
-        Process.setpriority(Process::PRIO_PROCESS, 0, nice)
-        exec command
-      end
-      Process.wait pid
-      duration = Time.now - start
-      if $?.signaled?
-        raise SignalException.new($?.termsig)
-      end
-      success = $?.success? && dst.size? && dst.size < src.size
-      if verbose
-        print "#{success ? '✓' : '✗'} #{duration}s #{command}\n"
-      end
-      success
+    # Check if operation resulted in optimized file
+    def optimized?(src, dst)
+      dst.size? && dst.size < src.size
     end
 
-    # Name of binary determined from class name
-    def default_bin
-      self.class.underscored_name
+  private
+
+    # Forward bin resolving to image_optim
+    def resolve_bin!(bin)
+      @image_optim.resolve_bin!(bin)
+    end
+
+    # Run command setting priority and hiding output
+    def execute(bin, *arguments)
+      resolve_bin!(bin)
+
+      command = [bin, *arguments].map(&:to_s).shelljoin
+      env_path = "#{@image_optim.resolve_dir}:#{ENV['PATH']}"
+      start = Time.now
+
+      system "env PATH=#{env_path.shellescape} nice -n #{@image_optim.nice} #{command} >& /dev/null"
+
+      raise SignalException.new($?.termsig) if $?.signaled?
+
+      $stderr << "#{$?.success? ? '✓' : '✗'} #{Time.now - start}s #{command}\n" if @image_optim.verbose?
+
+      $?.success?
     end
   end
 end

data/lib/image_optim/worker/advpng.rb

@@ -0,0 +1,22 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Advpng < Worker
+      # Compression level: 0 - don't compress, 1 - fast, 2 - normal, 3 - extra, 4 - extreme (defaults to 4)
+      attr_reader :level
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[-#{level} -z -q -- #{dst}]
+        execute(:advpng, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :level, 4){ |v| limit_with_range(v.to_i, 0..4) }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/gifsicle.rb

@@ -0,0 +1,22 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Gifsicle < Worker
+      # Turn on interlacing (defaults to false)
+      attr_reader :interlace
+
+      def optimize(src, dst)
+        args = %W[-o #{dst} -O3 --no-comments --no-names --same-delay --same-loopcount --no-warnings -- #{src}]
+        args.unshift('-i') if interlace
+        execute(:gifsicle, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :interlace, false){ |v| !!v }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jpegoptim.rb

@@ -0,0 +1,41 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Jpegoptim < Worker
+      # List of extra markers to strip: comments, exif, iptc, icc (defaults to 'all')
+      attr_reader :strip
+
+      # Maximum image quality factor (defaults to 100)
+      attr_reader :max_quality
+
+      # Run first if max_quality < 100
+      def run_order
+        max_quality < 100 ? -1 : 0
+      end
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[-q -- #{dst}]
+        strip.each do |strip_marker|
+          args.unshift "--strip-#{strip_marker}"
+        end
+        args.unshift "-m#{max_quality}" if max_quality < 100
+        execute(:jpegoptim, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :strip, :all) do |v|
+          markers = Array(v).map(&:to_s)
+          possible_markers = %w[all comments exif iptc icc]
+          unknown_markers = markers - possible_markers
+          warn "Unknown markers for jpegoptim: #{unknown_markers.join(', ')}" unless unknown_markers.empty?
+          markers & possible_markers
+        end
+        get_option!(options, :max_quality, 100){ |v| v.to_i }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/jpegtran.rb

@@ -0,0 +1,27 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Jpegtran < Worker
+      # Copy all chunks or none (defaults to false)
+      attr_reader :copy_chunks
+
+      # Create progressive JPEG file (defaults to true)
+      attr_reader :progressive
+
+      def optimize(src, dst)
+        args = %W[-optimize -outfile #{dst} #{src}]
+        args.unshift '-copy', copy_chunks ? 'all' : 'none'
+        args.unshift '-progressive' if progressive
+        execute(:jpegtran, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :copy_chunks, false){ |v| !!v }
+        get_option!(options, :progressive, true){ |v| !!v }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/optipng.rb

@@ -0,0 +1,27 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Optipng < Worker
+      # Optimization level preset 0..7 (0 is least, 7 is best, defaults to 6)
+      attr_reader :level
+
+      # Interlace, true - interlace on, false - interlace off, nil - as is in original image (defaults to false)
+      attr_reader :interlace
+
+      def optimize(src, dst)
+        src.copy(dst)
+        args = %W[-o#{level} -quiet -- #{dst}]
+        args.unshift "-i#{interlace ? 1 : 0}" unless interlace.nil?
+        execute(:optipng, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :level, 6){ |v| limit_with_range(v.to_i, 0..7) }
+        get_option!(options, :interlace, false){ |v| v && true }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/pngcrush.rb

@@ -0,0 +1,39 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Pngcrush < Worker
+      # List of chunks to remove or 'alla' - all except tRNS/transparency or 'allb' - all except tRNS and gAMA/gamma (defaults to 'alla')
+      attr_reader :chunks
+
+      # Fix otherwise fatal conditions such as bad CRCs (defaults to false)
+      attr_reader :fix
+
+      # Brute force try all methods, very time-consuming and generally not worthwhile (defaults to false)
+      attr_reader :brute
+
+      # Always run first
+      def run_order
+        -1
+      end
+
+      def optimize(src, dst)
+        args = %W[-reduce -cc -q -- #{src} #{dst}]
+        chunks.each do |chunk|
+          args.unshift '-rem', chunk
+        end
+        args.unshift '-fix' if fix
+        args.unshift '-brute' if brute
+        execute(:pngcrush, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :chunks, :alla){ |v| Array(v).map(&:to_s) }
+        get_option!(options, :fix, false){ |v| !!v }
+        get_option!(options, :brute, false){ |v| !!v }
+      end
+    end
+  end
+end

data/lib/image_optim/worker/pngout.rb

@@ -0,0 +1,30 @@
+require 'image_optim/worker'
+
+class ImageOptim
+  class Worker
+    class Pngout < Worker
+      # Copy optional chunks (defaults to false)
+      attr_reader :copy_chunks
+
+      # Strategy: 0 - xtreme, 1 - intense, 2 - longest Match, 3 - huffman Only, 4 - uncompressed (defaults to 0)
+      attr_reader :strategy
+
+      # Always run first
+      def run_order
+        -1
+      end
+
+      def optimize(src, dst)
+        args = %W[-k#{copy_chunks ? 1 : 0} -s#{strategy} -q -y #{src} #{dst}]
+        execute(:pngout, *args) && optimized?(src, dst)
+      end
+
+    private
+
+      def parse_options(options)
+        get_option!(options, :copy_chunks, false){ |v| !!v }
+        get_option!(options, :strategy, 0){ |v| limit_with_range(v.to_i, 0..4) }
+      end
+    end
+  end
+end

data/spec/image_optim_spec.rb

@@ -1,116 +1,153 @@
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'rspec'
 require 'image_optim'
+require 'tempfile'
 
-spec_dir = ImageOptim::ImagePath.new(__FILE__).dirname.relative_path_from(Dir.pwd)
-image_dir = spec_dir / 'images'
+TEST_IMAGES = (ImageOptim::ImagePath.new(__FILE__).dirname.relative_path_from(Dir.pwd) / 'images').glob('*')
 
-def temp_copy_path(original)
-  original.class.temp_dir do |dir|
-    temp_path = dir / original.basename
-    original.copy(temp_path)
-    yield temp_path
+Fixnum.class_eval do
+  def in_range?(range)
+    range.include?(self)
   end
 end
 
-class Tempfile
-  alias_method :initialize_orig, :initialize
-
-  def initialize(*args, &block)
-    self.class.initialize_called
-    initialize_orig(*args, &block)
+Tempfile.class_eval do
+  def self.init_count
+    class_variable_get(:@@init_count)
   end
 
-  def self.initialize_called
-    @@call_count ||= 0
-    @@call_count += 1
+  def self.init_count=(value)
+    class_variable_set(:@@init_count, value)
   end
 
-  def self.reset_call_count
-    @@call_count = 0
+  def self.reset_init_count
+    self.init_count = 0
   end
 
-  def self.call_count
-    @@call_count
+  reset_init_count
+
+  alias_method :initialize_orig, :initialize
+  def initialize(*args, &block)
+    self.class.init_count += 1
+    initialize_orig(*args, &block)
   end
 end
 
-Fixnum.class_eval do
-  def in_range?(range)
-    range.include?(self)
+ImageOptim::ImagePath.class_eval do
+  def temp_copy
+    temp_path.tap{ |path| copy(path) }
   end
 end
 
+def with_env(key, value)
+  saved, ENV[key] = ENV[key], value
+  yield
+ensure
+  ENV[key] = saved
+end
+
 describe ImageOptim do
-  image_dir.glob('*') do |original|
-    describe "optimizing #{original}" do
-      it "should optimize image" do
-        temp_copy_path(original) do |unoptimized|
-          Tempfile.reset_call_count
-          io = ImageOptim.new
-          optimized = io.optimize_image(unoptimized)
-          optimized.should be_a(FSPath)
-          unoptimized.read.should == original.read
-          optimized.size.should > 0
-          optimized.size.should < unoptimized.size
-          optimized.read.should_not == unoptimized.read
-          if io.workers_for_image(unoptimized).length > 1
-            Tempfile.call_count.should be_in_range(1..2)
+  describe "isolated" do
+    describe "optimize" do
+      TEST_IMAGES.each do |original|
+        it "should optimize #{original}" do
+          copy = original.temp_copy
+
+          Tempfile.reset_init_count
+          image_optim = ImageOptim.new
+          optimized_image = image_optim.optimize_image(copy)
+          optimized_image.should be_a(ImageOptim::ImagePath)
+          optimized_image.size.should be_in_range(1...original.size)
+          optimized_image.read.should_not == original.read
+          copy.read.should == original.read
+
+          if image_optim.workers_for_image(original).length > 1
+            Tempfile.init_count.should be_in_range(1..2)
           else
-            Tempfile.call_count.should === 1
+            Tempfile.init_count.should === 1
           end
         end
       end
+    end
+
+    describe "optimize in place" do
+      TEST_IMAGES.each do |original|
+        it "should optimize #{original}" do
+          copy = original.temp_copy
 
-      it "should optimize image in place" do
-        temp_copy_path(original) do |path|
-          Tempfile.reset_call_count
-          io = ImageOptim.new
-          io.optimize_image!(path).should be_true
-          path.size.should > 0
-          path.size.should < original.size
-          path.read.should_not == original.read
-          if io.workers_for_image(path).length > 1
-            Tempfile.call_count.should be_in_range(2..3)
+          Tempfile.reset_init_count
+          image_optim = ImageOptim.new
+          image_optim.optimize_image!(copy).should be_true
+          copy.size.should be_in_range(1...original.size)
+          copy.read.should_not == original.read
+
+          if image_optim.workers_for_image(original).length > 1
+            Tempfile.init_count.should be_in_range(2..3)
           else
-            Tempfile.call_count.should === 2
+            Tempfile.init_count.should === 2
           end
         end
       end
+    end
 
-      it "should stop optimizing" do
-        temp_copy_path(original) do |unoptimized|
-          count = (1..10).find do |i|
-            unoptimized = ImageOptim.optimize_image(unoptimized)
-            unoptimized.nil?
+    describe "stop optimizing" do
+      TEST_IMAGES.each do |original|
+        it "should stop optimizing #{original}" do
+          copy = original.temp_copy
+
+          tries = 0
+          10.times do
+            tries += 1
+            break unless ImageOptim.optimize_image!(copy)
           end
-          count.should >= 2
-          count.should < 10
+          tries.should be_in_range(2...3)
         end
       end
     end
   end
 
-  describe "unsupported file" do
+  describe "bunch" do
+    it "should optimize" do
+      copies = TEST_IMAGES.map(&:temp_copy)
+      optimized_images = ImageOptim.optimize_images(copies)
+      TEST_IMAGES.zip(copies, optimized_images).each do |original, copy, optimized_image|
+        optimized_image.should be_a(ImageOptim::ImagePath)
+        optimized_image.size.should be_in_range(1...original.size)
+        optimized_image.read.should_not == original.read
+        copy.read.should == original.read
+      end
+    end
+
+    it "should optimize in place" do
+      copies = TEST_IMAGES.map(&:temp_copy)
+      ImageOptim.optimize_images!(copies)
+      TEST_IMAGES.zip(copies).each do |original, copy|
+        copy.size.should be_in_range(1...original.size)
+        copy.read.should_not == original.read
+      end
+    end
+  end
+
+  describe "unsupported" do
     let(:original){ ImageOptim::ImagePath.new(__FILE__) }
 
     it "should ignore" do
-      temp_copy_path(original) do |unoptimized|
-        Tempfile.reset_call_count
-        optimized = ImageOptim.optimize_image(unoptimized)
-        Tempfile.call_count.should == 0
-        optimized.should be_nil
-        unoptimized.read.should == original.read
-      end
+      copy = original.temp_copy
+
+      Tempfile.reset_init_count
+      optimized_image = ImageOptim.optimize_image(copy)
+      Tempfile.init_count.should == 0
+      optimized_image.should be_nil
+      copy.read.should == original.read
     end
 
     it "should ignore in place" do
-      temp_copy_path(original) do |unoptimized|
-        Tempfile.reset_call_count
-        ImageOptim.optimize_image!(unoptimized).should_not be_true
-        Tempfile.call_count.should == 0
-        unoptimized.read.should == original.read
-      end
+      copy = original.temp_copy
+
+      Tempfile.reset_init_count
+      ImageOptim.optimize_image!(copy).should_not be_true
+      Tempfile.init_count.should == 0
+      copy.read.should == original.read
     end
   end
 
@@ -124,34 +161,118 @@ describe ImageOptim do
     end
 
     %w[optimize_images optimize_images!].each do |list_method|
-      single_method = list_method.sub('images', 'image')
-      describe "without block" do
-        it "should optimize images and return array of results" do
-          io = ImageOptim.new
-          dsts = []
-          srcs.each do |src|
-            dst = "#{src}_"
-            io.should_receive(single_method).with(src).and_return(dst)
-            dsts << dst
+      describe list_method do
+        single_method = list_method.sub('images', 'image')
+        describe "without block" do
+          it "should optimize images and return array of results" do
+            image_optim = ImageOptim.new
+            dsts = srcs.map do |src|
+              dst = "#{src}_"
+              image_optim.should_receive(single_method).with(src).and_return(dst)
+              dst
+            end
+            image_optim.send(list_method, srcs).should == dsts
           end
-          io.send(list_method, srcs).should == dsts
         end
-      end
 
-      describe "given block" do
-        it "should optimize images, yield path and result for each and return array of yield results" do
-          io = ImageOptim.new
-          results = []
-          srcs.each do |src|
-            dst = "#{src}_"
-            io.should_receive(single_method).with(src).and_return(dst)
-            results << "#{src} #{dst}"
+        describe "given block" do
+          it "should optimize images, yield path and result for each and return array of yield results" do
+            image_optim = ImageOptim.new
+            results = srcs.map do |src|
+              dst = "#{src}_"
+              image_optim.should_receive(single_method).with(src).and_return(dst)
+              "#{src} #{dst}"
+            end
+            image_optim.send(list_method, srcs) do |src, dst|
+              "#{src} #{dst}"
+            end.should == results
           end
-          io.send(list_method, srcs) do |src, dst|
-            "#{src} #{dst}"
-          end.should == results
         end
       end
     end
   end
+
+  describe "resolve bin" do
+    it "should resolve bin in path" do
+      with_env 'LS_BIN', nil do
+        image_optim = ImageOptim.new
+        image_optim.should_receive(:bin_accessible?).with(:ls).once.and_return(true)
+        FSPath.should_not_receive(:temp_dir)
+
+        5.times do
+          image_optim.resolve_bin!(:ls).should be_true
+        end
+      end
+    end
+
+    it "should resolve bin specified in ENV" do
+      path = (FSPath(__FILE__).dirname / '../bin/image_optim').relative_path_from(Dir.pwd).to_s
+      with_env 'IMAGE_OPTIM_BIN', path do
+        tmpdir = stub(:tmpdir)
+        symlink = stub(:symlink)
+
+        image_optim = ImageOptim.new
+        image_optim.should_receive(:bin_accessible?).with(symlink).once.and_return(true)
+        FSPath.should_receive(:temp_dir).once.and_return(tmpdir)
+        tmpdir.should_receive(:/).with(:image_optim).once.and_return(symlink)
+        symlink.should_receive(:make_symlink).with(File.expand_path(path)).once
+
+        at_exit_blocks = []
+        image_optim.should_receive(:at_exit).twice do |&block|
+          at_exit_blocks.unshift(block)
+        end
+
+        5.times do
+          image_optim.resolve_bin!(:image_optim).should be_true
+        end
+
+        FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+        symlink.should_receive(:unlink)
+        at_exit_blocks.each(&:call)
+      end
+    end
+
+    it "should raise on failure to resolve bin" do
+      with_env 'SHOULD_NOT_EXIST_BIN', nil do
+        image_optim = ImageOptim.new
+        image_optim.should_receive(:bin_accessible?).with(:should_not_exist).once.and_return(false)
+        FSPath.should_not_receive(:temp_dir)
+
+        5.times do
+          expect do
+            image_optim.resolve_bin!(:should_not_exist)
+          end.to raise_error ImageOptim::BinNotFoundError
+        end
+      end
+    end
+
+    it "should raise on failure to resolve bin specified in ENV" do
+      path = (FSPath(__FILE__).dirname / '../bin/should_not_exist_bin').relative_path_from(Dir.pwd).to_s
+      with_env 'SHOULD_NOT_EXIST_BIN', path do
+        tmpdir = stub(:tmpdir)
+        symlink = stub(:symlink)
+
+        image_optim = ImageOptim.new
+        image_optim.should_receive(:bin_accessible?).with(symlink).once.and_return(false)
+        FSPath.should_receive(:temp_dir).once.and_return(tmpdir)
+        tmpdir.should_receive(:/).with(:should_not_exist).once.and_return(symlink)
+        symlink.should_receive(:make_symlink).with(File.expand_path(path)).once
+
+        at_exit_blocks = []
+        image_optim.should_receive(:at_exit).twice do |&block|
+          at_exit_blocks.unshift(block)
+        end
+
+        5.times do
+          expect do
+            image_optim.resolve_bin!(:should_not_exist)
+          end.to raise_error ImageOptim::BinNotFoundError
+        end
+
+        FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+        symlink.should_receive(:unlink)
+        at_exit_blocks.each(&:call)
+      end
+    end
+  end
 end