mini_magick 3.8.0 → 4.0.0.rc

data/lib/mini_magick.rb

@@ -1,89 +1,53 @@
-require 'tempfile'
-require 'subexec'
-require 'stringio'
-require 'pathname'
-require 'shellwords'
-require 'mini_magick/command_builder'
-require 'mini_magick/errors'
+require 'mini_magick/configuration'
+require 'mini_magick/tool'
 require 'mini_magick/image'
-require 'mini_magick/utilities'
 
 module MiniMagick
-  @validate_on_create = true
-  @validate_on_write = true
 
-  class << self
-    attr_accessor :processor
-    attr_accessor :processor_path
-    attr_accessor :timeout
-    attr_accessor :validate_on_create
-    attr_accessor :validate_on_write
-
-    ##
-    # Tries to detect the current processor based if any of the processors exist.
-    # Mogrify have precedence over gm by default.
-    #
-    # === Returns
-    # * [String] The detected procesor
-    def choose_processor
-      self.processor = if MiniMagick::Utilities.which('mogrify')
-                         :mogrify
-                       elsif MiniMagick::Utilities.which('gm')
-                         :gm
-                       else
-                         nil
-                       end
-    end
-
-    ##
-    # Discovers the imagemagick version based on mogrify's output.
-    #
-    # === Returns
-    # * The imagemagick version
-    def image_magick_version
-      @@version ||= Gem::Version.create(`mogrify --version`.split(' ')[2].split('-').first)
-    end
-
-    ##
-    # The minimum allowed imagemagick version
-    #
-    # === Returns
-    # * The minimum imagemagick version
-    def minimum_image_magick_version
-      @@minimum_version ||= Gem::Version.create('6.6.3')
-    end
+  extend MiniMagick::Configuration
+
+  ##
+  # You might want to execute only certain blocks of processing with a
+  # different CLI, because for example that CLI does that particular thing
+  # faster. After the block CLI resets to its previous value.
+  #
+  # @example
+  #   MiniMagick.with_cli :graphicsmagick do
+  #     # operations that are better done with GraphicsMagick
+  #   end
+  def self.with_cli(cli)
+    old_cli = self.cli
+    self.cli = cli
+    yield
+    self.cli = old_cli
+  end
 
-    ##
-    # Checks whether the imagemagick's version is valid
-    #
-    # === Returns
-    # * [Boolean]
-    def valid_version_installed?
-      image_magick_version >= minimum_image_magick_version
-    end
+  ##
+  # Checks whether the CLI used is ImageMagick.
+  #
+  # @return [Boolean]
+  def self.imagemagick?
+    cli == :imagemagick
+  end
 
-    ##
-    # Picks the right processor if it isn't set and returns whether it's mogrify or not.
-    #
-    # === Returns
-    # * [Boolean]
-    def mogrify?
-      choose_processor if processor.nil?
+  ##
+  # Checks whether the CLI used is GraphicsMagick.
+  #
+  # @return [Boolean]
+  def self.graphicsmagick?
+    cli == :graphicsmagick
+  end
 
-      return processor.to_s.downcase.to_sym == :mogrify unless processor.nil?
-      false
-    end
+  ##
+  # Returns ImageMagick's/GraphicsMagick's version.
+  #
+  # @return [String]
+  def self.cli_version
+    output = MiniMagick::Tool::Identify.new(&:version)
+    output[/\d+\.\d+\.\d+(-\d+)?/]
+  end
 
-    ##
-    # Picks the right processor if it isn't set and returns whether it's graphicsmagick or not.
-    #
-    # === Returns
-    # * [Boolean]
-    def gm?
-      choose_processor if processor.nil?
+  class Error < RuntimeError; end
+  class Invalid < StandardError; end
 
-      return processor.to_s.downcase.to_sym == :gm unless processor.nil?
-      false
-    end
-  end
 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

@@ -0,0 +1,407 @@
+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 "#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]/)
+        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 "reads exif" do
+          subject = described_class.new(image_path(:exif))
+          expect(subject["EXIF:ColorSpace"]).to eq "1"
+        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))
+      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
+      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 "#method_missing" do
+        it "executes the command correctly" do
+          expect { subject.resize '20x30!' }
+            .to change { subject.dimensions }.to [20, 30]
+        end
+
+        it "fails with a correct NoMethodError" do
+          expect { subject.foo }
+            .to raise_error(NoMethodError, /MiniMagick::Image/)
+        end
+
+        it "returns self" do
+          expect(subject.resize('20x30!')).to eq subject
+        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

@@ -0,0 +1,66 @@
+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
+  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 "timeouts afer a period of time" do
+      allow(MiniMagick).to receive(:timeout).and_return(0.001)
+      expect { subject.execute(%W[identify -format %[EXIF:*] #{image_path(:exif)}]) }
+        .to raise_error(Timeout::Error)
+    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