mini_magick 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65e1d54473e9a429c269d44123e8a6977bf489fe
-  data.tar.gz: 7b2b4762e6ee9d6d47ade148b65df993c3b9e08e
+  metadata.gz: 8921e089d8d63d1391e76876bc63b4e3ff953706
+  data.tar.gz: 38930195578ded9545d86b4225718671a9cd8b6a
 SHA512:
-  metadata.gz: 4852bcf9522da52f7603a2ef96635312b91fef2e72dbcaa77dbec94dddd8e949e4c34d3e6ccc3da8588e42efe6c43b01cace0166d840f40c478966252f0390d0
-  data.tar.gz: 77bd9eac7c1a015ad7e6cc6de77657a210fc6b7bbb907928aafb08a0bb0b0c237e85a2ca4cd7ecd75cdfda7b55732352ebda096f46adb699ea62b52695385feb
+  metadata.gz: 39cc0fccd098a964a02be8e2cde7565d492ab9a5831df89a2f1b90d751d67368c13584c05ef3253aab51f8aecf107a52ca489a6849bd32e80a334869500f4628
+  data.tar.gz: 9c620a81d8b8e601a172d3b8333f4020048e2b7d385ce40fe85caff7f6df7480f1e08c8046d8fa10d66164eb264efe06d9303f111444f55c6193546ca34ab0f2

data/lib/mini_gmagick.rb

@@ -1,3 +1,3 @@
 require 'mini_magick'
 
-MiniMagick.processor = :graphicsmagick
+MiniMagick.processor = :gm

data/lib/mini_magick/configuration.rb

@@ -45,6 +45,7 @@ module MiniMagick
     # @return [Logger]
     #
     attr_accessor :logger
+
     ##
     # If set to `true`, it will `identify` every newly created image, and raise
     # `MiniMagick::Invalid` if the image is not valid. Useful for validating
@@ -63,9 +64,28 @@ module MiniMagick
     #
     attr_accessor :validate_on_write
 
+    ##
+    # If set to `false`, it will not raise errors when ImageMagick returns
+    # status code different than 0. Defaults to `true`.
+    #
+    # @return [Boolean]
+    #
+    attr_accessor :whiny
+
+    ##
+    # Instructs MiniMagick how to execute the shell commands. Available
+    # APIs are "open3" (default) and "posix-spawn" (requires the "posix-spawn"
+    # gem).
+    #
+    # @return [String]
+    #
+    attr_accessor :shell_api
+
     def self.extended(base)
       base.validate_on_create = true
       base.validate_on_write = true
+      base.whiny = true
+      base.shell_api = "open3"
     end
 
     ##
@@ -103,6 +123,8 @@ module MiniMagick
         case processor.to_s
         when "mogrify" then :imagemagick
         when "gm"      then :graphicsmagick
+        else
+          raise MiniMagick::Error, "ImageMagick/GraphicsMagick is not installed"
         end
     end
 

data/lib/mini_magick/image.rb

@@ -80,10 +80,10 @@ module MiniMagick
     #
     def self.open(path_or_url, ext = nil)
       ext ||=
-        if path_or_url.to_s =~ URI.regexp
-          File.extname(URI(path_or_url).path)
-        else
+        if File.exist?(path_or_url)
           File.extname(path_or_url)
+        else
+          File.extname(URI(path_or_url).path)
         end
 
       Kernel.open(path_or_url, "rb") do |file|
@@ -121,7 +121,11 @@ module MiniMagick
     #
     def self.attribute(name, key = name.to_s)
       define_method(name) do |*args|
-        @info[key, *args]
+        if args.any? && MiniMagick::Tool::Mogrify.instance_methods.include?(name)
+          mogrify { |b| b.send(name, *args) }
+        else
+          @info[key, *args]
+        end
       end
     end
 
@@ -401,7 +405,7 @@ module MiniMagick
             builder << output_to
           end
         else
-          FileUtils.copy_file path, output_to
+          FileUtils.copy_file path, output_to unless path == output_to.to_s
         end
       else
         IO.copy_stream File.open(path, "rb"), output_to

