RubyGems

https://guides.rubygems.org/
Admin
RubyGems is a package manager for Ruby that allows developers to easily download, install, and use...
Tokens:182,528
Snippets:1,568
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### bundle install output for the example Gemfile

Source: https://guides.rubygems.org/command-reference/bundle-update

Output of running bundle install for the first time with the example Gemfile. It shows the resolved dependency tree (26 gems total) and the message about using bundle show to locate installed gems.

```text
Fetching gem metadata from https://rubygems.org/.........
Resolving dependencies...
Installing builder 2.1.2
Installing abstract 1.0.0
Installing rack 1.2.8
Using bundler 1.7.6
Installing rake 10.4.0
Installing polyglot 0.3.5
Installing mime-types 1.25.1
Installing i18n 0.4.2
Installing mini_portile 0.6.1
Installing tzinfo 0.3.42
Installing rack-mount 0.6.14
Installing rack-test 0.5.7
Installing treetop 1.4.15
Installing thor 0.14.6
Installing activesupport 3.0.0.rc
Installing erubis 2.6.6
Installing activemodel 3.0.0.rc
Installing arel 0.4.0
Installing mail 2.2.20
Installing activeresource 3.0.0.rc
Installing actionpack 3.0.0.rc
Installing activerecord 3.0.0.rc
Installing actionmailer 3.0.0.rc
Installing railties 3.0.0.rc
Installing rails 3.0.0.rc
Installing nokogiri 1.6.5

Bundle complete! 2 Gemfile dependencies, 26 gems total.
Use `bundle show [gemname]` to see where a bundled gem is installed.

```

--------------------------------

### bundle install development output

Source: https://guides.rubygems.org/using_bundler_in_applications

Example output from running bundle install in development, showing dependency resolution and installation summary.

```text
Fetching gem metadata from https://rubygems.org/
Fetching version metadata from https://rubygems.org/
Fetching dependency metadata from https://rubygems.org/
Resolving dependencies...
Using mini_portile2 2.1.0
Using pkg-config 1.1.7
Using bundler 1.12.5
Using nokogiri 1.6.8
Bundle complete! 1 Gemfile dependency, 4 gems now installed.
Use `bundle show [gemname]` to see where a bundled gem is installed.
```

--------------------------------

### Example .gemrc YAML configuration

Source: https://guides.rubygems.org/command-reference

Example YAML configuration for a .gemrc file, showing verbose, install, update, and disable_default_gem_server settings.

```yaml
:verbose: false
install: --no-wrappers
update: --no-wrappers
:disable_default_gem_server: true
```

--------------------------------

### Example: bundle issue

Source: https://guides.rubygems.org/command-reference/bundle-issue

Example of running bundle issue to get issue reporting information.

```bash
$ bundle issue

```

--------------------------------

### Add gem server and install gem

Source: https://guides.rubygems.org/run-your-own-gem-server

Add a local gem server to system-wide gem sources and install a gem from it. The example adds http://localhost:9292 and installs secretgem.

```shell
$ gem sources --add http://localhost:9292
```

```shell
$ gem install secretgem
Successfully installed secretgem-0.0.1
1 gem installed
```

--------------------------------

### Example of installing and using nokogiri executable

Source: https://guides.rubygems.org/make-your-own-gem

Shows installing the nokogiri gem and using its executable to parse a URL. The output demonstrates the @doc variable and accessing the title.

```text
$ gem install -N nokogiri
[...]
$ nokogiri https://www.ruby-lang.org/
Your document is stored in @doc...
3.1.2 :001 > @doc.title
=> "Ruby Programming Language"
```

--------------------------------

### Set up and run Gem in a Box

Source: https://guides.rubygems.org/run-your-own-gem-server

Set up Gem in a Box: install geminabox with puma and rackup, create a data directory, configure config.ru, and start the server with rackup. The server listens on http://127.0.0.1:9292.

```shell
$ gem install geminabox puma rackup
```

```shell
$ mkdir data
```

```ruby
require "geminabox"

Geminabox.data = "./data"
run Geminabox::Server
```

