mojo_magick 0.3.0

data/README

@@ -0,0 +1,112 @@
+MojoMagick
+==========
+
+MojoMagick is a "dog simple, do very little" image library. It is basically a couple of stateless
+module methods that make it somewhat more convenient than calling ImageScience by hand.
+
+The main reason to use MojoMagick is that you should consolidate your ImageScience calls into
+one place, so why not do it here? If you improve on this tool, send me the patch.
+
+This tool came about because I wanted a fast, simple, lightweight, nothing-goes-wrong-with-it-
+because-it's-too-simple-to-break image tool.
+
+Examples
+========
+
+# Obtain the size of an image (assuming image is "120wx222h")
+dimensions = MojoMagick::get_image_size(test_image)
+ # ==> dimensions now holds a hash: {:height => 120, :width => 222}
+
+# Resize an image so that it fits within a 100w x 200h bounding box
+# (Note: this will scale an image either up or down to fit these dimensions
+#        which may not be what you want.)
+# In this example, we overwrite our image, but if you pass in a different file for the
+# second file name, a new file will be created with the resized dimensions
+MojoMagick::resize('/img/test.jpg', '/img/test.jpg', {:width=>100, :height=>200})
+
+## Code sample of how to shrink all jpg's in a folder
+{{{
+require 'mojo_magick'
+
+image_folder = '/tmp/img'
+Dir::glob(File::join(image_folder, '*.jpg')).each do |image|
+  begin
+    # shrink all the images *in place* to no bigger than 60pix x 60pix
+    MojoMagick::shrink(image, image, {:width => 60, :height => 60})
+    puts "Shrunk: #{image}"
+  rescue MojoMagick::MojoFailed => e
+    STDERR.puts "Unable to shrink image '#{image}' - probably an invalid image\n#{e.message}"
+  rescue MojoMagick::MojoMagickException => e
+    STDERR.puts "Unknown exception on image '#{image}'\n#{e.message}"
+  end
+end
+}}}
+
+## More Code on setting memory limits for imagemagick
+# (Be sure you�re upgraded to the current release of ImageMagick.)
+
+# set limits on disk, area, map and ram usage
+# obtain/print a hash of default limits:
+puts MojoMagick::get_default_limits.inspect
+# current_limits shows same values:
+puts MojoMagick::get_current_limits.inspect
+
+MojoMagick::set_limits(:area => '32mb', :disk => '0', :memory => '64mb', :map => '32mb')
+puts MojoMagick::get_current_limits.inspect
+
+### More sample code (thanks to Elliot Nelson for adding this code to the system)
+# Two command-line builders, #convert and #mogrify, have been added to simplify
+# complex commands. Examples included below.
+
+# Example #convert usage:
+
+MojoMagick::convert('source.jpg', 'dest.jpg') do |c|
+  c.crop '250x250+0+0'
+  c.repage!
+  c.strip
+  c.set 'comment', 'my favorite file'
+end
+
+# Equivalent to:
+
+MojoMagick::raw_command('convert', 'source.jpg -crop 250x250+0+0 +repage -strip -set comment "my favorite file" dest.jpg')
+
+# Example #mogrify usage:
+
+MojoMagick::mogrify('image.jpg') {|i| i.shave '10x10'}
+
+# Equivalent to:
+
+MojoMagick::raw_command('mogrify', '-shave 10x10 image.jpg')
+
+# Example showing some additional options:
+
+MojoMagick::convert do |c|
+  c.file 'source.jpg'
+  c.blob my_binary_data
+  c.append
+  c.crop '256x256+0+0'
+  c.repage!
+  c.file 'output.jpg'
+end
+
+# Use .file to specify file names, .blob to create and include a tempfile. The
+# bang (!) can be appended to command names to use the '+' versions
+# instead of '-' versions.
+
+Availablility
+=============
+SVN Repo access from here: http://trac.misuse.org/science/wiki/MojoMagick
+Contact author or discuss MojoMagick here: http://www.misuse.org/science/2008/01/30/mojomagick-ruby-image-library-for-imagemagick/
+
+
+Updates by Jon Rogers (jon@2rye.com)
+------------------------------------
+# added gemspec for building gem with bundler
+# updated tests for ImageMagick 6.6
+# added ability to do fill + crop resizing
+# bumped version to 0.3.0
+
+
+Copyright (c) 2008 Steve Midgley, released under the MIT license
+ Credit to Elliot Nelson for significant code contributions. Thanks Elliot!