data/lib/mini_magick/shell.rb

@@ -1,6 +1,4 @@
 require "mini_magick/logger"
-
-require "open3"
 require "timeout"
 
 module MiniMagick
@@ -35,14 +33,29 @@ module MiniMagick
       stdout, stderr, status =
         MiniMagick.logger.debug(command.join(" ")) do
           Timeout.timeout(MiniMagick.timeout) do
-            Open3.capture3(*command)
+            send("execute_#{MiniMagick.shell_api.gsub("-", "_")}", *command)
           end
         end
 
       [stdout, stderr, status.exitstatus]
-    rescue Errno::ENOENT
+    rescue Errno::ENOENT, IOError
       ["", "executable not found: \"#{command.first}\"", 127]
     end
 
+    private
+
+    def execute_open3(*command)
+      require "open3"
+      Open3.capture3(*command)
+    end
+
+    def execute_posix_spawn(*command)
+      require "posix-spawn"
+      pid, stdin, stdout, stderr = POSIX::Spawn.popen4(*command)
+      Process.waitpid(pid)
+
+      [stdout.read, stderr.read, $?]
+    end
+
   end
 end

data/lib/mini_magick/tool.rb

@@ -65,7 +65,7 @@ module MiniMagick
     #   MiniMagick::Tool::Identify.new(false) do |identify|
     #     identify.help # returns exit status 1, which would otherwise throw an error
     #   end
-    def initialize(name, whiny = true)
+    def initialize(name, whiny = MiniMagick.whiny)
       @name  = name
       @whiny = whiny
       @args  = []
@@ -149,10 +149,11 @@ module MiniMagick
     # Changes the last operator to its "plus" form.
     #
     # @example
-    #   mogrify = MiniMagick::Tool::Mogrify.new
-    #   mogrify.antialias.+
-    #   mogrify.distort.+("Perspective '0,0,4,5'")
-    #   mogrify.command #=> ["mogrify", "+antialias", "+distort", "Perspective '0,0,4,5'"]
+    #   MiniMagick::Tool::Mogrify.new do |mogrify|
+    #     mogrify.antialias.+
+    #     mogrify.distort.+("Perspective", "0,0,4,5 89,0,45,46")
+    #   end
+    #   # executes `mogrify +antialias +distort Perspective '0,0,4,5 89,0,45,46'`
     #
     # @return [self]
     #
@@ -162,6 +163,27 @@ module MiniMagick
       self
     end
 
+    ##
+    # Create an ImageMagick stack in the command (surround.
+    #
+    # @example
+    #   MiniMagick::Tool::Convert.new do |convert|
+    #     convert << "wand.gif"
+    #     convert.stack do |stack|
+    #       stack << "wand.gif"
+    #       stack.rotate(30)
+    #     end
+    #     convert.append.+
+    #     convert << "images.gif"
+    #   end
+    #   # executes `convert wand.gif \( wizard.gif -rotate 30 \) +append images.gif`
+    #
+    def stack
+      self << "("
+      yield self
+      self << ")"
+    end
+
     private
 
     ##
@@ -202,11 +224,12 @@ module MiniMagick
       ##
       # Creates method based on command-line option's name.
       #
-      #  mogrify = MiniMagick::Tool.new("mogrify")
-      #  mogrify.antialias
-      #  mogrify.depth(8)
-      #  mogrify.resize("500x500")
-      #  mogirfy.command.join(" ") #=> "mogrify -antialias -depth "8" -resize "500x500""
+      #   mogrify = MiniMagick::Tool.new("mogrify")
+      #   mogrify.antialias
+      #   mogrify.depth(8)
+      #   mogrify.resize("500x500")
+      #   mogirfy.command.join(" ")
+      #   #=> "mogrify -antialias -depth 8 -resize 500x500"
       #
       def option(*options)
         options.each do |option|

data/lib/mini_magick/version.rb