```shell
$ rackup
Puma starting in single mode...
* Listening on http://127.0.0.1:9292
```

--------------------------------

### bundle console with pry

Source: https://guides.rubygems.org/command-reference/bundle-console

Example of setting the console to pry and then starting bundle console. The output shows dependency resolution and the pry prompt. Ensure pry is in your Gemfile.

```bash
$ bundle config set console pry
$ bundle console
Resolving dependencies...
[1] pry(main)>
```

--------------------------------

### Example .gemrc file demonstrating symbol keys and command defaults

Source: https://guides.rubygems.org/configuration

An example .gemrc file. Symbol keys like :sources and :backtrace set RubyGems options; string keys like install and update set default arguments for gem commands, and the special key 'gem' sets defaults for every command. With this file, `gem install rails` behaves as if you had typed `gem install rails --no-document`. Command-line arguments are appended after the defaults.

```yaml
:sources:
- https://rubygems.org/
:backtrace: true
:concurrent_downloads: 16
install: --no-document
update: --no-document
```

--------------------------------

### Install the gems Ruby client library

Source: https://guides.rubygems.org/rubygems-org-api

Install the 'gems' Ruby client library, which provides a Ruby interface to all RubyGems.org resources. The library has full documentation with basic usage examples in its README.

```bash
gem install gems
```

--------------------------------

### Install a gem with dependencies using gem install drip

Source: https://guides.rubygems.org/rubygems-basics

The `install` command downloads and installs the gem and its dependencies, builds native extensions, and generates documentation. The output shows the installation steps and success messages.

```shell
$ gem install drip
Fetching drip-0.1.1.gem
Fetching rbtree-0.4.5.gem
Building native extensions. This could take a while...
Successfully installed rbtree-0.4.5
Successfully installed drip-0.1.1
Parsing documentation for rbtree-0.4.5
Installing ri documentation for rbtree-0.4.5
Parsing documentation for drip-0.1.1
Installing ri documentation for drip-0.1.1
Done installing documentation for rbtree, drip after 0 seconds
2 gems installed
```

--------------------------------

### Install a gem from a local file with --local

Source: https://guides.rubygems.org/caching-and-vendoring

Installs a gem from a local .gem file using the --local flag. The output shows a successful installation message.

```shell
$ gem install --local ./rake-13.4.2.gem
Successfully installed rake-13.4.2
```

--------------------------------

### gem install usage syntax

Source: https://guides.rubygems.org/command-reference

Usage syntax for the gem install command. It installs one or more gems into the local repository, with optional build flags passed after the -- separator.

```shell
gem install [options] GEMNAME [GEMNAME ...] -- --build-flags [options]
```

--------------------------------

### Bundler Recommended Workflow Commands

Source: https://guides.rubygems.org/command-reference/bundle-update

Recommended workflow for managing a Bundler-managed application: initial install, version control check-in, install on other machines, deployment install, updating dependencies, and resolving conflicts.

```shell
$ bundle install
```

```shell
$ git add Gemfile.lock
```

```shell
$ bundle install
```

```shell
$ bundle install --deployment
```

```shell
$ bundle install
```

```shell
$ git add Gemfile.lock
```

```shell
$ bundle update rails thin
```

```shell
$ bundle update --all
```

--------------------------------

### Install dependencies with bundle install

Source: https://guides.rubygems.org/dependency_management

Installs all gems declared in the Gemfile and their dependencies, writing a snapshot of the installed versions to Gemfile.lock. If all dependencies are already present, bundler skips the installation process.

```shell
$ bundle install

```

--------------------------------

### bundle install output for overlapping dependencies

Source: https://guides.rubygems.org/command-reference/bundle-update

Output of bundle install for the example Gemfile. Shows that rack is installed once and shared by both thin and rack-perftools-profiler.

