mini_magick 3.8.1 → 4.0.0.rc

data/lib/mini_magick/tool/composite.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/composite.php
+    #
+    class Composite < MiniMagick::Tool
+
+      def initialize
+        super("composite")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/conjure.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/conjure.php
+    #
+    class Conjure < MiniMagick::Tool
+
+      def initialize
+        super("conjure")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/convert.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/convert.php
+    #
+    class Convert < MiniMagick::Tool
+
+      def initialize
+        super("convert")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/display.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/display.php
+    #
+    class Display < MiniMagick::Tool
+
+      def initialize
+        super("display")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/identify.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/identify.php
+    #
+    class Identify < MiniMagick::Tool
+
+      def initialize
+        super("identify")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/import.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/import.php
+    #
+    class Import < MiniMagick::Tool
+
+      def initialize
+        super("import")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/mogrify.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/mogrify.php
+    #
+    class Mogrify < MiniMagick::Tool
+
+      def initialize
+        super("mogrify")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/montage.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/montage.php
+    #
+    class Montage < MiniMagick::Tool
+
+      def initialize
+        super("montage")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/stream.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/stream.php
+    #
+    class Stream < MiniMagick::Tool
+
+      def initialize
+        super("stream")
+      end
+
+    end
+  end
+end

data/lib/mini_magick/utilities.rb

@@ -1,62 +1,35 @@
-require 'rbconfig'
-require 'shellwords'
-require 'pathname'
+require "tempfile"
 
 module MiniMagick
+  # @private
   module Utilities
-    class << self
-      # Cross-platform way of finding an executable in the $PATH.
-      #
-      #   which('ruby') #=> /usr/bin/ruby
-      def which(cmd)
-        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-          exts.each do |ext|
-            exe = File.join(path, "#{cmd}#{ext}")
-            return exe if File.executable? exe
-          end
-        end
-        nil
-      end
 
-      # Finds out if the host OS is windows
-      def windows?
-        RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-      end
+    module_function
 
-      def escape(value)
-        if windows?
-          windows_escape(value)
-        else
-          shell_escape(value)
-        end
-      end
-
-      def shell_escape(value)
-        Shellwords.escape(value)
-      end
-
-      def windows_escape(value)
-        # For Windows, ^ is the escape char, equivalent to \ in Unix.
-        escaped = value.gsub(/\^/, '^^').gsub(/>/, '^>')
-        if escaped !~ /^".+"$/ && escaped.include?("'")
-          escaped.inspect
-        else
-          escaped
+    ##
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    # @example
+    #   MiniMagick::Utilities.which('ruby') #=> "/usr/bin/ruby"
+    #
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable? exe
         end
       end
+      nil
+    end
 
-      def path(path)
-        if windows?
-          # For Windows, if a path contains space char, you need to quote it,
-          # otherwise you SHOULD NOT quote it. If you quote a path that does
-          # not contains space, it will not work.
-          pathname = Pathname.new(path).to_s
-          path.include?(' ') ? pathname.inspect : pathname
-        else
-          path
-        end
+    def tempfile(extension)
+      Tempfile.new(["mini_magick", extension]).tap do |tempfile|
+        tempfile.binmode
+        yield tempfile if block_given?
+        tempfile.close
       end
     end
+
   end
 end

data/lib/mini_magick/version.rb

@@ -1,16 +1,16 @@
 module MiniMagick
   ##
-  # Returns the version of the currently loaded MiniMagick as
-  # a <tt>Gem::Version</tt>.
+  # @return [Gem::Version]
+  #
   def self.version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 3
-    MINOR = 8
-    TINY  = 1
-    PRE   = nil
+    MAJOR = 4
+    MINOR = 0
+    TINY  = 0
+    PRE   = "rc"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end

data/spec/fixtures/not_an_image.rb

@@ -0,0 +1 @@
+expect(__FILE__).not_to be_an_image

