Ruby has libraries for attaching programs to the three main types of user interface. The web interface, Ruby's most popular, is covered in depth in Chapters 15, 16, and (to a lesser extent) 14. This chapter covers the other two interfaces: the terminal or console interface, and the graphical ( GUI) interface. We also cover some unorthodox interfaces (Recipe 21.11).
The terminal interface is is a text-based interface usually invoked from a command line. It's used by programs like
and the Ruby interpreter itself. The terminal interface is usually seen on Unix systems, but all modern operating systems support it.
In the classic Unix-style "command-line program," the user interface consists of the options used to invoke the program (Recipe 21.3); and the program's standard input, output, and error streams (Recipe 21.1; also see Recipe 6.16). The Ruby interpreter is a good example of this kind of program. You can invoke the
program with arguments like
, but once the interpreter starts, your options are limited to typing in a Ruby program and executing it.
The advantage of this simple interface is that you can use Unix shell tools like redirection and pipes to connect these programs to each other. Instead of manually typing a Ruby program into the interpreter's standard input, you can send it a file with the Unix command
ruby < file.rb
. If you've got another program that generates Ruby code and prints it to standard output, you can pipe the generated code into the interpreter with
is that these programs are not very user-friendly. Libraries like Curses (Recipe 21.5), Readline, and HighLine can add
and sophistication to your terminal programs. The
interactive interpreter uses Readline to offer interactive line editing instead of the simpler interface
by the Unix shell (Recipe 21.10).
The graphical user interface is the most common interface in the world. Even a web interface is usually interpreted within a GUI on the client end. However, there's not much that's Ruby-specific about GUI programming. All the common GUI libraries (like Tk, GTK, and QT) are written in C, and Ruby's bindings to them look a lot like the bindings for other dynamic languages such as Perl and Python.
All the GUI libraries work pretty much the same way. You create objects corresponding to GUI elements, or "widgets," attach
of code to them as callbacks (so that something will happen when, for instance, the user clicks a button), and then "pack" them into a frame for display. Because it's
to do the GUI layout work in a tool like Glade, and write only the callbacks in regular Ruby, this chapter contains only a few sample recipes on GUI programming.