mini_magick 4.7.2 → 4.13.2

data/lib/mini_magick/configuration.rb

@@ -5,24 +5,23 @@ module MiniMagick
   module Configuration
 
     ##
-    # Set whether you want to use [ImageMagick](http://www.imagemagick.org) or
-    # [GraphicsMagick](http://www.graphicsmagick.org).
-    #
-    # @return [Symbol] `:imagemagick` or `:graphicsmagick`
+    # If you don't have the CLI tools in your PATH, you can set the path to the
+    # executables.
     #
-    attr_accessor :cli
+    attr_writer :cli_path
     # @private (for backwards compatibility)
-    attr_accessor :processor
+    attr_accessor :processor_path
 
     ##
-    # If you don't have the CLI tools in your PATH, you can set the path to the
-    # executables.
+    # Adds a prefix to the CLI command.
+    # For example, you could use `firejail` to run all commands in a sandbox.
+    # Can be a string, or an array of strings.
+    # e.g. 'firejail', or ['firejail', '--force']
     #
     # @return [String]
+    # @return [Array<String>]
     #
-    attr_accessor :cli_path
-    # @private (for backwards compatibility)
-    attr_accessor :processor_path
+    attr_accessor :cli_prefix
 
     ##
     # If you don't want commands to take too long, you can set a timeout (in
@@ -32,12 +31,12 @@ module MiniMagick
     #
     attr_accessor :timeout
     ##
-    # When set to `true`, it outputs each command to STDOUT in their shell
+    # When get to `true`, it outputs each command to STDOUT in their shell
     # version.
     #
     # @return [Boolean]
     #
-    attr_accessor :debug
+    attr_reader :debug
     ##
     # Logger for {#debug}, default is `MiniMagick::Logger.new(STDOUT)`, but
     # you can override it, for example if you want the logs to be written to
@@ -46,6 +45,13 @@ module MiniMagick
     # @return [Logger]
     #
     attr_accessor :logger
+    ##
+    # Temporary directory used by MiniMagick, default is `Dir.tmpdir`, but
+    # you can override it.
+    #
+    # @return [String]
+    #
+    attr_accessor :tmpdir
 
     ##
     # If set to `true`, it will `identify` every newly created image, and raise
@@ -58,7 +64,7 @@ module MiniMagick
     ##
     # If set to `true`, it will `identify` every image that gets written (with
     # {MiniMagick::Image#write}), and raise `MiniMagick::Invalid` if the image
-    # is not valid. Useful for validating that processing was sucessful,
+    # is not valid. Useful for validating that processing was successful,
     # although it adds a bit of overhead. Defaults to `true`.
     #
     # @return [Boolean]
@@ -74,20 +80,17 @@ module MiniMagick
     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
+    # If set to `false`, it will not forward warnings from ImageMagick to
+    # standard error.
+    attr_accessor :warnings
 
     def self.extended(base)
+      base.tmpdir = Dir.tmpdir
       base.validate_on_create = true
       base.validate_on_write = true
       base.whiny = true
-      base.shell_api = "open3"
       base.logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+      base.warnings = true
     end
 
     ##
@@ -102,51 +105,95 @@ module MiniMagick
       yield self
     end
 
+    CLI_DETECTION = {
+      imagemagick7:   "magick",
+      imagemagick:    "mogrify",
+      graphicsmagick: "gm",
+    }
+
+    # @private (for backwards compatibility)
     def processor
-      @processor ||= ["mogrify", "gm"].detect do |processor|
+      @processor ||= CLI_DETECTION.values.detect do |processor|
         MiniMagick::Utilities.which(processor)
       end
     end
 
+    # @private (for backwards compatibility)
     def processor=(processor)
       @processor = processor.to_s
 
-      unless ["mogrify", "gm"].include?(@processor)
+      unless CLI_DETECTION.value?(@processor)
         raise ArgumentError,
-          "processor has to be set to either \"mogrify\" or \"gm\"" \
+          "processor has to be set to either \"magick\", \"mogrify\" or \"gm\"" \
           ", was set to #{@processor.inspect}"
       end
     end
 
+    ##
+    # Get [ImageMagick](http://www.imagemagick.org) or
+    # [GraphicsMagick](http://www.graphicsmagick.org).
+    #
+    # @return [Symbol] `:imagemagick` or `:graphicsmagick`
+    #
     def cli
-      @cli ||
-        case processor.to_s
-        when "mogrify" then :imagemagick
-        when "gm"      then :graphicsmagick
-        else
-          raise MiniMagick::Error, "ImageMagick/GraphicsMagick is not installed"
-        end
+      if instance_variable_defined?("@cli")
+        instance_variable_get("@cli")
+      else
+        cli = CLI_DETECTION.key(processor) or
+          fail MiniMagick::Error, "You must have ImageMagick or GraphicsMagick installed"
+
+        instance_variable_set("@cli", cli)
+      end
     end
 