data/init.rb

@@ -0,0 +1 @@
+require File::expand_path(File::join(File::dirname(__FILE__), 'lib', 'mojo_magick'))

data/lib/image_resources.rb

@@ -0,0 +1,124 @@
+# This module provides some mix-in methods to permit resource limitation commands in MojoMagick
+# They're stored here simply to make MojoMagick more readable
+module ImageMagickResources
+  module ResourceLimits
+    @@resource_limits = {}
+
+    # controls limits on memory and other resources for imagemagick.
+    # possible values for type can include:
+    #    Area, Disk, File, Map, or Memory
+    # value is byte size for everything but Disk, where it's number of files
+    # type can be string or symbol.
+    # Just limiting Memory will not solve problems with imagemagick going out of
+    # control with resource consumption on certain bad files. You have to set disk,
+    # area and map limits too. Read up on imagemagick website for more.
+    # Different options have different units
+    #   DISK: N GB
+    #   AREA, MAP, MEMORY: N MB
+    #   FILE: N num file handles
+    # Examples:
+    #   # set disk to 5 gigabytes limit
+    #   MiniMagick::Image::set_limit(:disk => 5)
+    #   # set memory to 32mb, map to 64mb and disk to 0
+    #   MiniMagick::Image::set_limit(:memory => 32, 'map' => 64, 'disk' => 0)
+      def set_limits(options)
+        mem_fix = 1
+        options.each do |resource, value|
+          @@resource_limits[resource.to_s.downcase.to_sym] = value.to_s
+        end
+      end
+
+      # remove a limit
+      def remove_limits(*options)
+        mem_fix = 1
+        @@resource_limits.delete_if do |resource, value|
+          resource == options.values_at(options.index(resource))[0].to_s.downcase.to_sym
+        end
+      end
+
+      # remove limits from resources
+      def unset_limits(options = {})
+        mem_fix = 1
+        @@resource_limits = {}
+        if options[:unset_env]
+          ENV["MAGICK_AREA_LIMIT"]=nil
+          ENV["MAGICK_MAP_LIMIT"]=nil
+          ENV["MAGICK_MEMORY_LIMIT"]=nil
+          ENV["MAGICK_DISK_LIMIT"]=nil
+        end
+      end
+
+      # returns the default limits that imagemagick is using, when run with no "-limit" parameters
+    # options:
+    #   :show_actual_values => true (default false) - will return integers instead of readable values
+      def get_default_limits(options = {})
+        mem_fix = 1
+        parse_limits(options.merge(:get_current_limits => false))
+      end
+
+      # returns the limits that imagemagick is running based on any "set_limits" calls
+      def get_current_limits(options = {})
+        mem_fix = 1
+        parse_limits(options.merge(:get_current_limits => true))
+      end
+
+      alias :get_limits :get_current_limits
+
+      def parse_limits(options)
+        show_actual_values = options[:show_actual_values]
+        if options[:get_current_limits]
+          raw_limits = self.raw_command('identify', '-list resource')
+        else
+          # we run a raw shell command here to obtain limits without applying command line limit params
+          raw_limits = `identify -list resource`
+        end
+        row_limits = raw_limits.split("\n")
+        header = row_limits[0].chomp
+        data = row_limits[2].chomp
+        resources = header.strip.split
+        limits = data.strip.split
+        #resources = header.scan(/^ *([A-Z][a-z]+) +([A-Z][a-z]+) +([A-Z][a-z]+) +([A-Z][a-z]+) +([A-Z][a-z]+)/)[0]
+        #limits = data.scan(/^ *([0-9]+[.0-9a-z]+) +([0-9]+[.0-9a-z]+) +([0-9]+[.0-9a-z]+) +([0-9]+[.0-9a-z]+) +([0-9]+[.0-9a-z]+)/)[0]
+        actual_values = {}
+        readable_values = {}
+        resources.each_index do |i|
+          resource = resources[i].downcase.to_sym
+          scale = limits[i].match(%r{[a-z]+$}) || []
+          value = limits[i].match(%r{^[0-9]+})
+          unscaled_value = value ? value[0].to_i : -1
+          case scale[0]
+            when 'eb'
+              scaled_value = unscaled_value * (2 ** 60)
+            when 'pb'
+              scaled_value = unscaled_value * (2 ** 50)
+            when 'tb'
+              scaled_value = unscaled_value * (2 ** 40)
+            when 'gb'
+              scaled_value = unscaled_value * (2 ** 30)
+            when 'mb'
+              scaled_value = unscaled_value * (2 ** 20)
+            when 'kb'
+              scaled_value = unscaled_value * (2 ** 10)
+            when 'b'
+              scaled_value = unscaled_value
+            else
+              scaled_value = unscaled_value
+          end
+          actual_values[resource] = scaled_value
+          readable_values[resource] = limits[i]
+        end
+        # return actual values if requested in options, otherwise readable values
+        show_actual_values ? actual_values : readable_values
+      end # parse_limits
+
+      # returns a string suitable for passing as a set of imagemagick params
+    # that contains all the limit constraints
+    def get_limits_as_params
+      retval = ''
+      @@resource_limits.each do |type, value|
+        retval += " -limit #{type.to_s} #{value} "
+      end
+      retval
+    end
+  end
+end