@@ -8,7 +8,7 @@ module MiniMagick
 
   module VERSION
     MAJOR = 4
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
     PRE   = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mini_magick
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Corey Johnson
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-14 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -42,6 +42,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: posix-spawn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Manipulate images with minimal use of memory via ImageMagick / GraphicsMagick
 email:
 - probablycorey@gmail.com
@@ -76,19 +90,6 @@ files:
 - lib/mini_magick/tool/stream.rb
 - lib/mini_magick/utilities.rb
 - lib/mini_magick/version.rb
-- spec/fixtures/animation.gif
-- spec/fixtures/default.jpg
-- spec/fixtures/exif.jpg
-- spec/fixtures/image.psd
-- spec/fixtures/not_an_image.rb
-- spec/lib/mini_magick/configuration_spec.rb
-- spec/lib/mini_magick/image_spec.rb
-- spec/lib/mini_magick/shell_spec.rb
-- spec/lib/mini_magick/tool_spec.rb
-- spec/lib/mini_magick/utilities_spec.rb
-- spec/lib/mini_magick_spec.rb
-- spec/spec_helper.rb
-- spec/support/helpers.rb
 homepage: https://github.com/minimagick/minimagick
 licenses:
 - MIT
@@ -110,21 +111,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - You must have ImageMagick or GraphicsMagick installed
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Manipulate images with minimal use of memory via ImageMagick / GraphicsMagick
-test_files:
-- spec/fixtures/animation.gif
-- spec/fixtures/default.jpg
-- spec/fixtures/exif.jpg
-- spec/fixtures/image.psd
-- spec/fixtures/not_an_image.rb
-- spec/lib/mini_magick/configuration_spec.rb
-- spec/lib/mini_magick/image_spec.rb
-- spec/lib/mini_magick/shell_spec.rb
-- spec/lib/mini_magick/tool_spec.rb
-- spec/lib/mini_magick/utilities_spec.rb
-- spec/lib/mini_magick_spec.rb
-- spec/spec_helper.rb
-- spec/support/helpers.rb
+test_files: []
+has_rdoc: 

data/spec/fixtures/not_an_image.rb

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

data/spec/lib/mini_magick/configuration_spec.rb