```text
Fetching source index for https://rubygems.org/
Installing daemons (1.1.0)
Installing eventmachine (0.12.10) with native extensions
Installing open4 (1.0.1)
Installing perftools.rb (0.4.7) with native extensions
Installing rack (1.2.1)
Installing rack-perftools_profiler (0.0.2)
Installing thin (1.2.7) with native extensions
Using bundler (1.0.0.rc.3)

```

--------------------------------

### Install a gem and track dependencies with Bundler

Source: https://guides.rubygems.org/

Shows how to install a gem with the `gem` command and how to initialize a Gemfile and add a dependency using Bundler commands.

```bash
# Install a gem and use it right away
gem install nokogiri

# Track dependencies for a project
bundle init
bundle add rack

```

--------------------------------

### Start development server with bundle exec rackup

Source: https://guides.rubygems.org/sinatra

Run the development server using bundle exec rackup. This loads Sinatra via Bundler.

```shell
$ bundle exec rackup
```

--------------------------------

### List and install the published gem

Source: https://guides.rubygems.org/make-your-own-gem

Shows how to verify the published gem is available remotely and then install it, including the expected output.

```shell
gem list -r hola

*** REMOTE GEMS ***

hola (0.1.3)
```

```shell
gem install hola
Fetching hola-0.1.3.gem
Successfully installed hola-0.1.3
Parsing documentation for hola-0.1.3
Installing ri documentation for hola-0.1.3
Done installing documentation for hola after 0 seconds
1 gem installed
```

--------------------------------

### Example Gemfile.lock content

Source: https://guides.rubygems.org/using_bundler_in_applications

Example Gemfile.lock content generated by bundle install, listing resolved gems, platforms, dependencies, and Bundler version.

```text
GEM
  remote: https://rubygems.org/
  specs:
    mini_portile2 (2.1.0)
    nokogiri (1.6.8)
      mini_portile2 (~> 2.1.0)
      pkg-config (~> 1.1.7)
    pkg-config (1.1.7)

PLATFORMS
  ruby

DEPENDENCIES
  nokogiri (>= 1.4.0)

BUNDLED WITH
   1.12.5
```

--------------------------------

### Install and run Gemstash

Source: https://guides.rubygems.org/run-your-own-gem-server

Install and start Gemstash, then configure Bundler to use it as a cache for RubyGems.org. The server runs on port 9292 by default.

```shell
$ gem install gemstash
```

```shell
$ gemstash start
```

```shell
$ bundle config set mirror.https://rubygems.org http://localhost:9292
```

--------------------------------

### Install bundle to vendor/bundle with --deployment

Source: https://guides.rubygems.org/deploying

Installs all dependencies to the vendor/bundle directory, ensuring all dependencies are met. This is the recommended deployment command.

```shell
$ bundle install --deployment
```

--------------------------------

### Set up load path for specific groups with Bundler.setup

Source: https://guides.rubygems.org/groups

Restricts the load path to gems in the :default and :ci groups. Bundler.setup can only be called once; subsequent calls are no-ops. Since bundle exec already calls Bundler.setup, later calls in user code are ignored. Use BUNDLE_WITH and BUNDLE_WITHOUT to control groups loaded by bundle exec.

```ruby
require 'bundler'
Bundler.setup(:default, :ci)
require 'nokogiri'

```

--------------------------------

### Conditionally install gems with install_if

Source: https://guides.rubygems.org/gemfile

Use install_if with a proc or lambda to conditionally install gems, useful for optional gems that require certain software or conditions. The example installs pasteboard only on macOS (darwin).

```ruby
install_if -> { RUBY_PLATFORM =~ /darwin/ } do
  gem "pasteboard"
end
```

--------------------------------

### Pass build flags to gem install

Source: https://guides.rubygems.org/troubleshooting

Pass build flags to the gem installer after a `--` separator when a library is installed in a location the build cannot find. This example passes the pg_config path for the pg gem.

```bash
gem install pg -- --with-pg-config=/path/to/pg_config
```

--------------------------------

### bundle version command

Source: https://guides.rubygems.org/command-reference/bundle-version

Prints Bundler version information. The example shows the command and its sample output, which includes the version, build date, and commit hash.

```shell
bundle version
```

