bundle

Install all gems defined in the Gemfile expected in the working directory

$ bundle install

$ bundle exec [command] [arguments]

$ bundle update

$ bundle update [gem_name1] [gem_name2]

$ bundle update --patch [gem_name1] [gem_name2]

$ bundle update --group [development]

$ bundle outdated

$ bundle gem [gem_name]

bundle <command> [arguments] [options]

Examples:
bundle install [options]
bundle update [gems] [options]
bundle exec command [arguments]
bundle add gem_name [options]

--local
    Do not fetch remote gems; use only cached gems.

--path <directory>
    Install gems to a specified directory rather than the system-wide Gem Path. Often used for vendoring dependencies.

--without <groups>
    Do not install gems belonging to the specified groups (e.g., 'development test').

--clean
    Removes old gems from the bundle directory after installation (only applicable when using --path).

--force
    Reinstall all gems, even if they appear to be installed.

--no-install
    Resolves dependencies and updates Gemfile.lock without actually installing gems.

--gemfile <file>
    Use a specific Gemfile instead of the default.

--verbose
    Print extra information for debugging purposes.

bundle is the primary command-line interface for Bundler, a dependency manager for Ruby applications. It ensures that a Ruby application runs with the specific versions of gems (libraries) it needs. Bundler achieves this by reading a Gemfile, which specifies an application's dependencies, and then resolving and installing those gems. It creates a Gemfile.lock file, which precisely records the versions of all installed gems, ensuring consistent environments across development, testing, and production. bundle provides various subcommands to manage the entire dependency lifecycle, including installing, updating, and executing commands within the bundled environment. It is crucial for maintaining project stability and portability in the Ruby ecosystem.

bundle is not a standard utility shipped with most Linux distributions. It must be installed separately, typically via gem install bundler, after Ruby is set up. It is specifically designed for Ruby projects and is not applicable to other programming languages or general system dependency management. Its functionality relies heavily on the presence of a Gemfile in the project directory.

bundle acts as a front-end for a rich set of subcommands, each designed for a specific dependency management task. Examples include install (to resolve and install gems), update (to update gems to newer versions), exec (to run a command within the bundled environment), add (to add new gem dependencies), show (to display installed gems), and config (to manage Bundler settings).

These two files are central to Bundler's operation. The Gemfile declares the project's direct gem dependencies, while the Gemfile.lock is a generated file that precisely records the exact versions of all gems (including transitive dependencies) that were resolved and installed. This ensures that anyone running bundle install on the same project gets the exact same gem setup, promoting consistency across environments.

Bundler was first released in 2010 to address the growing need for consistent and reproducible dependency management within Ruby projects. Before Bundler, managing gem dependencies was often manual and prone to 'works on my machine' issues due to differing gem versions across development environments. It quickly became the de-facto standard for Ruby dependency resolution, integrating seamlessly with RubyGems. Its adoption by the Ruby on Rails framework further solidified its position as an essential tool in the Ruby ecosystem, ensuring project stability and easing collaboration among developers.

gem(1), ruby(1), rake(1), rails(1), rbenv(1), rvm(1)