mini_magick 3.8.1 → 4.0.0

data/lib/mini_magick/logger.rb

@@ -0,0 +1,40 @@
+require "benchmark"
+
+module MiniMagick
+  ##
+  # Responsible for logging commands to stdout (activated when
+  # `MiniMagick.debug` is set to `true`). Implements a simplified Logger
+  # interface.
+  #
+  # @private
+  #
+  class Logger
+
+    attr_accessor :format
+
+    def initialize(io)
+      @io     = io
+      @format = "[%<duration>.2fs] %<command>s"
+    end
+
+    def debug(command, &action)
+      benchmark(action) do |duration|
+        output(duration: duration, command: command) if MiniMagick.debug
+      end
+    end
+
+    private
+
+    def output(data)
+      printf @io, "#{format}\n", data
+    end
+
+    def benchmark(action)
+      return_value = nil
+      duration = Benchmark.realtime { return_value = action.call }
+      yield duration
+      return_value
+    end
+
+  end
+end

data/lib/mini_magick/shell.rb

@@ -0,0 +1,48 @@
+require "mini_magick/logger"
+
+require "open3"
+require "timeout"
+
+module MiniMagick
+  ##
+  # Sends commands to the shell (more precisely, it sends commands directly to
+  # the operating system).
+  #
+  # @private
+  #
+  class Shell
+
+    def initialize(whiny = true)
+      @whiny = whiny
+    end
+
+    def run(command)
+      stdout, stderr, code = execute(command)
+
+      case code
+      when 1
+        fail MiniMagick::Error, "`#{command.join(" ")}` failed with error:\n#{stderr}"
+      when 127
+        fail MiniMagick::Error, stderr
+      end if @whiny
+
+      $stderr.print(stderr)
+
+      stdout
+    end
+
+    def execute(command)
+      stdout, stderr, status =
+        MiniMagick.logger.debug(command.join(" ")) do
+          Timeout.timeout(MiniMagick.timeout) do
+            Open3.capture3(*command)
+          end
+        end
+
+      [stdout, stderr, status.exitstatus]
+    rescue Errno::ENOENT
+      ["", "executable not found: \"#{command.first}\"", 127]
+    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/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/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,250 @@
+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
+
+    autoload :Animate,   "mini_magick/tool/animate"
+    autoload :Compare,   "mini_magick/tool/compare"
+    autoload :Composite, "mini_magick/tool/composite"
+    autoload :Conjure,   "mini_magick/tool/conjure"
+    autoload :Convert,   "mini_magick/tool/convert"
+    autoload :Display,   "mini_magick/tool/display"
+    autoload :Identify,  "mini_magick/tool/identify"
+    autoload :Import,    "mini_magick/tool/import"
+    autoload :Mogrify,   "mini_magick/tool/mogrify"
+    autoload :Montage,   "mini_magick/tool/montage"
+    autoload :Stream,    "mini_magick/tool/stream"
+
+    # @private
+    def self.inherited(child)
+      child_name = child.name.split("::").last.downcase
+      child.send :include, MiniMagick::Tool::OptionMethods.new(child_name)
+    end
+
+    ##
+    # 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(false) do |identify|
+    #     identify.help # returns exit status 1, which would otherwise throw an error
+    #   end
+    def initialize(name, whiny = true)
+      @name  = name
+      @whiny = whiny
+      @args  = []
+    end
+
+    ##
+    # Executes the command that has been built up.
+    #
+    # @example
+    #   mogrify = MiniMagick::Tool::Mogrify.new
+    #   mogrify.resize("500x500")
+    #   mogrify << "path/to/image.jpg"
+    #   mogirfy.call # executes `mogrify -resize 500x500 path/to/image.jpg`
+    #
+    # @param whiny [Boolean] Whether you want an error to be raised when
+    #   ImageMagick returns an exit code of 1. You may want this because
+    #   some ImageMagick's commands (`identify -help`) return exit code 1,
+    #   even though no error happened.
+    #
+    # @return [String] Output of the command
+    #
+    def call(whiny = @whiny)
+      shell = MiniMagick::Shell.new(whiny)
+      shell.run(command).strip
+    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} and {MiniMagick::Configuration#cli_path}.
+    #
+    # @return [Array<String>]
+    #
+    # @example
+    #   MiniMagick.configure { |config| config.cli = :graphicsmagick }
+    #   identify = MiniMagick::Tool::Identify.new
+    #   identify.executable #=> ["gm", "identify"]
+    #
+    def executable
+      exe = [name]
+      exe.unshift "gm" if MiniMagick.graphicsmagick?
+      exe.unshift File.join(MiniMagick.cli_path, exe.shift) if MiniMagick.cli_path
+      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
+    #   mogrify = MiniMagick::Tool::Mogrify.new
+    #   mogrify.antialias.+
+    #   mogrify.distort.+("Perspective '0,0,4,5'")
+    #   mogrify.command #=> ["mogrify", "+antialias", "+distort", "Perspective '0,0,4,5'"]
+    #
+    # @return [self]
+    #
+    def +(*values)
+      args[-1] = args[-1].sub(/^-/, '+')
+      self.merge!(values)
+      self
+    end
+
+    private
+
+    ##
+    # Dynamically generates modules with dynamically generated option methods
+    # for each command-line tool. It uses the `-help` page of a command-line
+    # tool and generates methods from it. It then includes the generated
+    # module into the tool class.
+    #
+    # @private
+    #
+    class OptionMethods < Module # think about it for a minute
+
+      def self.instances
+        @instances ||= []
+      end
+
+      def initialize(tool_name)
+        @tool_name = tool_name
+        reload_methods
+        self.class.instances << self
+      end
+
+      def to_s
+        "OptionMethods(#{@tool_name})"
+      end
+
+      ##
+      # Dynamically generates operator methods from the "-help" page.
+      #
+      def reload_methods
+        instance_methods(false).each { |method| undef_method(method) }
+        creation_operator *creation_operators
+        option *cli_options
+      end
+
+      private
+
+      ##
+      # 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""
+      #
+      def option(*options)
+        options.each do |option|
+          define_method(option[1..-1].gsub('-', '_')) do |*values|
+            self << option
+            self.merge!(values)
+            self
+          end
+        end
+      end
+
+      ##
+      # Creates method based on creation operator's name.
+      #
+      #   mogrify = MiniMagick::Tool.new("mogrify")
+      #   mogrify.canvas("khaki")
+      #   mogrify.command.join(" ") #=> "mogrify canvas:khaki"
+      #
+      def creation_operator(*operators)
+        operators.each do |operator|
+          define_method(operator.gsub('-', '_')) do |value = nil|
+            self << "#{operator}:#{value}"
+            self
+          end
+        end
+      end
+
+      def creation_operators
+        %w[xc canvas logo rose gradient radial-gradient
+           plasma tile pattern label caption text]
+      end
+
+      def cli_options
+        help = MiniMagick::Tool.new(@tool_name, false) { |b| b << "-help" }
+        cli_options = help.scan(/^\s+-[a-z\-]+/).map(&:strip)
+      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,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 = 0
+    TINY  = 0
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')