Programming often involves repetitive tasks. Most programming languages give you some way to package common code, making it reusable across multiple applications. In this article, we’ll look at how Ruby solves the problem of code reuse in a repeatable way with Ruby Gems. We’ll also take a look at managing gem sources, giving you more options to install additional functionality libraries from various third parties.



  • Ruby version – 2.1.2 or newer


Expanding Your App’s Capabilities

As your software code base grows more complex, you may find that you have to write the same code multiple times. This repetition is obviously inefficient since now any changes to that code need to occur in multiple places when you introduce a new feature or a bug fix. You can mitigate this issue by encapsulating the code into separate classes–which solves the reuse problem–but this solution only scales to a certain point. Once you start trying to add complex functionality–such as HTTP communication between different applications–you will often find yourself working in well-defined problem domains that have well-known solutions. So while it might be a good learning exercise to write your own solution to one of these problems, ultimately your application would be best served by using one of these pre-existing solutions.


Ruby Gems

In Ruby, we address this issue by using third-party libraries known as Gems. Ruby Gems are sets of code that implement common functionality. Using a third-party library simply requires downloading the code and putting it into a common location accessible from any program running on your computer.

Basic Gem Management Commands

We’ll start with some of the more commonly used gem commands.


Adding New Gems

The gem install command works in a similar fashion to package management installers in Unix or Unix-like environments.

gem install XXXX

This command uses the RubyGems application to access your installed gem sources and locate a gem named XXXX. RubyGems downloads the gem and installs it into your current Ruby version’s common directory. Then, all of the Ruby applications in your development environment that use the current version of Ruby will have access to the new gem’s functionality.


Checking Local Gem Installs

Figuring out which gems are currently installed on your machine can be daunting, and in a worst-case scenario would involve navigating to the RVM install directory for your current version. Luckily, we have access to gem list. The default command lists all gems installed in your current environment.

gem list

You can also search for a specific gem by appending either its name or a regular expression to the command:

gem list NAME/REGEX

Finally, you can obtain extra information (including gem authors, version, appropriate license, and install directory) by adding the -d flag:

gem list -d


Adding a New Gem Source

Many of the most popular gems are accessible from, the default gem source for Ruby. To add a new gem source:

gem sources -a URL

The -a flag indicates that we will be appending a new gem source, and the URL that follows is the web address of the gem server you wish to add.


Managing Gem Sources

Sometimes you want to manage your source list–typically when a gem’s source changes locations. Ruby Gems gives you several options for managing your gem source list.

To list all gem sources, use the -l flag.

gem sources -l

To remove a gem source, use the r flag followed by the URL of the source to be removed.

gem sources -r URL

You can find a complete reference for the gem sources command, along with other gem-related commands, at


Other Helpful Gem Commands

For most day-to-day work, you’ll most often only need the above gem commands. There are many others, though, so we’ll present a few interesting examples.


Uninstalling a Gem

Sometimes a gem outlives its usefulness, or it is superseded by a superior alternative. In those cases, you might want to uninstall these gems to prevent too much unused cruft from building up in your Ruby install. To uninstall a gem, use the following command (where GEMNAME is the name of the gem to uninstall):

gem uninstall GEMNAME


Updating Installed Gems

Gems are often under active development by the community, which makes it important to keep your local gemset up-to-date. To update all gems in your system, use the gem update command.

gem update

You can also update a specific gem by providing a regular expression that matches gem names (replacing NAME below with your regular expression):

gem update NAME


Getting Information on Available Gems

Searching for gems that may already be available in your gem sources can be tedious if using the web interfaces available (such as that at To get around this chore, we can use gem query. This comamnd queries all configured gem repositories on your machine for additional information, and is the quickest way to tell whether or not you have access to a given gem. To see if a specific gem is present in your local and remote sources, use the following command:

gem query -b NAME

In place of NAME substitute either the name of a gem or a suitable regular expression. The -b flag indicates that you want to check both local and remote sources. To check either local or remote sources, use the -l or -r flags, respectively.


Building Documentation

Many gem developers will include comments compatible with automatic documentation generators such as RDoc. To generate RDoc documentation for an installed gem, use the following command (replacing NAME with the name of the gem):

gem rdoc NAME

Additionally, you can generate RDoc documentation for all installed gems with the --all flag (note: this will likely take a long time to complete).

gem rdoc --all


Finding New Gems

There are two typical places that Ruby developers find gems:

  • Recommendations from the Ruby community. Often another Ruby developer will write a blog post about a specific set of functionality, or a developer will ask a question on a forum (such as Stack Overflow) about how to overcome a specific problem using Ruby.
  • Searches on Ruby Gems repository or other repositories. These repos tend to offer stats on a particular library, such as a brief statement of a gem’s purpose, a gauge of the gem’s general popularity, and a link to the original host of the gem.

Once you do locate a gem, you may also have to evaluate its effectiveness and trustworthiness. Of course, with open-source Ruby gems, analyzing the code to ensure nothing strange is taking place is a straightforward matter of looking at the gem’s Github repo. Using a gem repository’s reporting functionality can solve the trustworthiness problem, but it’s not perfect. For example, a brand-new gem that solves a problem in the most efficient way possible may be falsely reported as being inferior to another more-popular-but-older gem that solves the problem in a less efficient manner.



Through judicious use of RubyGems, you can greatly reduce the time required to develop Ruby applications by leveraging the expertise of other developers from around the world. You can then ensure that your code operates with a common interface that matches community development standards.