mini_magick 3.8.1 → 4.9.4

data/lib/mini_magick/shell.rb

@@ -0,0 +1,81 @@
+require "timeout"
+require "benchmark"
+
+module MiniMagick
+  ##
+  # Sends commands to the shell (more precisely, it sends commands directly to
+  # the operating system).
+  #
+  # @private
+  #
+  class Shell
+
+    def run(command, options = {})
+      stdout, stderr, status = execute(command, stdin: options[:stdin])
+
+      if status != 0 && options.fetch(:whiny, MiniMagick.whiny)
+        fail MiniMagick::Error, "`#{command.join(" ")}` failed with error:\n#{stderr}"
+      end
+
+      $stderr.print(stderr) unless options[:stderr] == false
+
+      [stdout, stderr, status]
+    end
+
+    def execute(command, options = {})
+      stdout, stderr, status =
+        log(command.join(" ")) do
+          send("execute_#{MiniMagick.shell_api.gsub("-", "_")}", command, options)
+        end
+
+      [stdout, stderr, status.exitstatus]
+    rescue Errno::ENOENT, IOError
+      ["", "executable not found: \"#{command.first}\"", 127]
+    end
+
+    private
+
+    def execute_open3(command, options = {})
+      require "open3"
+
+      # We would ideally use Open3.capture3, but it wouldn't allow us to
+      # terminate the command after timing out.
+      Open3.popen3(*command) do |in_w, out_r, err_r, thread|
+        [in_w, out_r, err_r].each(&:binmode)
+        stdout_reader = Thread.new { out_r.read }
+        stderr_reader = Thread.new { err_r.read }
+        begin
+          in_w.write options[:stdin].to_s
+        rescue Errno::EPIPE
+        end
+        in_w.close
+
+        begin
+          Timeout.timeout(MiniMagick.timeout) { thread.join }
+        rescue Timeout::Error
+          Process.kill("TERM", thread.pid) rescue nil
+          Process.waitpid(thread.pid)      rescue nil
+          raise Timeout::Error, "MiniMagick command timed out: #{command}"
+        end
+
+        [stdout_reader.value, stderr_reader.value, thread.value]
+      end
+    end
+
+    def execute_posix_spawn(command, options = {})
+      require "posix-spawn"
+      child = POSIX::Spawn::Child.new(*command, input: options[:stdin].to_s, timeout: MiniMagick.timeout)
+      [child.out, child.err, child.status]
+    rescue POSIX::Spawn::TimeoutExceeded
+      raise Timeout::Error, "MiniMagick command timed out: #{command}"
+    end
+
+    def log(command, &block)
+      value = nil
+      duration = Benchmark.realtime { value = block.call }
+      MiniMagick.logger.debug "[%.2fs] %s" % [duration, command]
+      value
+    end
+
+  end
+end

data/lib/mini_magick/tool/animate.rb

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

data/lib/mini_magick/tool/compare.rb

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

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(*args)
+        super("composite", *args)
+      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(*args)
+        super("conjure", *args)
+      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(*args)
+        super("convert", *args)
+      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(*args)
+        super("display", *args)
+      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(*args)
+        super("identify", *args)
+      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(*args)
+        super("import", *args)
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/magick.rb

@@ -0,0 +1,14 @@
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/command-line-processing.php
+    #
+    class Magick < MiniMagick::Tool
+
+      def initialize(*args)
+        super("magick", *args)
+      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(*args)
+        super("mogrify", *args)
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool/mogrify_restricted.rb

@@ -0,0 +1,15 @@
+require "mini_magick/tool/mogrify"
+
+module MiniMagick
+  class Tool
+    ##
+    # @see http://www.imagemagick.org/script/mogrify.php
+    #
+    class MogrifyRestricted < Mogrify
+      def format(*args)
+        fail NoMethodError,
+          "you must call #format on a MiniMagick::Image directly"
+      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(*args)
+        super("montage", *args)
+      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(*args)
+        super("stream", *args)
+      end
+
+    end
+  end
+end

data/lib/mini_magick/tool.rb

