mini_magick 4.12.0 → 5.2.0

data/lib/mini_magick/configuration.rb

@@ -5,12 +5,11 @@ module MiniMagick
   module Configuration
 
     ##
-    # If you don't have the CLI tools in your PATH, you can set the path to the
-    # executables.
+    # Uses [GraphicsMagick](http://www.graphicsmagick.org/) instead of
+    # ImageMagick, by prefixing commands with `gm` instead of `magick`.
     #
-    attr_writer :cli_path
-    # @private (for backwards compatibility)
-    attr_accessor :processor_path
+    # @return [Boolean]
+    attr_accessor :graphicsmagick
 
     ##
     # Adds a prefix to the CLI command.
@@ -24,23 +23,35 @@ module MiniMagick
     attr_accessor :cli_prefix
 
     ##
-    # If you don't want commands to take too long, you can set a timeout (in
-    # seconds).
+    # Adds environment variables to every CLI command call.
+    # For example, you could use it to set `LD_PRELOAD="/path/to/libsomething.so"`.
+    # Must be a hash of strings keyed to valid environment variable name strings.
+    # e.g. {'MY_ENV' => 'my value'}
     #
-    # @return [Integer]
+    # @return [Hash]
     #
-    attr_accessor :timeout
+    attr_accessor :cli_env
+
     ##
-    # When get to `true`, it outputs each command to STDOUT in their shell
-    # version.
+    # If set to true, Open3 will restrict system calls to access only
+    # environment variables defined in :cli_env, plus HOME, PATH, and LANG
+    # since those are required for such system calls. It will not pass on any
+    # other environment variables from the system.
     #
     # @return [Boolean]
     #
-    attr_reader :debug
+    attr_accessor :restricted_env
+
     ##
-    # 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
-    # a file.
+    # If you don't want commands to take too long, you can set a timeout (in
+    # seconds).
+    #
+    # @return [Integer]
+    #
+    attr_accessor :timeout
+    ##
+    # Logger for commands, default is `Logger.new($stdout)`, but you can
+    # override it, for example if you want the logs to be written to a file.
     #
     # @return [Logger]
     #
@@ -53,146 +64,38 @@ module MiniMagick
     #
     attr_accessor :tmpdir
 
-    ##
-    # If set to `true`, it will `identify` every newly created image, and raise
-    # `MiniMagick::Invalid` if the image is not valid. Useful for validating
-    # user input, although it adds a bit of overhead. Defaults to `true`.
-    #
-    # @return [Boolean]
-    #
-    attr_accessor :validate_on_create
-    ##
-    # 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,
-    # although it adds a bit of overhead. Defaults to `true`.
-    #
-    # @return [Boolean]
-    #
-    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
+    attr_accessor :errors
 
     ##
-    # 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.errors = true
       base.logger = Logger.new($stdout).tap { |l| l.level = Logger::INFO }
+      base.warnings = true
+      base.cli_env = {}.freeze
+      base.restricted_env = false
+      base.graphicsmagick = false
     end
 
     ##
     # @yield [self]
     # @example
     #   MiniMagick.configure do |config|
-    #     config.cli = :graphicsmagick
     #     config.timeout = 5
     #   end
     #
     def configure
       yield self
     end
-
-    CLI_DETECTION = {
-      imagemagick7:   "magick",
-      imagemagick:    "mogrify",
-      graphicsmagick: "gm",
-    }
-
-    # @private (for backwards compatibility)
-    def 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 CLI_DETECTION.value?(@processor)
-        raise ArgumentError,
-          "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
-      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 CLI_DETECTION.key?(@cli)
-        raise ArgumentError,
-          "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
-      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
-
-    # Backwards compatibility
-    def reload_tools
-      warn "MiniMagick.reload_tools is deprecated because it is no longer necessary"
-    end
-
   end
 end

data/lib/mini_magick/image/info.rb

@@ -17,8 +17,6 @@ module MiniMagick
           cheap_info(value)
         when "colorspace"
           colorspace
-        when "mime_type"
-          mime_type
         when "resolution"
           resolution(*args)
         when "signature"
