Context Binding in Ruby - rubycademy

By Mehdi Farsi

Context Binding in Ruby

Mehdi Farsi

In this article we’re going to explore the following topics:

  • The Binding class
  • The TOPLEVEL_BINDING constant
  • ERB Templates

The Binding class

An instance of the Binding class is able to encapsulate the execution context of the receiver object.

The execution context is the entire environment needed for a given piece of code to be executed. A code without execution context cannot be properly executed.

The execution context contains the variables, the methods and self for a given scope.

The Execution Context is a bit more complicated than this. Anyway, let’s keep it simple as it’s not the main topic of this article.

I’ll detail this key-concept in another article.

The Binding class is not publicly instantiable — as the new method is undefined during the Binding class initialization.

Otherwise, this class can be internally instantiated via the Kernel#binding method.

As the Kernel#binding method is private, we access this method through the Context#get_binding method.

So the real purpose of this class is:

Encapsulating an Execution Context and being able to access it from another Execution Context.

I know that this notion can be a bit tricky to understand.

Anyway, we’re going to detail 2 concrete examples in the next two sections.

NB: feel free to have a look to the private and protected: a matter of message article if you’re unfamiliar with the private keyword in Ruby.

The TOPLEVEL_BINDING constant

The main object is the top-level scope. Any object in Ruby is instantiated, at least, under this scope.

NB: feel free to have a look to the Ruby Object Model article if you’re unfamiliar with the main object in Ruby.

In order to access the Execution Context of the main object at any time, Ruby provides a global constant named as TOPLEVEL_BINDING

The Binding#receiver method returns the receiver of the Kernel#binding message. So, the calling Execution Context is retained — in our case, the main object.

Then we access the @a variable within an instance of the Addition class using the TOPLEVEL_BINDING global constant.

ERB templates

Let’s illustrate the use of the Binding concept by breaking down a Ruby on Rails concept that you’ve surely worked with: the ERB templates

In app/controllers/users_controller.rb

In app/views/users/show.html.erb

Here the show.html.erb template gets access to the @user instance variable from the UsersController class.

So, how it works behind the scene?

The ERB class provides a result method that takes an instance of the Binding class as parameter.

So let’s redo the previous example by explicitly instantiating the ERB class to make you understand what happens behind the scene

So, in this example, the instance of ERB can access the @user variable defined in the UsersController instance via the Binding instance passed as parameter of the ERB#result method.

Voilà!

May I have your attention please 🎤🎤

Feel free to subscribe here: www.rubycademy.com