Ruby

Related articles
List of programming languages
Ruby
is a dynamic, interpreted, open source programming language with a focus on simplicity and productivity.
Installation
To use Ruby,
install
the
ruby
package.
To install IRB,
install
the
ruby-irb
package.
Multiple versions
If you want to run multiple versions on the same system (e.g. 2.0.0-p0 and 1.9.3-p392),
the easiest way is to use one of
RVM
,
chruby
AUR
,
rbenv
,
asdf-vm
AUR
.
Documentation
To make documentation available through the
ri
command-line tool,
install
ruby-rdoc
and
ruby-docs
for the documentation itself.
You can then query the docs with:
ri Array
,
ri Array.pop
etc. (much like man-pages)
JRuby
The
Java
implementation of Ruby,
JRuby
can be installed with the
jruby
package.
Standard Library
Part of Ruby's standard library consists of Ruby modules (see
RubyGems
for more 
information about modules.) The
ruby
package does not include all of the standard modules 
that a Ruby user can assume to be installed on any Ruby system, so some Ruby code may not work
out-of-the-box. More information about the set of standard library modules can be found at
https://stdgems.org/
.
The
RubyGems
section discusses several methods for installing modules. To install
the standard modules system-wide using
pacman
, one can install the
ruby-stdlib
package. Note that this is not needed for JRuby, as the
jruby
package includes the standard 
modules.
RubyGems
RubyGems is a package manager for Ruby modules (called
gems
),
somewhat comparable to what
pacman
is to Arch Linux.
It can be installed with the
rubygems
package, which is a dependency of
ruby
.
Configuration
By default in Arch Linux, when running
gem
, gems are installed per-user (into
~/.local/share/gem/ruby/
), instead of system-wide (into
/usr/lib/ruby/gems/
). This is considered the best way to manage gems on Arch, because otherwise they might interfere with gems installed by Pacman.
The recommended way to setup that is by manually specifying your
$GEM_HOME
, which then can be
appended
to your
$PATH
environment variable
in order to allow RubyGems binaries to be executed:
~/.profile
export GEM_HOME="$(gem env user_gemhome)"
export PATH="$PATH:$GEM_HOME/bin"
This is required for executable gems to work without typing out the full location, although libraries will work without having to modify your path.
Note
After saving the changes, restart the terminal for changes to apply.
Use
gem env
to view the current RubyGems environment:
$ gem env
Usage
To see what gems are installed:
$ gem list
To get information about a gem:
$ gem spec
gem_name
By default,
gem list
and
gem spec
use the
--local
option, which forces
gem
to search only the local system. This can be overridden with the
--remote
flag. Thus, to search for the mysql2 gem:
$ gem list --remote mysql2
To install a gem:
$ gem install mysql2
The process can be sped up somewhat if you do not need local documentation:
$ gem install mysql2 --no-document
Note
This can be made the default option by configuring the following
~/.gemrc
file:
~/.gemrc
gem: --no-document
To update all installed gems:
$ gem update
Installing gems system-wide
Gems can be installed system wide by running the
gem
command as root, appended with the
--no-user-install
flag. This flag can be set as default by replacing
--user-install
by
--no-user-install
in
/etc/gemrc
(system-wide) or
~/.gemrc
(per-user, overrides system-wide).
Bundler
can be used to avoid system-wide gem installations by packaging gems into your application. See the section below on using bundler.
Bundler
Bundler
allows you to specify which gems your application depends upon, and optionally which version those gems should be. Once this specification is in place, Bundler installs all required gems (including the full gem dependency tree) and logs the results for later inspection. By default, Bundler installs gems into a shared location, but they can also be installed directly into your application. When your application is run, Bundler provides the correct version of each gem, even if multiple versions of each gem have been installed. This requires a little bit of work: applications should be called with
bundle exec
, and two lines of boilerplate code must be placed in your application's main executable.
To install Bundler:
$ gem install bundler
To start a new bundle:
$ bundle init
Then edit
Gemfile
in the current directory (created by bundle init) and list your required gems:
Gemfile
gem "rails", "3.2.9"
gem "mysql2"
Run the following to install gems into
GEM_HOME
:
$ bundle install
Alternatively, run the following to install gems to
.bundle
in the working directory:
$ bundle config set --local path '.bundle'
Note
command `bundle install --path .bundle` is deprecated because it relies on being remembered across bundler invocations, which bundler will no longer do in future versions. But if above command is not valid, maybe your ruby version is old so you should use this command.
Do not forget to edit your main executable:
#!/usr/bin/env ruby

# "This will automatically discover your Gemfile, and make all of the gems in
# your Gemfile available to Ruby."
https://bundler.io/rationale.html
require 'bundler/setup'

...
Finally, run your program:
$ bundle exec
main_executable_name.rb
Managing RubyGems using pacman
Instead of managing gems with
gem
, you can use
pacman
, or an
AUR helper
. Ruby packages follow the naming convention ruby-
gemname
.
This option provides the following advantages:
Gems are updated along with the rest of your system.
Installed gems are available system-wide, instead of being available only to the user who installed them.
Note
There are also tools integrating
gem
with
pacman
by automatically generating PKGBUILDs for specified gems: see
Creating packages#PKGBUILD generators
.
Quarry
Quarry is a tool that allows to maintain a
rubygems
binary repository for Arch Linux, as an easier alternative to building packages manually from the AUR. The source is hosted at
Github
.
The repository is maintained by the Arch developer anatolik at
https://pkgbuild.com/~anatolik/quarry/
. It contains many popular gems and new gems can be added upon request.
See
Unofficial user repositories#quarry
to enable it.
Then
install
the required gem. The name of the package is
ruby-
gem-name
.
General questions can be asked at
https://bbs.archlinux.org/viewtopic.php?id=182729
.
Interactive Shell
Pry
Pry is a powerful alternative to the standard IRB shell for Ruby. It features syntax highlighting, a flexible plugin architecture, runtime invocation and source and documentation browsing.
$ gem install pry
$ pry
Performance Tuning
Enable JIT
ruby
is built with JIT support which is disabled by default. JIT can optimize hot code paths for long running program (e.g. servers). Enable it with:
$ ruby --jit
For other commands that doesn't accept
--jit
, you can pass the argument to Ruby with the environment variable
RUBYOPT
e.g.
RUBYOPT=--jit
.
jemalloc
Ruby can use
jemalloc
instead of malloc(3) as its default memory allocator.
It can reduce memory bloat
. To enable it, install
jemalloc
and run Ruby with:
$ LD_PRELOAD=libjemalloc.so ruby ...
To verify that jemalloc is actually being used:
$ LD_PRELOAD=libjemalloc.so MALLOC_CONF=stats_print:true ruby -e exit
See also
Ruby on Rails
Ruby -
https://www.ruby-lang.org/
Bundler -
https://bundler.io/
why's (poignant) Guide to Ruby
Learn Ruby The Hard Way