jf--mini_magick 3.1

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2005 Corey Johnson probablycorey@gmail.com
+
+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.rdoc

@@ -0,0 +1,92 @@
+= MiniMagick
+
+A ruby wrapper for ImageMagick or GraphicsMagick command line.
+
+Tested on both Ruby 1.9.2 and Ruby 1.8.7.
+
+== Why?
+
+I was using RMagick and loving it, but it was eating up huge amounts
+of memory. A simple script like this...
+
+  Magick::read("image.jpg") do |f|
+    f.write("manipulated.jpg")
+  end
+
+...would use over 100 Megs of Ram. On my local machine this wasn't a
+problem, but on my hosting server the ruby apps would crash because of
+their 100 Meg memory limit.
+
+
+== Solution!
+
+Using MiniMagick the ruby processes memory remains small (it spawns
+ImageMagick's command line program mogrify which takes up some memory
+as well, but is much smaller compared to RMagick)
+
+MiniMagick gives you access to all the commandline options ImageMagick
+has (Found here http://www.imagemagick.org/script/mogrify.php)
+
+
+== Examples
+
+Want to make a thumbnail from a file...
+
+  image = MiniMagick::Image.open("input.jpg")
+  image.resize "100x100"
+  image.write  "output.jpg"
+
+Want to make a thumbnail from a blob...
+
+  image = MiniMagick::Image.read(blob)
+  image.resize "100x100"
+  image.write  "output.jpg"
+  
+Got an incoming IOStream?
+
+  image = MiniMagick::Image.read(stream)
+
+Want to make a thumbnail of a remote image?
+
+  image = MiniMagick::Image.open("http://www.google.com/images/logos/logo.png")
+  image.resize "5x5"
+  image.format "gif"
+  image.write "localcopy.gif"
+
+Need to combine several options?
+
+  image = MiniMagick::Image.open("input.jpg")
+  image.combine_options do |c|
+    c.sample "50%"
+    c.rotate "-90>"
+  end
+  image.write "output.jpg"
+
+Want to composite two images? Super easy! (Aka, put a watermark on!)
+
+  image = Image.from_file("original.png")
+  result = image.composite(Image.open("watermark.png", "jpg") do |c|
+    c.gravity "center"
+  end
+  result.write "my_output_file.jpg"
+
+Want to manipulate an image at its source (You won't have to write it
+out because the transformations are done on that file)
+
+  image = MiniMagick::Image.new("input.jpg")
+  image.resize "100x100"
+
+Want to get some meta-information out?
+
+  image = MiniMagick::Image.open("input.jpg")
+  image[:width]               # will get the width (you can also use :height and :format)
+  image["EXIF:BitsPerSample"] # It also can get all the EXIF tags
+  image["%m:%f %wx%h"]        # Or you can use one of the many options of the format command
+
+For more on the format command see
+http://www.imagemagick.org/script/command-line-options.php#format
+
+
+== Requirements
+
+You must have ImageMagick or GraphicsMagick installed.

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$:.unshift(File.dirname(__FILE__) + "/lib")
+require 'mini_magick'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the mini_magick plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the mini_magick plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MiniMagick'
+  rdoc.options << '--line-numbers'
+  rdoc.options << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = eval(File.read('mini_magick.gemspec'))
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/VERSION

@@ -0,0 +1 @@
+3.1

data/lib/mini_gmagick.rb

@@ -0,0 +1,2 @@
+require 'mini_magick'
+MiniMagick.processor = :gm

data/lib/mini_magick.rb

@@ -0,0 +1,426 @@
+require 'tempfile'
+require 'subexec'
+require 'pathname'
+
+module MiniMagick
+  class << self
+    attr_accessor :processor
+    attr_accessor :timeout
+
+
+    # Experimental method for automatically selecting a processor
+    # such as gm. Only works on *nix.
+    #
+    # TODO: Write tests for this and figure out what platforms it supports
+    def choose_processor
+      if `type -P mogrify`.size > 0
+        return
+      elsif `type -P gm`.size > 0
+        self.processor = "gm"
+      end
+    end
+  end
+
+  MOGRIFY_COMMANDS = %w{adaptive-blur adaptive-resize adaptive-sharpen adjoin affine alpha annotate antialias append authenticate auto-gamma auto-level auto-orient background bench iterations bias black-threshold blue-primary point blue-shift factor blur border bordercolor brightness-contrast caption string cdl filename channel type charcoal radius chop clip clamp clip-mask filename clip-path id clone index clut contrast-stretch coalesce colorize color-matrix colors colorspace type combine comment string compose operator composite compress type contrast convolve coefficients crop cycle amount decipher filename debug events define format:option deconstruct delay delete index density depth despeckle direction type display server dispose method distort type coefficients dither method draw string edge radius emboss radius encipher filename encoding type endian type enhance equalize evaluate operator evaluate-sequence operator extent extract family name fft fill filter type flatten flip floodfill flop font name format string frame function name fuzz distance fx expression gamma gaussian-blur geometry gravity type green-primary point help identify ifft implode amount insert index intent type interlace type interline-spacing interpolate method interword-spacing kerning label string lat layers method level limit type linear-stretch liquid-rescale log format loop iterations mask filename mattecolor median radius modulate monitor monochrome morph morphology method kernel motion-blur negate noise radius normalize opaque ordered-dither NxN orient type page paint radius ping pointsize polaroid angle posterize levels precision preview type print string process image-filter profile filename quality quantizespace quiet radial-blur angle raise random-threshold low,high red-primary point regard-warnings region remap filename render repage resample resize respect-parentheses roll rotate degrees sample sampling-factor scale scene seed segments selective-blur separate sepia-tone threshold set attribute shade degrees shadow sharpen shave shear sigmoidal-contrast size sketch solarize threshold splice spread radius strip stroke strokewidth stretch type style type swap indexes swirl degrees texture filename threshold thumbnail tile filename tile-offset tint transform transparent transparent-color transpose transverse treedepth trim type type undercolor unique-colors units type unsharp verbose version view vignette virtual-pixel method wave weight type white-point point white-threshold write filename}
+
+  class Error < RuntimeError; end
+  class Invalid < StandardError; end
+
+  class Image
+    # @return [String] The location of the current working file
+    attr :path
+
+    # Class Methods
+    # -------------
+    class << self
+      # This is the primary loading method used by all of the other class methods.
+      #
+      # Use this to pass in a stream object. Must respond to Object#read(size) or be a binary string object (BLOBBBB)
+      #
+      # As a change from the old API, please try and use IOStream objects. They are much, much better and more efficient!
+      #
+      # Probably easier to use the #open method if you want to open a file or a URL.
+      #
+      # @param stream [IOStream, String] Some kind of stream object that needs to be read or is a binary String blob!
+      # @param ext [String] A manual extension to use for reading the file. Not required, but if you are having issues, give this a try.
+      # @return [Image]
+      def read(stream, ext = nil)
+        if stream.is_a?(String)
+          stream = StringIO.new(stream)
+        end
+
+        create(ext) do |f|
+          while chunk = stream.read(8192)
+            f.write(chunk)
+          end
+        end
+      end
+
+      # @deprecated Please use Image.read instead!
+      def from_blob(blob, ext = nil)
+        warn "Warning: MiniMagick::Image.from_blob method is deprecated. Instead, please use Image.read"
+        create(ext) { |f| f.write(blob) }
+      end
+
+      # Opens a specific image file either on the local file system or at a URI.
+      #
+      # Use this if you don't want to overwrite the image file.
+      #
+      # Extension is either guessed from the path or you can specify it as a second parameter.
+      #
+      # If you pass in what looks like a URL, we require 'open-uri' before opening it.
+      #
+      # @param file_or_url [String] Either a local file path or a URL that open-uri can read
+      # @param ext [String] Specify the extension you want to read it as
+      # @return [Image] The loaded image
+      def open(file_or_url, ext = File.extname(file_or_url))
+        file_or_url = file_or_url.to_s # Force it to be a String... hell or highwater
+        if file_or_url.include?("://")
+          require 'open-uri'
+          self.read(Kernel::open(file_or_url), ext)
+        else
+          File.open(file_or_url, "rb") do |f|
+            self.read(f, ext)
+          end
+        end
+      end
+
+      # @deprecated Please use MiniMagick::Image.open(file_or_url) now
+      def from_file(file, ext = nil)
+        warn "Warning: MiniMagick::Image.from_file is now deprecated. Please use Image.open"
+        open(file, ext)
+      end
+
+      # Used to create a new Image object data-copy. Not used to "paint" or that kind of thing.
+      #
+      # Takes an extension in a block and can be used to build a new Image object. Used
+      # by both #open and #read to create a new object! Ensures we have a good tempfile!
+      #
+      # @param ext [String] Specify the extension you want to read it as
+      # @yield [IOStream] You can #write bits to this object to create the new Image
+      # @return [Image] The created image
+      def create(ext = nil, &block)
+        begin
+          tempfile = Tempfile.new(['mini_magick', ext.to_s])
+          tempfile.binmode
+          block.call(tempfile)
+          tempfile.close
+
+          image = self.new(tempfile.path, tempfile)
+
+          if !image.valid?
+            raise MiniMagick::Invalid
+          end
+          return image
+        ensure
+          tempfile.close if tempfile
+        end
+      end
+    end
+
+    # Create a new MiniMagick::Image object
+    #
+    # _DANGER_: The file location passed in here is the *working copy*. That is, it gets *modified*.
+    # you can either copy it yourself or use the MiniMagick::Image.open(path) method which creates a
+    # temporary file for you and protects your original!
+    #
+    # @param input_path [String] The location of an image file
+    # @todo Allow this to accept a block that can pass off to Image#combine_options
+    def initialize(input_path, tempfile = nil)
+      @path = input_path
+      @tempfile = tempfile # ensures that the tempfile will stick around until this image is garbage collected.
+    end
+    
+    def escaped_path
+      Pathname.new(@path).to_s.gsub(" ", "\\ ")
+    end
+
+    # Checks to make sure that MiniMagick can read the file and understand it.
+    #
+    # This uses the 'identify' command line utility to check the file. If you are having
+    # issues with this, then please work directly with the 'identify' command and see if you
+    # can figure out what the issue is.
+    #
+    # @return [Boolean]
+    def valid?
+      run_command("identify", @path)
+      true
+    rescue MiniMagick::Invalid
+      false
+    end
+
+    # A rather low-level way to interact with the "identify" command. No nice API here, just
+    # the crazy stuff you find in ImageMagick. See the examples listed!
+    #
+    # @example
+    #    image["format"]      #=> "TIFF"
+    #    image["height"]      #=> 41 (pixels)
+    #    image["width"]       #=> 50 (pixels)
+    #    image["dimensions"]  #=> [50, 41]
+    #    image["size"]        #=> 2050 (bits)
+    #    image["original_at"] #=> 2005-02-23 23:17:24 +0000 (Read from Exif data)
+    #    image["EXIF:ExifVersion"] #=> "0220" (Can read anything from Exif)
+    #
+    # @param format [String] A format for the "identify" command
+    # @see For reference see http://www.imagemagick.org/script/command-line-options.php#format
+    # @return [String, Numeric, Array, Time, Object] Depends on the method called! Defaults to String for unknown commands
+    def [](value)
+      # Why do I go to the trouble of putting in newlines? Because otherwise animated gifs screw everything up
+      case value.to_s
+      when "format"
+        run_command("identify", "-format", format_option("%m"), escaped_path).split("\n")[0]
+      when "height"
+        run_command("identify", "-format", format_option("%h"), escaped_path).split("\n")[0].to_i
+      when "width"
+        run_command("identify", "-format", format_option("%w"), escaped_path).split("\n")[0].to_i
+      when "dimensions"
+        run_command("identify", "-format", format_option("%w %h"), escaped_path).split("\n")[0].split.map{|v|v.to_i}
+      when "size"
+        File.size(@path) # Do this because calling identify -format "%b" on an animated gif fails!
+      when "original_at"
+        # Get the EXIF original capture as a Time object
+        Time.local(*self["EXIF:DateTimeOriginal"].split(/:|\s+/)) rescue nil
+      when /^EXIF\:/i
+        result = run_command('identify', '-format', "\"%[#{value}]\"", escaped_path).chop
+        if result.include?(",")
+          read_character_data(result)
+        else
+          result
+        end
+      else
+        run_command('identify', '-format', "\"#{value}\"", escaped_path).split("\n")[0]
+      end
+    end
+
+    # Sends raw commands to imagemagick's `mogrify` command. The image path is automatically appended to the command.
+    #
+    # Remember, we are always acting on this instance of the Image when messing with this.
+    #
+    # @return [String] Whatever the result from the command line is. May not be terribly useful.
+    def <<(*args)
+      run_command("mogrify", *args << escaped_path)
+    end
+
+    # This is used to change the format of the image. That is, from "tiff to jpg" or something like that.
+    # Once you run it, the instance is pointing to a new file with a new extension!
+    #
+    # *DANGER*: This renames the file that the instance is pointing to. So, if you manually opened the
+    # file with Image.new(file_path)... then that file is DELETED! If you used Image.open(file) then
+    # you are ok. The original file will still be there. But, any changes to it might not be...
+    #
+    # Formatting an animation into a non-animated type will result in ImageMagick creating multiple
+    # pages (starting with 0).  You can choose which page you want to manipulate.  We default to the
+    # first page.
+    #
+    # @param format [String] The target format... like 'jpg', 'gif', 'tiff', etc.
+    # @param page [Integer] If this is an animated gif, say which 'page' you want with an integer. Leave as default if you don't care.
+    # @return [nil]
+    def format(format, page = 0)
+      run_command("mogrify", "-format", format, @path)
+
+      old_path = @path.dup
+      @path.sub!(/(\.\w*)?$/, ".#{format}")
+      File.delete(old_path) if old_path != @path
+
+      unless File.exists?(@path)
+        begin
+          FileUtils.copy_file(@path.sub(".#{format}", "-#{page}.#{format}"), @path)
+        rescue => ex
+          raise MiniMagick::Error, "Unable to format to #{format}; #{ex}" unless File.exist?(@path)
+        end
+      end
+    ensure
+      Dir[@path.sub(/(\.\w+)?$/, "-[0-9]*.#{format}")].each do |fname|
+        File.unlink(fname)
+      end
+    end
+
+    # Collapse images with sequences to the first frame (ie. animated gifs) and
+    # preserve quality
+    def collapse!
+      run_command("mogrify", "-quality", "100", "#{path}[0]")
+    end
+
+    # Writes the temporary file out to either a file location (by passing in a String) or by
+    # passing in a Stream that you can #write(chunk) to repeatedly
+    #
+    # @param output_to [IOStream, String] Some kind of stream object that needs to be read or a file path as a String
+    # @return [IOStream, Boolean] If you pass in a file location [String] then you get a success boolean. If its a stream, you get it back.
+    # Writes the temporary image that we are using for processing to the output path
+    def write(output_to)
+      if output_to.kind_of?(String) || !output_to.respond_to?(:write)
+        FileUtils.copy_file @path, output_to
+        run_command "identify", output_to # Verify that we have a good image
+      else # stream
+        File.open(@path, "rb") do |f|
+          f.binmode
+          while chunk = f.read(8192)
+            output_to.write(chunk)
+          end
+        end
+        output_to
+      end
+    end
+
+    # Gives you raw image data back
+    # @return [String] binary string
+    def to_blob
+      f = File.new @path
+      f.binmode
+      f.read
+    ensure
+      f.close if f
+    end
+
+    # If an unknown method is called then it is sent through the morgrify program
+    # Look here to find all the commands (http://www.imagemagick.org/script/mogrify.php)
+    def method_missing(symbol, *args)
+      combine_options do |c|
+        c.method_missing(symbol, *args)
+      end
+    end
+
+    # You can use multiple commands together using this method. Very easy to use!
+    #
+    # @example
+    #   image.combine_options do |c|
+    #     c.draw "image Over 0,0 10,10 '#{MINUS_IMAGE_PATH}'"
+    #     c.thumbnail "300x500>"
+    #     c.background background
+    #   end
+    #
+    # @yieldparam command [CommandBuilder]
+    def combine_options(&block)
+      c = CommandBuilder.new('mogrify')
+      block.call(c)
+      c << @path
+      run(c)
+    end
+
+    # Check to see if we are running on win32 -- we need to escape things differently
+    def windows?
+      !(RUBY_PLATFORM =~ /win32|mswin|mingw/).nil?
+    end
+
+    def composite(other_image, output_extension = 'jpg', &block)
+      begin
+        second_tempfile = Tempfile.new(output_extension)
+        second_tempfile.binmode
+      ensure
+        second_tempfile.close
+      end
+
+      command = CommandBuilder.new("composite")
+      block.call(command) if block
+      command.push(other_image.path)
+      command.push(self.path)
+      command.push(second_tempfile.path)
+
+      run(command)
+      return Image.new(second_tempfile.path, second_tempfile)
+    end
+
+    # Outputs a carriage-return delimited format string for Unix and Windows
+    def format_option(format)
+      windows? ? "\"#{format}\\n\"" : "\"#{format}\\\\n\""
+    end
+
+    def run_command(command, *args)
+      # -ping "efficiently determine image characteristics."
+      if command == 'identify'
+        args.unshift '-ping'
+      end
+
+      run(CommandBuilder.new(command, *args))
+    end
+
+    def run(command_builder)
+      command = command_builder.command
+
+      sub = Subexec.run(command, :timeout => MiniMagick.timeout)
+
+      if sub.exitstatus != 0
+        # Clean up after ourselves in case of an error
+        destroy!
+
+        # Raise the appropriate error
+        if sub.output =~ /no decode delegate/i || sub.output =~ /did not return an image/i
+          raise Invalid, sub.output
+        else
+          # TODO: should we do something different if the command times out ...?
+          # its definitely better for logging.. otherwise we dont really know
+          raise Error, "Command (#{command.inspect.gsub("\\", "")}) failed: #{{:status_code => sub.exitstatus, :output => sub.output}.inspect}"
+        end
+      else
+        sub.output
+      end
+    end
+
+    def destroy!
+      return if @tempfile.nil?
+      File.unlink(@tempfile.path)
+      @tempfile = nil
+    end
+
+    private
+      # Sometimes we get back a list of character values
+      def read_character_data(list_of_characters)
+        chars = list_of_characters.gsub(" ", "").split(",")
+        result = ""
+        chars.each do |val|
+          result << ("%c" % val.to_i)
+        end
+        result
+      end
+  end
+
+  class CommandBuilder
+    attr :args
+    attr :command
+
+    def initialize(command, *options)
+      @command = command
+      @args = []
+      options.each { |arg| push(arg) }
+    end
+
+    def command
+      "#{MiniMagick.processor} #{@command} #{@args.join(' ')}".strip
+    end
+
+    def method_missing(symbol, *options)
+      guessed_command_name = symbol.to_s.gsub('_','-')
+      if guessed_command_name == "format"
+        raise Error, "You must call 'format' on the image object directly!"
+      elsif MOGRIFY_COMMANDS.include?(guessed_command_name)
+        add(guessed_command_name, *options)
+        self
+      else
+        super(symbol, *args)
+      end
+    end
+
+    def +(*options)
+      push(@args.pop.gsub /^-/, '+')
+      if options.any?
+        options.each do |o|
+          push "\"#{ o }\""
+        end
+      end
+    end
+
+    def add(command, *options)
+      push "-#{command}"
+      if options.any?
+        options.each do |o|
+          push "\"#{ o }\""
+        end
+      end
+    end
+
+    def push(arg)
+      @args << arg.to_s.strip
+    end
+    alias :<< :push
+  end
+end

data/test/command_builder_test.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'test/unit'
+require File.expand_path('../../lib/mini_magick', __FILE__)
+
+class CommandBuilderTest < Test::Unit::TestCase
+  include MiniMagick
+
+  def test_basic
+    c = CommandBuilder.new("test")
+    c.resize "30x40"
+    assert_equal "-resize \"30x40\"", c.args.join(" ")
+  end
+
+  def test_complicated
+    c = CommandBuilder.new("test")
+    c.resize "30x40"
+    c.alpha "1 3 4"
+    c.resize "mome fingo"
+    assert_equal "-resize \"30x40\" -alpha \"1 3 4\" -resize \"mome fingo\"", c.args.join(" ")
+  end
+
+  def test_plus_modifier_and_multiple_options
+    c = CommandBuilder.new("test")
+    c.distort.+ 'srt', '0.6 20'
+    assert_equal "+distort \"srt\" \"0.6 20\"", c.args.join(" ")
+  end
+  
+  def test_valid_command
+    begin
+      c = CommandBuilder.new("test", "path")
+      c.input 2
+      assert false
+    rescue NoMethodError
+      assert true
+    end
+  end
+
+  def test_dashed
+    c = CommandBuilder.new("test")
+    c.auto_orient
+    assert_equal "-auto-orient", c.args.join(" ")
+  end
+end

data/test/image_test.rb

@@ -0,0 +1,264 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'pathname'
+require 'stringio'
+require File.expand_path('../../lib/mini_magick', __FILE__)
+
+#MiniMagick.processor = :gm
+
+class ImageTest < Test::Unit::TestCase
+  include MiniMagick
+
+  CURRENT_DIR = File.dirname(File.expand_path(__FILE__)) + "/"
+
+  SIMPLE_IMAGE_PATH = CURRENT_DIR + "simple.gif"
+  MINUS_IMAGE_PATH  = CURRENT_DIR + "simple-minus.gif"
+  TIFF_IMAGE_PATH   = CURRENT_DIR + "leaves spaced.tiff"
+  NOT_AN_IMAGE_PATH = CURRENT_DIR + "not_an_image.php"
+  GIF_WITH_JPG_EXT  = CURRENT_DIR + "actually_a_gif.jpg"
+  EXIF_IMAGE_PATH   = CURRENT_DIR + "trogdor.jpg"
+  ANIMATION_PATH    = CURRENT_DIR + "animation.gif"
+
+  def test_image_from_blob
+    File.open(SIMPLE_IMAGE_PATH, "rb") do |f|
+      image = Image.read(f.read)
+      assert image.valid?
+      image.destroy!
+    end
+  end
+
+  def test_image_open
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    assert image.valid?
+    image.destroy!
+  end
+
+  def test_image_io_reading
+    buffer = StringIO.new(File.read(SIMPLE_IMAGE_PATH))
+    image = Image.read(buffer)
+    image.destroy!
+  end
+
+  def test_image_create
+    image = Image.create do |f|
+      f.write(File.read(SIMPLE_IMAGE_PATH))
+    end
+    image.destroy!
+  end
+
+  def test_image_new
+    image = Image.new(SIMPLE_IMAGE_PATH)
+    image.destroy!
+  end
+
+  def test_remote_image
+    image = Image.open("http://www.google.com/images/logos/logo.png")
+    image.valid?
+    image.destroy!
+  end
+
+  def test_image_write
+    output_path = "output.gif"
+    begin
+      image = Image.new(SIMPLE_IMAGE_PATH)
+      image.write output_path
+
+      assert File.exists?(output_path)
+    ensure
+      File.delete output_path
+    end
+    image.destroy!
+  end
+
+  def test_image_write_with_stream
+    stream = StringIO.new
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    image.write("/tmp/foo.gif")
+    image.write(stream)
+#    assert Image.read(stream.string).valid?
+    image.destroy!
+  end
+
+  def test_not_an_image
+    image = Image.new(NOT_AN_IMAGE_PATH)
+    assert_equal false, image.valid?
+    image.destroy!
+  end
+
+  def test_throw_on_openining_not_an_image
+    assert_raise(MiniMagick::Invalid) do
+      image = Image.open(NOT_AN_IMAGE_PATH)
+      image.destroy
+    end
+  end
+
+  def test_image_meta_info
+    image = Image.new(SIMPLE_IMAGE_PATH)
+    assert_equal 150, image[:width]
+    assert_equal 55, image[:height]
+    assert_equal [150, 55], image[:dimensions]
+    assert_match(/^gif$/i, image[:format])
+    image.destroy!
+  end
+
+  def test_tiff
+    image = Image.new(TIFF_IMAGE_PATH)
+    assert_equal "tiff", image[:format].downcase
+    assert_equal 50, image[:width]
+    assert_equal 41, image[:height]
+    image.destroy!
+  end
+
+  def test_gif_with_jpg_format
+    image = Image.new(GIF_WITH_JPG_EXT)
+    assert_equal "gif", image[:format].downcase
+    image.destroy!
+  end
+
+  def test_image_resize
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    image.resize "20x30!"
+
+    assert_equal 20, image[:width]
+    assert_equal 30, image[:height]
+    assert_match(/^gif$/i, image[:format])
+    image.destroy!
+  end
+
+  def test_image_resize_with_minimum
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    original_width, original_height = image[:width], image[:height]
+    image.resize "#{original_width + 10}x#{original_height + 10}>"
+
+    assert_equal original_width, image[:width]
+    assert_equal original_height, image[:height]
+    image.destroy!
+  end
+
+  def test_image_combine_options_resize_blur
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    image.combine_options do |c|
+      c.resize "20x30!"
+      c.blur "50"
+    end
+
+    assert_equal 20, image[:width]
+    assert_equal 30, image[:height]
+    assert_match(/^gif$/i, image[:format])
+    image.destroy!
+  end
+
+  def test_image_combine_options_with_filename_with_minusses_in_it
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    background = "#000000"
+    assert_nothing_raised do
+      image.combine_options do |c|
+        c.draw "image Over 0,0 10,10 '#{MINUS_IMAGE_PATH}'"
+        c.thumbnail "300x500>"
+        c.background background
+      end
+    end
+    image.destroy!
+  end
+
+  def test_exif
+    image = Image.open(EXIF_IMAGE_PATH)
+    assert_equal('0220', image["exif:ExifVersion"])
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    assert_equal('', image["EXIF:ExifVersion"])
+    image.destroy!
+  end
+
+  def test_original_at
+    image = Image.open(EXIF_IMAGE_PATH)
+    assert_equal(Time.local('2005', '2', '23', '23', '17', '24'), image[:original_at])
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    assert_nil(image[:original_at])
+    image.destroy!
+  end
+
+  def test_tempfile_at_path
+    image = Image.open(TIFF_IMAGE_PATH)
+    assert_equal image.path, image.instance_eval("@tempfile.path")
+    image.destroy!
+  end
+
+  def test_tempfile_at_path_after_format
+    image = Image.open(TIFF_IMAGE_PATH)
+    image.format('png')
+    assert_equal image.path, image.instance_eval("@tempfile.path")
+    image.destroy!
+  end
+
+  def test_previous_tempfile_deleted_after_format
+    image = Image.open(TIFF_IMAGE_PATH)
+    before = image.path.dup
+    image.format('png')
+    assert !File.exist?(before)
+    image.destroy!
+  end
+
+  def test_bad_method_bug
+    image = Image.open(TIFF_IMAGE_PATH)
+    begin
+      image.to_blog
+    rescue NoMethodError
+      assert true
+    end
+    image.to_blob
+    assert true #we made it this far without error
+    image.destroy!
+  end
+
+  def test_simple_composite
+    image = Image.open(EXIF_IMAGE_PATH)
+    result = image.composite(Image.open(TIFF_IMAGE_PATH)) do |c|
+      c.gravity "center"
+    end
+    assert `diff -s #{result.path} test/composited.jpg`.include?("identical")
+  end
+
+  # http://github.com/probablycorey/mini_magick/issues#issue/8
+  def test_issue_8
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    assert_nothing_raised do
+      image.combine_options do |c|
+        c.sample "50%"
+        c.rotate "-90>"
+      end
+    end
+    image.destroy!
+  end
+
+  # http://github.com/probablycorey/mini_magick/issues#issue/15
+  def test_issue_15
+    image = Image.open(Pathname.new(SIMPLE_IMAGE_PATH))
+    output = Pathname.new("test.gif")
+    image.write(output)
+  ensure
+    FileUtils.rm("test.gif")
+  end
+
+  def test_throw_format_error
+    image = Image.open(SIMPLE_IMAGE_PATH)
+    assert_raise MiniMagick::Error do
+      image.combine_options do |c|
+        c.format "png"
+      end
+    end
+    image.destroy!
+  end
+
+  # testing that if copying files formatted from an animation fails,
+  # it raises an appropriate error
+  def test_throw_animation_copy_after_format_error
+    image = Image.open(ANIMATION_PATH)
+    FileUtils.stubs(:copy_file).raises(Errno::ENOENT)
+    assert_raises MiniMagick::Error do
+      image.format('png')
+    end
+  end
+
+
+end

data/test/not_an_image.php

@@ -0,0 +1 @@
+<?php I am so not an image ?>

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: jf--mini_magick
+version: !ruby/object:Gem::Version 
+  hash: 5
+  prerelease: false
+  segments: 
+  - 3
+  - 1
+  version: "3.1"
+platform: ruby
+authors: 
+- Corey Johnson
+- Hampton Catlin
+- Peter Kieltyka
+- Jeffrey 'jf' Lim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-26 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: subexec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 0
+        - 4
+        version: 0.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 0
+        - 9
+        - 9
+        version: 0.9.9
+  type: :development
+  version_requirements: *id002
+description: ""
+email: 
+- probablycorey@gmail.com
+- hcatlin@gmail.com
+- peter@nulayer.com
+- jfs.world@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION
+- MIT-LICENSE
+- Rakefile
+- lib/mini_gmagick.rb
+- lib/mini_magick.rb
+- test/actually_a_gif.jpg
+- test/animation.gif
+- test/command_builder_test.rb
+- test/composited.jpg
+- test/image_test.rb
+- test/leaves spaced.tiff
+- test/not_an_image.php
+- test/simple-minus.gif
+- test/simple.gif
+- test/trogdor.jpg
+has_rdoc: true
+homepage: http://github.com/jf/mini_magick
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Manipulate images with minimal use of memory via ImageMagick / GraphicsMagick. With jf's fixes and patches.
+test_files: 
+- test/actually_a_gif.jpg
+- test/animation.gif
+- test/command_builder_test.rb
+- test/composited.jpg
+- test/image_test.rb
+- test/leaves spaced.tiff
+- test/not_an_image.php
+- test/simple-minus.gif
+- test/simple.gif
+- test/trogdor.jpg