@@ -0,0 +1,297 @@
+require "mini_magick/shell"
+
+module MiniMagick
+  ##
+  # Abstract class that wraps command-line tools. It shouldn't be used directly,
+  # but through one of its subclasses (e.g. {MiniMagick::Tool::Mogrify}). Use
+  # this class if you want to be closer to the metal and execute ImageMagick
+  # commands directly, but still with a nice Ruby interface.
+  #
+  # @example
+  #   MiniMagick::Tool::Mogrify.new do |builder|
+  #     builder.resize "500x500"
+  #     builder << "path/to/image.jpg"
+  #   end
+  #
+  class Tool
+
+    CREATION_OPERATORS = %w[xc canvas logo rose gradient radial-gradient plasma
+                            pattern text pango]
+
+    ##
+    # Aside from classic instantiation, it also accepts a block, and then
+    # executes the command in the end.
+    #
+    # @example
+    #   version = MiniMagick::Tool::Identify.new { |b| b.version }
+    #   puts version
+    #
+    # @return [MiniMagick::Tool, String] If no block is given, returns an
+    #   instance of the tool, if block is given, returns the output of the
+    #   command.
+    #
+    def self.new(*args)
+      instance = super(*args)
+
+      if block_given?
+        yield instance
+        instance.call
+      else
+        instance
+      end
+    end
+
+    # @private
+    attr_reader :name, :args
+
+    # @param whiny [Boolean] Whether to raise errors on exit codes different
+    #   than 0.
+    # @example
+    #   MiniMagick::Tool::Identify.new(whiny: false) do |identify|
+    #     identify.help # returns exit status 1, which would otherwise throw an error
+    #   end
+    def initialize(name, options = {})
+      warn "MiniMagick::Tool.new(false) is deprecated and will be removed in MiniMagick 5, use MiniMagick::Tool.new(whiny: false) instead." if !options.is_a?(Hash)
+
+      @name  = name
+      @args  = []
+      @whiny = options.is_a?(Hash) ? options.fetch(:whiny, MiniMagick.whiny) : options
+    end
+
+    ##
+    # Executes the command that has been built up.
+    #
+    # @example
+    #   mogrify = MiniMagick::Tool::Mogrify.new
+    #   mogrify.resize("500x500")
+    #   mogrify << "path/to/image.jpg"
+    #   mogrify.call # executes `mogrify -resize 500x500 path/to/image.jpg`
+    #
+    # @example
+    #   mogrify = MiniMagick::Tool::Mogrify.new
+    #   # build the command
+    #   mogrify.call do |stdout, stderr, status|
+    #     # ...
+    #   end
+    #
+    # @yield [Array] Optionally yields stdout, stderr, and exit status
+    #
+    # @return [String] Returns the output of the command
+    #
+    def call(*args)
+      options = args[-1].is_a?(Hash) ? args.pop : {}
+      warn "Passing whiny to MiniMagick::Tool#call is deprecated and will be removed in MiniMagick 5, use MiniMagick::Tool.new(whiny: false) instead." if args.any?
+      whiny = args.fetch(0, @whiny)
+
+      options[:whiny] = whiny
+      options[:stderr] = false if block_given?
+
+      shell = MiniMagick::Shell.new
+      stdout, stderr, status = shell.run(command, options)
+      yield stdout, stderr, status if block_given?
+
+      stdout.chomp("\n")
+    end
+
+    ##
+    # The currently built-up command.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   mogrify = MiniMagick::Tool::Mogrify.new
+    #   mogrify.resize "500x500"
+    #   mogrify.contrast
+    #   mogrify.command #=> ["mogrify", "-resize", "500x500", "-contrast"]
+    #
+    def command
+      [*executable, *args]
+    end
+
+    ##
+    # The executable used for this tool. Respects
+    # {MiniMagick::Configuration#cli}, {MiniMagick::Configuration#cli_path},
+    # and {MiniMagick::Configuration#cli_prefix}.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   MiniMagick.configure { |config| config.cli = :graphicsmagick }
+    #   identify = MiniMagick::Tool::Identify.new
+    #   identify.executable #=> ["gm", "identify"]
+    #
+    # @example
+    #   MiniMagick.configure do |config|
+    #     config.cli = :graphicsmagick
+    #     config.cli_prefix = ['firejail', '--force']
+    #   end
+    #   identify = MiniMagick::Tool::Identify.new
+    #   identify.executable #=> ["firejail", "--force", "gm", "identify"]
+    #
+    def executable
+      exe = [name]
+      exe.unshift "magick" if MiniMagick.imagemagick7? && name != "magick"
+      exe.unshift "gm" if MiniMagick.graphicsmagick?
+      exe.unshift File.join(MiniMagick.cli_path, exe.shift) if MiniMagick.cli_path
+      Array(MiniMagick.cli_prefix).reverse_each { |p| exe.unshift p } if MiniMagick.cli_prefix
+      exe
+    end
+
+    ##
+    # Appends raw options, useful for appending image paths.
+    #
+    # @return [self]
+    #
+    def <<(arg)
+      args << arg.to_s
+      self
+    end
+
+    ##
+    # Merges a list of raw options.
+    #
+    # @return [self]
+    #
+    def merge!(new_args)
+      new_args.each { |arg| self << arg }
+      self
+    end
+
+    ##
+    # Changes the last operator to its "plus" form.
+    #
+    # @example
+    #   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]
+    #
+    def +(*values)
+      args[-1] = args[-1].sub(/^-/, '+')
+      self.merge!(values)
+      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
+
+    ##
+    # Adds ImageMagick's pseudo-filename `-` for standard input.
+    #
+    # @example
+    #   identify = MiniMagick::Tool::Identify.new
+    #   identify.stdin
+    #   identify.call(stdin: image_content)
+    #   # executes `identify -` with the given standard input
+    #
+    def stdin
+      self << "-"
+    end
+
+    ##
+    # Adds ImageMagick's pseudo-filename `-` for standard output.
+    #
+    # @example
+    #   content = MiniMagick::Tool::Convert.new do |convert|
+    #     convert << "input.jpg"
+    #     convert.auto_orient
+    #     convert.stdout
+    #   end
+    #   # executes `convert input.jpg -auto-orient -` which returns file contents
+    #
+    def stdout
+      self << "-"
+    end
+
+    ##
+    # Define creator operator methods
+    #
+    #   mogrify = MiniMagick::Tool.new("mogrify")
+    #   mogrify.canvas("khaki")
+    #   mogrify.command.join(" ") #=> "mogrify canvas:khaki"
+    #
+    CREATION_OPERATORS.each do |operator|
+      define_method(operator.gsub('-', '_')) do |value = nil|
+        self << "#{operator}:#{value}"
+        self
+      end
+    end
+
+    ##
+    # This option is a valid ImageMagick option, but it's also a Ruby method,
+    # so we need to override it so that it correctly acts as an option method.
+    #
+    def clone(*args)
+      self << '-clone'
+      self.merge!(args)
+      self
+    end
+
+    ##
+    # Any undefined method will be transformed into a CLI option
+    #
+    #   mogrify = MiniMagick::Tool.new("mogrify")
+    #   mogrify.adaptive_blur("...")
+    #   mogrify.foo_bar
+    #   mogrify.command.join(" ") "mogrify -adaptive-blur ... -foo-bar"
+    #
+    def method_missing(name, *args)
+      option = "-#{name.to_s.tr('_', '-')}"
+      self << option
+      self.merge!(args)
+      self
+    end
+
+    def self.option_methods
+      @option_methods ||= (
+        tool = new(whiny: false)
+        tool << "-help"
+        help_page = tool.call(stderr: false)
+
+        cli_options = help_page.scan(/^\s+-[a-z\-]+/).map(&:strip)
+        if tool.name == "mogrify" && MiniMagick.graphicsmagick?
+          # These options were undocumented before 2015-06-14 (see gm bug 302)
+          cli_options |= %w[-box -convolve -gravity -linewidth -mattecolor -render -shave]
+        end
+
+        cli_options.map { |o| o[1..-1].tr('-','_') }
+      )
+    end
+
+  end
+end
+
+require "mini_magick/tool/animate"
+require "mini_magick/tool/compare"
+require "mini_magick/tool/composite"
+require "mini_magick/tool/conjure"
+require "mini_magick/tool/convert"
+require "mini_magick/tool/display"
+require "mini_magick/tool/identify"
+require "mini_magick/tool/import"
+require "mini_magick/tool/magick"
+require "mini_magick/tool/mogrify"
+require "mini_magick/tool/mogrify_restricted"
+require "mini_magick/tool/montage"
+require "mini_magick/tool/stream"

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.fetch('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,15 +1,15 @@
 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
+    MAJOR = 4
+    MINOR = 9
+    TINY  = 4
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')