data/spec/lib/mini_magick/configuration_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+RSpec.describe MiniMagick::Configuration do
+  subject { Object.new.extend(MiniMagick::Configuration) }
+
+  describe "#configure" do
+    it "yields self" do
+      expect { |b| subject.configure(&b) }
+        .to yield_with_args(subject)
+    end
+  end
+
+  describe "#cli" do
+    it "can be assigned" do
+      subject.cli = :imagemagick
+      expect(subject.cli).to eq :imagemagick
+    end
+
+    it "returns :imagemagick if #processor is mogrify" do
+      allow(subject).to receive(:processor).and_return("mogrify")
+      expect(subject.cli).to eq :imagemagick
+    end
+
+    it "returns :graphicsmagick if #processor is gm" do
+      allow(subject).to receive(:processor).and_return("gm")
+      expect(subject.cli).to eq :graphicsmagick
+    end
+
+    it "returns nil of #processor is nil" do
+      allow(subject).to receive(:processor).and_return(nil)
+      expect(subject.cli).to eq nil
+    end
+  end
+
+  describe "#cli=" do
+    it "raises an error when set to an invalid value" do
+      expect { subject.cli = :grapicsmagick }
+        .to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#processor" do
+    it "assigns :mogrify by default" do
+      expect(subject.processor).to eq "mogrify"
+    end
+
+    it "assigns :gm if ImageMagick is not available" do
+      allow(MiniMagick::Utilities).to receive(:which).with("mogrify").and_return(nil)
+      allow(MiniMagick::Utilities).to receive(:which).with("gm").and_return(true)
+      expect(subject.processor).to eq "gm"
+    end
+
+    it "returns nil if neither ImageMagick nor GraphicsMagick are available" do
+      allow(MiniMagick::Utilities).to receive(:which).with("mogrify").and_return(nil)
+      allow(MiniMagick::Utilities).to receive(:which).with("gm").and_return(nil)
+      expect(subject.processor).to eq nil
+    end
+  end
+
+  describe "#processor=" do
+    it "raises an error when set to an invalid value" do
+      expect { subject.processor = "mogrfy" }
+        .to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/lib/mini_magick/image_spec.rb

@@ -1,499 +1,407 @@
-require 'spec_helper'
-require 'pathname'
-require 'tempfile'
-
-MiniMagick.processor = :mogrify
-
-describe MiniMagick::Image do
-  context 'when ImageMagick and GraphicsMagick are both unavailable' do
-    before do
-      MiniMagick::Utilities.expects(:which).at_least_once.returns(nil)
-      MiniMagick.instance_variable_set(:@processor, nil)
-      @old_path = ENV['PATH']
-      ENV['PATH'] = ''
-    end
-
-    after do
-      ENV['PATH'] = @old_path
-    end
+require "spec_helper"
+require "pathname"
+require "tempfile"
+require "fileutils"
+require "stringio"
+
+["ImageMagick", "GraphicsMagick"].each do |cli|
+  RSpec.context "With #{cli}", cli: cli.downcase.to_sym do
+    describe MiniMagick::Image do
+      subject { described_class.open(image_path) }
+
+      describe ".read" do
+        it "reads image from String" do
+          string = File.binread(image_path)
+          image = described_class.read(string)
+          expect(image).to be_valid
+        end
 
-    it "raises an exception with 'No such file' in the message" do
-      begin
-        described_class.open(SIMPLE_IMAGE_PATH)
-      rescue => e
-        expect(e.message).to match(/(No such file|not found)/)
-      end
-    end
-  end
+        it "reads image from StringIO" do
+          stringio = StringIO.new(File.binread(image_path))
+          image = described_class.read(stringio)
+          expect(image).to be_valid
+        end
 
-  describe 'ported from testunit', :ported => true do
-    it 'reads image from blob' do
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |f|
-        image = described_class.read(f.read)
-        expect(image).to be_valid
-        image.destroy!
+        it "reads image from tempfile" do
+          tempfile = Tempfile.open('magick')
+          FileUtils.cp image_path, tempfile.path
+          image = described_class.read(tempfile)
+          expect(image).to be_valid
+        end
       end
-    end
 
