dragonfly-minimagick 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dragonfly-minimagick.gemspec
+gemspec
+
+gem 'rspec', ">= 2.0"

data/README.markdown

@@ -0,0 +1,17 @@
+Dragonfly-Minimagick
+=================
+
+Dragonfly-Minimagick was extracted from the original dragonfly code and provides an analyser, processor, encoder and generator for Dragonfly using the MiniMagick image library. 
+
+It shouldn't be necessary and is provided here in case it's needed for some reason!
+
+Usage
+-----
+
+    require 'dragonfly-minimagick'
+    Dragonfly[:images].configure_with(:minimagick)
+
+In Rails, the above would be done in an initializer.
+
+See the [dragonfly documentation](http://markevans.github.com/dragonfly) for more info, as the equivalent ImageMagick methods have the same API.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/dragonfly-minimagick.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dragonfly-minimagick/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dragonfly-minimagick"
+  s.version     = Dragonfly::Minimagick::VERSION
+  s.authors     = ["Paul Spieker"]
+  s.email       = ["p.spieker@duenos.de"]
+  s.homepage    = "https://github.com/spieker/dragonfly-minimagick"
+  s.summary     = %q{Use MiniMagick for image processing within Dragonfly}
+  s.description = %q{Not yet completely implemented}
+
+  s.rubyforge_project = "dragonfly-minimagick"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("dragonfly", [">= 0.9"])
+  s.add_dependency("mini_magick", ["~> 3.3"])
+  s.add_development_dependency("rspec", [">= 2.0"])
+end

data/lib/dragonfly-minimagick.rb

@@ -0,0 +1,16 @@
+require "dragonfly-minimagick/version"
+
+module Dragonfly
+  module Minimagick
+    # Your code goes here...
+  end
+end
+
+require 'dragonfly-minimagick/analyser'
+require 'dragonfly-minimagick/processor'
+require 'dragonfly-minimagick/encoder'
+require 'dragonfly-minimagick/generator'
+require 'dragonfly-minimagick/config'
+
+Dragonfly::App.register_configuration(:minimagick){ Dragonfly::Minimagick::Config }
+Dragonfly::App.register_configuration(:mini_magick){ Dragonfly::Minimagick::Config }

data/lib/dragonfly-minimagick/analyser.rb

@@ -0,0 +1,67 @@
+require 'mini_magick'
+require 'dragonfly'
+require 'dragonfly-minimagick/utils'
+
+module Dragonfly
+  module Minimagick
+    class Analyser
+
+      include Utils
+      include Dragonfly::Configurable
+
+      def width(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:width]
+        end
+      end
+
+      def height(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:height]
+        end
+      end
+
+      def aspect_ratio(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:width].to_f / image[:height].to_f
+        end
+      end
+
+      def portrait?(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:width] <= image[:height]
+        end
+      end
+
+      def landscape?(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:width] >= image[:height]
+        end
+      end
+
+      def depth(temp_object)
+        minimagick_image(temp_object) do |image|
+          image.verbose.match(/(\d{1,2})-bit/)[1].to_i
+        end
+      end
+
+      def number_of_colours(temp_object)
+        minimagick_image(temp_object) do |image|
+          # image.colors
+          0
+        end
+      end
+      alias number_of_colors number_of_colours
+
+      def format(temp_object)
+        ping_minimagick_image(temp_object) do |image|
+          image[:format].downcase.to_sym
+        end
+      end
+
+      def image?(temp_object)
+        !!catch(:unable_to_handle){ format(temp_object) }
+      end
+    end
+  end
+end

data/lib/dragonfly-minimagick/config.rb

@@ -0,0 +1,40 @@
+module Dragonfly
+  module Minimagick
+
+    # Minimagick is a saved configuration for Dragonfly apps, which does the following:
+    # - registers an minimagick analyser
+    # - registers an minimagick processor
+    # - registers an minimagick encoder
+    # - registers an minimagick generator
+    # - adds thumb shortcuts like '280x140!', etc.
+    # Look at the source code for apply_configuration to see exactly how it configures the app.
+    module Config
+      def self.apply_configuration(app, opts={})
+        app.configure do |c|
+          c.analyser.register(Analyser) do |a|
+          end
+          c.processor.register(Processor) do |p|
+          end
+          c.encoder.register(Encoder) do |e|
+          end
+          c.generator.register(Generator) do |g|
+          end
+          c.job :thumb do |geometry, format|
+            process :thumb, geometry
+            encode format if format
+          end
+          c.job :gif do
+            encode :gif
+          end
+          c.job :jpg do
+            encode :jpg
+          end
+          c.job :png do
+            encode :png
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/dragonfly-minimagick/encoder.rb

@@ -0,0 +1,62 @@
+require 'mini_magick'
+require 'dragonfly'
+require 'dragonfly-minimagick/utils'
+
+module Dragonfly
+  module Minimagick
+    class Encoder
+
+      include Utils
+      include Dragonfly::Configurable
+
+      configurable_attr :supported_formats, [
+        :ai,
+        :bmp,
+        :eps,
+        :gif,
+        :gif87,
+        :ico,
+        :j2c,
+        :jp2,
+        :jpeg,
+        :jpg,
+        :pbm,
+        :pcd,
+        :pct,
+        :pcx,
+        :pdf,
+        :pict,
+        :pjpeg,
+        :png,
+        :png24,
+        :png32,
+        :png8,
+        :pnm,
+        :ppm,
+        :ps,
+        :psd,
+        :ras,
+        :tga,
+        :tiff,
+        :wbmp,
+        :xbm,
+        :xpm,
+        :xwd
+      ]
+
+      def encode(temp_object, format, encoding={})
+        format = format.to_s.downcase
+        throw :unable_to_handle unless supported_formats.include?(format.to_sym)
+        minimagick_image(temp_object) do |image|
+          if image[:format].downcase == format
+            temp_object # do nothing
+          else
+            image.format(format)
+            image
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly-minimagick/generator.rb

@@ -0,0 +1,156 @@
+require 'mini_magick'
+require 'dragonfly'
+require 'dragonfly-minimagick/utils'
+
+module Dragonfly
+  module Minimagick
+    class Generator
+
+      FONT_STYLES = {
+        'normal'  => 'normal', #Magick::NormalStyle,
+        'italic'  => 'italic', #Magick::ItalicStyle,
+        'oblique' => 'oblique' #Magick::ObliqueStyle
+      }
+
+      FONT_STRETCHES = {
+        'normal'          => 'normal', #Magick::NormalStretch,
+        'semi-condensed'  => 'semi-condensed', #Magick::SemiCondensedStretch,
+        'condensed'       => 'condensed', #Magick::CondensedStretch,
+        'extra-condensed' => 'extra-condensed', #Magick::ExtraCondensedStretch,
+        'ultra-condensed' => 'ultra-condensed', #Magick::UltraCondensedStretch,
+        'semi-expanded'   => 'semi-expanded', #Magick::SemiExpandedStretch,
+        'expanded'        => 'expanded', #Magick::ExpandedStretch,
+        'extra-expanded'  => 'extra-expanded', #Magick::ExtraExpandedStretch,
+        'ultra-expanded'  => 'ultra-expanded' #Magick::UltraExpandedStretch
+      }
+
+      FONT_WEIGHTS = {
+        'normal'  => 'normal', #Magick::NormalWeight,
+        'bold'    => 'bold', #Magick::BoldWeight,
+        'bolder'  => 'bolder', #Magick::BolderWeight,
+        'lighter' => 'lighter', #Magick::LighterWeight,
+        '100'     => 100,
+        '200'     => 200,
+        '300'     => 300,
+        '400'     => 400,
+        '500'     => 500,
+        '600'     => 600,
+        '700'     => 700,
+        '800'     => 800,
+        '900'     => 900
+      }
+
+      include Utils
+      include Dragonfly::Configurable
+
+      def plasma(width, height, format='png')
+        image = MiniMagick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
+        image.format = format.to_s
+        content = write_to_tempfile(image)
+        image.destroy!
+        [
+          content,
+          {:format => format.to_sym, :name => "plasma.#{format}"}
+        ]
+      end
+
+      def text(text_string, opts={})
+        opts = Dragonfly::HashWithCssStyleKeys[opts]
+
+        draw = MiniMagick::Draw.new
+        draw.gravity = 'center'
+        draw.text_antialias = true
+
+        # Font size
+        font_size = (opts[:font_size] || 12).to_i
+
+        # Scale up the text for better quality -
+        #  it will be reshrunk at the end
+        s = scale_factor_for(font_size)
+
+        # Settings
+        draw.pointsize    = font_size * s
+        draw.font         = opts[:font] if opts[:font]
+        draw.font_family  = opts[:font_family] if opts[:font_family]
+        draw.fill         = opts[:color] if opts[:color]
+        draw.stroke       = opts[:stroke_color] if opts[:stroke_color]
+        draw.font_style   = FONT_STYLES[opts[:font_style]] if opts[:font_style]
+        draw.font_stretch = FONT_STRETCHES[opts[:font_stretch]] if opts[:font_stretch]
+        draw.font_weight  = FONT_WEIGHTS[opts[:font_weight]] if opts[:font_weight]
+
+        # Padding
+        # NB the values are scaled up by the scale factor
+        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
+        padding_top    = (opts[:padding_top]    || pt || 0) * s
+        padding_right  = (opts[:padding_right]  || pr || 0) * s
+        padding_bottom = (opts[:padding_bottom] || pb || 0) * s
+        padding_left   = (opts[:padding_left]   || pl || 0) * s
+
+        # Calculate (scaled up) dimensions
+        metrics = draw.get_type_metrics(text_string)
+        width, height = metrics.width, metrics.height
+
+        scaled_up_width = padding_left + width + padding_right
+        scaled_up_height = padding_top + height + padding_bottom
+
+        # Draw the background
+        image = MiniMagick::Image.new(scaled_up_width, scaled_up_height){
+          self.background_color = opts[:background_color] || 'transparent'
+        }
+        # Draw the text
+        draw.annotate(image, width, height, padding_left, padding_top, text_string)
+
+        # Scale back down again
+        image.scale!(1/s)
+
+        format = opts[:format] || :png
+        image.format = format.to_s
+
+        # Output image either as a string or a tempfile
+        content = write_to_tempfile(image)
+        image.destroy!
+        [
+          content,
+          {:format => format, :name => "text.#{format}"}
+        ]
+      end
+
+      private
+
+      # Use css-style padding declaration, i.e.
+      # 10        (all sides)
+      # 10 5      (top/bottom, left/right)
+      # 10 5 10   (top, left/right, bottom)
+      # 10 5 10 5 (top, right, bottom, left)
+      def parse_padding_string(str)
+        padding_parts = str.gsub('px','').split(/\s+/).map{|px| px.to_i}
+        case padding_parts.size
+        when 1
+          p = padding_parts.first
+          [p,p,p,p]
+        when 2
+          p,q = padding_parts
+          [p,q,p,q]
+        when 3
+          p,q,r = padding_parts
+          [p,q,r,q]
+        when 4
+          padding_parts
+        else raise ArgumentError, "Couldn't parse padding string '#{str}' - should be a css-style string"
+        end
+      end
+
+      def scale_factor_for(font_size)
+        # Scale approximately to 64 if below
+        min_size = 64
+        if font_size < min_size
+          (min_size.to_f / font_size).ceil
+        else
+          1
+        end.to_f
+      end
+
+    end
+
+  end
+end

data/lib/dragonfly-minimagick/processor.rb

@@ -0,0 +1,155 @@
+require 'mini_magick'
+require 'dragonfly'
+require 'dragonfly-minimagick/utils'
+
+module Dragonfly
+  module Minimagick
+    class Processor
+
+      GRAVITIES = {
+        'nw' => 'NorthWest',
+        'n'  => 'North',
+        'ne' => 'NorthEast',
+        'w'  => 'West',
+        'c'  => 'Center',
+        'e'  => 'East',
+        'sw' => 'SouthWest',
+        's'  => 'South',
+        'se' => 'SouthEast'
+      }
+
+      # Geometry string patterns
+      RESIZE_GEOMETRY         = /^\d*x\d*[><%^!]?$|^\d+@$/ # e.g. '300x200!'
+      CROPPED_RESIZE_GEOMETRY = /^(\d+)x(\d+)#(\w{1,2})?$/ # e.g. '20x50#ne'
+      CROP_GEOMETRY           = /^(\d+)x(\d+)([+-]\d+)?([+-]\d+)?(\w{1,2})?$/ # e.g. '30x30+10+10'
+      THUMB_GEOMETRY = Regexp.union RESIZE_GEOMETRY, CROPPED_RESIZE_GEOMETRY, CROP_GEOMETRY
+
+      include Utils
+      include Dragonfly::Configurable
+
+      def crop(temp_object, opts={})
+        x       = opts[:x].to_i
+        y       = opts[:y].to_i
+        gravity = GRAVITIES[opts[:gravity]] || nil #Magick::ForgetGravity
+        width   = opts[:width].to_i
+        height  = opts[:height].to_i
+
+        unless opts.has_key?(:width) and opts.has_key?(:height) or opts.has_key?(:x) and opts.has_key?(:y)
+          return minimagick_image(temp_object) do |image|
+            image
+          end
+        end
+        minimagick_image(temp_object) do |image|
+          unless opts.has_key?(:width) and opts.has_key?(:height)
+            width  = image[:width] - x
+            height = image[:height] - y
+          end
+          # Minimagick throws an error if the cropping area is bigger than the image,
+          # when the gravity is something other than nw
+          width  = image[:width]  - x if x + width  > image[:width]
+          height = image[:height] - y if y + height > image[:height]
+# p "\n\n#{opts[:width]}x#{opts[:height]}+#{opts[:x]}+#{opts[:y]} \n#{width}x#{height}+#{x}+#{y}"
+          image.gravity gravity unless gravity.nil? or gravity.empty?
+          image.crop "#{width}x#{height}+#{x}+#{y}" #(gravity, x, y, width, height)
+          image
+        end
+      end
+
+      def flip(temp_object)
+        minimagick_image(temp_object) do |image|
+          image.flip
+          image
+        end
+      end
+
+      def flop(temp_object)
+        minimagick_image(temp_object) do |image|
+          image.flop
+          image
+        end
+      end
+
+      def greyscale(temp_object, opts={})
+        depth = opts[:depth] || 256
+        minimagick_image(temp_object) do |image|
+          image.quantize(depth, nil) #Magick::GRAYColorspace)
+          image
+        end
+      end
+      alias grayscale greyscale
+
+      def resize(temp_object, geometry)
+        minimagick_image(temp_object) do |image|
+        #   image.change_geometry!(geometry) do |cols, rows, img|
+        #    img.resize!(cols, rows)
+        #   end
+          image.resize geometry
+          image
+        end
+      end
+
+      def resize_and_crop(temp_object, opts={})
+        unless opts.has_key?(:width) or opts.has_key?(:height)
+          return minimagick_image(temp_object) do |image|
+            image
+          end
+        end
+
+        minimagick_image(temp_object) do |image|
+          width   = opts[:width] ? opts[:width].to_i : image[:width]
+          height  = opts[:height] ? opts[:height].to_i : image[:height]
+          gravity = GRAVITIES[opts[:gravity]] || 'center'
+          image.combine_options do |i|
+            i.resize "#{width}x#{height}^"
+            i.gravity gravity
+            i.extent "#{width}x#{height}"
+          end
+          # image.crop_resized(width, height, gravity)
+          image
+        end
+      end
+
+      def rotate(temp_object, amount, opts={})
+        args = [amount.to_f]
+        args << opts[:qualifier] if opts[:qualifier]
+        minimagick_image(temp_object) do |image|
+          image.background_color = opts[:background_colour] if opts[:background_colour]
+          image.background_color = opts[:background_color] if opts[:background_color]
+          image.rotate(args.join(''))
+          image
+        end
+      end
+
+      def thumb(temp_object, geometry)
+        case geometry
+        when RESIZE_GEOMETRY
+          resize(temp_object, geometry)
+        when CROPPED_RESIZE_GEOMETRY
+          resize_and_crop(temp_object, :width => $1, :height => $2, :gravity => $3)
+        when CROP_GEOMETRY
+          crop(temp_object,
+            :width => $1,
+            :height => $2,
+            :x => $3,
+            :y => $4,
+            :gravity => $5
+          )
+        else raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
+        end
+      end
+
+      def vignette(temp_object, opts={})
+        x      = opts[:x].to_f      || temp_object.width  * 0.1
+        y      = opts[:y].to_f      || temp_object.height * 0.1
+        radius = opts[:radius].to_f ||  0.0
+        sigma  = opts[:sigma].to_f  || 10.0
+
+        minimagick_image(temp_object) do |image|
+          image.vignette(x, y, radius, sigma)
+          image
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly-minimagick/utils.rb

@@ -0,0 +1,49 @@
+require 'tempfile'
+require 'mini_magick'
+require 'dragonfly'
+
+module Dragonfly
+  module Minimagick
+    module Utils
+
+      include Dragonfly::Loggable
+
+      private
+
+      def minimagick_image(temp_object, &block)
+        image = MiniMagick::Image.open(temp_object.path)
+        result = block.call(image)
+        case result
+        when MiniMagick::Image
+          content = write_to_tempfile(result)
+          result.destroy!
+        else
+          content = result
+        end
+        image.destroy!
+        content
+      rescue Exception => e
+        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+        throw :unable_to_handle
+      end
+
+      def ping_minimagick_image(temp_object, &block)
+        image = MiniMagick::Image.open(temp_object.path)
+        result = block.call(image)
+        image.destroy!
+        result
+      rescue Exception => e
+        log.warn("Unable to handle content in #{self.class} - got:\n#{e}")
+        throw :unable_to_handle
+      end
+
+      def write_to_tempfile(minimagick_image)
+        tempfile = Tempfile.new('dragonfly')
+        tempfile.close
+        minimagick_image.write(tempfile.path)
+        tempfile
+      end
+
+    end
+  end
+end

data/lib/dragonfly-minimagick/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  module Minimagick
+    VERSION = "0.0.1"
+  end
+end

data/spec/dragonfly-minimagick/analyser_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+shared_examples_for "image analyser methods" do
+
+  # NEEDS:
+  # @image
+  # @processor
+  
+  it "should return the width" do
+    @analyser.width(@image).should == 280
+  end
+
+  it "should return the height" do
+    @analyser.height(@image).should == 355
+  end
+
+  it "should return the aspect ratio" do
+    @analyser.aspect_ratio(@image).should == (280.0/355.0)
+  end
+
+  it "should say if it's portrait" do
+    @analyser.portrait?(@image).should be_true
+  end
+
+  it "should say if it's landscape" do
+    @analyser.landscape?(@image).should be_false
+  end
+
+  it "should return the number of colours" do
+    # @analyser.number_of_colours(@image).should == 34703
+  end
+
+  it "should return the depth" do
+    @analyser.depth(@image).should == 8
+  end
+
+  it "should return the format" do
+    @analyser.format(@image).should == :png
+  end
+
+  # %w(width height aspect_ratio number_of_colours depth format portrait? landscape?).each do |meth|
+  #   it "should throw unable_to_handle in #{meth.inspect} if it's not an image file" do
+  #     temp_object = Dragonfly::TempObject.new('blah')
+  #     lambda{
+  #       @analyser.send(meth, temp_object)
+  #     }.should throw_symbol(:unable_to_handle)
+  #   end
+  # end
+
+end
+
+describe Dragonfly::Minimagick::Analyser do
+
+  before(:each) do
+    image_path = SAMPLES_DIR + '/beach.png'
+    @image = Dragonfly::TempObject.new(File.new(image_path))
+    @analyser = Dragonfly::Minimagick::Analyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+
+  describe "when using the filesystem" do
+    before(:each) do
+    end
+    it_should_behave_like "image analyser methods"
+  end
+
+end

data/spec/dragonfly-minimagick/config_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Dragonfly::Minimagick::Config do
+
+  before(:each) do
+    @app = test_app
+  end
+
+  it "should configure all to use the filesystem by default" do
+    @app.configure_with(Dragonfly::Minimagick::Config)
+  end
+  
+  it "should allow configuring with :minimagick" do
+    @app.configure_with(:minimagick)
+    @app.analyser.objects.first.should be_a(Dragonfly::Minimagick::Analyser)
+  end
+
+  it "should allow configuring with :mini_magick" do
+    @app.configure_with(:mini_magick)
+    @app.analyser.objects.first.should be_a(Dragonfly::Minimagick::Analyser)
+  end
+
+end

data/spec/dragonfly-minimagick/encoder_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Dragonfly::Minimagick::Encoder do
+
+  before(:all) do
+    sample_file = SAMPLES_DIR + '/beach.png' # 280x355
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @encoder = Dragonfly::Minimagick::Encoder.new
+  end
+
+  describe "#encode" do
+  
+    it "should encode the image to the correct format" do
+      image = @encoder.encode(@image, :gif)
+      image.should have_format('gif')
+    end
+  
+    it "should throw :unable_to_handle if the format is not handleable" do
+      lambda{
+        @encoder.encode(@image, :goofy)
+      }.should throw_symbol(:unable_to_handle)
+    end
+  
+    it "should do nothing if the image is already in the correct format" do
+      image = @encoder.encode(@image, :png)
+      image.should == @image
+    end
+  
+    it "should work when not using the filesystem" do
+      image = @encoder.encode(@image, :gif)
+      image.should have_format('gif')
+    end
+
+  end
+
+end

data/spec/dragonfly-minimagick/generator_spectmp.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+# Needs: @generator
+shared_examples_for "image generator" do
+  
+  describe "generating an image with the given dimensions" do
+    before(:each) do
+      @image, @extra = @generator.plasma(23,12)
+    end
+    it {@image.should have_width(23)}
+    it {@image.should have_height(12)}
+    it {@image.should have_format('png')}
+    it {@extra.should == {:format => :png, :name => 'plasma.png'}}
+  end
+
+  describe "specifying the format" do
+    before(:each) do
+      @image, @extra = @generator.plasma(23, 12, :gif)
+    end
+    it {@image.should have_format('gif')}
+    it {@extra.should == {:format => :gif, :name => 'plasma.gif'}}
+  end
+
+  describe "text" do
+    before(:each) do
+      @text = "mmm"
+    end
+
+    describe "creating a text image" do
+      before(:each) do
+        @image, @extra = @generator.text(@text, :font_size => 12)
+      end
+      it {@image.should have_width(20..40)} # approximate
+      it {@image.should have_height(10..20)}
+      it {@image.should have_format('png')}
+      it {@extra.should == {:format => :png, :name => 'text.png'}}
+    end
+
+    describe "specifying the format" do
+      before(:each) do
+        @image, @extra = @generator.text(@text, :format => :gif)
+      end
+      it {@image.should have_format('gif')}
+      it {@extra.should == {:format => :gif, :name => 'text.gif'}}
+    end
+
+    describe "padding" do
+      before(:each) do
+        no_padding_text, extra = @generator.text(@text, :font_size => 12)
+        @width = image_properties(no_padding_text)[:width].to_i
+        @height = image_properties(no_padding_text)[:height].to_i
+      end
+      it "1 number shortcut" do
+        image, extra = @generator.text(@text, :padding => '10')
+        image.should have_width(@width + 20)
+        image.should have_height(@height + 20)
+      end
+      it "2 numbers shortcut" do
+        image, extra = @generator.text(@text, :padding => '10 5')
+        image.should have_width(@width + 10)
+        image.should have_height(@height + 20)
+      end
+      it "3 numbers shortcut" do
+        image, extra = @generator.text(@text, :padding => '10 5 8')
+        image.should have_width(@width + 10)
+        image.should have_height(@height + 18)
+      end
+      it "4 numbers shortcut" do
+        image, extra = @generator.text(@text, :padding => '1 2 3 4')
+        image.should have_width(@width + 6)
+        image.should have_height(@height + 4)
+      end
+      it "should override the general padding declaration with the specific one (e.g. 'padding-left')" do
+        image, extra = @generator.text(@text, :padding => '10', 'padding-left' => 9)
+        image.should have_width(@width + 19)
+        image.should have_height(@height + 20)
+      end
+      it "should ignore 'px' suffixes" do
+        image, extra = @generator.text(@text, :padding => '1px 2px 3px 4px')
+        image.should have_width(@width + 6)
+        image.should have_height(@height + 4)
+      end
+      it "bad padding string" do
+        lambda{
+          @generator.text(@text, :padding => '1 2 3 4 5')
+        }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+end
+
+
+describe Dragonfly::Minimagick::Generator do
+
+  before(:each) do
+    @generator = Dragonfly::Minimagick::Generator.new
+  end
+
+  describe "when using the filesystem" do
+    before(:each) do
+    end
+    it_should_behave_like 'image generator'
+  end
+
+end

data/spec/dragonfly-minimagick/processor_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+# NEEDS:
+#
+# @image
+# @processor
+#
+shared_examples_for "processing methods" do
+
+  describe "resize" do
+
+    it "should work correctly with xNN" do
+      image = @processor.resize(@image, 'x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+
+    it "should work correctly with NNx" do
+      image = @processor.resize(@image, '30x')
+      image.should have_width(30)
+      image.should have_height(38)
+    end
+
+    it "should work correctly with NNxNN" do
+      image = @processor.resize(@image, '30x30')
+      image.should have_width(24)
+      image.should have_height(30)
+    end
+
+    it "should work correctly with NNxNN!" do
+      image = @processor.resize(@image, '30x30!')
+      image.should have_width(30)
+      image.should have_height(30)
+    end
+
+    it "should work correctly with NNxNN%" do
+      image = @processor.resize(@image, '25x50%')
+      image.should have_width(70)
+      image.should have_height(178)
+    end
+
+    describe "NNxNN>" do
+
+      it "should not resize if the image is smaller than specified" do
+        image = @processor.resize(@image, '1000x1000>')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+
+      it "should resize if the image is larger than specified" do
+        image = @processor.resize(@image, '30x30>')
+        image.should have_width(24)
+        image.should have_height(30)
+      end
+
+    end
+
+    describe "NNxNN<" do
+
+      it "should not resize if the image is larger than specified" do
+        image = @processor.resize(@image, '10x10<')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
+
+      it "should resize if the image is smaller than specified" do
+        image = @processor.resize(@image, '400x400<')
+        image.should have_width(315)
+        image.should have_height(400)
+      end
+
+    end
+
+  end
+
+  describe "crop" do # Difficult to test here other than dimensions
+
+    it "should not crop if no args given" do
+      image = @processor.crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+
+    it "should crop using the offset given" do
+      image = @processor.crop(@image, :x => '7', :y => '12')
+      image.should have_width(273)
+      image.should have_height(343)
+    end
+
+    it "should crop using the dimensions given" do
+      image = @processor.crop(@image, :width => '10', :height => '20')
+      image.should have_width(10)
+      image.should have_height(20)
+    end
+
+    it "should crop in one dimension if given" do
+      image = @processor.crop(@image, :width => '10')
+      image.should have_width(10)
+      image.should have_height(355)
+    end
+
+    it "should take into account the gravity given" do
+      image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+
+    it "should clip bits of the image outside of the requested crop area when not nw gravity" do
+      # Minimagick was previously throwing an error when the cropping area was outside the image size, when
+      # using a gravity other than nw
+      image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
+      image.should have_width(180)
+      image.should have_height(155)
+    end
+
+  end
+
+  describe "greyscale" do
+    it "should not raise an error" do
+      # Bit tricky to test
+      @processor.greyscale(@image)
+    end
+  end
+
+  describe "resize_and_crop" do
+
+    it "should do nothing if no args given" do
+      image = @processor.resize_and_crop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+
+    it "should crop to the correct dimensions" do
+      image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
+      image.should have_width(100)
+      image.should have_height(100)
+    end
+
+    it "should allow cropping in one dimension" do
+      image = @processor.resize_and_crop(@image, :width => '100')
+      image.should have_width(100)
+      image.should have_height(355)
+    end
+
+    it "should take into account the gravity given" do
+      image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+      image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
+      image1.should_not == image2
+    end
+
+  end
+
+  describe "rotate" do
+
+    it "should rotate by 90 degrees" do
+      image = @processor.rotate(@image, 90)
+      image.should have_width(355)
+      image.should have_height(280)
+    end
+
+    it "should not rotate given a larger height and the '>' qualifier" do
+      image = @processor.rotate(@image, 90, :qualifier => '>')
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+
+    it "should rotate given a larger height and the '<' qualifier" do
+      image = @processor.rotate(@image, 90, :qualifier => '<')
+      image.should have_width(355)
+      image.should have_height(280)
+    end
+
+  end
+
+  describe "thumb" do
+    it "should call resize if the correct string given" do
+      @processor.should_receive(:resize).with(@image, '30x40').and_return(image = mock)
+      @processor.thumb(@image, '30x40').should == image
+    end
+    it "should call resize_and_crop if the correct string given" do
+      @processor.should_receive(:resize_and_crop).with(@image, :width => '30', :height => '40', :gravity => 'se').and_return(image = mock)
+      @processor.thumb(@image, '30x40#se').should == image
+    end
+    it "should call crop if x and y given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => '+10', :y => '+20', :gravity => nil).and_return(image = mock)
+      @processor.thumb(@image, '30x40+10+20').should == image
+    end
+    it "should call crop if just gravity given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => nil, :y => nil, :gravity => 'sw').and_return(image = mock)
+      @processor.thumb(@image, '30x40sw').should == image
+    end
+    it "should call crop if x, y and gravity given" do
+      @processor.should_receive(:crop).with(@image, :width => '30', :height => '40', :x => '-10', :y => '-20', :gravity => 'se').and_return(image = mock)
+      @processor.thumb(@image, '30x40-10-20se').should == image
+    end
+    it "should raise an argument error if an unrecognized string is given" do
+      lambda{ @processor.thumb(@image, '30x40#ne!') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "flip" do
+    it "should flip the image, leaving the same dimensions" do
+      image = @processor.flip(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+  end
+
+  describe "flop" do
+    it "should flop the image, leaving the same dimensions" do
+      image = @processor.flop(@image)
+      image.should have_width(280)
+      image.should have_height(355)
+    end
+  end
+
+end
+
+
+describe Dragonfly::Minimagick::Processor do
+
+  before(:each) do
+    sample_file = SAMPLES_DIR + '/beach.png' # 280x355
+    @image = Dragonfly::TempObject.new(File.new(sample_file))
+    @processor = Dragonfly::Minimagick::Processor.new
+  end
+
+  describe "when using the filesystem" do
+    before(:each) do
+    end
+    it_should_behave_like "processing methods"
+  end
+
+end

data/spec/spec.log

@@ -0,0 +1 @@
+# Logfile created on 2011-10-28 23:20:02 +0200 by logger.rb/25413

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'dragonfly-minimagick'
+require 'support/image_matchers'
+require 'dragonfly-minimagick/analyser'
+require 'dragonfly-minimagick/config'
+require 'dragonfly-minimagick/encoder'
+require 'dragonfly-minimagick/generator'
+require 'dragonfly-minimagick/processor'
+require 'dragonfly-minimagick/utils'
+
+SAMPLES_DIR = File.expand_path(File.dirname(__FILE__) + '/../samples') unless defined?(SAMPLES_DIR)
+
+require 'logger'
+LOG_FILE = File.dirname(__FILE__) + '/spec.log' unless defined?(LOG_FILE)
+FileUtils.rm_rf(LOG_FILE)
+
+def test_app
+  Dragonfly::App.send(:new)
+end

data/spec/support/image_matchers.rb

@@ -0,0 +1,47 @@
+def image_properties(image)
+  if image.is_a?(Tempfile)
+    tempfile = image
+  else
+    tempfile = Tempfile.new('image')
+    tempfile.write(image.is_a?(Dragonfly::TempObject) ? image.data : image)
+    tempfile.close
+  end
+  details = `identify #{tempfile.path}`
+  # example of details string:
+  # myimage.png PNG 200x100 200x100+0+0 8-bit DirectClass 31.2kb
+  filename, format, geometry, geometry_2, depth, image_class, size = details.split(' ')
+  width, height = geometry.split('x')
+  {
+    :filename => filename,
+    :format => format.downcase,
+    :width => width,
+    :height => height,
+    :depth => depth,
+    :image_class => image_class,
+    :size => size
+  }
+end
+
+RSpec::Matchers.define :have_width do |width|
+  match do |given|
+    width.should === image_properties(given)[:width].to_i
+  end
+end
+
+RSpec::Matchers.define :have_height do |height|
+  match do |given|
+    height.should === image_properties(given)[:height].to_i
+  end
+end
+
+RSpec::Matchers.define :have_format do |format|
+  match do |given|
+    image_properties(given)[:format].should == format
+  end
+end
+
+RSpec::Matchers.define :have_size do |size|
+  match do |given|
+    image_properties(given)[:size].should == size
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: dragonfly-minimagick
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Spieker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dragonfly
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mini_magick
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.3"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+description: Not yet completely implemented
+email: 
+- p.spieker@duenos.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- dragonfly-minimagick.gemspec
+- lib/dragonfly-minimagick.rb
+- lib/dragonfly-minimagick/analyser.rb
+- lib/dragonfly-minimagick/config.rb
+- lib/dragonfly-minimagick/encoder.rb
+- lib/dragonfly-minimagick/generator.rb
+- lib/dragonfly-minimagick/processor.rb
+- lib/dragonfly-minimagick/utils.rb
+- lib/dragonfly-minimagick/version.rb
+- samples/beach.png
+- spec/dragonfly-minimagick/analyser_spec.rb
+- spec/dragonfly-minimagick/config_spec.rb
+- spec/dragonfly-minimagick/encoder_spec.rb
+- spec/dragonfly-minimagick/generator_spectmp.rb
+- spec/dragonfly-minimagick/processor_spec.rb
+- spec/spec.log
+- spec/spec_helper.rb
+- spec/support/image_matchers.rb
+homepage: https://github.com/spieker/dragonfly-minimagick
+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: dragonfly-minimagick
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Use MiniMagick for image processing within Dragonfly
+test_files: 
+- spec/dragonfly-minimagick/analyser_spec.rb
+- spec/dragonfly-minimagick/config_spec.rb
+- spec/dragonfly-minimagick/encoder_spec.rb
+- spec/dragonfly-minimagick/generator_spectmp.rb
+- spec/dragonfly-minimagick/processor_spec.rb
+- spec/spec.log
+- spec/spec_helper.rb
+- spec/support/image_matchers.rb