```shell
bundle version

```

--------------------------------

### GET /names curl command and response

Source: https://guides.rubygems.org/rubygems-org-compact-index-api

Example of fetching the `/names` endpoint with `curl`. The response is a newline-delimited list of gem names, with a `---` separator line. The example is truncated.

```bash
curl https://rubygems.org/names
```

```text
---
_
-
0mq
0xdm5
[...SNIP...]
```

--------------------------------

### bundle platform example output

Source: https://guides.rubygems.org/command-reference/bundle-platform

Example output of running bundle platform on Ruby 3.1.2 with the provided Gemfile. It shows the current platform, supported platforms from the lockfile, and whether the Ruby version requirement is satisfied.

```text
Your platform is: x86_64-linux

Your app has gems that work on these platforms:
* arm64-darwin-21
* ruby
* x64-mingw-ucrt
* x86_64-linux

Your Gemfile specifies a Ruby version requirement:
* ruby 3.1.2

Your current platform satisfies the Ruby version requirement.

```

--------------------------------

### Gemfile for gem development with gemspec and dev dependencies

Source: https://guides.rubygems.org/rubygems

Example Gemfile for an existing gem. The `gemspec` method imports runtime dependencies from the gemspec, and rspec and rubocop are added as development dependencies. These dev dependencies are installed by `bundle install` but not included by `gem install mygem` or `bundle add mygem`.

```ruby
source "https://rubygems.org"
gemspec
gem "rspec", "~> 3.9"
gem "rubocop", "0.79.0"
```

--------------------------------

### bundle list usage examples

Source: https://guides.rubygems.org/command-reference/bundle-list

Example invocations of bundle list demonstrating the --name-only, --paths, --without-group, --only-group, and --format options.

```bash
bundle list --name-only
```

```bash
bundle list --paths
```

```bash
bundle list --without-group test
```

```bash
bundle list --only-group dev
```

```bash
bundle list --only-group dev test --paths
```

```bash
bundle list --format json
```

--------------------------------

### GET /api/v1/downloads.json with example response

Source: https://guides.rubygems.org/rubygems-org-api

Retrieve the total number of downloads on RubyGems. The response is a JSON object with a `total` field.

```bash
$ curl https://rubygems.org/api/v1/downloads.json
```

```json
{
  "total": 461672727
}
```

--------------------------------

### GET /api/v1/downloads/all.json with example response

Source: https://guides.rubygems.org/rubygems-org-api

Retrieve the 50 most downloaded gem versions. Each entry pairs a version record with its download count.

```bash
$ curl https://rubygems.org/api/v1/downloads/all.json
```

```json
{
  "gems": [
    [{ "number": "1.6.2", "full_name": "jmespath-1.6.2", ... }, 648386198],
    ...
  ]
}
```

--------------------------------

### bundle open command syntax

Source: https://guides.rubygems.org/command-reference/bundle-open

Shows the general usage syntax for the bundle open command. Use this to see the available arguments and options.

```bash
bundle open [GEM] [--path=PATH]
```

--------------------------------

### Get gem information with curl and JSON response

Source: https://guides.rubygems.org/rubygems-org-api

Query basic information about a gem using the GET /api/v1/gems/[GEM NAME].(json|yaml) endpoint. The example shows the curl command and the JSON response for the 'rails' gem, including metadata, dependencies, and download counts.

```bash
$ curl https://rubygems.org/api/v1/gems/rails.json
```