-    it 'reads image from tempfile', :if => !MiniMagick::Utilities.windows? do
-      tempfile = Tempfile.new('magick')
+      describe ".import_pixels" do
+        let(:dimensions) { [325, 200] }
+        let(:depth)      { 16 } # 16 bits (2 bytes) per pixel
+        let(:map)        { 'gray' }
+        let(:pixels)     { Array.new(dimensions.inject(:*)) { |i| i } }
+        let(:blob)       { pixels.pack('S*') } # unsigned short, native byte order
 
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |f|
-        tempfile.write(f.read)
-        tempfile.rewind
-      end
+        it "can import pixels with default format" do
+          image = described_class.import_pixels(blob, *dimensions, depth, map)
 
-      image = described_class.read(tempfile)
-      expect(image).to be_valid
-      image.destroy!
-    end
+          expect(image).to be_valid
+          expect(image.type).to eq 'PNG'
+          expect(image.dimensions).to eq dimensions
+        end
 
-    # from https://github.com/minimagick/minimagick/issues/163
-    it 'annotates image with whitespace' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
+        it "can import pixels with custom format" do
+          image = described_class.import_pixels(blob, *dimensions, depth, map, 'jpeg')
 
-      expect {
-        message = 'a b'
+          expect(image).to be_valid
+          expect(image.type).to eq 'JPEG'
+          expect(image.dimensions).to eq dimensions
+        end
+      end
 
-        image.combine_options do |c|
-          c.gravity 'SouthWest'
-          c.fill 'white'
-          c.stroke 'black'
-          c.strokewidth '2'
-          c.pointsize '48'
-          c.interline_spacing '-9'
-          c.annotate '0', message
+      describe ".open" do
+        it "makes a copy of the image" do
+          image = described_class.open(image_path)
+          expect(image.path).not_to eq image_path
+          expect(image).to be_valid
         end
-      }.to_not raise_error
-    end
 
-    it 'opens image' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "accepts a Pathname" do
+          image = described_class.open(Pathname(image_path))
+          expect(image).to be_valid
+        end
 
-    it 'reads image from buffer' do
-      buffer = StringIO.new File.open(SIMPLE_IMAGE_PATH, 'rb') { |f| f.read }
-      image = described_class.read(buffer)
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "loads a remote image" do
+          begin
+            image = described_class.open(image_url)
+            expect(image).to be_valid
+          rescue SocketError
+          end
+        end
 
-    describe '.create' do
-      subject(:create) do
-        described_class.create do |f|
-          # Had to replace the old File.read with the following to work across all platforms
-          f.write(File.open(SIMPLE_IMAGE_PATH, 'rb') { |fi| fi.read })
+        it "validates the image" do
+          expect { described_class.open(image_path(:not)) }
+            .to raise_error(MiniMagick::Invalid)
         end
       end
 
-      it 'creates an image' do
-        expect {
-          image = create
-          image.destroy!
-        }.to_not raise_error
-      end
+      describe ".create" do
+        def create(path = image_path)
+          described_class.create do |f|
+            f.write(File.binread(path))
+          end
+        end
 
-      describe 'validation' do
-        before do
-          @old_validate = MiniMagick.validate_on_create
-          MiniMagick.validate_on_create = validate
+        it "creates an image" do
+          image = create
+          expect(File.exists?(image.path)).to eq true
         end
 
-        context 'MiniMagick.validate_on_create = true' do
-          let(:validate) { true }
+        it "validates the image if validation is set" do
+          allow(MiniMagick).to receive(:validate_on_create).and_return(true)
+          expect { create(image_path(:not)) }
+            .to raise_error(MiniMagick::Invalid)
+        end
 
-          it 'validates image' do
-            described_class.any_instance.expects(:valid?).returns(true)
-            create
-          end
+        it "doesn't validate image if validation is disabled" do
+          allow(MiniMagick).to receive(:validate_on_create).and_return(false)
+          expect { create(image_path(:not)) }
+            .not_to raise_error
         end
+      end
 
-        context 'MiniMagick.validate_on_create = false' do
-          let(:validate) { false }
+      describe "#initialize" do
+        it "initializes a new image" do
+          image = described_class.new(image_path)
+          expect(image).to be_valid
+        end
 
-          it 'skips validation' do
-            described_class.any_instance.expects(:valid?).never
-            create
+        it "accepts a block which it passes on to #combine_options" do
+          image = described_class.new(subject.path) do |b|
+            b.resize "100x100!"
           end