+    ##
+    # Set whether you want to use [ImageMagick](http://www.imagemagick.org) or
+    # [GraphicsMagick](http://www.graphicsmagick.org).
+    #
     def cli=(value)
       @cli = value
 
-      if not [:imagemagick, :graphicsmagick].include?(@cli)
+      if not CLI_DETECTION.key?(@cli)
         raise ArgumentError,
-          "CLI has to be set to either :imagemagick or :graphicsmagick" \
+          "CLI has to be set to either :imagemagick, :imagemagick7 or :graphicsmagick" \
           ", was set to #{@cli.inspect}"
       end
     end
 
+    ##
+    # If you set the path of CLI tools, you can get the path of the
+    # executables.
+    #
+    # @return [String]
+    #
     def cli_path
-      @cli_path || @processor_path
+      if instance_variable_defined?("@cli_path")
+        instance_variable_get("@cli_path")
+      else
+        processor_path = instance_variable_get("@processor_path") if instance_variable_defined?("@processor_path")
+
+        instance_variable_set("@cli_path", processor_path)
+      end
     end
 
+    ##
+    # When set to `true`, it outputs each command to STDOUT in their shell
+    # version.
+    #
     def debug=(value)
       warn "MiniMagick.debug is deprecated and will be removed in MiniMagick 5. Use `MiniMagick.logger.level = Logger::DEBUG` instead."
       logger.level = value ? Logger::DEBUG : Logger::INFO
     end
 
+    def shell_api=(value)
+      warn "MiniMagick.shell_api is deprecated and will be removed in MiniMagick 5. The posix-spawn gem doesn't improve performance recent Ruby versions anymore, so support for it will be removed."
+      @shell_api = value
+    end
+
+    def shell_api
+      @shell_api || "open3"
+    end
+
     # Backwards compatibility
     def reload_tools
       warn "MiniMagick.reload_tools is deprecated because it is no longer necessary"

data/lib/mini_magick/image/info.rb

@@ -42,7 +42,7 @@ module MiniMagick
 
       def cheap_info(value)
         @info.fetch(value) do
-          format, width, height, size = self["%m %w %h %b"].split(" ")
+          format, width, height, size = parse_warnings(self["%m %w %h %b"]).split(" ")
 
           path = @path
           path = path.match(/\[\d+\]$/).pre_match if path =~ /\[\d+\]$/
@@ -62,11 +62,23 @@ module MiniMagick
         raise MiniMagick::Invalid, "image data can't be read"
       end
 
+      def parse_warnings(raw_info)
+        return raw_info unless raw_info.split("\n").size > 1
+
+        raw_info.split("\n").each do |line|
+          # must match "%m %w %h %b"
+          return line if line.match?(/^[A-Z]+ \d+ \d+ \d+(|\.\d+)([KMGTPEZY]{0,1})B$/)
+        end
+        raise TypeError
+      end
+
       def colorspace
         @info["colorspace"] ||= self["%r"]
       end
 
       def mime_type
+        warn "[MiniMagick] MiniMagick::Image#mime_type has been deprecated, because it wasn't returning correct result for all formats ImageMagick supports. Unfortunately, returning the correct MIME type would be very slow, because it would require ImageMagick to read the whole file. It's better to use Marcel and MimeMagic gems, which are able to determine the MIME type just from the image header."
+
         "image/#{self["format"].downcase}"
       end
 
@@ -91,7 +103,7 @@ module MiniMagick
             line = line.chomp("\n")
 
             case MiniMagick.cli
-            when :imagemagick
+            when :imagemagick, :imagemagick7
               if match = line.match(/^exif:/)
                 key, value = match.post_match.split("=", 2)
                 value = decode_comma_separated_ascii_characters(value) if ASCII_ENCODED_EXIF_KEYS.include?(key)
@@ -100,6 +112,7 @@ module MiniMagick
                 hash[hash.keys.last] << "\n#{line}"
               end
             when :graphicsmagick
+              next if line == "unknown"
               key, value = line.split("=", 2)
               value.gsub!("\\012", "\n") # convert "\012" characters to newlines
               hash[key] = value
@@ -119,7 +132,7 @@ module MiniMagick
       end
 
       def details