@@ -1,66 +0,0 @@
-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,460 +0,0 @@
-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 "reads image from StringIO" do
-          stringio = StringIO.new(File.binread(image_path))
-          image = described_class.read(stringio)
-          expect(image).to be_valid
-        end
-
-        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
-
-      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
-
-        it "can import pixels with default format" do
-          image = described_class.import_pixels(blob, *dimensions, depth, map)
-
-          expect(image).to be_valid
-          expect(image.type).to eq 'PNG'
-          expect(image.dimensions).to eq dimensions
-        end
-
-        it "can import pixels with custom format" do
-          image = described_class.import_pixels(blob, *dimensions, depth, map, 'jpeg')
-
-          expect(image).to be_valid
-          expect(image.type).to eq 'JPEG'
-          expect(image.dimensions).to eq dimensions
-        end
-      end
-
-      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
-
-        it "accepts a Pathname" do
-          image = described_class.open(Pathname(image_path))
-          expect(image).to be_valid
-        end
-
-        it "loads a remote image" do
-          begin
-            image = described_class.open(image_url)
-            expect(image).to be_valid
-          rescue SocketError
-          end
-        end
-
-        it "validates the image" do
-          expect { described_class.open(image_path(:not)) }
-            .to raise_error(MiniMagick::Invalid)
-        end
-      end
-
-      describe ".create" do
-        def create(path = image_path)
-          described_class.create do |f|
-            f.write(File.binread(path))
-          end
-        end
-
-        it "creates an image" do
-          image = create
-          expect(File.exists?(image.path)).to eq true
-        end
-
-        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 "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
-
-      describe "#initialize" do
-        it "initializes a new image" do
-          image = described_class.new(image_path)
-          expect(image).to be_valid
-        end
-
-        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
-      end
-
-      describe "equivalence" do
-        subject(:image) { described_class.new(image_path) }
-        let(:same_image) { described_class.new(image_path) }
-        let(:other_image) { described_class.new(image_path(:exif)) }
-
-        it "is #== and #eql? to itself" do
-          expect(image).to eq(image)
-          expect(image).to eql(image)
-        end
-
-        it "is #== and #eql? to an instance of the same image" do
-          expect(image).to eq(same_image)
-          expect(image).to eql(same_image)
-        end
-
-        it "is not #== nor #eql? to an instance of a different image" do
-          expect(image).not_to eq(other_image)
-          expect(image).not_to eql(other_image)
-        end
-
-        it "generates the same hash code for an instance of the same image" do
-          expect(image.hash).to eq(same_image.hash)
-        end
-
-        it "generates different same hash codes for a different image" do
-          expect(image.hash).not_to eq(other_image.hash)
-        end
-      end
-
-      describe "#format" do
-        subject { described_class.open(image_path(:jpg)) }
-
-        it "changes the format of the photo" do
-          expect { subject.format("png") }
-            .to change { subject.type }
-        end
-
-        it "reformats an image with a given extension" do
-          expect { subject.format('png') }
-            .to change { File.extname(subject.path) }.to ".png"
-        end
-
-        it "creates the file with new extension" do
-          subject.format('png')
-          expect(File.exist?(subject.path)).to eq true
-        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 "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
-
-        it "deletes the previous tempfile" do
-          old_path = subject.path.dup
-          subject.format('png')
-          expect(File.exist?(old_path)).to eq false
-        end
-
-        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
-
-        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
-
-        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
-
-        it "returns self" do
-          expect(subject.format('png')).to eq subject
-        end
-      end
-
-      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
-
-        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 "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
-
-        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
-
-      describe "#valid?" do
-        it "returns true when image is valid" do
-          image = described_class.new(image_path)
-          expect(image).to be_valid
-        end
-
-        it "returns false when image is not valid" do
-          image = described_class.new(image_path(:not))
-          expect(image).not_to be_valid
-        end
-      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]/)
-          expect(subject[:signature]).to match(/[[:alnum:]]{64}/)
-        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]/)
-          expect(subject['signature']).to match(/[[:alnum:]]{64}/)
-        end
-
-        it "reads exif" do
-          subject = described_class.new(image_path(:exif))
-          gps_latitude = subject.exif["GPSLatitude"].split(/\s*,\s*/)
-          gps_longitude = subject.exif["GPSLongitude"].split(/\s*,\s*/)
-
-          expect(subject["EXIF:ColorSpace"]).to eq "1"
-          expect(gps_latitude.size).to eq 3
-          expect(gps_longitude.size).to eq 3
-        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 "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))
-        expect(subject.signature).to match(/[[:alnum:]]{64}/)
-      end
-
-      describe "#exif" do
-        subject { described_class.new(image_path(:exif)) }
-
-        it "returns a hash of EXIF data" do
-          expect(subject.exif["DateTimeOriginal"]).to be_a(String)
-        end
-
-        it "decodes the ExifVersion" do
-          expect(subject.exif["ExifVersion"]).to eq("0221")
-        end
-      end
-
-      describe "#resolution" do
-        it "accepts units", skip_cli: :graphicsmagick do
-          expect(subject.resolution("PixelsPerCentimeter"))
-            .not_to eq subject.resolution("PixelsPerInch")
-        end
-      end
-
-      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
-
-      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 "returns multiple images for GIFs, PDFs and PSDs" do
-          gif = described_class.new(image_path(:gif))
-          psd = described_class.new(image_path(:psd))
-
-          expect(gif.frames.count).to be > 1
-          expect(psd.layers.count).to be > 1 unless MiniMagick.graphicsmagick?
-        end
-
-        it "returns one image for other formats" do
-          jpg = described_class.new(image_path(:jpg))
-
-          expect(jpg.layers.count).to eq 1
-        end
-      end
-
-      describe "missing methods" do
-        context "for a known method" do
-          it "is executed by #method_missing" do
-            expect { subject.resize '20x30!' }
-              .to change { subject.dimensions }.to [20, 30]
-          end
-
-          it "returns self" do
-            expect(subject.resize('20x30!')).to eq subject
-          end
-
-          it "can be responed to" do
-            expect(subject.respond_to?(:resize)).to eq true
-          end
-        end
-
-        context "for an unknown method" do
-          it "fails with a NoMethodError" do
-            expect { subject.foo }
-              .to raise_error(NoMethodError, /MiniMagick::Image/)
-          end
-
-          it "cannot be responded to" do
-            expect(subject.respond_to?(:foo)).to eq false
-          end
-        end
-      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 "doesn't allow calling of #format" do
-          expect { subject.combine_options { |c| c.format("png") } }
-            .to raise_error(NoMethodError)
-        end
-
-        it "returns self" do
-          expect(subject.combine_options {}).to eq subject
-        end
-      end
-
-      describe "#composite" do
-        let(:other_image) { described_class.open(image_path) }
-        let(:mask) { described_class.open(image_path) }
-
-        it "creates a composite of two images" do
-          image = subject.composite(other_image)
-          expect(image).to be_valid
-        end
-
-        it "creates a composite of two images with mask" do
-          image = subject.composite(other_image, 'jpg', mask)
-          expect(image).to be_valid
-        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 "makes the composited image with the provided extension" do
-          result = subject.composite(other_image, 'png')
-          expect(result.path).to end_with ".png"
-
-          result = subject.composite(other_image)
-          expect(result.path).to end_with ".jpg"
-        end
-      end
-
-      describe "#collapse!" do
-        subject { described_class.open(image_path(:animation)) }
-
-        it "collapses the image to one frame" do
-          subject.collapse!
-          expect(subject.identify.lines.count).to eq 1
-        end
-
-        it "keeps the extension" do
-          expect { subject.collapse! }
-            .not_to change { subject.type }
-        end
-
-        it "clears the info" do
-          expect { subject.collapse! }
-            .to change { subject.size }
-        end
-
-        it "returns self" do
-          expect(subject.collapse!).to eq subject
-        end
-      end
-
-      describe "#identify" do
-        it "returns the output of identify" do
-          expect(subject.identify).to match(subject.type)
-        end
-
-        it "yields an optional block" do
-          output = subject.identify do |b|
-            b.verbose
-          end
-          expect(output).to match("Format:")
-        end
-      end
-
-      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