+          expect(image.dimensions).to eq [100, 100]
         end
-
-        after { MiniMagick.validate_on_create = @old_validate }
       end
-    end
 
-    it 'loads a new image' do
-      expect {
-        image = described_class.new(SIMPLE_IMAGE_PATH)
-        image.destroy!
-      }.to_not raise_error
-    end
+      describe "#format" do
+        subject { described_class.open(image_path(:jpg)) }
 
-    it 'loads remote image' do
-      image = described_class.open('http://upload.wikimedia.org/wikipedia/en/b/bc/Wiki.png')
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "changes the format of the photo" do
+          expect { subject.format("png") }
+            .to change { subject.type }
+        end
 
-    it 'loads remote image with complex url' do
-      image = described_class.open(
-        'http://a0.twimg.com/a/1296609216/images/fronts/logo_withbird_home.png?extra=foo&plus=bar'
-      )
-      expect(image).to be_valid
-      image.destroy!
-    end
+        it "reformats an image with a given extension" do
+          expect { subject.format('png') }
+            .to change { File.extname(subject.path) }.to ".png"
+        end
 
-    it 'reformats an image with a given extension' do
-      expect {
-        image = described_class.open(CAP_EXT_PATH)
-        image.format 'jpg'
-      }.to_not raise_error
-    end
+        it "creates the file with new extension" do
+          subject.format('png')
+          expect(File.exist?(subject.path)).to eq true
+        end
 
-    describe '#write' do
-      it 'reformats a PSD with a given a extension and all layers' do
-        expect {
-          image = described_class.open(PSD_IMAGE_PATH)
-          image.format('jpg', nil)
-        }.to_not raise_error
-      end
+        it "accepts a block of additional commands" do
+          expect {
+            subject.format("png") do |b|
+              b.resize("100x100!")
+            end
+          }.to change { subject.dimensions }.to [100, 100]
+        end
 
-      it 'opens and writes an image' do
-        output_path = 'output.gif'
-        begin
-          image = described_class.new(SIMPLE_IMAGE_PATH)
-          image.write output_path
-          expect(File.exist?(output_path)).to be(true)
-        ensure
-          File.delete output_path
+        it "works without an extension" do
+          subject = described_class.open(image_path(:without_extension))
+          expect { subject.format("png") }
+            .to change { File.extname(subject.path) }.from("").to(".png")
         end
-        image.destroy!
-      end
 
-      it 'opens and writes an image with space in its filename' do
-        output_path = 'test output.gif'
-        begin
-          image = described_class.new(SIMPLE_IMAGE_PATH)
-          image.write output_path
+        it "deletes the previous tempfile" do
+          old_path = subject.path.dup
+          subject.format('png')
+          expect(File.exist?(old_path)).to eq false
+        end
 
-          expect(File.exist?(output_path)).to be(true)
-        ensure
-          File.delete output_path
+        it "doesn't delete itself when formatted to the same format" do
+          subject.format(subject.type.downcase)
+          expect(File.exists?(subject.path)).to eq true
         end
-        image.destroy!
-      end
 
-      it 'writes an image with stream' do
-        stream = StringIO.new
-        image = described_class.open(SIMPLE_IMAGE_PATH)
-        image.write("#{Dir.tmpdir}/foo.gif")
-        image.write(stream)
-        expect(described_class.read(stream.string)).to be_valid
-        image.destroy!
-      end
+        it "reformats multi-image formats to multiple images" do
+          subject = described_class.open(image_path(:animation))
+          subject.format('jpg', nil)
+          expect(Dir[subject.path.sub('.', '*.')]).not_to be_empty
+        end
 
-      describe 'validation' do
-        let(:image) { described_class.new(SIMPLE_IMAGE_PATH) }
-        let(:output_path) { 'output.gif' }
+        it "reformats multi-image formats to a single image" do
+          subject = described_class.open(image_path(:animation))
+          subject.format('jpg')
+          expect(subject).to be_valid
+        end
 
-        before do
-          @old_validate = MiniMagick.validate_on_write
-          MiniMagick.validate_on_write = validate
+        it "returns self" do
+          expect(subject.format('png')).to eq subject
         end
