Bundler

Bundler manages an application's dependencies through its entire life, across many machines, systematically and repeatably

bundler-audit provides patch-level verification for Bundled apps.

bundler-leak provides memory leak verification for Bundled apps.

Bundler support for Capistrano 3.x

Guard::Bundler automatically install/update your gem bundle when needed

Dependabot-Bundler provides support for bumping Ruby (bundler) gems via Dependabot. If you want support for multiple package managers, you probably want the meta-gem dependabot-omnibus.

Stop using bundle exec. Integrate Rubygems and Bundler. Make rubygems generate bundler aware executable wrappers.

managing jar dependencies with or without bundler. adding bundler like handling of version ranges for jar dependencies.

Guard::CtagsBundler uses ctags utility and generates 2 files: tags -- with tags generated from project's source tree and gems.tags -- with tags generated from rubygems from project's bundle.

Allow unloading bundler after Bundler.load

Appraisal integrates with bundler and rake to test your library against different versions of dependencies in repeatable scenarios called "appraisals."

Looks through your lockfile and tries to identify problematic use of dependencies

An easy way to vendor gem dependencies

A Framework for Bundlers.

Transaction::Simple provides a generic way to add active transaction support to objects. The transaction methods added by this module will work with most objects, excluding those that cannot be Marshal-ed (bindings, procedure objects, IO instances, or singleton objects). The transactions supported by Transaction::Simple are not associated with any sort of data store. They are "live" transactions occurring in memory on the object itself. This is to allow "test" changes to be made to an object before making the changes permanent. Transaction::Simple can handle an "infinite" number of transaction levels (limited only by memory). If I open two transactions, commit the second, but abort the first, the object will revert to the original version. Transaction::Simple supports "named" transactions, so that multiple levels of transactions can be committed, aborted, or rewound by referring to the appropriate name of the transaction. Names may be any object except nil. Transaction groups are also supported. A transaction group is an object wrapper that manages a group of objects as if they were a single object for the purpose of transaction management. All transactions for this group of objects should be performed against the transaction group object, not against individual objects in the group. Version 1.4.0 of Transaction::Simple adds a new post-rewind hook so that complex graph objects of the type in tests/tc_broken_graph.rb can correct themselves. Version 1.4.0.1 just fixes a simple bug with #transaction method handling during the deprecation warning. Version 1.4.0.2 is a small update for people who use Transaction::Simple in bundler (adding lib/transaction-simple.rb) and other scenarios where having Hoe as a runtime dependency (a bug fixed in Hoe several years ago, but not visible in Transaction::Simple because it has not needed a re-release). All of the files internally have also been marked as UTF-8, ensuring full Ruby 1.9 compatibility.

A Bundler for your Chef Cookbooks.

Extracts a dependency solution from bundler's Gemfile.lock to speed gem activation

Generate a Gemfile based on a Hoe spec's declared dependencies.

RubyAudit checks your current version of Ruby and RubyGems against known security vulnerabilities (CVEs), alerting you if you are using an insecure version. It complements bundler-audit, providing complete coverage for your Ruby stack.

bundler-inject is a bundler plugin that allows a developer to extend a project with their own personal gems and/or override existing gems, without having to modify the Gemfile, thus avoiding accidental modification of git history.

You really mean `gem install bundler`. It's okay. I'll fix it for you this one last time...

A simple measure of dependency freshness

BundlerDiff show changes with GitHub comapre view urls.

Gem to verify integrity of packages installed via Bundler. It allows to detect packages that were tampered with or replaced via cache poison or replaced. Add it to your Gemfile and run bundle exec bundler-integrity.

guard + bundler-audit = security

Manage Jar files for Ruby. In the spirit of Bundler, a Jarfile is used to generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test. The Jarfile.lock can be used to populate the classpath

Hooks into Pry and removes the restrictions on loading gems imposed by Bundler only when you're running in interactive mode.

Add the pessimistic constraint operator to all gems in your Gemfile, restricting the maximum update version. This is for people who work with projects that use bundler, such as rails projects. The pessimistic constraint operator (~>) allows you to specify the maximum version that a gem can be updated, and reduces potential breakages when running `bundle update`. Pessimize automatically retrieves the current versions of your gems, then adds them to your Gemfile (so you don't have to do it by hand).

A Bundler for your Ansible roles.

Let's have bundler manage our asset dependencies yo.

Find slowly loading gems for your Bundler-based projects

Bundles terraform modules

TarPit provides the glue for an unholy union of build tools. TarPit includes general automation for any rubygems project. It originally used and remains heavily influenced by Hoe (e.g. Manifest.txt.) However, it fully supports use of Bundler. The gemspec benefits from sensible automation but remains in a <project>.gemspec per Bundler's requirements.

A Framework for Bundlers, used by librarian-puppet.

Use Ruby gems and mock require statements within RubyMotion applications

Use bundler to generate gem tarball packages.

Bundler for Sprockets

Use a Bundler hook to automatically run `bundle exec licensed cache -s bundler` after running `bundle install` or `bundle update` commands.

Implement's bundler's --deployment functionality in CocoaPods.

Gem dependency prebuilder

Audit all Gemfiles of a user/organization on github for unpatched versions

Use `bundleup` whenever you want to update the locked Gemfile dependencies of a Ruby project. It shows exactly what gems will be updated with color output that calls attention to significant semver changes. Bundleup will also let you know when a version "pin" in your Gemfile is preventing an update. Bundleup is a standalone tool that leverages standard Bundler output and does not patch code or use Bundler internals.

We should use latest Bundler, but sometimes we are afraid we have to use older Bundler. RestoreBundledWith solves these conflicts.

Configurable fork of bundlers release tasks.

Keeps a log of your time waiting on bundler

Just requires bundler-audit, if you've mistakenly required bundle-audit

Simple fixture to generate for-realz Gemfile.lock files

Attempt to update every single gem of your Gemfile to its latest patch, minor then major release. Runs a test command to ensure the update succeeded

Simple gem building using bundler

Inspired by bundler and rack. Mostly built on top of Alexey Kovyrin's loops code. http://github.com/kovyrin/loops