Guice for the Rubyist

A little about our infrastructure and some code to showcase integration with Guice for Ruby.

Written by Matthew Todd and Matt Wilson.

Square heavily utilizes Guice in its Java codebase. Rather than fully wire Ruby into the dependency graph, we’ve built a small API to simulate field injection onto our Ruby objects. This allows our developers to write native-feeling Ruby code while still providing access to the underlying Guice-based framework.


Let’s take a moment to talk about Guice from the Rubyist’s point of view. In Ruby applications, the common idiom is to provide global access to the objects your code depends on: consider ActiveRecord::Base.connection,, and RSpec.configure. Java applications tend to use dependency injection instead, passing collaborators into constructors as needed. We can do that in Ruby (often to great effect), but it works so much more pleasantly in Java because the type system allows dependency injection libraries, like Guice, to automatically determine your classes’ dependencies, and their dependencies, all the way down. Guice can then instantiate your entire object graph for you.

If we were to write something like that in Ruby, it might look like this:

class Injector
def initialize(registrations)
@registrations = registrations
    def [](key)
klass = @registrations[key]
constructor = klass.method(:initialize)
      # Let's pretend Ruby let us do this:
arguments = do |type|
self[type] # recurse!

(Of course, it gets much more complicated than that.)


In our integration framework (Minecart), we’ve brought Guice-backed dependency injection to our Ruby code. In general, we aim to insulate our Ruby applications from needing to speak (or even know about) Java methods and types by providing small, native-feeling APIs. But to support developers who need access to an underlying Guice-bound Java object that we’ve not yet exposed, we provide something like field injection.

Here’s what it looks like:

# JRuby's So Awesome!
require 'javax.inject-1'
require 'guice-3.0-no_aop'
require 'injectable'
class DemoApp
include Minecart::Injectable
  inject :hello_world, :with => java.lang.String
  def demo
puts hello_world
class DemoModule <
def configure
bind(java.lang.String.java_class).toInstance("Hello World")
injector =
# => "Hello World"

You can run this in a JRuby irb console on your machine if you download injectable.rb, javax.inject-1.jar, and guice-3.0-no_aop.jar.

As you peruse the code, you may notice subtle calls to java_class and to_javaboth above and in Injectable. Suffice it to say those were some hard-won keystrokes. We’ll share those war stories another day.

This post is part of a series, which highlights discoveries and insights found while integrating Ruby with our robust Java stack.

One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.