@@ -27,8 +25,6 @@ module MiniMagick
           raw_exif(value)
         when "exif"
           exif
-        when "details"
-          details
         when "data"
           data
         else
@@ -76,10 +72,6 @@ module MiniMagick
         @info["colorspace"] ||= self["%r"]
       end
 
-      def mime_type
-        "image/#{self["format"].downcase}"
-      end
-
       def resolution(unit = nil)
         output = identify do |b|
           b.units unit if unit
@@ -100,20 +92,12 @@ module MiniMagick
           output.each_line do |line|
             line = line.chomp("\n")
 
-            case MiniMagick.cli
-            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)
-                hash[key] = value
-              else
-                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
+            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)
               hash[key] = value
+            else
+              hash[hash.keys.last] << "\n#{line}"
             end
           end
 
@@ -129,44 +113,9 @@ module MiniMagick
         @info["signature"] ||= self["%#"]
       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? || MiniMagick.imagemagick7?
-
-        @info["details"] ||= (
-          details_string = identify(&:verbose)
-          key_stack = []
-          details_string.lines.to_a[1..-1].each_with_object({}) do |line, details_hash|
-            next if !line.valid_encoding? || line.strip.length.zero?
-
-            level = line[/^\s*/].length / 2 - 1
-            if level >= 0
-              key_stack.pop until key_stack.size <= level
-            else
-              # Some metadata, such as SVG clipping paths, will be saved without
-              # indentation, resulting in a level of -1
-              last_key = details_hash.keys.last
-              details_hash[last_key] = '' if details_hash[last_key].empty?
-              details_hash[last_key] << line
-              next
-            end
-
-            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
-            else
-              hash[key] = value
-            end
-          end
-        )
-      end
-
       def data
