image_optim 0.9.1 → 0.10.0

data/lib/image_optim/runner.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+
+require 'image_optim'
+require 'image_optim/hash_helpers'
+require 'image_optim/true_false_nil'
+require 'progress'
+require 'optparse'
+require 'find'
+require 'yaml'
+
+class ImageOptim
+  class Runner
+    module Space
+      SIZE_SYMBOLS = %w[B K M G T P E].freeze
+      PRECISION = 1
+      LENGTH = 4 + PRECISION + 1
+
+      EMPTY_SPACE = ' ' * LENGTH
+
+      class << self
+        attr_writer :base10
+        def denominator
+          @denominator ||= @base10 ? 1000.0 : 1024.0
+        end
+
+        def space(size)
+          case size
+          when 0, nil
+            EMPTY_SPACE
+          else
+            log_denominator = Math.log(size) / Math.log(denominator)
+            degree = [log_denominator.floor, SIZE_SYMBOLS.length - 1].min
+            number = size / (denominator ** degree)
+            "#{degree == 0 ? number.to_i : "%.#{PRECISION}f" % number}#{SIZE_SYMBOLS[degree]}".rjust(LENGTH)
+          end
+        end
+      end
+    end
+
+    def initialize(args, options)
+      raise 'specify paths to optimize' if args.empty?
+      options = HashHelpers.deep_symbolise_keys(options)
+      @recursive = options.delete(:recursive)
+      @image_optim = ImageOptim.new(options)
+      @files = find_files(args)
+    end
+
+    def run!
+      unless @files.empty?
+        lines, original_sizes, optimized_sizes =
+        @image_optim.optimize_images!(@files.with_progress('optimizing')) do |original, optimized|
+          original_size = optimized ? optimized.original_size : original.size
+          optimized_size = optimized ? optimized.size : original.size
+          ["#{size_percent(original_size, optimized_size)}  #{original}", original_size, optimized_size]
+        end.transpose
+
+        puts lines, "Total: #{size_percent(original_sizes.inject(:+), optimized_sizes.inject(:+))}"
+      end
+
+      !warnings?
+    end
+
+    def warnings?
+      !!@warnings
+    end
+
+    def self.run!(args, options)
+      new(args, options).run!
+    end
+
+  private
+
+    def find_files(args)
+      files = []
+      args.each do |arg|
+        if File.file?(arg)
+          if @image_optim.optimizable?(arg)
+            files << arg
+          else
+            warning "#{arg} is not an image or there is no optimizer for it"
+          end
+        elsif @recursive && File.directory?(arg)
+          Find.find(arg) do |path|
+            files << path if File.file?(path) && @image_optim.optimizable?(path)
+          end
+        else
+          warning "#{arg} does not exist"
+        end
+      end
+      files
+    end
+
+    def warning(message)
+      @warnings = true
+      warn message
+    end
+
+    def size_percent(size_a, size_b)
+      if size_a == size_b
+        "------ #{Space::EMPTY_SPACE}"
+      else
+        '%5.2f%% %s' % [100 - 100.0 * size_b / size_a, Space.space(size_a - size_b)]
+      end
+    end
+
+  end
+end

data/lib/image_optim/true_false_nil.rb

@@ -0,0 +1,3 @@
+class ImageOptim
+  class TrueFalseNil; end
+end

data/lib/image_optim/worker/advpng.rb

@@ -1,4 +1,5 @@
 require 'image_optim/worker'
+require 'image_optim/option_helpers'
 
 class ImageOptim
   class Worker

data/lib/image_optim/worker/jpegoptim.rb

@@ -1,4 +1,5 @@
 require 'image_optim/worker'
+require 'image_optim/option_helpers'
 
 class ImageOptim
   class Worker

data/lib/image_optim/worker/optipng.rb

@@ -1,4 +1,6 @@
 require 'image_optim/worker'
+require 'image_optim/option_helpers'
+require 'image_optim/true_false_nil'
 
 class ImageOptim
   class Worker

data/lib/image_optim/worker/pngout.rb

@@ -1,4 +1,5 @@
 require 'image_optim/worker'
+require 'image_optim/option_helpers'
 
 class ImageOptim
   class Worker

data/lib/image_optim/worker.rb

@@ -1,9 +1,9 @@
 # encoding: UTF-8
 
+require 'image_optim/option_definition'
+require 'image_optim/option_helpers'
 require 'shellwords'
 