data/spec/lib/mini_magick/shell_spec.rb

@@ -1,66 +0,0 @@
-require "spec_helper"
-
-RSpec.describe MiniMagick::Shell do
-  subject { described_class.new }
-
-  describe "#run" do
-    it "calls #execute with the command" do
-      expect(subject).to receive(:execute).and_call_original
-      subject.run(%W[identify #{image_path}])
-    end
-
-    it "returns stdout" do
-      allow(subject).to receive(:execute).and_return(["stdout", "stderr", 0])
-      output = subject.run(%W[foo])
-      expect(output).to eq "stdout"
-    end
-
-    it "uses stderr for error messages" do
-      allow(subject).to receive(:execute).and_return(["", "stderr", 1])
-      expect { subject.run(%W[foo]) }
-        .to raise_error(MiniMagick::Error, /`foo`.*stderr/m)
-    end
-
-    it "raises an error when executable wasn't found" do
-      allow(subject).to receive(:execute).and_return(["", "not found", 127])
-      expect { subject.run(%W[foo]) }
-        .to raise_error(MiniMagick::Error, /not found/)
-    end
-
-    it "raises errors only in whiny mode" do
-      subject = described_class.new(false)
-      allow(subject).to receive(:execute).and_return(["stdout", "", 127])
-      expect(subject.run(%W[foo])).to eq "stdout"
-    end
-
-    it "prints to stderr output to $stderr in non-whiny mode" do
-      subject = described_class.new(false)
-      allow(subject).to receive(:execute).and_return(["", "stderr", 1])
-      expect { subject.run(%W[foo]) }.to output("stderr").to_stderr
-    end
-  end
-
-  describe "#execute" do
-    it "executes the command in the shell" do
-      stdout, * = subject.execute(%W[identify #{image_path(:gif)}])
-      expect(stdout).to match("GIF")
-    end
-
-    it "logs the command and execution time in debug mode" do
-      allow(MiniMagick).to receive(:debug).and_return(true)
-      expect { subject.execute(%W[identify #{image_path(:gif)}]) }.
-        to output(/\[\d+.\d+s\] identify #{image_path(:gif)}/).to_stdout
-    end
-
-    it "returns an appropriate response when command wasn't found" do
-      stdout, stderr, code = subject.execute(%W[unexisting command])
-      expect(code).to eq 127
-      expect(stderr).to match(/not found/)
-    end
-
-    it "doesn't break on spaces" do
-      stdout, * = subject.execute(["identify", "-format", "%w %h", image_path])
-      expect(stdout).to match(/\d+ \d+/)
-    end
-  end
-end

data/spec/lib/mini_magick/tool_spec.rb

@@ -1,107 +0,0 @@
-require "spec_helper"
-
-RSpec.describe MiniMagick::Tool do
-  subject { MiniMagick::Tool::Identify.new }
-
-  describe "#call" do
-    it "calls the shell to run the command" do
-      subject << image_path(:gif)
-      output = subject.call
-      expect(output).to match("GIF")
-    end
-
-    it "strips the output" do
-      subject << image_path
-      output = subject.call
-      expect(output).not_to end_with("\n")
-    end
-  end
-
-  describe ".new" do
-    it "accepts a block, and immediately executes the command" do
-      output = described_class.new("identify") do |builder|
-        builder << image_path(:gif)
-      end
-      expect(output).to match("GIF")
-    end
-  end
-
-  describe "#command" do
-    it "includes the executable and the arguments" do
-      allow(subject).to receive(:args).and_return(%W[-list Command])
-      expect(subject.command).to include(*%W[identify -list Command])
-    end
-  end
-
-  describe "#executable" do
-    it "prepends 'gm' to the command list when using GraphicsMagick" do
-      allow(MiniMagick).to receive(:cli).and_return(:graphicsmagick)
-      expect(subject.executable).to eq %W[gm identify]
-    end
-
-    it "respects #cli_path" do
-      allow(MiniMagick).to receive(:cli).and_return(:imagemagick)
-      allow(MiniMagick).to receive(:cli_path).and_return("path/to/cli")
-      expect(subject.executable).to eq %W[path/to/cli/identify]
-    end
-  end
-
-  describe "#<<" do
-    it "adds argument to the args list" do
-      subject << "foo" << "bar" << 123
-      expect(subject.args).to eq %W[foo bar 123]
-    end
-  end
-
-  describe "#merge!" do
-    it "adds arguments to the args list" do
-      subject << "pre-existing"
-      subject.merge! ["foo", 123]
-      expect(subject.args).to eq %W[pre-existing foo 123]
-    end
-  end
-
-  describe "#+" do
-    it "switches the last option to + form" do
-      subject.help
-      subject.help.+
-      subject.debug.+ "foo"
-      subject.debug.+ 8, "bar"
-      expect(subject.args).to eq %W[-help +help +debug foo +debug 8 bar]
-    end
-  end
-
-  ["ImageMagick", "GraphicsMagick"].each do |cli|
-    context "with #{cli}", cli: cli.downcase.to_sym do
-      it "adds dynamically generated operator methods" do
-        subject.help.depth(8)
-        expect(subject.args).to eq %W[-help -depth 8]
-      end
-
-      it "doesn't just delegate to #method_missing" do
-        expect(subject.class.instance_methods).to include(:help)
-      end
-
-      it "adds dynamically generated creation operator methods" do
-        subject.radial_gradient.canvas "khaki"
-        expect(subject.args).to eq %W[radial-gradient: canvas:khaki]
-      end
-    end
-  end
-
-  it "resets the dynamically generated operator methods on CLI change" do
-    MiniMagick.cli = :imagemagick
-    expect(subject).to respond_to(:quiet)
-
-    MiniMagick.cli = :graphicsmagick
-    expect(subject).not_to respond_to(:quiet)
-    expect(subject).to respond_to(:ping)
-  end
-
-  it "doesn't raise errors when false is passed to the constructor" do
-    subject.help
-    subject.call(false)
-
-    MiniMagick::Tool::Identify.new(false, &:help)
-  end
-end

data/spec/lib/mini_magick/utilities_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-RSpec.describe MiniMagick::Utilities do
-  describe ".which" do
-    it "identifies when mogrify exists" do
-      expect(MiniMagick::Utilities.which('mogrify')).not_to be_nil
-    end
-
-    it "identifies when gm exists" do
-      expect(MiniMagick::Utilities.which('gm')).not_to be_nil
-    end
-
-    it "returns nil on nonexistent executables" do
-      expect(MiniMagick::Utilities.which('yogrify')).to be_nil
-    end
-  end
-end

data/spec/lib/mini_magick_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-RSpec.describe MiniMagick do
-  describe ".imagemagick?" do
-    it "returns true if CLI is minimagick" do
-      allow(described_class).to receive(:cli).and_return(:imagemagick)
-      expect(described_class.imagemagick?).to eq true
-    end
-
-    it "returns false if CLI isn't minimagick" do
-      allow(described_class).to receive(:cli).and_return(:graphicsmagick)
-      expect(described_class.imagemagick?).to eq false
-    end
-  end
-
-  describe ".graphicsmagick?" do
-    it "returns true if CLI is graphicsmagick" do
-      allow(described_class).to receive(:cli).and_return(:graphicsmagick)
-      expect(described_class.graphicsmagick?).to eq true
-    end
-
-    it "returns false if CLI isn't graphicsmagick" do
-      allow(described_class).to receive(:cli).and_return(:imagemagick)
-      expect(described_class.graphicsmagick?).to eq false
-    end
-  end
-
-  describe ".cli_version" do
-    it "returns ImageMagick's version" do
-      allow(described_class).to receive(:cli).and_return(:imagemagick)
-      expect(described_class.cli_version).to match(/^\d+\.\d+\.\d+-\d+$/)
-    end
-
-    it "returns GraphicsMagick's version" do
-      allow(described_class).to receive(:cli).and_return(:graphicsmagick)
-      expect(described_class.cli_version).to match(/^\d+\.\d+\.\d+$/)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-require "bundler/setup"
-require "mini_magick"
-require "pry"
-
-require_relative "support/helpers"
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.formatter = "documentation"
-  config.color = true
-  config.fail_fast = true unless ENV["CI"]
-
-  [:imagemagick, :graphicsmagick].each do |cli|
-    config.around(cli: cli) do |example|
-      MiniMagick.with_cli(cli) { example.run }
-    end
-    config.around(skip_cli: cli) do |example|
-      example.run unless example.metadata[:cli] == cli
-    end
-  end
-end

data/spec/support/helpers.rb

@@ -1,37 +0,0 @@
-require "tempfile"
-
-module Helpers
-  def image_path(type = :default)
-    if type != :without_extension
-      File.join("spec/fixtures",
-        case type
-        when :default, :jpg   then "default.jpg"
-        when :animation, :gif then "animation.gif"
-        when :pdf             then "document.pdf"
-        when :psd             then "image.psd"
-        when :exif            then "exif.jpg"
-        when :not             then "not_an_image.rb"
-        else
-          fail "image #{type.inspect} doesn't exist"
-        end
-      )
-    else
-      path = random_path
-      FileUtils.cp image_path, path
-      path
-    end
-  end
-
-  def image_url
-    "https://avatars2.githubusercontent.com/u/795488?v=2&s=40"
-  end
-
-  def random_path(basename = "")
-    @tempfile = Tempfile.open(basename)
-    @tempfile.path
-  end
-end
-
-RSpec.configure do |config|
-  config.include Helpers
-end