One of the most fundamental operations on an image is simply getting basic information about the image. RMagick assigns dozens of attributes to an image. All you have to do is read the image and then call the attribute methods. Here's a Ruby program that takes image filenames from the command line and then prints a variety of information about each image to the terminal.
require 'RMagick'
ARGV.each { |file|
    puts file
    img = Magick::Image::read(file).first
    puts "   Format: #{img.format}"
    puts "   Geometry: #{img.columns}x#{img.rows}"
    puts "   Class: " + case img.class_type
                            when Magick::DirectClass
                                "DirectClass"
                            when Magick::PseudoClass
                                "PseudoClass"
                        end
    puts "   Depth: #{img.depth} bits-per-pixel"
    puts "   Colors: #{img.number_colors}"
    puts "   Filesize: #{img.filesize}"
    puts "   Resolution: #{img.x_resolution.to_i}x#{img.y_resolution.to_i} "+
        "pixels/#{img.units == Magick::PixelsPerInchResolution ?
        "inch" : "centimeter"}"
    if img.properties.length > 0
        puts "   Properties:"
        img.properties { |name,value|
            puts %Q|      #{name} = "#{value}"|
        }
    end
    }
  Converting an image to another format is as simple as writing the image to a file. ×Magick uses the output filename suffix (".jpg" for JPEG, ".gif" for GIF, for example) or prefix ("ps:" for PostScript, for example) to determine the format of the output image.
RMagick gives you four different methods for resizing an
  image: resize,
  sample, scale, and thumbnail. All four are
  equally easy to use. Specify the number of columns and rows you
  want the thumbnail to have, like this:
img = Image.new "bigimage.gif" thumb = img.scale(125, 125) thumb.write "thumb.gif"
Alternatively, just pass a single Float argument
  that represents the change in size. For example, to
  proportionally reduce the size of an image to 25% of its original
  size, do this:
img = Image.new "bigimage.gif" thumb = img.scale(0.25) thumb.write "thumb.gif"
The resize method gives you more control by
  allowing you to specify a filter to use when scaling the
  image. Some filters produce a better-looking thumbnail at the
  expense of extra processing time. You can also use a
  blur argument, which specifies how much blurriness
  or sharpness the resize method should introduce.
The sample method, unlike the other two, does not
  do any color interpolation when resizing.
The thumbnail method is faster than
  resize if the thumbnail is less than 10% of the size
  of the original image.
Say you need to make all your thumbnails no bigger than 64x64
  but with the same aspect ratio as the original. Or, you don't
  want to resize the image if it's already smaller than 64x64. The
  change_geometry
  method can help.
The change_geometry method accepts an
  ×Magick geometry string
  argument and a block. The geometry string specifies how to change
  the image's size: one or two numbers to specify the new size and
  optional flags to describe any constraints. The
  change_geometry method parses the geometry string
  and computes new width and height values. Then it calls the
  block, passing the values it computed.
Within the block you can do whatever you want with the new
  values. Typically you'll call one of the resize methods mentioned
  in the previous section and make the resized image the return
  value from the block. The change_geometry method
  then returns that value to its caller.
Use the quantize method with the
  Magick::GRAYColorspace
  argument. If you want real "grayscale," quantize the image to 256
  colors. If you want to convert a color image to black-and-white,
  use 2 colors. See demo.rb.
Many image formats, including JPEG, PDF, and BMP, support compressed image files. The type of compression used depends on the format. Specify the compression type by assigning a CompressionType value to the compression optional argument to the write method.
The JPEGCompression and ZipCompression types support multiple
  levels of compression. Use the quality optional argument to the
  write method. The quality attribute is a number
  between 0 and 100, with 100 representing the least compression.
  When you compress an image using JPEGCompression, more
  compression usually results in a lower-quality image. When you
  compress an image using ZipCompression, more compression usually
  takes longer.
For more information, see the ×Magick documentation for
  the -quality option to the utility commands.
img.write("myimage.jpg") { self.quality = 50 }
  Here's one way to make a drop shadow behind text. Make the
  shadow first by drawing the text in a light gray color. Position
  the text slightly to the right and down from where the real text
  will be. Then use the blur_image method to
  make the shadow by blurring the text. Finally, draw the text
  again in whatever color you want. (Click the image to see the
  Ruby program that created it.)