-require 'image_optim'
-
 class ImageOptim
   class Worker
     class << self
@@ -32,15 +32,22 @@ class ImageOptim
       end
     end
 
-    include OptionHelpers
-
     # Configure (raises on extra options)
     def initialize(image_optim, options = {})
       @image_optim = image_optim
       self.class.option_definitions.each do |option_definition|
-        get_option!(options, option_definition.name, option_definition.default, &option_definition.proc)
+        value = if options.has_key?(option_definition.name)
+          options[option_definition.name]
+        else
+          option_definition.default
+        end
+        if option_definition.proc
+          value = option_definition.proc[value]
+        end
+        instance_variable_set("@#{option_definition.name}", value)
       end
-      assert_options_empty!(options)
+
+      assert_no_unknown_options!(options)
     end
 
     # List of formats which worker can optimize
@@ -55,6 +62,10 @@ class ImageOptim
       0
     end
 
+    def <=>(other)
+      run_order <=> other.run_order
+    end
+
     # Check if operation resulted in optimized file
     def optimized?(src, dst)
       dst.size? && dst.size < src.size
@@ -62,6 +73,14 @@ class ImageOptim
 
   private
 
+    def assert_no_unknown_options!(options)
+      known_keys = self.class.option_definitions.map(&:name)
+      unknown_options = options.reject{ |key, value| known_keys.include?(key) }
+      unless unknown_options.empty?
+        raise ConfigurationError, "unknown options #{unknown_options.inspect} for #{self}"
+      end
+    end
+
     # Forward bin resolving to image_optim
     def resolve_bin!(bin)
       @image_optim.resolve_bin!(bin)

data/lib/image_optim.rb

@@ -1,19 +1,12 @@
-require 'in_threads'
-require 'shellwords'
-
+require 'image_optim/bin_resolver'
+require 'image_optim/config'
+require 'image_optim/handler'
 require 'image_optim/image_path'
-require 'image_optim/option_helpers'
-require 'image_optim/option_definition'
 require 'image_optim/worker'
+require 'in_threads'
+require 'shellwords'
 
 class ImageOptim
-  class ConfigurationError < StandardError; end
-  class BinNotFoundError < StandardError; end
-
-  class TrueFalseNil; end
-
-  include OptionHelpers
-
   # Nice level
   attr_reader :nice
 
@@ -43,88 +36,71 @@ class ImageOptim
   #
   #     ImageOptim.new(:nice => 20)
   def initialize(options = {})
-    @resolved_bins = {}
-    @resolver_lock = Mutex.new
-
-    nice = options.delete(:nice)
-    @nice = case nice
-    when true, nil
-      10
-    when false
-      0
-    else
-      nice.to_i
-    end
+    @bin_resolver = BinResolver.new
 
-    threads = options.delete(:threads)
-    threads = case threads
-    when true, nil
-      processor_count
-    when false
-      1
-    else
-      threads.to_i
-    end
-    @threads = OptionHelpers.limit_with_range(threads, 1..16)
-
-    @verbose = !!options.delete(:verbose)
+    config = Config.new(options)
+    @nice = config.nice
+    @threads = config.threads
+    @verbose = config.verbose
 
     @workers_by_format = {}
     Worker.klasses.each do |klass|
-      case worker_options = options.delete(klass.bin_sym)
-      when Hash
-      when true, nil
-        worker_options = {}
-      when false
-        next
-      else
-        raise ConfigurationError, "Got #{worker_options.inspect} for #{klass.name} options"
-      end
-      worker = klass.new(self, worker_options)
-      worker.image_formats.each do |format|
-        @workers_by_format[format] ||= []
-        @workers_by_format[format] << worker
+      if worker_options = config.for_worker(klass)
+        worker = klass.new(self, worker_options)
+        worker.image_formats.each do |format|
+          @workers_by_format[format] ||= []
+          @workers_by_format[format] << worker
+        end
       end
     end
-    @workers_by_format.each do |format, workers|
-      workers.replace workers.sort_by(&:run_order) # There is no sort_by! in ruby 1.8
-    end
+    @workers_by_format.values.each(&:sort!)
 
-    assert_options_empty!(options)
+    config.assert_no_unused_options!
+
+    puts config if verbose?
   end
 
   # Get workers for image
   def workers_for_image(path)
-    @workers_by_format[ImagePath.new(path).format]
+    @workers_by_format[ImagePath.convert(path).format]
   end
 
