You're working on a Rails project, that requires version X of some gem. But you're also working on another project, that requires version Y. If you use the right version on one, and ever clean things up, you break the other. And if you ever need to look at the source of a gem, it's squirreled away in some directory far from the projects. What to do, what to do?
You could use
rvm, to create a new gemset for each one. After a few years of projects, you wind up with a gazillion gemsets. And if you ever try to upgrade the Ruby a project uses, by so much as a patchlevel, you have the hassle of moving all those gems. And the paths to your gems get even hairier.
Alternative Ruby-management tools like
chrubymight offer some relief, frankly I don't know... but I'm not holding my breath.
But there's still hope!
You could stash each project's gems safely away from all other projects, inside the project! How, you wonder?
When you create a new Rails app, don't just do
rails new myproject. Instead, do
rails new myproject --skip-bundle. This will cause Rails not to install your gems... yet.
Now, cd into your project directory. Edit your
Gemfile; you know you would anyway! When your
Gemfileis all to your satisfaction, now comes the magic:
bundle install --path vendor.
What's that do, you wonder? Simply put, it puts your gems down inside your vendor subdirectory -- yes, the same one that would normally hold plugins, "vendored" assets, etc. There will be a new subdirectory in there called
ruby, under which will be subdirectories called
specifications, and the one we're interested in here:
Now you can upgrade your gems without fear of interfering with another project. You can also treat the project directory as a complete self-contained unit.
But wait! There's more! As an extra special bonus, if you want to absolutely ensure that there is complete separation between projects (handy if you're a consultant, like me), you can even make these project directories entirely separate disk images! For even more security, you can then encrypt them, without having to encrypt other non-sensitive information, let alone your whole drive. Now how much would you pay? ;-)
In the interests of fairness, though, I must admit there is a downside to this approach: duplication of gems. Suppose Projects A, B, and C all depend on version X of gem Y. Each project will have its own copy. For large projects, that can soak up a gigabyte of disk space each. You can cut down on this by making the gems symlinks or hardlinks to a central gem directory... but why bother, in this age when disk space is so cheap?
If you know of a better way, or more downsides to this, or have any other commentary, please speak up! Meanwhile, go try it for yourself, at least on a little toy side-project. I think you'll be please with the simplified gem-source access, and much looser coupling between projects.
UPDATE: Some people read the above and thought I meant to put the installed gems in your source code repository (e.g.,
git), so that the gems would be put into your staging and production environments from there. This is a serious problem for gems with C-extensions to compile, if your staging and/or production environments are on different system types from your development environment. That situation is very common, as many (if not most) Rails developers prefer Macs, and the production machine (and staging if any) is typically Linux, or occasionally one of the BSD family.
This is not what I meant. Instead, you probably want to put your gem directory (usually
vendor/ruby) into your
.gitignorefile (or equivalent for whatever other SCM system you may be using), so that your SCM repo will ignore them. Do still SCM your
Gemfile.lock. Then, when you install to staging or production, you will get the same versions of the same bunch of gems, but the C-extensions will still be compiled for the particular environment.