image_squeeze 0.1.0

data/CONTRIBUTORS

@@ -0,0 +1,16 @@
+Images files from the artwork at:
+-------------------------------------------------------
+
+-  http://www.kongregate.com/collabs/art/spartan619/chillin-patato
+-  http://www.kongregate.com/collabs/art/ethaN12349/face
+-  http://www.kongregate.com/collabs/art/ETHANR26/super-lightningrod-guitar-gif
+-  http://www.kongregate.com/collabs/art/DeathQueen/dq
+-  http://www.kongregate.com/collabs/art/nygiantsroxursox/the-beach
+  
+Additional thanks to:
+-------------------------------------------------------
+
+- Nicole Sullivan and Stoyan Stefanov for the idea (http://www.smushit.com/ysmush.it/)
+- Steve Souders and all the authors of Even Faster Web Sites
+- Duncan Beevers
+- All the cool guys at Kongregate

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Andrew Grim, Kongregate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+# image_squeeze
+
+A library for automated lossless image optimization
+
+## Installation
+
+The default processors depend on ImageMagick, pngcrush, gifsicle, and jpegtran.  ImageMagick is required for all processors.
+
+## Usage
+
+    # set up an ImageSqueeze with the default processors
+    squeezer = ImageSqueeze.new(:default_processors => true)
+    
+    # in-place squeeze of our png
+    squeezer.squeeze!('my_logo.png')
+
+    # non-destructive squeeze
+    result = squeezer.squeeze('your_logo.png')
+    puts "result saved #{result.bytes_saved} bytes, new image located at #{result.output_filename}"
+    
+    # move tmp file to final location
+    squeezer.finalize_results(result)
+
+## TODO
+
+* Command line runner
+
+## Copyright
+
+Copyright (c) 2010 Andrew Grim. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'lib/image_squeeze'
+
+desc "Run all tests"
+task 'default' => ['test:functionals']
+
+namespace 'test' do
+  functional_tests = FileList['test/functional/**/*_test.rb']
+
+  desc "Run functional tests"
+  Rake::TestTask.new('functionals') do |t|
+    t.libs << 'test'
+    t.test_files = functional_tests
+    t.verbose = true
+    t.warning = false
+  end
+end
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "a library for automated lossless image optimization"
+  s.name = 'image_squeeze'
+  s.version = ImageSqueeze::VERSION
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.files = FileList[
+      "lib/**/*", "test/**/*", "[a-zA-Z]*"
+  ].exclude(/\.gitignore/)
+  s.description = "a library for automated lossless image optimization"
+  s.homepage = "http://github.com/stopdropandrew/image_squeeze"
+  s.author = "Andrew Grim"
+  s.email = "stopdropandrew@gmail.com"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/lib/image_squeeze/image_identifier.rb

@@ -0,0 +1,24 @@
+class ImageSqueeze
+  def self.image_type(filename)
+    return ImageSqueeze::NOT_FOUND unless File.exist?(filename)
+  
+    case identified_format(filename)
+    when /^GIFGIF/
+      ImageSqueeze::ANIMATED_GIF
+    when /GIF/
+      ImageSqueeze::GIF
+    when /JPEG/
+      ImageSqueeze::JPEG
+    when /PNG/
+      ImageSqueeze::PNG
+    else
+      ImageSqueeze::UNKNOWN
+    end
+    
+  end
+
+  private
+  def self.identified_format(filename)
+    `identify -format %m #{filename} 2> /dev/null`
+  end
+end

data/lib/image_squeeze/log_factory.rb

@@ -0,0 +1,14 @@
+class ImageSqueeze
+  class LogFactory
+    def self.logger
+      @logger ||= create_logger
+    end
+    
+    private
+    def self.create_logger
+      return Rails.logger if defined?(Rails) && defined?(Rails.logger)
+      return RAILS_DEFAULT_LOGGER if defined?(RAILS_DEFAULT_LOGGER)
+      return Logger.new(STDERR)
+    end
+  end
+end

data/lib/image_squeeze/processors/gif_to_png_processor.rb

@@ -0,0 +1,19 @@
+class ImageSqueeze
+  class GIFToPNGProcessor < Processor
+    def self.input_type
+      GIF
+    end
+    
+    def self.output_extension
+      '.png'
+    end
+    
+    def self.squeeze(filename, output_filename)
+      intermediate_tmp_filename = tmp_filename(filename)
+      
+      system("convert #{filename} PNG:#{intermediate_tmp_filename} 2> /dev/null")
+      
+      PNGCrushProcessor.squeeze(intermediate_tmp_filename, output_filename) # run it through PNGCrush afterwards
+    end
+  end
+end

data/lib/image_squeeze/processors/gifsicle_processor.rb

@@ -0,0 +1,11 @@
+class ImageSqueeze
+  class GifsicleProcessor < Processor
+    def self.input_type
+      ANIMATED_GIF
+    end
+    
+    def self.squeeze(filename, output_filename)
+      system("gifsicle -O2 #{filename} > #{output_filename} 2> /dev/null")
+    end
+  end
+end

data/lib/image_squeeze/processors/jpeg_tran_non_progressive_processor.rb

@@ -0,0 +1,11 @@
+class ImageSqueeze
+  class JPEGTranNonProgressiveProcessor < Processor
+    def self.input_type
+      JPEG
+    end
+    
+    def self.squeeze(filename, output_filename)
+      system("jpegtran -copy none -optimize #{filename} > #{output_filename}")
+    end
+  end
+end

data/lib/image_squeeze/processors/jpeg_tran_progressive_processor.rb

@@ -0,0 +1,11 @@
+class ImageSqueeze
+  class JPEGTranProgressiveProcessor < Processor
+    def self.input_type
+      JPEG
+    end
+    
+    def self.squeeze(filename, output_filename)
+      system("jpegtran -copy none -optimize -progressive #{filename} > #{output_filename}")
+    end
+  end
+end

data/lib/image_squeeze/processors/png_crush_processor.rb

@@ -0,0 +1,11 @@
+class ImageSqueeze
+  class PNGCrushProcessor < Processor
+    def self.input_type
+      PNG
+    end
+    
+    def self.squeeze(filename, output_filename)
+      system("pngcrush -rem alla -brute -reduce #{filename} #{output_filename} > /dev/null")
+    end
+  end
+end

data/lib/image_squeeze/processors/processor.rb

@@ -0,0 +1,37 @@
+require 'tempfile'
+
+class ImageSqueeze
+  class Processor
+    attr_reader :filename
+    
+    def self.tmp_filename(filename)
+      t = Time.now.strftime("%Y%m%d")
+      path = "#{File.basename(filename)}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+         
+      File.join(Dir::tmpdir, path)
+    end
+    
+    def self.squeeze_to_tmp(filename)
+      tmp = tmp_filename(filename)
+      squeeze(filename, tmp)
+      tmp
+    end
+    
+    def self.squeeze(filename, output_filename)
+      raise "#{to_s}#squeeze should be defined in subclass and should convert filename to something at output_filename"
+    end
+    
+    def self.handles?(image_type)
+      image_type == input_type
+    end
+    
+    def self.input_type
+      raise "#{to_s}#input_type should be defined in subclass"
+    end
+    
+    # override if you want a different output extensions
+    def self.output_extension
+      ImageSqueeze::IMAGE_TYPE_TO_EXTENSION[input_type]
+    end
+  end
+end

data/lib/image_squeeze/result.rb

@@ -0,0 +1,20 @@
+class ImageSqueeze
+  class Result
+    attr_reader :filename, :output_filename, :bytes_saved, :output_extension
+    
+    def initialize(options = {})
+      @filename = options[:filename]
+      @output_filename = options[:output_filename]
+      @bytes_saved = options[:bytes_saved]
+      @output_extension = options[:output_extension]
+    end
+    
+    def optimized?
+      bytes_saved.to_i > 0
+    end
+    
+    def <=>(other)
+      self.bytes_saved <=> other.bytes_saved
+    end
+  end
+end

data/lib/image_squeeze/utils.rb

@@ -0,0 +1,13 @@
+class ImageSqueeze
+  module Utils
+    def self.image_utility_available?(bin, extension, log_level = Logger::WARN)
+      return true if system("which #{bin} > /dev/null")
+      if log_level >= Logger::ERROR
+        ImageSqueeze.logger.error("#{bin} utility is required for running ImageSqueeze, get it installed already")
+        raise StandardError, "#{bin} utility is required for running ImageSqueeze, get it installed already"
+      else
+        ImageSqueeze.logger.log(log_level, "#{bin} utility could not be found, your #{extension} files won't be squeezed")
+      end
+    end
+  end
+end

data/lib/image_squeeze.rb

@@ -0,0 +1,108 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'logger'
+require 'image_squeeze/log_factory'
+require 'image_squeeze/utils'
+require 'image_squeeze/image_identifier'
+require 'image_squeeze/result'
+
+# processors
+require 'image_squeeze/processors/processor'
+require 'image_squeeze/processors/png_crush_processor'
+require 'image_squeeze/processors/jpeg_tran_progressive_processor'
+require 'image_squeeze/processors/jpeg_tran_non_progressive_processor'
+require 'image_squeeze/processors/gifsicle_processor'
+require 'image_squeeze/processors/gif_to_png_processor'
+
+class ImageSqueeze
+  attr_reader :processors
+  
+  VERSION = '0.1.0'
+  
+  # Image Types
+  GIF = 'gif'
+  ANIMATED_GIF = 'animated gif'
+  JPEG = 'jpeg'
+  PNG = 'png'
+  UNKNOWN = 'unknown'
+  NOT_FOUND = 'not_found'
+  
+  IMAGE_TYPE_TO_EXTENSION = {
+    GIF => '.gif',
+    ANIMATED_GIF => '.gif',
+    JPEG => '.jpg',
+    PNG => '.png'
+  }
+  
+  def initialize(options = {})
+    # identify is required
+    ImageSqueeze::Utils.image_utility_available?('identify', 'all image', Logger::ERROR)
+    
+    @processors = options[:processors] || []
+    @processors += self.class.default_processors if options[:default_processors]
+  end
+  
+  def self.default
+    @processors = self.class.default_processors
+  end
+  
+  def squeeze(filename)
+    image_type = self.class.image_type(filename)
+    return if [UNKNOWN, NOT_FOUND].include?(image_type)
+
+    processors = @processors.select{ |processor| processor.handles?(image_type) }
+    return if processors.empty?
+    
+    original_file_size = File.size(filename)
+    sorted_results = processors.map do |processor_class|
+      output_filename = processor_class.squeeze_to_tmp(filename)
+      output_file_size = File.size(output_filename)
+      result_options = { :filename => filename, :output_filename => output_filename, :bytes_saved => original_file_size - output_file_size, :output_extension => processor_class.output_extension }
+      Result.new(result_options)
+    end.sort
+    
+    most_optimized = sorted_results.pop if sorted_results[-1].optimized?
+    sorted_results.each do |result|
+      FileUtils.rm(result.output_filename)
+    end
+    most_optimized
+  end
+  
+  def squeeze!(filename)
+    result = squeeze(filename)
+    
+    output_filename = filename
+    output_filename = finalize_result(result) if result
+  end
+  
+  def finalize_result(result)
+    filename = output_filename = result.filename
+    if File.extname(result.filename) != result.output_extension
+      output_filename = filename.sub(Regexp.new(Regexp.escape(File.extname(result.filename)) + '$'), result.output_extension)
+      FileUtils.cp(result.output_filename, output_filename)
+      FileUtils.rm(result.filename)
+    else
+      FileUtils.cp(result.output_filename, result.filename)
+    end
+    output_filename
+  end
+  
+  def logger
+    LogFactory.logger
+  end
+  
+  def self.default_processors
+    processors = []
+    ImageSqueeze::Utils.image_utility_available?('identify', 'all image', Logger::ERROR)
+    if ImageSqueeze::Utils.image_utility_available?('pngcrush', 'pngs and gif', Logger::WARN)
+      processors << PNGCrushProcessor
+      processors << GIFToPNGProcessor if ImageSqueeze::Utils.image_utility_available?('convert', 'gif', Logger::WARN)
+    end
+    processors << GifsicleProcessor if ImageSqueeze::Utils.image_utility_available?('gifsicle', 'animated gif', Logger::WARN)
+    if ImageSqueeze::Utils.image_utility_available?('jpegtran', 'jpeg', Logger::WARN)
+      processors << JPEGTranProgressiveProcessor
+      processors << JPEGTranNonProgressiveProcessor
+    end
+    processors
+  end
+end

data/test/functional/default_processors_test.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class DefaultProcessorsTest < Test::Unit::TestCase
+  def test_png_crush_processor_with_unoptimize_png
+    assert_processor_optimizes_file(ImageSqueeze::PNGCrushProcessor, 'unoptimized_png.png')
+  end
+  
+  def test_png_crush_processor_with_optimized_png
+    assert_processor_doesnt_optimize_file(ImageSqueeze::PNGCrushProcessor, 'already_optimized_png.png')
+  end
+  
+  def test_jpegtran_progressive_processor_with_already_optimized
+    assert_processor_doesnt_optimize_file(ImageSqueeze::JPEGTranProgressiveProcessor, 'already_optimized_jpg.jpg')
+  end
+  
+  def test_jpegtran_progressive_processor_with_progressive_optimized
+    assert_processor_optimizes_file(ImageSqueeze::JPEGTranProgressiveProcessor, 'better_as_progressive.jpg')
+  end
+  
+  def test_jpegtran_non_progressive_processor_with_already_optimized
+    assert_processor_doesnt_optimize_file(ImageSqueeze::JPEGTranNonProgressiveProcessor, 'already_optimized_jpg.jpg')
+  end
+  
+  def test_jpegtran_non_progressive_processor_with_progressive_optimized
+    assert_processor_optimizes_file(ImageSqueeze::JPEGTranNonProgressiveProcessor, 'better_without_progressive.jpg')
+  end
+  
+  def test_gifsicle_processor_with_unoptimized_animated_gif
+    assert_processor_optimizes_file(ImageSqueeze::GifsicleProcessor, 'unoptimized_animated_gif.gif')
+  end
+  
+  def test_gifsicle_processor_with_already_optimized_animated_gif
+    assert_processor_doesnt_optimize_file(ImageSqueeze::GifsicleProcessor, 'already_optimized_animated_gif.gif')
+  end
+  
+  def test_gif_to_png_processor_with_unoptimized_gif
+    assert_processor_optimizes_file(ImageSqueeze::GIFToPNGProcessor, 'unoptimized_gif.gif')
+  end
+
+  def test_gif_to_png_processor_with_already_optimized_animated_gif
+    assert_processor_doesnt_optimize_file(ImageSqueeze::GIFToPNGProcessor, 'already_optimized_gif.gif')
+  end
+  
+  private
+  def assert_processor_optimizes_file(processor, file)
+    squeezer = ImageSqueeze.new(:processors => [processor])
+    filename = fixtures(file)
+    old_size = File.size(filename)
+    new_filename = squeezer.squeeze!(filename)
+    assert File.size(new_filename) < old_size, "New file size of #{File.size(new_filename)} should be smaller than original of #{old_size}"
+  end
+  
+  def assert_processor_doesnt_optimize_file(processor, file)
+    squeezer = ImageSqueeze.new(:processors => [processor])
+    filename = fixtures(file)
+    old_size = File.size(filename)
+    new_filename = squeezer.squeeze!(filename)
+    assert File.size(new_filename) >= old_size, "New file size of #{File.size(new_filename)} should be at least as big as original of #{old_size}"
+  end
+end

data/test/functional/image_identifier_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ImageTypeTest < Test::Unit::TestCase
+  def test_image_type_not_found_when_no_file
+    image_type = ImageSqueeze.image_type('blah.jpg')
+    assert_equal ImageSqueeze::NOT_FOUND, image_type
+  end
+  
+  def test_image_type_correctly_identifies_gif
+    image_type = ImageSqueeze.image_type(fixtures('already_optimized_gif.gif'))
+    assert_equal ImageSqueeze::GIF, image_type
+  end
+  
+  def test_image_type_correctly_identifies_animated_gif
+    image_type = ImageSqueeze.image_type(fixtures('unoptimized_animated_gif.gif'))
+    assert_equal ImageSqueeze::ANIMATED_GIF, image_type
+  end
+
+  def test_image_type_correctly_identifies_png
+    image_type = ImageSqueeze.image_type(fixtures('already_optimized_png.png'))
+    assert_equal ImageSqueeze::PNG, image_type
+  end
+
+  def test_image_type_correctly_identifies_jpeg
+    image_type = ImageSqueeze.image_type(fixtures('already_optimized_jpg.jpg'))
+    assert_equal ImageSqueeze::JPEG, image_type
+  end
+  
+  def test_image_type_correctly_identifies_non_images
+    image_type = ImageSqueeze.image_type(fixtures('textfile.txt'))
+    assert_equal ImageSqueeze::UNKNOWN, image_type
+  end
+  
+  def test_image_type_correctly_identifies_image_with_wrong_extension
+    image_type = ImageSqueeze.image_type(fixtures('mislabeled_gif.png'))
+    assert_equal ImageSqueeze::GIF, image_type
+  end
+  
+end

data/test/functional/result_test.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+
+class ResultTest < Test::Unit::TestCase
+  def test_results_sort_by_bytes_saved
+    small = ImageSqueeze::Result.new(:bytes_saved => -10)
+    medium = ImageSqueeze::Result.new(:bytes_saved => 20)
+    big = ImageSqueeze::Result.new(:bytes_saved => 100)
+    
+    assert_equal [small, medium, big], [medium, big, small].sort
+  end
+end

data/test/functional/squeeze_test.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', 'test_helper')
+require 'mocha'
+
+class SqueezeTest < Test::Unit::TestCase
+  def setup
+    @image_squeezer = ImageSqueeze.new
+  end
+  
+  def test_squeeze_results_in_unoptimized_for_unknown_file_type
+    assert !@image_squeezer.squeeze(__FILE__)
+  end
+
+  def test_squeeze_result_is_unoptimized_for_file_not_found
+    assert !@image_squeezer.squeeze('thisisnotarealfile.jjj')
+  end
+  
+  def test_squeeze_a_image_without_a_processor
+    assert !@image_squeezer.squeeze(fixtures('already_optimized_gif.gif'))
+  end
+
+  def test_squeeze_result_is_unoptimized_when_no_optimization_is_made
+    image_squeezer = custom_image_squeezer(NeverOptimize)
+    assert !image_squeezer.squeeze(fixtures('already_optimized_gif.gif'))
+  end
+
+  def test_squeeze_result_is_deleted_when_no_optimization_is_made
+    image_squeezer = custom_image_squeezer(NeverOptimize)
+    NeverOptimize.stubs(:tmp_filename).returns(output_filename = File.join(File.dirname(__FILE__), '..', 'tmp', 'tmpfile'))
+    assert !image_squeezer.squeeze(fixtures('already_optimized_gif.gif'))
+    assert !File.exists?(output_filename)
+  end
+
+  def test_squeeze_result_is_optimized_when_an_optimization_is_made
+    image_squeezer = custom_image_squeezer(AlwaysOptimize)
+    result = image_squeezer.squeeze(fixtures('already_optimized_gif.gif'))
+    assert result.optimized?
+  end
+  
+  def test_squeeze_picks_the_best_result_when_processors_return_different_sizes
+    image_squeezer = custom_image_squeezer(AlwaysOptimize, NeverOptimize)
+    result = image_squeezer.squeeze(fixtures('already_optimized_gif.gif'))
+    assert result.optimized?
+  end
+  
+  def test_squeezebang_overwrites_original_file
+    image_squeezer = custom_image_squeezer(AlwaysOptimize)
+    filename = fixtures('already_optimized_gif.gif')
+    old_size = File.size(filename)
+    result = image_squeezer.squeeze!(filename)
+    
+    assert File.size(filename) < old_size
+  end
+
+  def test_squeezebang_removes_old_file_when_extension_is_changed
+    image_squeezer = custom_image_squeezer(PNGOutput)
+    filename = fixtures('already_optimized_gif.gif')
+    result = image_squeezer.squeeze!(filename)
+    
+    assert !File.exists?(filename), "Old file should be gone"
+    assert File.exists?(filename.gsub(/\.gif/, '.png')), "New file should exist"
+  end
+
+  def test_squeezebang_handles_changing_extension_when_dot_extension_is_repeated
+    image_squeezer = custom_image_squeezer(PNGOutput)
+    filename = fixtures('gif.gif.gif.gif')
+    result = image_squeezer.squeeze!(filename)
+    
+    assert !File.exists?(filename), "Old file should be gone"
+    assert File.exists?(filename.gsub(/\.gif$/, '.png')), "New file should exist"
+  end
+  
+  def test_squeezebang_doesnt_overwrite_when_file_not_optimized
+    image_squeezer = custom_image_squeezer(AlwaysBigger)
+    filename = fixtures('already_optimized_gif.gif')
+    old_size = File.size(filename)
+    result = image_squeezer.squeeze!(filename)
+    assert_equal old_size, File.size(filename)
+  end
+  
+  private
+  class AlwaysOptimize < ImageSqueeze::Processor
+    def self.squeeze(filename, output_filename)
+      `echo 'real small' > #{output_filename}` # this will make the new file really small
+    end
+    
+    def self.input_type; ImageSqueeze::GIF; end
+  end
+  
+  class NeverOptimize < ImageSqueeze::Processor
+    def self.squeeze(filename, output_filename)
+      `cp #{filename} #{output_filename}`
+    end
+
+    def self.input_type; ImageSqueeze::GIF; end
+  end
+
+  class AlwaysBigger < ImageSqueeze::Processor
+    def self.squeeze(filename, output_filename)
+      `cp #{filename} #{output_filename}; echo "hi" >> #{output_filename}`
+    end
+    def self.input_type; ImageSqueeze::GIF; end
+  end
+
+  class PNGOutput < ImageSqueeze::Processor
+    def self.squeeze(filename, output_filename)
+      `echo 'real small' > #{output_filename}` # this will make the new file really small
+    end
+    
+    def self.input_type; ImageSqueeze::GIF; end
+    def self.output_extension; '.png'; end
+  end
+
+  def custom_image_squeezer(*processors)
+    ImageSqueeze.new(:processors => processors )
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'ruby-debug'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'image_squeeze')
+
+class Test::Unit::TestCase
+  def fixtures(filename)
+    original_file = File.join(File.dirname(__FILE__), 'fixtures', filename)
+    new_file = File.join(Dir::tmpdir, filename)
+    FileUtils.cp(original_file, new_file)
+    new_file
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: image_squeeze
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrew Grim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-17 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: a library for automated lossless image optimization
+email: stopdropandrew@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/image_squeeze/image_identifier.rb
+- lib/image_squeeze/log_factory.rb
+- lib/image_squeeze/processors/gif_to_png_processor.rb
+- lib/image_squeeze/processors/gifsicle_processor.rb
+- lib/image_squeeze/processors/jpeg_tran_non_progressive_processor.rb
+- lib/image_squeeze/processors/jpeg_tran_progressive_processor.rb
+- lib/image_squeeze/processors/png_crush_processor.rb
+- lib/image_squeeze/processors/processor.rb
+- lib/image_squeeze/result.rb
+- lib/image_squeeze/utils.rb
+- lib/image_squeeze.rb
+- test/fixtures/already_optimized_animated_gif.gif
+- test/fixtures/already_optimized_gif.gif
+- test/fixtures/already_optimized_jpg.jpg
+- test/fixtures/already_optimized_png.png
+- test/fixtures/better_as_progressive.jpg
+- test/fixtures/better_without_progressive.jpg
+- test/fixtures/gif.gif.gif.gif
+- test/fixtures/mislabeled_gif.png
+- test/fixtures/textfile.txt
+- test/fixtures/unoptimized_animated_gif.gif
+- test/fixtures/unoptimized_gif.gif
+- test/fixtures/unoptimized_png.png
+- test/functional/default_processors_test.rb
+- test/functional/image_identifier_test.rb
+- test/functional/result_test.rb
+- test/functional/squeeze_test.rb
+- test/test_helper.rb
+- CONTRIBUTORS
+- LICENSE
+- Rakefile
+- README.md
+has_rdoc: true
+homepage: http://github.com/stopdropandrew/image_squeeze
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- none
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: a library for automated lossless image optimization
+test_files: []
+