-  # Optimize one file, return new path or nil if optimization failed
+  # Optimize one file, return new path as OptimizedImagePath or nil if optimization failed
   def optimize_image(original)
-    original = ImagePath.new(original)
+    original = ImagePath.convert(original)
     if workers = workers_for_image(original)
-      result = nil
-      ts = [original, original.temp_path]
+      handler = Handler.new(original)
       workers.each do |worker|
-        if result && ts.length < 3
-          ts << original.temp_path
-        end
-        if worker.optimize(*ts.last(2))
-          result = ts.last
-          if ts.length == 3
-            ts[-2, 2] = ts[-1], ts[-2]
-          end
+        handler.process do |src, dst|
+          worker.optimize(src, dst)
         end
       end
-      result
+      if handler.result
+        ImagePath::Optimized.new(handler.result, original)
+      end
     end
   end
 
-  # Optimize one file in place, return optimization status
+  # Optimize one file in place, return original as OptimizedImagePath or nil if optimization failed
   def optimize_image!(original)
-    original = ImagePath.new(original)
+    original = ImagePath.convert(original)
     if result = optimize_image(original)
       result.replace(original)
-      true
+      ImagePath::Optimized.new(original, result.original_size)
+    end
+  end
+
+  # Optimize image data, return new data or nil if optimization failed
+  def optimize_image_data(original_data)
+    format = ImageSize.new(original_data).format
+    ImagePath.temp_file %W[image_optim .#{format}] do |temp|
+      temp.binmode
+      temp.write(original_data)
+      temp.close
+
+      if result = optimize_image(temp.path)
+        result.read
+      end
     end
   end
 
@@ -132,19 +108,26 @@ class ImageOptim
   # if block given yields path and result for each image and returns array of yield results
   # else return array of results
   def optimize_images(paths, &block)
-    run_method_for(paths, :optimize_image, &block)
+    run_method_for(paths.map{ |path| ImagePath.convert(path) }, :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 results
   def optimize_images!(paths, &block)
-    run_method_for(paths, :optimize_image!, &block)
+    run_method_for(paths.map{ |path| ImagePath.convert(path) }, :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 results
+  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.to_s =~ /^optimize_images?\!?$/
+    if method_defined?(method) && method.to_s =~ /^optimize_image/
       new.send(method, *args, &block)
     else
       super
@@ -161,37 +144,14 @@ class ImageOptim
     !!workers_for_image(path)
   end
 
-  # Temp directory for symlinks to bins with path coming from ENV
-  attr_reader :resolve_dir
-
   # 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 = bin.to_sym
-    @resolved_bins.include?(bin) || @resolver_lock.synchronize do
-      @resolved_bins.include?(bin) || begin
-        if path = ENV["#{bin}_bin".upcase]
-          unless @resolve_dir
-            @resolve_dir = FSPath.temp_dir
-            at_exit{ FileUtils.remove_entry_secure @resolve_dir }
-          end
-          symlink = @resolve_dir / bin
-          symlink.make_symlink(File.expand_path(path))
-          at_exit{ symlink.unlink }
-
-          @resolved_bins[bin] = bin_accessible?(symlink)
-        else
-          @resolved_bins[bin] = bin_accessible?(bin)
-        end
-      end
-    end
-    @resolved_bins[bin] or raise BinNotFoundError, "`#{bin}` not found"
+    @bin_resolver.resolve!(bin)
   end
 
-  VENDOR_PATH = File.expand_path('../../vendor', __FILE__)
-
   # Join resolve_dir, default path and vendor path for PATH environment variable
   def env_path
-    "#{resolve_dir}:#{ENV['PATH']}:#{VENDOR_PATH}"
+    @bin_resolver.env_path
   end
 
 private
@@ -199,7 +159,6 @@ private
   # Run method for each path and yield each path and result if block given
   def run_method_for(paths, method_name, &block)
     apply_threading(paths).map do |path|
-      path = ImagePath.new(path)
       result = send(method_name, path)
       if block
         block.call(path, result)
@@ -217,33 +176,6 @@ private
       enum
     end
   end
-
-  # Check if bin can be accessed
-  def bin_accessible?(bin)
-    `env PATH=#{env_path.shellescape} which #{bin.to_s.shellescape}` != ''
-  end
-
-  # http://stackoverflow.com/questions/891537/ruby-detect-number-of-cpus-installed
-  def processor_count
-    @processor_count ||= case host_os = RbConfig::CONFIG['host_os']
-    when /darwin9/
-      `hwprefs cpu_count`
-    when /darwin/
-      (`which hwprefs` != '') ? `hwprefs thread_count` : `sysctl -n hw.ncpu`
-    when /linux/
-      `grep -c processor /proc/cpuinfo`
-    when /freebsd/
-      `sysctl -n hw.ncpu`
-    when /mswin|mingw/
-      require 'win32ole'
-      wmi = WIN32OLE.connect('winmgmts://')
-      cpu = wmi.ExecQuery('select NumberOfLogicalProcessors from Win32_Processor')
-      cpu.to_enum.first.NumberOfLogicalProcessors
-    else
-      warn "Unknown architecture (#{host_os}) assuming one processor."
-      1
-    end.to_i
-  end
 end
 
 %w[
@@ -253,3 +185,5 @@ end
 ].each do |worker|
   require "image_optim/worker/#{worker}"
 end
+
+require 'image_optim/railtie' if defined?(Rails)

data/script/update_worker_options_in_readme

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'image_optim'
+
+README_FILE = File.expand_path('../../README.markdown', __FILE__)
+BEGIN_MARKER = '<!---<worker-options>-->'
+END_MARKER = '<!---</worker-options>-->'
+
+def worker_options
+  io = StringIO.new
+
+  ImageOptim::Worker.klasses.each_with_index do |klass, i|
+    unless klass.option_definitions.empty?
+      io.puts "### #{klass.bin_sym}"
+      klass.option_definitions.each do |option_definition|
+        io.puts "* `:#{option_definition.name}` — #{option_definition.description} *(defaults to #{option_definition.default})*"
+      end
+      io.puts
+    end
+  end
+
+  io.string
+end
+
+readme = File.read(README_FILE)
+
+if readme.sub!(/#{Regexp.escape(BEGIN_MARKER)}.*#{Regexp.escape(END_MARKER)}/m, "#{BEGIN_MARKER}\n\n#{worker_options.strip}\n\n#{END_MARKER}")
+  File.open(README_FILE, 'w') do |f|
+    f.write readme
+  end
+else
+  abort "Did not update worker options"
+end

data/spec/image_optim/bin_resolver_spec.rb

@@ -0,0 +1,92 @@
+$:.unshift File.expand_path('../../../lib', __FILE__)
+require 'rspec'
+require 'image_optim/bin_resolver'
+
+def with_env(key, value)
+  saved, ENV[key] = ENV[key], value
+  yield
+ensure
+  ENV[key] = saved
+end
+
+describe ImageOptim::BinResolver do
+  it "should resolve bin in path" do
+    with_env 'LS_BIN', nil do
+      resolver = ImageOptim::BinResolver.new
+      resolver.should_receive(:accessible?).with(:ls).once.and_return(true)
+      FSPath.should_not_receive(:temp_dir)
+
+      5.times do
+        resolver.resolve!(: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 = double(:tmpdir)
+      symlink = double(:symlink)
+
+      resolver = ImageOptim::BinResolver.new
+      resolver.should_receive(: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 = []
+      resolver.should_receive(:at_exit).once do |&block|
+        at_exit_blocks.unshift(block)
+      end
+
+      5.times do
+        resolver.resolve!(:image_optim).should be_true
+      end
+
+      FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+      at_exit_blocks.each(&:call)
+    end
+  end
+
+  it "should raise on failure to resolve bin" do
+    with_env 'SHOULD_NOT_EXIST_BIN', nil do
+      resolver = ImageOptim::BinResolver.new
+      resolver.should_receive(:accessible?).with(:should_not_exist).once.and_return(false)
+      FSPath.should_not_receive(:temp_dir)
+
+      5.times do
+        expect do
+          resolver.resolve!(: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 = double(:tmpdir)
+      symlink = double(:symlink)
+
+      resolver = ImageOptim::BinResolver.new
+      resolver.should_receive(: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 = []
+      resolver.should_receive(:at_exit).once do |&block|
+        at_exit_blocks.unshift(block)
+      end
+
+      5.times do
+        expect do
+          resolver.resolve!(:should_not_exist)
+        end.to raise_error ImageOptim::BinNotFoundError
+      end
+
+      FileUtils.should_receive(:remove_entry_secure).with(tmpdir)
+      at_exit_blocks.each(&:call)
+    end
+  end
+end