Bypassing bundler for auxiliary development gems

In the Gemfile of my Rails project, I am starting to have auxiliary gems like "ruby-debug19", "perftools.rb", or "irbtools". All of these really have nothing to do with the project, but rather are part of my local development setup. But since I'm using bundler, I cannot load these gems (even though they are installed system-wide) unless I add them to the Gemfile. In my view that is a bit of a code smell.

For example, I would like to be able to require 'irbtools' in rails console without addin开发者_运维问答g "irbtools" to my Gemfile.

Is there a way to keep auxiliary gems out of the Gemfile and still be able to load them for debugging, profiling, etc. when I need them?

Actually, you can create a group in you Gemfile like:

group :auxiliary do
  gem 'irbtools'
end

And then use bundle install --without auxiliary if you don't want to use irbtools. Why do you think adding them to Gemfile is a code smell? And if it possible to do this without adding gems to the Gemfile it will be many more code smell I think.

Thanks to this post I have a great solution.

1. Add this line at the end of your Gemfile:

   eval(File.read(File.dirname(__FILE__) + '/Gemfile.local'), binding) rescue nil
   

2. Create a file called Gemfile.local.

3. Add your development gems to Gemfile local. For example:

   group :development do
     gem 'cucumber'
   end
   

4. Add Gemfile.local to .gitignore.

Now you can add your auxiliary development gems without changing the Gemfile for other folks on the team. Very cool.

I put the code below in a file in my app root, so it's easy to load from irb.

If you want it in something like a rails server, you probably need to add the load statement to environments/development.rb etc. That still creates problems if you accidentally check that in, but it's less annoying than having to add it to the Gemfile and causing your Gemfile.lock to change also.

# Example usage:
#   add_more_gems("ruby-debug-base19-0.11.26", "linecache19-0.5.13")
# or
#   add_more_gems(%w(ruby-debug-base19-0.11.26 linecache19-0.5.13))
#
# Note that you are responsible for:
# - adding all gem dependencies manually
# - making sure manually-added gem versions don't conflict with Gemfile.lock
# To list deps, run e.g. "gem dep ruby-debug-base19 -v 0.11.26"
#
def add_more_gems(*gem_names_and_vers)
  gem_names_and_vers.flatten!
  gem_base = File.expand_path(Gem.dir)

  gem_names_and_vers.each do |gem_name_and_ver|
    # uncomment if desired
    ###puts "Adding lib paths for #{gem_name_and_ver.inspect}"
    spec_file = File.join(gem_base, 'specifications', "#{gem_name_and_ver}.gemspec")
    spec = Gem::Specification.load spec_file
    this_gem_dir = File.join(gem_base, 'gems', gem_name_and_ver)
    spec.require_paths.each {|path| 
      dir_to_add = File.join(this_gem_dir, path)
      $: << dir_to_add  unless $:.member?(dir_to_add)
    }
  end
end

# put your often-used gems here
add_more_gems(
  %w(
    ruby-debug-base19-0.11.26
    ruby-debug-ide19-0.4.12
    linecache19-0.5.13
  )
)

Not sure if this would work for you. It depends on whether or not you're using RVM. If you are, then you could install those auxiliary gems into the @global gemset that is created automatically for every Ruby interpreter. The gems in the @global gemset are available to all project-specific gemsets by default. This way you won't need to clutter up your Gemfiles.