+      end
 
-        subject(:write) { image.write output_path }
+      describe "#write" do
+        it "writes the image" do
+          output_path = random_path("test output")
+          subject.write(output_path)
+          expect(described_class.new(output_path)).to be_valid
+        end
 
-        context 'MiniMagick.validate_on_write = true' do
-          let(:validate) { true }
+        it "writes an image with stream" do
+          output_stream = StringIO.new
+          subject.write(output_stream)
+          expect(described_class.read(output_stream.string)).to be_valid
+        end
 
-          it 'runs post-validation' do
-            image.expects(:run_command).with('identify', output_path)
-            write
-          end
+        it "writes layers" do
+          output_path = random_path(["", ".#{subject.type.downcase}"])
+          subject = described_class.new(image_path(:gif))
+          subject.frames.first.write(output_path)
+          expect(described_class.new(output_path)).to be_valid
         end
 
-        context 'MiniMagick.validate_on_write = false' do
-          let(:validate) { false }
+        it "accepts a Pathname" do
+          output_path = Pathname(random_path)
+          subject.write(output_path)
+          expect(described_class.new(output_path.to_s)).to be_valid
+        end
+      end
 
-          it 'runs post-validation' do
-            image.expects(:run_command).never
-            write
-          end
+      describe "#valid?" do
+        it "returns true when image is valid" do
+          image = described_class.new(image_path)
+          expect(image).to be_valid
         end
 
-        after do
-          image.destroy!
-          File.delete output_path
-          MiniMagick.validate_on_write = @old_validate
+        it "returns false when image is not valid" do
+          image = described_class.new(image_path(:not))
+          expect(image).not_to be_valid
         end
       end
-    end
 
-    it 'tells when an image is invalid' do
-      image = described_class.new(NOT_AN_IMAGE_PATH)
-      expect(image).not_to be_valid
-      image.destroy!
-    end
+      describe "#[]" do
+        it "inspects image meta info" do
+          expect(subject[:width]).to be_a(Fixnum)
+          expect(subject[:height]).to be_a(Fixnum)
+          expect(subject[:dimensions]).to all(be_a(Fixnum))
+          expect(subject[:colorspace]).to be_a(String)
+          expect(subject[:format]).to match(/[A-Z]/)
+        end
 
-    it "raises error when opening a file that isn't an image" do
-      expect {
-        image = described_class.open(NOT_AN_IMAGE_PATH)
-        image.destroy
-      }.to raise_error(MiniMagick::Invalid)
-    end
+        it "supports string keys" do
+          expect(subject["width"]).to be_a(Fixnum)
+          expect(subject["height"]).to be_a(Fixnum)
+          expect(subject["dimensions"]).to all(be_a(Fixnum))
+          expect(subject["colorspace"]).to be_a(String)
+          expect(subject["format"]).to match(/[A-Z]/)
+        end
 
-    it "raises error when imagemagick raised an error during processing" do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.rotate "invalid_value"
-      expect { image.run_queue }.to raise_error(MiniMagick::Error)
-    end
+        it "reads exif" do
+          subject = described_class.new(image_path(:exif))
+          expect(subject["EXIF:ColorSpace"]).to eq "1"
+        end
 
-    it 'inspects image meta info' do
-      image = described_class.new(SIMPLE_IMAGE_PATH)
-      expect(image[:width]).to be(150)
-      expect(image[:height]).to be(55)
-      expect(image[:dimensions]).to match_array [150, 55]
-      expect(image[:colorspace]).to be_an_instance_of(String)
-      expect(image[:format]).to match(/^gif$/i)
-      image.destroy!
-    end
+        it "passes unknown values directly to -format" do
+          expect(subject["%w %h"].split.map(&:to_i)).to eq [subject[:width], subject[:height]]
+        end
+      end
 