data/lib/mojo_magick.rb

@@ -0,0 +1,226 @@
+require File::expand_path(File::join(File::dirname(__FILE__), 'image_resources'))
+require 'tempfile'
+
+# MojoMagick is a stateless set of module methods which present a convient interface
+# for accessing common tasks for ImageMagick command line library.
+#
+# MojoMagick is specifically designed to be efficient and simple and most importantly
+# to not leak any memory. For complex image operations, you will find MojoMagick limited.
+# You might consider the venerable MiniMagick or RMagick for your purposes if you care more
+# about ease of use rather than speed and memory management.
+
+# all commands raise "MojoMagick::MojoFailed" if command fails (ImageMagick determines command success status)
+
+# Two command-line builders, #convert and #mogrify, have been added to simplify
+# complex commands. Examples included below.
+#
+# Example #convert usage:
+#
+#   MojoMagick::convert('source.jpg', 'dest.jpg') do |c|
+#     c.crop '250x250+0+0'
+#     c.repage!
+#     c.strip
+#     c.set 'comment', 'my favorite file'
+#   end
+# 
+# Equivalent to:
+#
+#   MojoMagick::raw_command('convert', 'source.jpg -crop 250x250+0+0 +repage -strip -set comment "my favorite file" dest.jpg')
+#
+# Example #mogrify usage:
+#
+#   MojoMagick::mogrify('image.jpg') {|i| i.shave '10x10'}
+#
+# Equivalent to:
+# 
+#   MojoMagick::raw_command('mogrify', '-shave 10x10 image.jpg')
+#
+# Example showing some additional options:
+#
+#   MojoMagick::convert do |c|
+#     c.file 'source.jpg'
+#     c.blob my_binary_data
+#     c.append
+#     c.crop '256x256+0+0'
+#     c.repage!
+#     c.file 'output.jpg'
+#   end
+#
+# Use .file to specify file names, .blob to create and include a tempfile. The
+# bang (!) can be appended to command names to use the '+' versions
+# instead of '-' versions.
+#
+module MojoMagick
+
+  VERSION = "0.2.0"
+
+  class MojoMagickException < StandardError; end
+  class MojoError < MojoMagickException; end
+  class MojoFailed < MojoMagickException; end
+
+  # enable resource limiting functionality
+  extend ImageMagickResources::ResourceLimits
+
+  def MojoMagick::windows?
+    mem_fix = 1
+    !(RUBY_PLATFORM =~ /win32/).nil?
+  end
+
+  def MojoMagick::raw_command(command, args, options = {})
+    # this suppress error messages to the console
+    err_pipe = windows? ? "2>nul" : "2>/dev/null"
+    begin
+      execute = "#{command} #{get_limits_as_params} #{args} #{err_pipe}"
+      retval = `#{execute}`
+    # guarantee that only MojoError exceptions are raised here
+    rescue Exception => e
+      raise MojoError, "#{e.class}: #{e.message}"
+    end
+    if $? && !$?.success?
+      err_msg = options[:err_msg] || "MojoMagick command failed: #{command}."
+      raise(MojoFailed, "#{err_msg} (Exit status: #{$?.exitstatus})\n  Command: #{execute}")
+    end
+    retval
+  end
+
+  def MojoMagick::shrink(source_file, dest_file, options)
+    opts = options.dup
+    opts.delete(:expand_only)
+    MojoMagick::resize(source_file, dest_file, opts.merge(:shrink_only => true))
+  end
+
+  def MojoMagick::expand(source_file, dest_file, options)
+    opts = options.dup
+    opts.delete(:shrink_only)
+    MojoMagick::resize(source_file, dest_file, opts.merge(:expand_only => true))
+  end
+
+  # resizes an image and returns the filename written to
+  # options:
+  #   :width / :height => scale to these dimensions
+  #   :scale => pass scale options such as ">" to force shrink scaling only or "!" to force absolute width/height scaling (do not preserve aspect ratio)
+  #   :percent => scale image to this percentage (do not specify :width/:height in this case)
+  def MojoMagick::resize(source_file, dest_file, options)
+    retval = nil
+    scale_options = []
+    scale_options << '">"' unless options[:shrink_only].nil?
+    scale_options << '"<"' unless options[:expand_only].nil?
+    scale_options << '"!"' unless options[:absolute_aspect].nil?
+    scale_options << '"^"' unless options[:fill].nil?
+    scale_options = scale_options.join(' ')
+    
+    extras = []
+    if !options[:width].nil? && !options[:height].nil?
+      geometry = "#{options[:width]}X#{options[:height]}"
+    elsif !options[:percent].nil?
+      geometry = "#{options[:percent]}%"
+    else
+      raise MojoMagickError, "Unknown options for method resize: #{options.inspect}"
+    end
+    if !options[:fill].nil? && !options[:crop].nil?
+      extras << "-extent #{geometry}"
+      extras << "-gravity center"
+    end
+    retval = raw_command("convert", "\"#{source_file}\" -resize #{geometry}#{scale_options} #{extras.join(' ')} \"#{dest_file}\"")
+    dest_file
+  end
+
+  # returns an empty hash or a hash with :width and :height set (e.g. {:width => INT, :height => INT})
+  # raises MojoFailed when results are indeterminate (width and height could not be determined)
+  def MojoMagick::get_image_size(source_file)
+    # returns width, height of image if available, nil if not
+    retval = raw_command("identify", "-format \"w:%w h:%h\" \"#{source_file}\"")
+    return {} if !retval
+    width = retval.match(%r{w:([0-9]+) })
+    width = width ? width[1].to_i : nil
+    height = retval.match(%r{h:([0-9]+)})
+    height = height ? height[1].to_i : nil
+    raise(MojoFailed, "Indeterminate results in get_image_size: #{source_file}") if !height || !width
+    {:width=>width, :height=>height}
+  end
+
+  def MojoMagick::convert(source = nil, dest = nil)
+    opts = OptBuilder.new
+    opts.file source if source
+    yield opts
+    opts.file dest if dest
+    raw_command('convert', opts.to_s)
+  end
+
+  def MojoMagick::mogrify(dest = nil)
+    opts = OptBuilder.new
+    yield opts
+    opts.file dest if dest
+    raw_command('mogrify', opts.to_s)
+  end
+
+  # Option builder used in #convert and #mogrify helpers.
+  class OptBuilder
+    def initialize
+      @opts = []
+    end
+
+    # Add command-line options with no processing
+    def <<(arg)
+      if arg.is_a?(Array)
+        @opts += arg
+      else
+        @opts << arg
+      end
+      self
+    end
+
+    # Add files to command line, formatted if necessary
+    def file(*args)
+      args.each do |arg|
+        add_formatted arg
+      end
+      self
+    end
+    alias files file
+
+    # Create a temporary file for the given image and add to command line
+    def blob(arg)
+      file MojoMagick::tempfile(arg)
+    end
+
+    # Generic commands. Arguments will be formatted if necessary
+    def method_missing(command, *args)
+      if command.to_s[-1, 1] == '!'
+        @opts << "+#{command.to_s.chop}"
+      else
+        @opts << "-#{command}"
+      end
+      args.each do |arg|
+        add_formatted arg
+      end 
+      self
+    end
+
+    def to_s
+      @opts.join ' '
+    end
+
+    protected
+    def add_formatted(arg)
+      # Quote anything that would cause problems on *nix or windows
+      if arg =~ /[<>^|&();` ]/
+        @opts << "\"#{arg.gsub('"', '\"')}\""
+      else
+        @opts << arg
+      end
+    end
+  end
+
+  def MojoMagick::tempfile(data)
+    file = Tempfile.new("mojo")
+    file.binmode
+    file.write(data)
+    file.path
+  ensure
+    file.close
+  end
+    
+end # MojoMagick
+
+

data/test/mojo_magick_test.rb

@@ -0,0 +1,248 @@
+require 'test/unit'
+require File::expand_path(File::join(File::dirname(__FILE__), '..', 'init'))
+require 'fileutils'
+require 'tempfile'
+
+class MojoMagickTest < Test::Unit::TestCase
+
+  # we keep a fixtures path and a working path so that we can easily test image
+  # manipulation routines without tainting the original images
+  def setup
+    @fixtures_path = File.expand_path(File::join(File.dirname(__FILE__), 'fixtures'))
+    @working_path = File::join(@fixtures_path, 'tmp')
+  end
+
+  def reset_images
+    FileUtils::rm_r(@working_path) if File::exists?(@working_path)
+    FileUtils::mkdir(@working_path)
+    Dir::glob(File::join(@fixtures_path, '*')).each do |file|
+      FileUtils::cp(file, @working_path) if File::file?(file)
+    end
+  end
+
+  def test_image_management
+    reset_images
+    test_image = File::join(@working_path, '5742.jpg')
+    orig_image_size = File::size(test_image)
+    retval = MojoMagick::get_image_size(test_image)
+    assert_equal orig_image_size, File::size(test_image)
+    assert_equal 500, retval[:height]
+    assert_equal 333, retval[:width]
+
+    # test basic resizing
+    size_test_temp = Tempfile::new('mojo_test')
+    size_test = size_test_temp.path
+    retval = MojoMagick::resize(test_image, size_test, {:width=>100, :height=>100})
+    assert_equal size_test, retval
+    assert_equal orig_image_size, File::size(test_image)
+    assert_equal retval, size_test
+    new_dimensions = MojoMagick::get_image_size(size_test)
+    assert_equal 100, new_dimensions[:height]
+    assert_equal 67, new_dimensions[:width]
+
+    # we should be able to resize image right over itself
+    retval = MojoMagick::resize(test_image, test_image, {:width=>100, :height=>100})
+    assert_equal test_image, retval
+    assert_not_equal orig_image_size, File::size(test_image)
+    new_dimensions = MojoMagick::get_image_size(test_image)
+    assert_equal 100, new_dimensions[:height]
+    assert_equal 67, new_dimensions[:width]
+
+    # image shouldn't resize if we specify very large dimensions and specify "shrink_only"
+    reset_images
+    orig_image_size = File::size(test_image)
+    retval = MojoMagick::shrink(test_image, test_image, {:width=>1000, :height=>1000})
+    assert_equal test_image, retval
+    new_dimensions = MojoMagick::get_image_size(test_image)
+    assert_equal 500, new_dimensions[:height]
+    assert_equal 333, new_dimensions[:width]
+    # image should resize if we specify small dimensions and shrink_only
+    retval = MojoMagick::shrink(test_image, test_image, {:width=>1000, :height=>100})
+    assert_equal test_image, retval
+    new_dimensions = MojoMagick::get_image_size(test_image)
+    assert_equal 100, new_dimensions[:height]
+    assert_equal 67, new_dimensions[:width]
+
+    # image shouldn't resize if we specify small dimensions and expand_only
+    reset_images
+    orig_image_size = File::size(test_image)
+    retval = MojoMagick::expand(test_image, test_image, {:width=>10, :height=>10})
+    assert_equal test_image, retval
+    new_dimensions = MojoMagick::get_image_size(test_image)
+    assert_equal 500, new_dimensions[:height]
+    assert_equal 333, new_dimensions[:width]
+    # image should resize if we specify large dimensions and expand_only
+    retval = MojoMagick::expand(test_image, test_image, {:width=>1000, :height=>1000})
+    assert_equal test_image, retval
+    new_dimensions = MojoMagick::get_image_size(test_image)
+    assert_equal 1000, new_dimensions[:height]
+    assert_equal 666, new_dimensions[:width]
+
+
+    # test bad images
+    bad_image = File::join(@working_path, 'not_an_image.jpg')
+    zero_image = File::join(@working_path, 'zero_byte_image.jpg')
+    assert_raise(MojoMagick::MojoFailed) {MojoMagick::get_image_size(bad_image)}
+    assert_raise(MojoMagick::MojoFailed) {MojoMagick::get_image_size(zero_image)}
+    assert_raise(MojoMagick::MojoFailed) {MojoMagick::get_image_size('/file_does_not_exist_here_ok.jpg')}
+  end
+
+  def test_resource_limits
+    orig_limits = MojoMagick::get_default_limits
+    assert_equal 7, orig_limits.size
+    orig_limits_test = orig_limits.dup
+    orig_limits_test.delete_if do |resource, value|
+      assert [:area, :map, :disk, :memory, :file, :thread, :time].include?(resource), "Found unexpected resource #{resource}"
+      true
+    end
+    assert_equal 0, orig_limits_test.size
+
+    # set area to 32mb limit
+    MojoMagick::set_limits(:area => '32mb')
+    new_limits = MojoMagick::get_current_limits
+    assert_equal '32mb', new_limits[:area].downcase
+
+    # remove limits on area
+    MojoMagick::remove_limits(:area)
+    new_limits = MojoMagick::get_current_limits
+    assert_equal orig_limits[:area], new_limits[:area]
+
+    # set memory to 64 mb, disk to 0 and
+    MojoMagick::set_limits(:memory => '64mb', :disk => '0b')
+    new_limits = MojoMagick::get_current_limits(:show_actual_values => true)
+    assert_equal 61, new_limits[:memory]
+    assert_equal 0, new_limits[:disk]
+
+    # return to original/default limit values
+    MojoMagick::unset_limits
+    new_limits = MojoMagick::get_current_limits
+    assert_equal orig_limits, new_limits
+  end
+
+  def test_tempfile
+    # Create a tempfile and return the path
+    filename = MojoMagick::tempfile('binary data')
+    File.open(filename, 'rb') do |f|
+      assert_equal f.read, 'binary data'
+    end
+  end
+
+  # These tests make the assumption that if we call #raw_command with the
+  # correct strings, ImageMagick itself will operate correctly. We're only
+  # verifying that the option builder produces the correct strings.
+  def test_option_builder
+    # Passing in basic commands produces a string
+    b = MojoMagick::OptBuilder.new
+    b.strip
+    b.repage
+    assert_equal '-strip -repage', b.to_s
+
+    # Chaining commands works
+    b = MojoMagick::OptBuilder.new.strip.repage
+    assert_equal '-strip -repage', b.to_s
+
+    # Bang (!) indicates the plus version of commands
+    b = MojoMagick::OptBuilder.new
+    b.repage
+    b.repage!
+    assert_equal '-repage +repage', b.to_s
+
+    # Accepts raw data as-is
+    b = MojoMagick::OptBuilder.new
+    b.opt1
+    b << 'a ! b !'
+    b.opt2
+    assert_equal '-opt1 a ! b ! -opt2', b.to_s
+
+    # Treats an array of raw data as different arguments
+    b = MojoMagick::OptBuilder.new
+    b << ['leave this data','alone']
+    assert_equal 'leave this data alone', b.to_s
+
+    # String includes command arguments
+    b = MojoMagick::OptBuilder.new
+    b.extent '256x256+0+0'
+    b.crop '64x64'
+    assert_equal '-extent 256x256+0+0 -crop 64x64', b.to_s
+
+    # Arguments are quoted (doublequote) if appropriate
+    b = MojoMagick::OptBuilder.new
+    b.comment 'white space'
+    b.comment 'w&b'
+    b.crop '6x6^'
+    assert_equal '-comment "white space" -comment "w&b" -crop "6x6^"', b.to_s
+
+    # Existing doublequotes are escaped
+    b = MojoMagick::OptBuilder.new
+    b.comment 'Fred "Woot" Rook'
+    assert_equal '-comment "Fred \"Woot\" Rook"', b.to_s
+
+    # Multi-argument commands should not be quoted together
+    b = MojoMagick::OptBuilder.new
+    b.set 'comment', 'the "best" comment'
+    assert_equal '-set comment "the \"best\" comment"', b.to_s
+
+    # File and files are helper methods
+    b = MojoMagick::OptBuilder.new
+    b.files 'source.jpg', 'source2.jpg'
+    b.append
+    b.crop '64x64'
+    b.file 'dest%d.jpg'
+    assert_equal 'source.jpg source2.jpg -append -crop 64x64 dest%d.jpg', b.to_s
+
+    # Files are quoted (doublequote) if appropriate
+    b = MojoMagick::OptBuilder.new
+    b.file 'probably on windows.jpg'
+    assert_equal '"probably on windows.jpg"', b.to_s
+   
+    # Blob is a shortcut for the #tempfile helper method
+    b = MojoMagick::OptBuilder.new
+    b.blob 'binary data'
+    filename = b.to_s
+    File.open(filename, 'rb') do |f|
+      assert_equal f.read, 'binary data'
+    end
+  end
+
+  def test_command_helpers
+    reset_images
+    test_image = File::join(@working_path, '5742.jpg')
+    out_image = File::join(@working_path, 'out1.jpg')
+
+    # Simple convert test
+    MojoMagick::convert do |c|
+      c.file test_image
+      c.crop '92x64+0+0'
+      c.repage!
+      c.file out_image
+    end
+    retval = MojoMagick::get_image_size(out_image)
+    assert_equal 92, retval[:width]
+    assert_equal 64, retval[:height]    
+
+    # Simple mogrify test
+    MojoMagick::mogrify do |m|
+      m.crop '32x32+0+0'
+      m.repage!
+      m.file out_image
+    end
+    retval = MojoMagick::get_image_size(out_image)
+    assert_equal 32, retval[:width]
+    assert_equal 32, retval[:height]
+
+    # Convert test, using file shortcuts
+    MojoMagick::convert(test_image, out_image) do |c|
+      c.crop '100x100+0+0'
+      c.repage!
+    end
+    retval = MojoMagick::get_image_size(out_image)
+    assert_equal 100, retval[:width]
+    assert_equal 100, retval[:height]
+
+    # Mogrify test, using file shortcut
+    MojoMagick::mogrify(out_image) { |m| m.shave('25x25').repage! }
+    retval = MojoMagick::get_image_size(out_image)
+    assert_equal 50, retval[:width]
+    assert_equal 50, retval[:height]
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: mojo_magick
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Steve Midgley
+- Elliot Nelson
+- Jon Rogers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-28 00:00:00 Z
+dependencies: []
+
+description: Simple Ruby stateless module interface to imagemagick.
+email: 
+- public@misuse.org
+- j@2rye.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- init.rb
+- lib/image_resources.rb
+- lib/mojo_magick.rb
+- test/fixtures/5742.jpg
+- test/fixtures/not_an_image.jpg
+- test/fixtures/tmp/5742.jpg
+- test/fixtures/tmp/not_an_image.jpg
+- test/fixtures/tmp/zero_byte_image.jpg
+- test/fixtures/zero_byte_image.jpg
+- test/mojo_magick_test.rb
+homepage: http://github.com/bunnymatic/mojo_magick
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: mojo_magick
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: mojo_magick-0.3.0
+test_files: 
+- test/fixtures/5742.jpg
+- test/fixtures/not_an_image.jpg
+- test/fixtures/tmp/5742.jpg
+- test/fixtures/tmp/not_an_image.jpg
+- test/fixtures/tmp/zero_byte_image.jpg
+- test/fixtures/zero_byte_image.jpg
+- test/mojo_magick_test.rb