MiniMagick::Image

# File lib/mini_magick.rb, line 158
def create(ext = nil, validate = true, &block)
  begin
    tempfile = Tempfile.new(['mini_magick', ext.to_s.downcase])
    tempfile.binmode
    block.call(tempfile)
    tempfile.close

    image = self.new(tempfile.path, tempfile)

    if validate and !image.valid?
      raise MiniMagick::Invalid
    end
    return image
  ensure
    tempfile.close if tempfile
  end
end

# File lib/mini_magick.rb, line 85
def from_blob(blob, ext = nil)
  warn "Warning: MiniMagick::Image.from_blob method is deprecated. Instead, please use Image.read"
  create(ext) { |f| f.write(blob) }
end

# File lib/mini_magick.rb, line 144
def from_file(file, ext = nil)
  warn "Warning: MiniMagick::Image.from_file is now deprecated. Please use Image.open"
  open(file, ext)
end

# File lib/mini_magick.rb, line 105
def import_pixels(blob, columns, rows, depth, map, format="png")
  # Create an image object with the raw pixel data string:
  image = create(".dat", validate = false) { |f| f.write(blob) }
  # Use ImageMagick to convert the raw data file to an image file of the desired format:
  converted_image_path = image.path[0..-4] + format
  arguments = ["-size", "#{columns}x#{rows}", "-depth", "#{depth}", "#{map}:#{image.path}", "#{converted_image_path}"]
  cmd = CommandBuilder.new("convert", *arguments) #Example: convert -size 256x256 -depth 16 gray:blob.dat blob.png
  image.run(cmd)
  # Update the image instance with the path of the properly formatted image, and return:
  image.path = converted_image_path
  image
end

# File lib/mini_magick.rb, line 185
def initialize(input_path, tempfile = nil)
  @path = input_path
  @tempfile = tempfile # ensures that the tempfile will stick around until this image is garbage collected.
end

# File lib/mini_magick.rb, line 129
def open(file_or_url, ext = nil)
  file_or_url = file_or_url.to_s # Force it to be a String... hell or highwater
  if file_or_url.include?("://")
    require 'open-uri'
    ext ||= File.extname(URI.parse(file_or_url).path)
    self.read(Kernel::open(file_or_url), ext)
  else
    ext ||= File.extname(file_or_url)
    File.open(file_or_url, "rb") do |f|
      self.read(f, ext)
    end
  end
end

# File lib/mini_magick.rb, line 64
def read(stream, ext = nil)
  if stream.is_a?(String)
    stream = StringIO.new(stream)
  elsif stream.is_a?(StringIO)
    # Do nothing, we want a StringIO-object
  elsif stream.respond_to? :path
    if File.respond_to?(:binread)
      stream = StringIO.new File.binread(stream.path.to_s)
    else
      stream = StringIO.new File.open(stream.path.to_s,"rb") { |f| f.read }
    end
  end

  create(ext) do |f|
    while chunk = stream.read(8192)
      f.write(chunk)
    end
  end
end

# File lib/mini_magick.rb, line 255
def <<(*args)
  run_command("mogrify", *args << path)
end

# File lib/mini_magick.rb, line 220
def [](value)
  # Why do I go to the trouble of putting in newlines? Because otherwise animated gifs screw everything up
  case value.to_s
  when "colorspace"
    run_command("identify", "-format", '%r\n', path).split("\n")[0].strip
  when "format"
    run_command("identify", "-format", '%m\n', path).split("\n")[0]
  when "height"
    run_command("identify", "-format", '%h\n', path).split("\n")[0].to_i
  when "width"
    run_command("identify", "-format", '%w\n', path).split("\n")[0].to_i
  when "dimensions"
    run_command("identify", "-format", '%w %h\n', path).split("\n")[0].split.map{|v|v.to_i}
  when "size"
    File.size(path) # Do this because calling identify -format "%b" on an animated gif fails!
  when "original_at"
    # Get the EXIF original capture as a Time object
    Time.local(*self["EXIF:DateTimeOriginal"].split(/:|\s+/)) rescue nil
  when /^EXIF\:/
    result = run_command('identify', '-format', "%[#{value}]", path).chop
    if result.include?(",")
      read_character_data(result)
    else
      result
    end
  else
    run_command('identify', '-format', value, path).split("\n")[0]
  end
