mini_magick 3.8.1 → 4.0.0.rc

data/lib/mini_magick/image/info.rb

@@ -0,0 +1,104 @@
+module MiniMagick
+  class Image
+    # @private
+    class Info
+
+      def initialize(path)
+        @path = path
+        @info = {}
+      end
+
+      def [](value, *args)
+        case value
+        when "format", "width", "height", "dimensions", "size"
+          cheap_info(value)
+        when "colorspace"
+          colorspace
+        when "mime_type"
+          mime_type
+        when "resolution"
+          resolution(*args)
+        when /^EXIF\:/i
+          raw_exif(value)
+        when "exif"
+          exif
+        else
+          raw(value)
+        end
+      end
+
+      def clear
+        @info.clear
+      end
+
+      private
+
+      def cheap_info(value)
+        @info.fetch(value) do
+          format, width, height, size = self["%m %w %h %b"].split(" ")
+
+          @info.update(
+            "format"     => format,
+            "width"      => Integer(width),
+            "height"     => Integer(height),
+            "dimensions" => [Integer(width), Integer(height)],
+            "size"       => size.to_i,
+          )
+
+          @info.fetch(value)
+        end
+      end
+
+      def colorspace
+        @info.fetch("colorspace") do
+          @info["colorspace"] = self["%r"]
+        end
+      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.fetch("exif") do
+          output = self["%[EXIF:*]"]
+          pairs = output.gsub(/^exif:/, "").split("\n").map { |line| line.split("=") }
+          exif = Hash[pairs].tap do |hash|
+            hash.each do |key, value|
+              if value.include?(",")
+                # Sometimes exif comes in a comma-separated list of character values
+                hash[key] = value.scan(/\d+/).map(&:to_i).map(&:chr).join
+              end
+            end
+          end
+
+          @info["exif"] = exif
+        end
+      end
+
+      def raw(value)
+        identify { |b| b.format(value) }
+      end
+
+      def identify
+        MiniMagick::Tool::Identify.new do |builder|
+          yield builder if block_given?
+          builder << "#{@path}[0]"
+        end
+      end
+
+    end
+  end
+end

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,46 @@
+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
+
+      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.rb

@@ -0,0 +1,233 @@
+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
+
+    def initialize(name)
+      @name = name
+      @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 = true)
+      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
+
+    ##
+    # 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 +(value = nil)
+      args.last.sub!(/^-/, '+')
+      args << value.to_s if value
+      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
+
+      def self.instances
+        @instances ||= []
+      end
+
+      def self.new(*args, &block)
+        super.tap do |instance|
+          self.instances << instance
+        end
+      end
+
+      def initialize(tool_name)
+        super() do
+          @tool_name = tool_name
+          reload_methods
+        end
+      end
+
+      ##
+      # Dynamically generates operator methods from the "-help" page.
+      #
+      def reload_methods
+        instance_methods(false).each { |method| undef_method(method) }
+
+        self.creation_operator *%w[xc canvas logo rose gradient radial-gradient
+                                   plasma tile pattern label caption text]
+
+        help = (MiniMagick::Tool.new(@tool_name) << "-help").call(false)
+        cli_options = help.scan(/^\s+-[a-z\-]+/).map(&:strip)
+        self.option *cli_options
+      end
+
+      ##
+      # 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 |value = nil|
+          self << option
+          self << value.to_s if value
+          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 to_s
+        "OptionMethods(#{@tool_name})"
+      end
+
+    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
+        super("animate")
+      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
+        super("compare")
+      end
+
+    end
+  end
+end