```json
{
  "name": "rails",
  "downloads": 769153204,
  "version": "8.1.3.1",
  "version_created_at": "2026-07-29T15:02:41.060Z",
  "version_downloads": 78333,
  "platform": "ruby",
  "ruby_abi": null,
  "authors": "David Heinemeier Hansson",
  "info": "Ruby on Rails is a full-stack web framework optimized for programmer happiness and sustainable productivity.",
  "licenses": ["MIT"],
  "metadata": {
    "changelog_uri": "https://github.com/rails/rails/releases/tag/v8.1.3.1",
    "bug_tracker_uri": "https://github.com/rails/rails/issues",
    "source_code_uri": "https://github.com/rails/rails/tree/v8.1.3.1",
    "rubygems_mfa_required": "true"
  },
  "yanked": false,
  "sha": "ccd11a36bfc171bf9c66d585d14c0ece91c0c9dde840aae60c0118d6f5c9c52a",
  "spec_sha": "5b60af49df6edf722925a85d144f1118abda22485a820da2c516e97cab8347b8",
  "project_uri": "https://rubygems.org/gems/rails",
  "gem_uri": "https://rubygems.org/gems/rails-8.1.3.1.gem",
  "homepage_uri": "https://rubyonrails.org",
  "wiki_uri": null,
  "documentation_uri": "https://api.rubyonrails.org/v8.1.3.1/",
  "mailing_list_uri": "https://discuss.rubyonrails.org/c/rubyonrails-talk",
  "source_code_uri": "https://github.com/rails/rails/tree/v8.1.3.1",
  "bug_tracker_uri": "https://github.com/rails/rails/issues",
  "changelog_uri": "https://github.com/rails/rails/releases/tag/v8.1.3.1",
  "funding_uri": null,
  "dependencies": {
    "development": [],
    "runtime": [
      {
        "name": "actioncable",
        "requirements": "= 8.1.3.1"
      },
      {
        "name": "actionmailbox",
        "requirements": "= 8.1.3.1"
      },
      {
        "name": "actionmailer",
        "requirements": "= 8.1.3.1"
      },
      ...
    ]
  }
}
```

--------------------------------

### Example Gemfile with nokogiri

Source: https://guides.rubygems.org/command-reference/bundle-cache

Example Gemfile used to illustrate remote fetching behavior. When running bundle cache under C Ruby, bundler retrieves the version of nokogiri for the 'ruby' platform. If deploying to JRuby and running bundle install, bundler checks for a 'java' platformed nokogiri.

```ruby
source "https://rubygems.org"

gem "nokogiri"

```

--------------------------------

### Add development dependency with add_development_dependency

Source: https://guides.rubygems.org/specification-reference

Adds a development dependency named 'example' with the given version requirements. Development dependencies are not installed by default and are not activated when the gem is required.

```ruby
spec.add_development_dependency 'example', '~> 1.1', '>= 1.1.4'
```

--------------------------------

### Set a mirror for rubygems.org

Source: https://guides.rubygems.org/command-reference/bundle-config

Example of using a mirror hosted at https://example.org for https://rubygems.org.

```shell
bundle config set --global mirror.https://rubygems.org https://example.org

```

--------------------------------

### Load bundled environment with bundler/setup

Source: https://guides.rubygems.org/dependency_management

Place this at the top of your application code to load the bundled environment before requiring any gems. The comment indicates where to require your gems as usual.

```ruby
require 'bundler/setup'

# require your gems as usual
require 'nokogiri'

```

--------------------------------

### GET /api/v1/downloads/[GEM NAME]-[GEM VERSION].json with example response

Source: https://guides.rubygems.org/rubygems-org-api

Retrieve download counts for a specific gem version. The response includes `version_downloads` and `total_downloads`.

```bash
$ curl https://rubygems.org/api/v1/downloads/rails_admin-0.0.0.json
```

```json
{
  "version_downloads": 3142,
  "total_downloads": 3142
}
```

--------------------------------

### Install a Bundler plugin

Source: https://guides.rubygems.org/bundler_plugins

Installs a Bundler plugin from a gem server, a git repository, or a local path. The --git and --path flags specify the source location.

```shell
bundle plugin install my_plugin
bundle plugin install my_plugin --git https://github.com/example/my_plugin
bundle plugin install my_plugin --path /path/to/my_plugin
```

--------------------------------

### Example Gemfile for bundle platform

Source: https://guides.rubygems.org/command-reference/bundle-platform

Example Gemfile used to illustrate the bundle platform command. It specifies a Ruby version requirement and a gem dependency.

```ruby
source "https://rubygems.org"

ruby "3.1.2"

gem "rack"

```