end

# File lib/mini_magick.rb, line 299
def collapse!
  run_command("mogrify", "-quality", "100", "#{path}[0]")
end

# File lib/mini_magick.rb, line 357
def combine_options(tool = "mogrify", &block)
  c = CommandBuilder.new(tool)

  c << path if tool.to_s == "convert"
  block.call(c)
  c << path
  run(c)
end

# File lib/mini_magick.rb, line 366
def composite(other_image, output_extension = 'jpg', &block)
  begin
    second_tempfile = Tempfile.new(output_extension)
    second_tempfile.binmode
  ensure
    second_tempfile.close
  end

  command = CommandBuilder.new("composite")
  block.call(command) if block
  command.push(other_image.path)
  command.push(self.path)
  command.push(second_tempfile.path)

  run(command)
  return Image.new(second_tempfile.path, second_tempfile)
end

# File lib/mini_magick.rb, line 416
def destroy!
  return if @tempfile.nil?
  File.unlink(@tempfile.path) if File.exists?(@tempfile.path)
  @tempfile = nil
end

# File lib/mini_magick.rb, line 278
def format(format, page = 0)
  c = CommandBuilder.new('mogrify', '-format', format)
  yield c if block_given?
  if page
    c << "#{path}[#{page}]"
  else
    c << path
  end
  run(c)

  old_path = path
  self.path = path.sub(/(\.\w*)?$/, ".#{format}")
  File.delete(old_path) if old_path != path

  unless File.exists?(path)
    raise MiniMagick::Error, "Unable to format to #{format}"
  end
end

# File lib/mini_magick.rb, line 341
def method_missing(symbol, *args)
  combine_options do |c|
    c.send(symbol, *args)
  end
end

# File lib/mini_magick.rb, line 334
def mime_type
  format = self[:format]
  "image/" + format.to_s.downcase
end

# File lib/mini_magick.rb, line 394
def run(command_builder)
  command = command_builder.command

  sub = Subexec.run(command, :timeout => MiniMagick.timeout)

  if sub.exitstatus != 0
    # Clean up after ourselves in case of an error
    destroy!

    # Raise the appropriate error
    if sub.output =~ /no decode delegate/ || sub.output =~ /did not return an image/
      raise Invalid, sub.output
    else
      # TODO: should we do something different if the command times out ...?
      # its definitely better for logging.. otherwise we dont really know
      raise Error, "Command (#{command.inspect.gsub("\\", "")}) failed: #{{:status_code => sub.exitstatus, :output => sub.output}.inspect}"
    end
  else
    sub.output
  end
end

# File lib/mini_magick.rb, line 384
def run_command(command, *args)
  # -ping "efficiently determine image characteristics."
  if command == 'identify'
    args.unshift '-ping'
    args.unshift '-quiet' unless MiniMagick.processor.to_s == 'gm'
  end

  run(CommandBuilder.new(command, *args))
end

# File lib/mini_magick.rb, line 326
def to_blob
  f = File.new path
  f.binmode
  f.read
ensure
  f.close if f
end

# File lib/mini_magick.rb, line 197
def valid?
  run_command("identify", path)
  true
rescue MiniMagick::Invalid
  false
end

# File lib/mini_magick.rb, line 309
def write(output_to)
  if output_to.kind_of?(String) || !output_to.respond_to?(:write)
    FileUtils.copy_file path, output_to
    run_command "identify", output_to.to_s # Verify that we have a good image
  else # stream
    File.open(path, "rb") do |f|
      f.binmode
      while chunk = f.read(8192)
        output_to.write(chunk)
      end
    end
    output_to
  end
end