-    it 'supports string keys for dimension attributes' do
-      image = described_class.new(SIMPLE_IMAGE_PATH)
-      expect(image["width"]).to be(150)
-      expect(image["height"]).to be(55)
-      expect(image["dimensions"]).to match_array [150, 55]
-      image.destroy!
-    end
+      it "has attributes" do
+        expect(subject.type).to match(/^[A-Z]+$/)
+        expect(subject.mime_type).to match(/^image\/[a-z]+$/)
+        expect(subject.width).to be_a(Fixnum).and be_nonzero
+        expect(subject.height).to be_a(Fixnum).and be_nonzero
+        expect(subject.dimensions).to all(be_a(Fixnum))
+        expect(subject.size).to be_a(Fixnum).and be_nonzero
+        expect(subject.colorspace).to be_a(String)
+        expect(subject.resolution).to all(be_a(Fixnum))
+      end
 
-    it 'inspects an erroneus image meta info' do
-      image = described_class.new(ERRONEOUS_IMAGE_PATH)
-      expect(image[:width]).to be(10)
-      expect(image[:height]).to be(10)
-      expect(image[:dimensions]).to match_array [10, 10]
-      expect(image[:format]).to eq 'JPEG'
-      image.destroy!
-    end
+      describe "#exif" do
+        subject { described_class.new(image_path(:exif)) }
 
-    it 'inspects meta info from tiff images' do
-      image = described_class.new(TIFF_IMAGE_PATH)
-      expect(image[:format].to_s.downcase).to eq 'tiff'
-      expect(image[:width]).to be(50)
-      expect(image[:height]).to be(41)
-      image.destroy!
-    end
+        it "returns a hash of EXIF data" do
+          expect(subject.exif["DateTimeOriginal"]).to be_a(String)
+        end
+      end
 
-    it 'inspects a gif with jpg format correctly' do
-      image = described_class.new(GIF_WITH_JPG_EXT)
-      expect(image[:format].to_s.downcase).to eq 'gif'
-      image.destroy!
-    end
+      describe "#resolution" do
+        it "accepts units", skip_cli: :graphicsmagick do
+          expect(subject.resolution("PixelsPerCentimeter"))
+            .not_to eq subject.resolution("PixelsPerInch")
+        end
+      end
 
-    it 'resizes an image correctly' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.resize '20x30!'
+      describe "#mime_type" do
+        it "returns the correct mime type" do
+          jpg = described_class.new(image_path(:jpg))
+          expect(jpg.mime_type).to eq 'image/jpeg'
+        end
+      end
 
-      expect(image[:width]).to be(20)
-      expect(image[:height]).to be(30)
-      expect(image[:format]).to match(/^gif$/i)
-      image.destroy!
-    end
+      describe "#layers" do
+        it "returns a list of images" do
+          expect(subject.layers).to all(be_a(MiniMagick::Image))
+          expect(subject.layers.first).to be_valid
+        end
 
-    it 'resizes an image with minimum dimensions' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      original_width, original_height = image[:width], image[:height]
-      image.resize "#{original_width + 10}x#{original_height + 10}>"
+        it "returns multiple images for GIFs, PDFs and PSDs" do
+          gif = described_class.new(image_path(:gif))
+          psd = described_class.new(image_path(:psd))
 
-      expect(image[:width]).to be original_width
-      expect(image[:height]).to be original_height
-      image.destroy!
-    end
+          expect(gif.frames.count).to be > 1
+          expect(psd.layers.count).to be > 1 unless MiniMagick.graphicsmagick?
+        end
 
-    it 'combines options to create an image with resize and blur' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      image.combine_options do |c|
-        c.resize '20x30!'
-        c.blur '50'
-      end
+        it "returns one image for other formats" do
+          jpg = described_class.new(image_path(:jpg))
 
-      expect(image[:width]).to be(20)
-      expect(image[:height]).to be(30)
-      expect(image[:format]).to match(/\Agif\z/i)
-      image.destroy!
-    end
+          expect(jpg.layers.count).to eq 1
+        end
+      end
 
-    it "combines options to create an image even with minuses symbols on it's name it" do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      background = '#000000'
-      expect {
-        image.combine_options do |c|
-          c.draw "image Over 0,0 10,10 '#{MINUS_IMAGE_PATH}'"
-          c.thumbnail '300x500>'
-          c.background background
-        end
-      }.to_not raise_error
-      image.destroy!
-    end
+      describe "#method_missing" do
+        it "executes the command correctly" do
+          expect { subject.resize '20x30!' }
+            .to change { subject.dimensions }.to [20, 30]
+        end
 