-        raise Error, "MiniMagick::Image#data isn't supported on GraphicsMagick. Use MiniMagick::Image#details instead." if MiniMagick.graphicsmagick?
-
         @info["data"] ||= (
-          json = MiniMagick::Tool::Convert.new do |convert|
+          json = MiniMagick.convert do |convert|
             convert << path
             convert << "json:"
           end
@@ -178,7 +127,7 @@ module MiniMagick
       end
 
       def identify
-        MiniMagick::Tool::Identify.new do |builder|
+        MiniMagick.identify do |builder|
           yield builder if block_given?
           builder << path
         end

data/lib/mini_magick/image.rb

@@ -51,11 +51,11 @@ module MiniMagick
     #
     def self.import_pixels(blob, columns, rows, depth, map, format = 'png')
       # Create an image object with the raw pixel data string:
-      create(".dat", false) { |f| f.write(blob) }.tap do |image|
+      read(blob, ".dat").tap do |image|
         output_path = image.path.sub(/\.\w+$/, ".#{format}")
         # Use ImageMagick to convert the raw data file to an image file of the
         # desired format:
-        MiniMagick::Tool::Convert.new do |convert|
+        MiniMagick.convert do |convert|
           convert.size "#{columns}x#{rows}"
           convert.depth depth
           convert << "#{map}:#{image.path}"
@@ -79,33 +79,15 @@ module MiniMagick
     # @param options [Hash] Specify options for the open method
     # @return [MiniMagick::Image] The loaded image
     #
-    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
-          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
-
-      if openable.is_a?(URI::Generic)
-        openable.open(options) { |file| read(file, ext) }
+    def self.open(path_or_url, ext = nil, **options)
+      if path_or_url.to_s =~ %r{\A(https?|ftp)://}
+        uri = URI(path_or_url)
+        ext ||= File.extname(uri.path).sub(/:.*/, '') # handle URL including a colon
+        uri.open(options) { |file| read(file, ext) }
       else
-        openable.open(**options) { |file| read(file, ext) }
+        pathname = Pathname(path_or_url)
+        ext ||= File.extname(pathname.to_s)
+        pathname.open(binmode: true, **options) { |file| read(file, ext) }
       end
     end
 
@@ -118,18 +100,14 @@ module MiniMagick
     # we have a good tempfile.
     #
     # @param ext [String] Specify the extension you want to read it as
-    # @param validate [Boolean] If false, skips validation of the created
-    #   image. Defaults to true.
     # @yield [Tempfile] You can #write bits to this object to create the new
     #   Image
     # @return [MiniMagick::Image] The created image
     #
-    def self.create(ext = nil, validate = MiniMagick.validate_on_create, &block)
+    def self.create(ext = nil, &block)
       tempfile = MiniMagick::Utilities.tempfile(ext.to_s.downcase, &block)
 
-      new(tempfile.path, tempfile).tap do |image|
-        image.validate! if validate
-      end
+      new(tempfile.path, tempfile)
     end
 
     ##
@@ -164,7 +142,7 @@ module MiniMagick
     # which creates a temporary file for you and protects your original.
     #
     # @param input_path [String, Pathname] The location of an image file
-    # @yield [MiniMagick::Tool::Mogrify] If block is given, {#combine_options}
+    # @yield [MiniMagick::Tool] If block is given, {#combine_options}
     #   is called.
     #
     def initialize(input_path, tempfile = nil, &block)
@@ -228,10 +206,6 @@ module MiniMagick
     #
     attribute :type, "format"
     ##
-    # @return [String]
-    #
-    attribute :mime_type
-    ##
     # @return [Integer]
     #
     attribute :width
@@ -274,7 +248,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.
@@ -286,17 +260,10 @@ module MiniMagick
     #
     attribute :signature
     ##
-    # Returns the information from `identify -verbose` in a Hash format, for
-    # ImageMagick.
+    # Returns the result of converting the image to JSON format.
     #
     # @return [Hash]
     attribute :data
-    ##
-    # Returns the information from `identify -verbose` in a Hash format, for
-    # GraphicsMagick.
-    #
-    # @return [Hash]
-    attribute :details
 
     ##
     # Use this method if you want to access raw Identify's format API.
@@ -367,7 +334,7 @@ module MiniMagick
     # @return [Array] Matrix of each color of each pixel
     def get_pixels(map="RGB")
       raise ArgumentError, "Invalid map value" unless ["RGB", "RGBA"].include?(map)
-      convert = MiniMagick::Tool::Convert.new
+      convert = MiniMagick.convert
       convert << path
       convert.depth(8)
       convert << "#{map}:-"
@@ -397,10 +364,10 @@ module MiniMagick
     # @example
     #   # It is given in readme.md file
     ##
-    def self.get_image_from_pixels(pixels, dimension, map, depth, mime_type)
+    def self.get_image_from_pixels(pixels, dimension, map, depth, format)
       pixels = pixels.flatten
       blob = pixels.pack('C*')
-      import_pixels(blob, *dimension, depth, map, mime_type)
+      import_pixels(blob, *dimension, depth, map, format)
     end
 
     ##
@@ -426,7 +393,7 @@ module MiniMagick
     #   will convert all pages.
     # @param read_opts [Hash] Any read options to be passed to ImageMagick
     #   for example: image.format('jpg', page, {density: '300'})
-    # @yield [MiniMagick::Tool::Convert] It optionally yields the command,
+    # @yield [MiniMagick::Tool] It optionally yields the command,
     #   if you want to add something.
     # @return [self]
     #
@@ -441,7 +408,7 @@ module MiniMagick
       input_path = path.dup
       input_path << "[#{page}]" if page && !layer?
 
-      MiniMagick::Tool::Convert.new do |convert|
+      MiniMagick.convert do |convert|
         read_opts.each do |opt, val|
           convert.send(opt.to_s, val)
         end
@@ -477,7 +444,7 @@ module MiniMagick
     #     c.background "blue"
     #   end
     #
-    # @yield [MiniMagick::Tool::Mogrify]
+    # @yield [MiniMagick::Command]
     # @see http://www.imagemagick.org/script/mogrify.php
     # @return [self]
     #
@@ -498,8 +465,11 @@ module MiniMagick
       end
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      MiniMagick::Tool::Mogrify.option_methods.include?(method_name.to_s)
+    ##
+    # Prevents ruby from calling `#to_ary` on the image when checking if it's a
+    # splattable data structure in certain cases.
+    def respond_to_missing?(name, include_all)
+      false
     end
 
     ##
@@ -514,7 +484,7 @@ module MiniMagick
       case output_to
       when String, Pathname
         if layer?
-          MiniMagick::Tool::Convert.new do |builder|
+          MiniMagick.convert do |builder|
             builder << path
             builder << output_to
           end
@@ -541,7 +511,7 @@ module MiniMagick
     def composite(other_image, output_extension = type.downcase, mask = nil)
       output_tempfile = MiniMagick::Utilities.tempfile(".#{output_extension}")
 
-      MiniMagick::Tool::Composite.new do |composite|
+      MiniMagick.composite do |composite|
         yield composite if block_given?
         composite << other_image.path
         composite << path
@@ -583,27 +553,21 @@ module MiniMagick
     #     b.verbose
     #   end # runs `identify -verbose image.jpg`
     # @return [String] Output from `identify`
-    # @yield [MiniMagick::Tool::Identify]
+    # @yield [MiniMagick::Tool]
     #
     def identify
-      MiniMagick::Tool::Identify.new do |builder|
+      MiniMagick.identify do |builder|
         yield builder if block_given?
         builder << path
       end
     end
 
-    # @private
-    def run_command(tool_name, *args)
-      MiniMagick::Tool.const_get(tool_name.capitalize).new do |builder|
-        args.each do |arg|
-          builder << arg
-        end
-      end
-    end
-
     def mogrify(page = nil)
-      MiniMagick::Tool::MogrifyRestricted.new do |builder|
+      MiniMagick.mogrify do |builder|
         yield builder if block_given?
+        if builder.args.include?("-format")
+          fail MiniMagick::Error, "you must call #format on a MiniMagick::Image directly"
+        end
         builder << (page ? "#{path}[#{page}]" : path)
       end
 

data/lib/mini_magick/shell.rb

@@ -1,4 +1,4 @@
-require "timeout"
+require "open3"
 require "benchmark"
 
 module MiniMagick
@@ -10,64 +10,38 @@ module MiniMagick
   #
   class Shell
 
-    def run(command, options = {})
-      stdout, stderr, status = execute(command, stdin: options[:stdin])
+    def run(command, errors: MiniMagick.errors, warnings: MiniMagick.warnings, **options)
+      stdout, stderr, status = execute(command, **options)
 
-      if status != 0 && options.fetch(:whiny, MiniMagick.whiny)
-        fail MiniMagick::Error, "`#{command.join(" ")}` failed with status: #{status} and error:\n#{stderr}"
+      if status != 0
+        if stderr.include?("time limit exceeded")
+          fail MiniMagick::TimeoutError, "`#{command.join(" ")}` has timed out"
+        elsif errors
+          fail MiniMagick::Error, "`#{command.join(" ")}` failed with status: #{status.inspect} and error:\n#{stderr}"
+        end
       end
 
-      $stderr.print(stderr) unless options[:stderr] == false
+      $stderr.print(stderr) if warnings
 
       [stdout, stderr, status]
     end
 
-    def execute(command, options = {})
-      stdout, stderr, status =
-        log(command.join(" ")) do
-          send("execute_#{MiniMagick.shell_api.tr("-", "_")}", command, options)
-        end
+    def execute(command, stdin: "", timeout: MiniMagick.timeout)
+      env = MiniMagick.restricted_env ? ENV.slice("HOME", "PATH", "LANG") : {}
+      env.merge!(MiniMagick.cli_env)
+      env["MAGICK_TIME_LIMIT"] = timeout.to_s if timeout
+
+      stdout, stderr, status = log(command.join(" ")) do
+        Open3.capture3(env, *command, stdin_data: stdin, unsetenv_others: MiniMagick.restricted_env)
+      end
 
-      [stdout, stderr, status.exitstatus]
+      [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
-
-        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
-
-        [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 }