image_proc 0.1.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-01-09
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,15 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+init.rb
+lib/image_proc.rb
+test/input/horizontal.gif
+test/input/horizontal.jpg
+test/input/horizontal.png
+test/input/vertical.gif
+test/input/vertical.jpg
+test/input/vertical.png
+test/resize_test_helper.rb
+test/test_geom.rb
+test/test_image_proc.rb

data/README.txt

@@ -0,0 +1,36 @@
+= ImageProc
+
+* http://wiretap.rubyforge.org/image_proc
+
+== DESCRIPTION:
+
+A no-frills image resizer, with pluggable backends. No extra software required on OS X
+
+== INSTALL:
+
+* sudo gem install image_proc
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Julik Tarkhanov <me@julik.nl>
+
+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/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'hoe'
+require './lib/image_proc.rb'
+
+Hoe.new('image_proc', ImageProc::VERSION) do |p|
+  p.description = 'A no-frills image metadata and resizing'
+  p.developer('Julik', 'me@julik.nl')
+  p.rubyforge_name = 'wiretap'
+  p.remote_rdoc_dir = 'image_proc'
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/image_proc'

data/lib/image_proc.rb

@@ -0,0 +1,293 @@
+# A simplistic interface to shell-based image processing. Pluggable, compact and WIN32-incompatible by
+# design. Sort of like the Processors in attachment_fu but less. Less.
+#
+#    width, height = ImageProc.get_bounds("image.png")
+#    thumb_filename = ImageProc.resize("image.png", "thumb.png", "50x50")
+#
+# The whole idea is: a backend does not have to support cropping (we don't do it), it has only to be able to resize,
+# and a backend should have 2 public methods. That's the game.
+require 'open3'
+
+class ImageProc
+  VERSION = '0.1.0'
+
+  class Error < RuntimeError; end
+  class MissingInput < Error; end
+  class NoDestinationDir < Error; end
+  class DestinationLocked < Error; end
+  class NoOverwrites < Error; end
+  class FormatUnsupported < Error; end
+  class InvalidOptions < Error; end
+  
+  HARMLESS = []
+  class << self
+    # Assign a specific processor class
+    def engine=(kls); @@engine = kls; end
+  
+    # Get the processor class currently assigned
+    def engine; @@engine ||= detect_engine; @@engine; end
+    
+    # Tries to detect the best engine available
+    def detect_engine
+      if RUBY_PLATFORM =~ /darwin/i
+        ImageProcSips
+      elsif (`which convert` =~ /^\// )
+        ImageProcConvert
+      else
+        raise "This system has no image processing facitilites that we can use"
+      end
+    end
+    
+    # Qukckly get bounds of an image
+    #   ImageProc.get_bounds("/tmp/upload.tif") #=> [100, 120]
+    def get_bounds(of)
+      engine.new.get_bounds(File.expand_path(of))
+    end
+    
+    def method_missing(*args) #:nodoc:
+      engine.new.send(*args)
+    end
+  end
+  
+  # Deprecated - pass the fitting as geometry string. Will use proportional fitting.
+  def resize(from, to, geom)
+    to_width, to_height = geom.scan(/(\d+)/).flatten
+    resize_fit_both(from, to, to_width, to_height).shift
+  end
+  alias_method :process, :resize
+  
+  # Resizes with specific options passed as a hash
+  #   ImageProc.resize_with_options "/tmp/foo.jpg", "bla.jpg", :width => 120, :height => 30
+  def resize_with_options(from_path, to_path, opts = {})
+    # raise InvalidOptions,
+    #   "The only allowed options are :width, :height and :fill" if (opts.keys - [:width, :height, :fill]).any?
+    raise InvalidOptions,
+      "Pass width, height or both" unless (opts.keys & [:width, :height]).any?
+    opts.each_pair { |k,v|  raise InvalidOptions, "#{k.inspect} cannot be set to nil" if v.nil? }
+    
+    if opts[:width] && opts[:height] && opts[:fill]
+      resize_fit_fill(from_path, to_path, opts[:width], opts[:height])
+    elsif opts[:width] && opts[:height]
+      resize_fit(from_path, to_path, opts[:width], opts[:height])
+    elsif opts[:width]
+      resize_fit_width(from_path, to_path, opts[:width])
+    elsif opts[:height]
+      resize_fit_height(from_path, to_path, opts[:height])
+    else
+      raise "This should never happen"
+    end
+  end
+  
+  # Resize an image fitting the biggest side of it to the side of a square. A must for thumbs.
+  def resize_fit_square(from_path, to_path, square_side)
+    resize_fit_both(from_path, to_path, square_side, square_side)
+  end
+
+  # Resize an image fitting the boundary exactly. Will stretch and squash.
+  def resize_exact(from_path, to_path, to_width, to_height)
+    validate_input_output_files(from_path, to_path)
+    @target_w, @target_h = to_width, to_height
+    resetting_state_afterwards { process_exact }
+  end
+
+  # Resize an image fitting it into a rect.
+  def resize_fit_both(from_path, to_path, to_width, to_height)
+    validate_input_output_files(from_path, to_path)
+    @target_w, @target_h = fit_sizes(get_bounds(from_path), :width => to_width, :height => to_height)
+    resetting_state_afterwards { process_exact }
+  end
+  alias_method :resize_fit, :resize_fit_both
+
+  # Resize an image fitting the biggest side of it to the side of a square. A must for thumbs.  
+  def resize_fit_width(from_path, to_path, width)
+    validate_input_output_files(from_path, to_path)
+    
+    @target_w, @target_h = fit_sizes get_bounds(from_path), :width => width
+    resetting_state_afterwards { process_exact }
+  end
+
+  # Same as resize_fit_width  
+  def resize_fit_height(from_path, to_path, height)
+    validate_input_output_files(from_path, to_path)
+    @target_w, @target_h = fit_sizes(get_bounds(from_path), :height => height)
+    resetting_state_afterwards { process_exact }
+  end
+
+  # Will resize the image so that it's part always fills the rect of +width+ and +height+
+  # It's recommended to then simply use CSS overflow to crop off the edges which are not necessary.
+  # If you want more involved processing calculate the geometry directly.
+  def resize_fit_fill(from_path, to_path, width, height)
+    validate_input_output_files(from_path, to_path)
+    @target_w, @target_h = fit_sizes_with_crop get_bounds(from_path), :height => height, :width => width
+    resetting_state_afterwards { process_exact }
+  end
+  
+  # Will fit the passed array of [input_width, input_heitght] proportionally and return an array of
+  # [recommended_width, recommended_height] honoring the following parameters:
+  #
+  # :width - maximum width of the bounding rect
+  # :height - maximum height of the bounding rect
+  #
+  # If you pass both the bounds will be fit into the rect having the :width and :height proportionally, downsizing the
+  # bounds if necessary. Useful for calculating needed size before resizing.
+  def fit_sizes(bounds, opts)
+    
+    disallow_nil_values_in(opts)
+    integerize_values_of(opts)
+    
+    ratio = bounds[0].to_f / bounds[1].to_f
+    floats = case (opts.keys & [:height, :width])
+      when []
+        raise "The options #{opts.inspect} do not contain proper bounds"
+      when [:width]
+        desired_w = opts[:width]
+        [desired_w, desired_w / ratio]
+      when [:height]
+        desired_h = opts[:height]
+        [desired_h * ratio, desired_h]
+      else # both, use reduction
+        smallest_side = [opts[:width], opts[:height]].sort.shift
+        if bounds[0] > bounds[1] # horizontal
+          fit_sizes bounds, :width => smallest_side
+        else
+          fit_sizes bounds, :height => smallest_side
+        end
+    end
+  
+    # Prevent zero results 
+    prevent_zeroes_in(floats)
+
+    # Nudge output values to pixels so that we fit exactly    
+    floats[0] = opts[:width] if (opts[:width] && floats[0] > opts[:width])
+    floats[1] = opts[:height] if (opts[:height] && floats[1] > opts[:height])
+    floats
+  end
+
+  # Will fit the passed array of [input_width, input_heitght] to fill the whole rect and return an array of
+  # [recommended_width, recommended_height] honoring the following parameters:
+  #
+  # :width - maximum width of the bounding rect
+  # :height - maximum height of the bounding rect
+  #
+  # In contrast to fit_sizes it requires BOTH.
+  #
+  # It's recommended to clip the image which will be created with these bounds using CSS, as not all resizers support
+  # cropping - and besides it's just too many vars.
+  def fit_sizes_with_crop(bounds, opts)
+    raise Error, "fit_sizes_with_crop requires both width and height" unless (opts.keys & [:width, :height]).length == 2
+    scale = [opts[:width].to_f / bounds[0], opts[:height].to_f / bounds[1]].sort.pop
+    result = [bounds[0] * scale, bounds[1] * scale]
+    result.map{|e| e.round}
+  end
+  
+  private
+    def prevent_zeroes_in(floats)
+      floats.map!{|f| r = f.round.to_i; (r.zero? ? 1 : r) }
+    end
+    
+    def disallow_nil_values_in(floats)
+      floats.each_pair{|k,v| floats.delete(k) if v.nil? }
+    end
+    
+    # cleanup any stale ivars and return the path to result and the resulting bounds
+    def resetting_state_afterwards
+      begin
+        @dest = @dest % [@target_w, @target_h] if File.basename(@dest).include?('%')
+        kept = [@dest, @target_w, @target_h]; yield
+      ensure
+        @source, @dest, @source_w, @dest_w, @source_h, @dest_h = nil
+      end
+      kept
+    end
+    
+    def validate_input_output_files(from_path, to_path)
+      @source, @dest = [from_path, to_path].map{|p| File.expand_path(p) }
+      destdir = File.dirname(@dest)
+      raise MissingInput, "No such file or directory #{@source}" unless File.exist?(@source)
+      raise NoDestinationDir, "No destination directory #{destdir}" unless File.exist?(destdir)
+      raise DestinationLocked, "Cannot write to #{destdir}" unless File.writable?(destdir)
+      raise NoOverwrites, "This will overwrite #{@dest}" if File.exist?(@dest)
+      # This will raise if anything happens
+      @source_w, @source_h = get_bounds(from_path)
+    end
+    
+    def integerize_values_of(h)
+      h.each_pair{|k,v| v.nil? ? h.delete(k) : (h[k] = v.to_i)}
+    end
+    
+    def wrap_stderr(cmd)
+      inp, outp, err = Open3.popen3(cmd)
+      error = err.read.to_s.strip
+      result = outp.read.strip
+      unless self.class::HARMLESS.select{|warning| error =~ warning }.any?
+        raise Error, "Problem with #{@source}: #{error}" unless error.nil? || error.empty?
+      end
+      [inp, outp, err].map{|socket| begin; socket.close; rescue IOError; end }
+      result
+    end
+  
+end
+
+class ImageProcConvert < ImageProc
+  HARMLESS = [/unknown field with tag/]
+  def process_exact
+    wrap_stderr("convert -resize #{@target_w}x#{@target_h}! #{@source} #{@dest}")
+  end
+  
+  def get_bounds(of)
+    wrap_stderr("identify #{of}").scan(/(\d+)x(\d+)/)[0].map{|e| e.to_i }
+  end
+end
+
+class ImageProcRmagick < ImageProc
+  def get_bounds(of)
+    run_require
+    comp = wrap_err { Magick::Image.ping(of)[0] }
+    res = comp.columns, comp.rows
+    comp = nil; return res
+  end
+
+  def process_exact
+    run_require
+    img = wrap_err { Magick::Image.read(@source).first }
+    img.scale(@target_w, @target_h).write(@dest)
+    img = nil # deallocate the ref
+  end
+  private
+    def run_require
+      require 'RMagick' unless defined?(Magick)
+    end
+    
+    def wrap_err
+      begin
+        yield
+      rescue Magick::ImageMagickError => e
+        raise Error, e.to_s
+      end
+    end
+end
+
+class ImageProcSips < ImageProc
+  # -Z pixelsWH --resampleHeightWidthMax pixelsWH
+  FORMAT_MAP = { ".tif" => "tiff", ".png" => "png", ".tif" => "tiff", ".gif" => "gif" }
+  HARMLESS = [/XRefStm encountered but/, /CGColor/]
+  def process_exact
+    fmt = detect_source_format
+    wrap_stderr("sips -s format #{fmt} --resampleHeightWidth #{@target_h} #{@target_w} #{@source} --out '#{@dest}'")
+  end
+  
+  def get_bounds(of)
+    wrap_stderr("sips #{of} -g pixelWidth -g pixelHeight").scan(/(pixelWidth|pixelHeight): (\d+)/).to_a.map{|e| e[1].to_i}
+  end
+  
+  private
+    def detect_source_format
+      suspected = FORMAT_MAP[File.extname(@source)]
+      suspected =  (suspected.nil? || suspected.empty?) ? 'jpeg' : suspected
+      case suspected
+        when "png", "gif"
+          raise FormatUnsupported, "SIPS cannot resize indexed color GIF or PNG images, call Apple if you want to know why"
+      end
+      return suspected
+    end
+end

data/test/resize_test_helper.rb

@@ -0,0 +1,251 @@
+module ResizeTestHelper
+  INPUTS = File.expand_path(File.dirname(__FILE__) + '/input')
+  OUTPUTS = File.expand_path(File.dirname(__FILE__) + '/output')
+  
+  def setup
+    Dir.glob(File.dirname(__FILE__) + '/output/*.*').map{ |e| FileUtils.rm e }
+
+    @extensions = ["jpg", "png", "gif"]
+    @landscapes =  @extensions.map { | ext | "horizontal.#{ext}" }
+    @portraits =  @extensions.map { | ext | "vertical.#{ext}" }
+    @landscape_bounds = 780, 520
+    @portraits_bounds = 466, 699
+  end
+  
+  def test_get_bounds_raise_when_file_passed_does_not_exist
+    assert_raise(ImageProc::Error) do
+      @processor.get_bounds("/tmp/__non_existent/#{Time.now.to_i}")
+    end
+  end
+  
+  def test_get_bounds_raise_when_file_passed_is_not_an_image
+    assert_raise(ImageProc::Error) do
+      @processor.get_bounds(INPUTS + '/not.an.image.tmp')
+    end
+  end
+  
+  def test_properly_detects_bounds
+    @landscapes.map do |file| 
+      assert_equal @landscape_bounds, @processor.get_bounds(INPUTS + "/" + file)
+    end
+    
+    @portraits.map do |file| 
+      assert_equal @portraits_bounds, @processor.get_bounds(INPUTS + "/" + file)
+    end
+  end
+  
+  def test_resize_raises_when_trying_to_overwrite
+    assert_raise(ImageProc::NoOverwrites) do
+      @processor.resize INPUTS + '/' + @landscapes[0], INPUTS + '/' + @portraits[0], "100x100"
+    end
+  end
+  
+  def test_resize_raises_when_source_missing
+    missing_input = "/tmp/___imageproc_missing.jpg"
+    assert !File.exist?(missing_input)
+    assert_raise(ImageProc::MissingInput) do
+      @processor.resize missing_input, OUTPUTS + '/zeoutput.jpg', "100x100"
+    end
+  end
+  
+  def test_resize_raises_wheh_destination_dir_missing
+    missing_output = "/tmp/___imageproc_missing/__missing.jpg"
+    from = (INPUTS + '/' + @landscapes[0])
+    
+    assert !File.exist?(File.dirname(missing_output))
+    assert_raise(ImageProc::NoDestinationDir) do
+      @processor.resize from, missing_output, "100x100"
+    end    
+  end
+  
+  def test_resize_exact
+    names = (@landscapes  + @portraits)
+    sources = names.map{|file| INPUTS + "/" + file }
+
+    sources.each_with_index do | source, index |
+      assert_nothing_raised do
+        path, w, h  = @processor.resize_exact(source, OUTPUTS + '/' + names[index], 65, 65)
+        assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [65, 65], get_bounds(result_p), "The image should have been resized exactly"
+    end
+  end
+  
+  def test_resize_fitting_proportionally_into_square
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+        path, w, h  = @processor.resize_fit(source, OUTPUTS + '/' + name, 300, 300)
+        assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [300, 200], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+    end
+    
+    with_each_vertical_path_and_name do | source, name |
+      assert_nothing_raised { @processor.resize_fit(source, OUTPUTS + '/' + name, 300, 300) }
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [200, 300 ], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+    end
+  end
+  
+  def test_fit_square_is_alias_for_proportional_resize
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+        path, w, h  = @processor.resize_fit_square(source, OUTPUTS + '/' + name, 300)
+        assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [300, 200], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+    end
+  end
+  
+  def test_resize_fitting_proportionally_into_portrait
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+        path, w, h  = @processor.resize_fit(source, OUTPUTS + '/' + name, 20, 100)
+        assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [20, 13], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+    end
+  end
+  
+  def test_resize_fitting_proportionally_into_landscape
+     with_each_vertical_path_and_name do | source, name |
+       assert_nothing_raised do
+         path, w, h  = @processor.resize_fit(source, OUTPUTS + '/' + name, 100, 20)
+         assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+       end
+
+       result_p = OUTPUTS + '/' + File.basename(source)
+       assert File.exist?(result_p), "#{result_p} should have been created"
+       assert_equal [13, 20], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+     end
+  end
+  
+  def test_replaces_wildcards_in_filenames_after_resizing
+    source = INPUTS + '/' + @landscapes[0]
+    with_wildcards = OUTPUTS + '/resized_%dx%d' + File.extname(@landscapes[0])
+    reference_path = with_wildcards % [300, 200]
+    assert_nothing_raised do
+      path, w, h  = @processor.resize_fit(source, with_wildcards, 300, 300)
+      assert_equal path, reference_path, "The wildcards should be replaced with computed width and height and the file saved"
+      assert_equal [300, 200], get_bounds(reference_path)
+    end
+  end
+  
+  def test_resize_is_alias_for_fit_with_geometry_string
+     with_each_horizontal_path_and_name do | source, name |
+       assert_nothing_raised { @processor.resize(source, OUTPUTS + '/' + name, "300x300") }
+     
+       result_p = OUTPUTS + '/' + File.basename(source)
+       assert File.exist?(result_p), "#{result_p} should have been created"
+       assert_equal [300, 200], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+     end
+   
+     with_each_vertical_path_and_name do | source, name |
+       assert_nothing_raised do
+          path = @processor.resize(source, OUTPUTS + '/' + name, "300x300")
+          assert_kind_of String, path, "ImageProc#resize is legacy so it should return the path and nothing else"
+          assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result"
+       end
+       
+       result_p = OUTPUTS + '/' + File.basename(source)
+       assert File.exist?(result_p), "#{result_p} should have been created"
+       assert_equal [200, 300 ], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into rect proortionally"
+     end
+  end
+  
+  def test_resize_fit_width
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+         path, w, h = @processor.resize_fit_width(source, OUTPUTS + '/' + name, 400)
+         assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [400, 267], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been into width"
+    end
+    
+    with_each_vertical_path_and_name do | source, name |
+      assert_nothing_raised do
+         path, w, h = @processor.resize_fit_width(source, OUTPUTS + '/' + name, 400)
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [400, 600 ], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into width"
+    end
+  end
+  
+  def test_resize_fit_height
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+         path, w, h = @processor.resize_fit_height(source, OUTPUTS + '/' + name, 323)
+         assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [485, 323], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been into width"
+    end
+    
+    with_each_vertical_path_and_name do | source, name |
+      assert_nothing_raised do
+         path, w, h = @processor.resize_fit_width(source, OUTPUTS + '/' + name, 323)
+         assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [323, 485], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been fit into width"
+    end
+  end
+  
+  def test_resize_fit_fill
+    with_each_horizontal_path_and_name do | source, name |
+      assert_nothing_raised do
+         path, w, h = @processor.resize_fit_fill(source, OUTPUTS + '/' + name, 260, 250)
+         assert_equal OUTPUTS + '/' + File.basename(source), path, "The proc should return the path to the result as first ret"
+      end
+      
+      result_p = OUTPUTS + '/' + File.basename(source)
+      assert File.exist?(result_p), "#{result_p} should have been created"
+      assert_equal [375, 250], get_bounds(result_p), "The image of #{get_bounds(source).join("x")} should have been into width"
+    end
+  end
+  
+  private
+    def get_bounds(of)
+      if RUBY_PLATFORM =~ /darwin/i
+        `sips #{of} -g pixelWidth -g pixelHeight`.scan(/(pixelWidth|pixelHeight): (\d+)/).to_a.map{|e| e[1]}
+      else
+        `identify #{of}`.scan(/(\d+)x(\d+)/)[0]
+      end.map{|e| e.to_i}
+    end
+    
+    def with_each_vertical_path_and_name
+      @portraits.each do | file |
+        yield(INPUTS + "/" + file, file)
+      end
+    end
+    
+    def with_each_horizontal_path_and_name
+      @landscapes.each do | file |
+        yield(INPUTS + "/" + file, file)
+      end
+    end
+    
+end

data/test/test_geom.rb

@@ -0,0 +1,112 @@
+require 'test/unit'
+require 'fileutils'
+require 'resize_test_helper'
+require 'image_proc'
+
+class TestGeometryFitting < Test::Unit::TestCase
+  def setup
+    @x = ImageProc.new
+    class << @x
+      public :fit_sizes
+    end
+  end
+  
+  def test_fit_width
+    bounds = [1024, 500]
+    assert_equal [50, 24], @x.fit_sizes(bounds, :width => 50)
+    assert_equal [50, 24], @x.fit_sizes(bounds, :width => 50, :height => nil)
+
+    bounds = [500, 1024]
+    assert_equal [50, 102], @x.fit_sizes(bounds, :width => 50)
+  end
+  
+  def test_fit_width_should_not_modify_values_if_image_fits_already
+    bounds = [100, 400]
+    assert_equal bounds, @x.fit_sizes(bounds, :width => 100)
+  end
+
+  def test_fit_height_should_not_modify_values_if_image_fits_already
+    bounds = [100, 400]
+    assert_equal bounds, @x.fit_sizes(bounds, :height => 400)
+  end
+  
+  def test_fit_height
+    bounds = [1024, 500]
+    assert_equal [102, 50], @x.fit_sizes(bounds, :height => 50)
+    assert_equal [102, 50], @x.fit_sizes(bounds, :height => 50, :width => nil)
+
+    bounds = [500, 1024]
+    assert_equal [24, 50], @x.fit_sizes(bounds, :height => 50)
+  end
+  
+  def test_fit_both
+    bounds = 1024, 500
+    assert_equal [70, 34], @x.fit_sizes(bounds, :height => 70, :width => 70)
+
+    bounds = 500, 1024
+    assert_equal [34, 70], @x.fit_sizes(bounds, :height => 70, :width => 70)
+    
+    bounds = 780, 520
+    assert_equal [120, 80], @x.fit_sizes(bounds, :height => 120, :width => 120)
+  end
+  
+  def test_fit_groks_strings_too
+    bounds = [1024, 500]
+    assert_equal [70, 34], @x.fit_sizes(bounds, :height => "70", :width => "70")
+  end
+  
+  def test_fit_rejects_nil_values
+    bounds = [1024, 500]
+    assert_equal [50, 24], @x.fit_sizes(bounds, :width => 50, :height => nil)
+    assert_equal [102, 50], @x.fit_sizes(bounds, :height => 50, :width => nil)
+  end
+
+  def test_fit_nevere_produces_zeroes
+    bounds = [1000, 20]
+    assert_equal [20, 1], @x.fit_sizes(bounds, :width => 20, :height => 20)
+  end
+end
+
+class TestGeometryFittingWithCrop < Test::Unit::TestCase
+  def setup
+    @x = ImageProc.new
+  end
+  
+  def test_fit_suare_into_smaller_square_requires_no_cropping
+    bounds = [100, 100]
+    assert_equal [20, 20], @x.fit_sizes_with_crop(bounds, :width => 20, :height => 20)
+  end
+
+  def test_fit_landscape_into_square_will_slice_off_left_and_right
+    bounds = [768, 575]
+    assert_equal [27, 20], @x.fit_sizes_with_crop(bounds, :width => 20, :height => 20)
+
+    bounds = [200, 40]
+    assert_equal [100, 20], @x.fit_sizes_with_crop(bounds, :width => 20, :height => 20)
+  end
+
+  def test_fit_portrait_into_square_will_slice_off_top_and_bottom
+    bounds = [576, 768]
+    assert_equal [300, 400], @x.fit_sizes_with_crop(bounds, :width => 300, :height => 300)
+  end
+
+  def test_fit_portrait_into_portrait_will_resize
+    bounds = [576, 768]
+    assert_equal [200, 267], @x.fit_sizes_with_crop(bounds, :width => 200, :height => 210)
+  end
+
+  def test_fit_landscape_into_portrait_will_resize
+    bounds = [768, 576]
+    assert_equal [280, 210], @x.fit_sizes_with_crop(bounds, :width => 200, :height => 210)
+  end
+  
+  def test_fit_with_crop_does_not_lie_when_small_floats_might_be_involved
+   bounds = [20, 1000]
+   assert_equal bounds, @x.fit_sizes_with_crop(bounds, :width => 20, :height => 20)
+  end
+  
+  def test_fit_with_crop_should_not_overnudge
+    bounds = [780, 520]
+    assert_equal [375, 250], @x.fit_sizes_with_crop(bounds, :width => 260, :height => 250)
+  end
+end

data/test/test_image_proc.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+require 'fileutils'
+require 'resize_test_helper'
+require 'image_proc'
+
+#class TestQuickProcessViaClassWithGeomString < Test::Unit::TestCase
+#  def test_works
+#    source = File.dirname(__FILE__) + '/input/horizontal.jpg'
+#    dest = File.dirname(__FILE__) + '/output/resized.jpg'
+#    assert_nothing_raised { ImageProc.resize(source, dest, "50x50") }
+#    FileUtils.rm dest
+#  end
+#end
+
+class TestQuickProcessWithOptions < Test::Unit::TestCase
+  def test_resize_with_options
+    source = File.dirname(__FILE__) + '/input/horizontal.jpg'
+    dest = File.dirname(__FILE__) + '/output/resized.jpg'
+    opts = {:height=>75, :fill=>true}
+    begin
+      assert_nothing_raised do
+        path, w, h = ImageProc.resize_with_options(source, dest, opts)
+      end
+    ensure
+      File.unlink(dest) rescue nil
+    end
+  end
+  
+  def test_raises_on_invalid_options
+    assert_raise(ImageProc::InvalidOptions) do
+      source = File.dirname(__FILE__) + '/input/horizontal.jpg'
+      dest = File.dirname(__FILE__) + '/output/resized.jpg'
+      opts = {:too => 4, :doo => 10}
+      ImageProc.resize_with_options(source, dest, opts)
+    end
+
+    assert_raise(ImageProc::InvalidOptions) do
+      source = File.dirname(__FILE__) + '/input/horizontal.jpg'
+      dest = File.dirname(__FILE__) + '/output/resized.jpg'
+      opts = {}
+      ImageProc.resize_with_options(source, dest, opts)
+    end
+  end
+end
+
+class TestEngineAssignmentSticks < Test::Unit::TestCase
+  def test_foreign_engine_assignment_sticks
+    dummy = "foobar"
+    ImageProc.engine = dummy
+    assert_equal dummy, ImageProc.engine
+    ImageProc.engine = nil
+  end
+end
+
+if RUBY_PLATFORM =~ /darwin/i
+  class TestImageProcSips < Test::Unit::TestCase
+    def setup
+      super
+      @processor = ImageProcSips.new
+      @landscapes.reject!{|e| e =~ /\.(png|gif)/}
+      @portraits.reject!{|e| e =~ /\.(png|gif)/}
+    end
+  
+    def test_sips_does_not_grok_pngs
+      assert_raise(ImageProc::FormatUnsupported) do
+        @processor.resize(INPUTS + '/horizontal.gif', OUTPUTS + '/horizontal.gif', "100x100")
+      end
+    end
+  
+    def test_sips_does_not_grok_gifs
+      assert_raise(ImageProc::FormatUnsupported) do
+        @processor.resize(INPUTS + '/horizontal.png', OUTPUTS + '/horizontal.png', "100x100")
+      end
+    end
+  
+    include ResizeTestHelper
+  end
+end
+
+if(`which convert`)
+  class TestImageProcConvert < Test::Unit::TestCase
+    def setup
+      super
+      @processor = ImageProcConvert.new
+    end
+  
+    include ResizeTestHelper
+  end
+end
+
+begin
+  require 'RMagick'
+  class TestImageProcRmagick < Test::Unit::TestCase
+    def setup
+      super
+      @processor = ImageProcRmagick.new
+    end
+  
+    include ResizeTestHelper
+  end
+rescue LoadError
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: image_proc
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Julik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-09 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: A no-frills image metadata and resizing
+email: 
+- me@julik.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- init.rb
+- lib/image_proc.rb
+- test/input/horizontal.gif
+- test/input/horizontal.jpg
+- test/input/horizontal.png
+- test/input/vertical.gif
+- test/input/vertical.jpg
+- test/input/vertical.png
+- test/resize_test_helper.rb
+- test/test_geom.rb
+- test/test_image_proc.rb
+has_rdoc: true
+homepage: http://wiretap.rubyforge.org/image_proc
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wiretap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A no-frills image resizer, with pluggable backends
+test_files: 
+- test/test_geom.rb
+- test/test_image_proc.rb