--------------------------------

### Gemfile with rails and nokogiri

Source: https://guides.rubygems.org/command-reference/bundle-update

Example Gemfile with two gems: rails pinned to version 3.0.0.rc and nokogiri with no version constraint. This is the starting point for the bundle update --all workflow.

```ruby
source "https://rubygems.org"

gem "rails", "3.0.0.rc"
gem "nokogiri"

```

--------------------------------

### GitHub Actions: Install gems with ruby/setup-ruby bundler-cache

Source: https://guides.rubygems.org/ci

GitHub Actions workflow using ruby/setup-ruby with bundler-cache: true to install and cache gems. Omitting ruby-version uses .ruby-version, .tool-versions, or mise.toml if present.

```yaml
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: ruby/setup-ruby@v1
        with:
          bundler-cache: true
      - run: bundle exec rake
```

--------------------------------

### Gemfile with production group

Source: https://guides.rubygems.org/command-reference/bundle-install

Example Gemfile showing a production group with rack-perftools-profiler. Used to illustrate how the 'without' setting skips installing gems in excluded groups while still resolving their dependencies.

```ruby
source 'https://rubygems.org'

gem 'sinatra'

group :production do
  gem 'rack-perftools-profiler'
end

```

--------------------------------

### Pushing a gem with OTP

Source: https://guides.rubygems.org/using-mfa-in-command-line

Example of pushing a gem after signing in, showing the OTP prompt and successful registration.

```text
$ gem push hello-0.0.1.gem
Pushing gem to https://rubygems.org...
You have enabled multi-factor authentication. Please enter OTP code.
Code:   111111
Successfully registered gem: hello (0.0.1)
```

--------------------------------

### Bundler inline gemfile example

Source: https://guides.rubygems.org/bundler_in_a_single_file_ruby_script

Use this snippet to declare and automatically install gems within a single Ruby script. It requires 'bundler/inline', defines a gemfile block with a source and gem dependencies, and then runs code that uses those gems. Running the script will install any missing gems and require the listed gems before executing the rest of the code.

```ruby
require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'json', require: false
  gem 'nap', require: 'rest'
  gem 'cocoapods', '~> 0.34.1'
end

puts 'Gems installed and loaded!'
puts "The nap gem is at version #{REST::VERSION}"
```

--------------------------------

### bundle plugin command syntax

Source: https://guides.rubygems.org/command-reference/bundle-plugin

Shows the full command syntax for the bundle plugin command, including install, uninstall, list, and help subcommands with their options.

```bash
bundle plugin install PLUGINS [--source=SOURCE] [--version=VERSION]
                              [--git=GIT] [--branch=BRANCH|--ref=REF]
                              [--path=PATH]  

bundle plugin uninstall PLUGINS [--all]  

bundle plugin list  

bundle plugin help [COMMAND]
```

--------------------------------

### Install gem with extension build options after --

Source: https://guides.rubygems.org/command-reference

Shows the sequence for installing a gem whose extension fails to compile, then retrying with build options passed after `--` (e.g. `--with-extension-lib=/path/to/lib`). The gem remains unpacked and the failure is logged to `gem_make.out`; after a successful build, `gem list` confirms the installed version.

```shell
$ gem install some_extension_gem
[build fails]
Gem files will remain installed in \
/path/to/gems/some_extension_gem-1.0 for inspection.
Results logged to /path/to/gems/some_extension_gem-1.0/gem_make.out
$ gem install some_extension_gem -- --with-extension-lib=/path/to/lib
[build succeeds]
$ gem list some_extension_gem

*** LOCAL GEMS ***

some_extension_gem (1.0)
$
```

--------------------------------

### Set global Bundler build config for mysql

Source: https://guides.rubygems.org/troubleshooting

Store build flags in Bundler's configuration so they are passed every time a particular gem is installed. This example sets the mysql config path globally.

```bash
bundle config set --global build.mysql --with-mysql-config=/usr/local/mysql/bin/mysql_config
```
Tokens:
Raw