-        warn "[MiniMagick] MiniMagick::Image#details has been deprecated, as it was causing too many parsing errors. You should use MiniMagick::Image#data instead, which differs in a way that the keys are in camelcase." if MiniMagick.imagemagick?
+        warn "[MiniMagick] MiniMagick::Image#details has been deprecated, as it was causing too many parsing errors. You should use MiniMagick::Image#data instead, which differs in a way that the keys are in camelcase." if MiniMagick.imagemagick? || MiniMagick.imagemagick7?
 
         @info["details"] ||= (
           details_string = identify(&:verbose)
@@ -139,8 +152,8 @@ module MiniMagick
               next
             end
 
-            key, _, value = line.partition(/:[\s\n]/).map(&:strip)
-            hash = key_stack.inject(details_hash) { |hash, key| hash.fetch(key) }
+            key, _, value = line.partition(/:[\s]/).map(&:strip)
+            hash = key_stack.inject(details_hash) { |_hash, _key| _hash.fetch(_key) }
             if value.empty?
               hash[key] = {}
               key_stack.push key

data/lib/mini_magick/image.rb

@@ -15,7 +15,7 @@ module MiniMagick
     # methods.
     #
     # Use this to pass in a stream object. Must respond to #read(size) or be a
-    # binary string object (BLOBBBB)
+    # binary string object (BLOB)
     #
     # Probably easier to use the {.open} method if you want to open a file or a
     # URL.
@@ -76,20 +76,36 @@ module MiniMagick
     # @param path_or_url [String] Either a local file path or a URL that
     #   open-uri can read
     # @param ext [String] Specify the extension you want to read it as
+    # @param options [Hash] Specify options for the open method
     # @return [MiniMagick::Image] The loaded image
     #
-    def self.open(path_or_url, ext = nil)
-      ext ||=
-        if File.exist?(path_or_url)
-          File.extname(path_or_url)
+    def self.open(path_or_url, ext = nil, options = {})
+      options, ext = ext, nil if ext.is_a?(Hash)
+
+      # Don't use Kernel#open, but reuse its logic
+      openable =
+        if path_or_url.respond_to?(:open)
+          path_or_url
+        elsif path_or_url.respond_to?(:to_str) &&
+              %r{\A[A-Za-z][A-Za-z0-9+\-\.]*://} =~ path_or_url &&
+              (uri = URI.parse(path_or_url)).respond_to?(:open)
+          uri
         else
-          File.extname(URI(path_or_url).path)
+          options = { binmode: true }.merge(options)
+          Pathname(path_or_url)
         end
 
+      if openable.is_a?(URI::Generic)
+        ext ||= File.extname(openable.path)
+      else
+        ext ||= File.extname(openable.to_s)
+      end
       ext.sub!(/:.*/, '') # hack for filenames or URLs that include a colon
 
-      Kernel.open(path_or_url, "rb") do |file|
-        read(file, ext)
+      if openable.is_a?(URI::Generic)
+        openable.open(options) { |file| read(file, ext) }
+      else
+        openable.open(**options) { |file| read(file, ext) }
       end
     end
 
@@ -258,7 +274,7 @@ module MiniMagick
     #
     attribute :resolution
     ##
-    # Returns the message digest of this image as a SHA-256, hexidecimal
+    # Returns the message digest of this image as a SHA-256, hexadecimal
     # encoded string. This signature uniquely identifies the image and is
     # convenient for determining if an image has been modified or whether two
     # images are identical.
@@ -324,13 +340,18 @@ module MiniMagick
     #
     # 1) one for each row of pixels
     # 2) one for each column of pixels
-    # 3) three elements in the range 0-255, one for each of the RGB color channels
+    # 3) three or four elements in the range 0-255, one for each of the RGB(A) color channels
     #
     # @example
     #   img = MiniMagick::Image.open 'image.jpg'
     #   pixels = img.get_pixels
     #   pixels[3][2][1] # the green channel value from the 4th-row, 3rd-column pixel
     #
+    # @example
+    #   img = MiniMagick::Image.open 'image.jpg'
+    #   pixels = img.get_pixels("RGBA")
+    #   pixels[3][2][3] # the alpha channel value from the 4th-row, 3rd-column pixel
+    #
     # It can also be called after applying transformations:
     #
     # @example
@@ -341,16 +362,22 @@ module MiniMagick
     #
     # In this example, all pixels in pix should now have equal R, G, and B values.
     #
+    # @param map [String] A code for the mapping of the pixel data. Must be either
+    #   'RGB' or 'RGBA'. Default to 'RGB'
     # @return [Array] Matrix of each color of each pixel
-    def get_pixels
-      output = MiniMagick::Tool::Convert.new do |convert|
-        convert << path
-        convert.depth(8)
-        convert << "RGB:-"
-      end
+    def get_pixels(map="RGB")
+      raise ArgumentError, "Invalid map value" unless ["RGB", "RGBA"].include?(map)
+      convert = MiniMagick::Tool::Convert.new
+      convert << path
+      convert.depth(8)
+      convert << "#{map}:-"
+
+      # Do not use `convert.call` here. We need the whole binary (unstripped) output here.
+      shell = MiniMagick::Shell.new
+      output, * = shell.run(convert.command)
 
       pixels_array = output.unpack("C*")
-      pixels = pixels_array.each_slice(3).each_slice(width).to_a
+      pixels = pixels_array.each_slice(map.length).each_slice(width).to_a
 
       # deallocate large intermediary objects
       output.clear
@@ -359,6 +386,23 @@ module MiniMagick
       pixels
     end
 
+    ##
+    # This is used to create image from pixels. This might be required if you
+    # create pixels for some image processing reasons and you want to form 
+    # image from those pixels.
+    #
+    # *DANGER*: This operation can be very expensive. Please try to use with
+    # caution. 
+    # 
+    # @example
+    #   # It is given in readme.md file
+    ##
+    def self.get_image_from_pixels(pixels, dimension, map, depth, mime_type)
+      pixels = pixels.flatten
+      blob = pixels.pack('C*')
+      import_pixels(blob, *dimension, depth, map, mime_type)
+    end
+
     ##
     # This is used to change the format of the image. That is, from "tiff to
     # jpg" or something like that. Once you run it, the instance is pointing to
@@ -417,6 +461,9 @@ module MiniMagick
       @info.clear
 
       self
+    rescue MiniMagick::Invalid, MiniMagick::Error => e
+      new_tempfile.unlink if new_tempfile && @tempfile != new_tempfile
+      raise e
     end
 
     ##
@@ -568,5 +615,31 @@ module MiniMagick
     def layer?
       path =~ /\[\d+\]$/
     end
+
+    ##
+    # Compares if image width
+    # is greater than height
+    # ============
+    # |          |
+    # |          |
+    # ============
+    # @return [Boolean]
+    def landscape?
+      width > height
+    end
+
+    ##
+    # Compares if image height
+    # is greater than width
+    # ======
+    # |    |
+    # |    |
+    # |    |
+    # |    |
+    # ======
+    # @return [Boolean]
+    def portrait?
+      height > width
+    end
   end
 end

data/lib/mini_magick/shell.rb

@@ -14,9 +14,10 @@ module MiniMagick
       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}"
+        fail MiniMagick::Error, "`#{command.join(" ")}` failed with status: #{status.inspect} and error:\n#{stderr}"
       end
 
+      stderr = stderr.lines[2..-1].join if stderr.start_with? %(WARNING: The convert command is deprecated in IMv7)
       $stderr.print(stderr) unless options[:stderr] == false
 
       [stdout, stderr, status]
@@ -25,10 +26,10 @@ module MiniMagick
     def execute(command, options = {})
       stdout, stderr, status =
         log(command.join(" ")) do
-          send("execute_#{MiniMagick.shell_api.gsub("-", "_")}", command, options)
+          send("execute_#{MiniMagick.shell_api.tr("-", "_")}", command, options)
         end
 
-      [stdout, stderr, status.exitstatus]
+      [stdout, stderr, status&.exitstatus]
     rescue Errno::ENOENT, IOError
       ["", "executable not found: \"#{command.first}\"", 127]
     end
@@ -38,38 +39,34 @@ module MiniMagick
     def execute_open3(command, options = {})
       require "open3"
 
-      in_w, out_r, err_r, subprocess_thread = Open3.popen3(*command)
+      # 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
+
+        unless thread.join(MiniMagick.timeout)
+          Process.kill("TERM", thread.pid) rescue nil
+          Process.waitpid(thread.pid)      rescue nil
+          raise Timeout::Error, "MiniMagick command timed out: #{command}"
+        end
 
-      capture_command(in_w, out_r, err_r, subprocess_thread, options)
+        [stdout_reader.value, stderr_reader.value, thread.value]
+      end
     end
 
     def execute_posix_spawn(command, options = {})
       require "posix-spawn"
-
-      pid, in_w, out_r, err_r = POSIX::Spawn.popen4(*command)
-      subprocess_thread = Process.detach(pid)
-
-      capture_command(in_w, out_r, err_r, subprocess_thread, options)
-    end
-
-    def capture_command(in_w, out_r, err_r, subprocess_thread, options)
-      [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
-
-      Timeout.timeout(MiniMagick.timeout) { subprocess_thread.join }
-
-      [stdout_reader.value, stderr_reader.value, subprocess_thread.value]
-    rescue Timeout::Error => error
-      Process.kill("TERM", subprocess_thread.pid)
-      raise error
-    ensure
-      [out_r, err_r].each(&:close)
+      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)

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