-    it 'inspects the EXIF of an image' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      expect(image['exif:ExifVersion']).to eq '0220'
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image['EXIF:ExifVersion']).to be_empty
-      image.destroy!
-    end
+        it "fails with a correct NoMethodError" do
+          expect { subject.foo }
+            .to raise_error(NoMethodError, /MiniMagick::Image/)
+        end
 
-    it 'inspects the original at of an image' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      expect(image[:original_at]).to eq Time.local('2005', '2', '23', '23', '17', '24')
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect(image[:original_at]).to be_nil
-      image.destroy!
-    end
+        it "returns self" do
+          expect(subject.resize('20x30!')).to eq subject
+        end
+      end
 
-    it 'has the same path for tempfile and image' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      expect(image.instance_eval('@tempfile.path')).to eq image.path
-      image.destroy!
-    end
+      describe "#combine_options" do
+        it "chains multiple options and executes them in one command" do
+          expect {
+            subject.combine_options { |c| c.resize '20x30!' }
+          }.to change { subject.dimensions }.to [20, 30]
+        end
 
-    it 'has the tempfile at path after format' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      image.format('png')
-      expect(File.exist?(image.path)).to be(true)
-      image.destroy!
-    end
+        it "doesn't allow calling of #format" do
+          expect { subject.combine_options { |c| c.format("png") } }
+            .to raise_error(NoMethodError)
+        end
 
-    it "hasn't previous tempfile at path after format" do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      before = image.path.dup
-      image.format('png')
-      expect(File.exist?(before)).to be(false)
-      image.destroy!
-    end
+        it "returns self" do
+          expect(subject.combine_options {}).to eq subject
+        end
+      end
 
-    it 'changes the format of image with special characters', :if => !MiniMagick::Utilities.windows? do
-      tempfile = Tempfile.new('magick with special! "chars\'')
+      describe "#composite" do
+        let(:other_image) { described_class.open(image_path) }
+        let(:mask) { described_class.open(image_path) }
 
-      File.open(SIMPLE_IMAGE_PATH, 'rb') do |file|
-        tempfile.write(file.read)
-        tempfile.rewind
-      end
+        it "creates a composite of two images" do
+          image = subject.composite(other_image)
+          expect(image).to be_valid
+        end
 
-      image = described_class.new(tempfile.path)
-      image.format('png')
-      expect(File.exist?(image.path)).to be(true)
-      image.destroy!
+        it "creates a composite of two images with mask" do
+          image = subject.composite(other_image, 'jpg', mask)
+          expect(image).to be_valid
+        end
 
-      File.delete(image.path)
-      tempfile.unlink
-    end
+        it "yields an optional block" do
+          expect { |b| subject.composite(other_image, &b) }
+            .to yield_with_args(an_instance_of(MiniMagick::Tool::Composite))
+        end
 
-    it 'raises exception when calling wrong method' do
-      image = described_class.open(TIFF_IMAGE_PATH)
-      expect { image.to_blog }.to raise_error(NoMethodError)
-      image.to_blob
-      image.destroy!
-    end
+        it "makes the composited image with the provided extension" do
+          result = subject.composite(other_image, 'png')
+          expect(result.path).to end_with ".png"
 
-    it 'can create a composite of two images' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      result = image.composite(described_class.open(TIFF_IMAGE_PATH)) do |c|
-        c.gravity 'center'
+          result = subject.composite(other_image)
+          expect(result.path).to end_with ".jpg"
+        end
       end
-      expect(File.exist?(result.path)).to be(true)
-    end
 
-    # https://github.com/minimagick/minimagick/issues/212
-    it 'can create a composite of two images with mask' do
-      image = described_class.open(EXIF_IMAGE_PATH)
-      result = image.composite(described_class.open(TIFF_IMAGE_PATH), 'jpg', described_class.open(PNG_PATH)) do |c|
-        c.gravity 'center'
-      end
-      expect(File.exist?(result.path)).to be(true)
-    end
+      describe "#collapse!" do
+        subject { described_class.open(image_path(:animation)) }
 
