mini_magick 3.7.0 → 4.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 095e582679936f6e2e1a42ea57b449867fa6eb75
-  data.tar.gz: eb49ba1a91002faa50fc14d512e95668f55e398d
+SHA256:
+  metadata.gz: f97cb0365a2a45cdb41c9091a4339fdd75a37cdb041c454cab800fd9464f5c0f
+  data.tar.gz: b5f97721ee2657631def0e8c498f257639e126a3ad745688356ae5a15ff5de9f
 SHA512:
-  metadata.gz: 0de53204c54171eae9d42c7789b62b7e11733b1019c2994656c76ca2c43040268e47a1f6c30baa9f41675880ff36cf5e22f47a028a3a8d9a2260d0340b570c0c
-  data.tar.gz: c03b97bb8c6be54b917afbc80ef3d738ced59c705ed209f3001c32cfe753bb4dc1e831397a1d0fb617b02cc95b9cb2d2a1574e2adc1334b90113e42d03556e4b
+  metadata.gz: 5339cf648a6cdc78f5a115e03ab77ec3f61bd83de5fcea0638ccb354e9b03b4c29e59b31e6681da9e1a238b2bee73b2a460ed5db0989eca90c097f29a9b0ebb5
+  data.tar.gz: 53b55f439ac4172e68e82c20e67a357160303fc3c382c0d7bb4bfeb4ba1e3e469b95ff89c517ab15f0c67436ab1c831fee5d7e88d0e981876cbc059b5c7dfad6

data/Rakefile

@@ -6,13 +6,13 @@ $:.unshift 'lib'
 desc 'Default: run unit tests.'
 task :default => [:print_version, :spec]
 
-task :print_version do 
+task :print_version do
   puts `mogrify --version`
 end
 
 require 'rspec/core/rake_task'
 
-desc "Run specs"
+desc 'Run specs'
 RSpec::Core::RakeTask.new do |t|
-  t.pattern = "./spec/**/*_spec.rb"
+  t.pattern = './spec/**/*_spec.rb'
 end

data/lib/mini_gmagick.rb

@@ -1,2 +1,3 @@
 require 'mini_magick'
+
 MiniMagick.processor = :gm

data/lib/mini_magick/configuration.rb

@@ -0,0 +1,190 @@
+require 'mini_magick/utilities'
+require 'logger'
+
+module MiniMagick
+  module Configuration
+
+    ##
+    # If you don't have the CLI tools in your PATH, you can set the path to the
+    # executables.
+    #
+    attr_writer :cli_path
+    # @private (for backwards compatibility)
+    attr_accessor :processor_path
+
+    ##
+    # 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_prefix
+
+    ##
+    # If you don't want commands to take too long, you can set a timeout (in
+    # seconds).
+    #
+    # @return [Integer]
+    #
+    attr_accessor :timeout
+    ##
+    # When get to `true`, it outputs each command to STDOUT in their shell
+    # version.
+    #
+    # @return [Boolean]
+    #
+    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
+    # a file.
+    #
+    # @return [Logger]
+    #
+    attr_accessor :logger
+
+    ##
+    # 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
+
+    ##
+    # 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
+
+    def self.extended(base)
+      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 }
+    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

@@ -0,0 +1,202 @@
+require "json"
+
+module MiniMagick
+  class Image
+    # @private
+    class Info
+      ASCII_ENCODED_EXIF_KEYS = %w[ExifVersion FlashPixVersion]
+
+      def initialize(path)
+        @path = path
+        @info = {}
+      end
+
+      def [](value, *args)
+        case value
+        when "format", "width", "height", "dimensions", "size", "human_size"
+          cheap_info(value)
+        when "colorspace"
+          colorspace
+        when "mime_type"
+          mime_type
+        when "resolution"
+          resolution(*args)
+        when "signature"
+          signature
+        when /^EXIF\:/i
+          raw_exif(value)
+        when "exif"
+          exif
+        when "details"
+          details
+        when "data"
+          data
+        else
+          raw(value)
+        end
+      end
+
+      def clear
+        @info.clear
+      end
+
+      def cheap_info(value)
+        @info.fetch(value) do
+          format, width, height, size = parse_warnings(self["%m %w %h %b"]).split(" ")
+
+          path = @path
+          path = path.match(/\[\d+\]$/).pre_match if path =~ /\[\d+\]$/
+
+          @info.update(
+            "format"     => format,
+            "width"      => Integer(width),
+            "height"     => Integer(height),
+            "dimensions" => [Integer(width), Integer(height)],
+            "size"       => File.size(path),
+            "human_size" => size,
+          )
+
+          @info.fetch(value)
+        end
+      rescue ArgumentError, TypeError
+        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+B$/
+        end
+        raise TypeError
+      end
+
+      def colorspace
+        @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
+          b.format "%x %y"
+        end
+        output.split(" ").map(&:to_i)
+      end
+
+      def raw_exif(value)
+        self["%[#{value}]"]
+      end
+
+      def exif
+        @info["exif"] ||= (
+          hash = {}
+          output = self["%[EXIF:*]"]
+
+          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
+              hash[key] = value
+            end
+          end
+
+          hash
+        )
+      end
+
+      def raw(value)
+        @info["raw:#{value}"] ||= identify { |b| b.format(value) }
+      end
+
+      def signature
+        @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|
+            convert << path
+            convert << "json:"
+          end
+
+          data = JSON.parse(json)
+          data = data.fetch(0) if data.is_a?(Array)
+          data.fetch("image")
+        )
+      end
+
+      def identify
+        MiniMagick::Tool::Identify.new do |builder|
+          yield builder if block_given?
+          builder << path
+        end
+      end
+
+      private
+
+      def decode_comma_separated_ascii_characters(encoded_value)
+        return encoded_value unless encoded_value.include?(',')
+        encoded_value.scan(/\d+/).map(&:to_i).map(&:chr).join
+      end
+
+      def path
+        value = @path
+        value += "[0]" unless value =~ /\[\d+\]$/
+        value
+      end
+
+    end
+  end
+end