-    # https://github.com/minimagick/minimagick/issues/8
-    it 'has issue 8 fixed' do
-      image = described_class.open(SIMPLE_IMAGE_PATH)
-      expect {
-        image.combine_options do |c|
-          c.sample '50%'
-          c.rotate '-90>'
+        it "collapses the image to one frame" do
+          subject.collapse!
+          expect(subject.identify.lines.count).to eq 1
         end
-      }.to_not raise_error
-      image.destroy!
-    end
 
-    # https://github.com/minimagick/minimagick/issues/8
-    it 'has issue 15 fixed' do
-      expect {
-        image = described_class.open(Pathname.new(SIMPLE_IMAGE_PATH))
-        output = Pathname.new('test.gif')
-        image.write(output)
-      }.to_not raise_error
-      FileUtils.rm('test.gif')
-    end
-
-    # https://github.com/minimagick/minimagick/issues/37
-    it 'respects the language set' do
-      original_lang = ENV['LANG']
-      ENV['LANG'] = 'fr_FR.UTF-8'
+        it "keeps the extension" do
+          expect { subject.collapse! }
+            .not_to change { subject.type }
+        end
 
-      expect {
-        image = described_class.open(NOT_AN_IMAGE_PATH)
-        image.destroy
-      }.to raise_error(MiniMagick::Invalid)
+        it "clears the info" do
+          expect { subject.collapse! }
+            .to change { subject.size }
+        end
 
-      ENV['LANG'] = original_lang
-    end
+        it "returns self" do
+          expect(subject.collapse!).to eq subject
+        end
+      end
 
-    it 'can import pixels with default format' do
-      columns = 325
-      rows    = 200
-      depth   = 16 # 16 bits (2 bytes) per pixel
-      map     = 'gray'
-      pixels  = Array.new(columns * rows) { |i| i }
-      blob    = pixels.pack('S*') # unsigned short, native byte order
-      image   = described_class.import_pixels(blob, columns, rows, depth, map)
-
-      expect(image).to be_valid
-      expect(image[:format].to_s.downcase).to eq 'png'
-      expect(image[:width]).to eq columns
-      expect(image[:height]).to eq rows
-      image.write("#{Dir.tmpdir}/imported_pixels_image.png")
-    end
+      describe "#identify" do
+        it "returns the output of identify" do
+          expect(subject.identify).to match(subject.type)
+        end
 
-    it 'can import pixels with custom format' do
-      columns = 325
-      rows    = 200
-      depth   = 16 # 16 bits (2 bytes) per pixel
-      map     = 'gray'
-      format  = 'jpeg'
-      pixels  = Array.new(columns * rows) { |i| i }
-      blob    = pixels.pack('S*') # unsigned short, native byte order
-      image   = described_class.import_pixels(blob, columns, rows, depth, map, format)
-
-      expect(image).to be_valid
-      expect(image[:format].to_s.downcase).to eq format
-      expect(image[:width]).to eq columns
-      expect(image[:height]).to eq rows
-      image.write("#{Dir.tmpdir}/imported_pixels_image." + format)
-    end
+        it "yields an optional block" do
+          output = subject.identify do |b|
+            b.verbose
+          end
+          expect(output).to match("Format:")
+        end
+      end
 
-    it 'loads mimetype correctly' do
-      gif        = described_class.open(SIMPLE_IMAGE_PATH)
-      jpeg       = described_class.open(EXIF_IMAGE_PATH)
-      png        = described_class.open(PNG_PATH)
-      tiff       = described_class.open(TIFF_IMAGE_PATH)
-      hidden_gif = described_class.open(GIF_WITH_JPG_EXT)
-
-      expect(gif.mime_type).to eq 'image/gif'
-      expect(jpeg.mime_type).to eq 'image/jpeg'
-      expect(png.mime_type).to eq 'image/png'
-      expect(tiff.mime_type).to eq 'image/tiff'
-      expect(hidden_gif.mime_type).to eq 'image/gif'
+      describe "#run_command" do
+        it "runs the given command" do
+          output = subject.run_command("identify", "-format", "%w", subject.path)
+          expect(output).to eq subject.width.to_s
+        end
+      end
     end
   end
 end