Question

This is a description of how to create a helper method in Rspec taken from the Rspec book (page 149). This example assumes that there is a method called ‘set_status’ which is triggered when the ‘Thing’ object is created.

Both sets of code create a new ‘Thing’ object, set the status, then do ‘fancy_stuff’. The first set of code is perfect clear to me. One of the ‘it’ statements it triggered, which then calls the ‘create_thing’ method with options. A new ‘Thing’ object is created and the ‘set_status’ method is called with the ‘options’ attribute as the parameter.

The second set of code is similar. One of the ‘it’ statements is triggered, which then calls the ‘given_thing_with’ method while passing ‘:status’ hash assignment as a parameter. Within the ‘given_thing_with’ method the ‘yield’ is triggered taking the ‘Thing.new’ as a parameter. This is where I am having trouble. When I try to run this code I get an error of “block given to yield”. I understand that whatever attributes that are passed by yield will be returned to the ‘thing’ in pipe brace from the ‘it’ statement that called the ‘given_thing_with’ method. I can get the new

What I don’t understand is why the code block is not called in the ‘given_thing_with’ method after the ‘yield’ command. In other words, I can’t code in that block to run.

Thanks in advance for your help.

The remainder of this question is quoted directly from the Rspec book:

describe Thing do
  def create_thing(options)
    thing = Thing.new
    thing.set_status(options[:status])
    thing
  end

  it "should do something when ok" do
    thing = create_thing(:status => 'ok')
    thing.do_fancy_stuff(1, true, :move => 'left', :obstacles => nil)
    ...
  end

  it "should do something else when not so good" do
    thing = create_thing(:status => 'not so good')
    thing.do_fancy_stuff(1, true, :move => 'left', :obstacles => nil)
    ...
  end
end

One idiom you can apply to clean this up even more is to yield self from initializers in your objects. Assuming that Thing’s initialize() method does this and set_status() does as well, you can write the previous like this:

describe Thing do
  def given_thing_with(options)
    yield Thing.new do |thing| 
      thing.set_status(options[:status])
    end
  end

  it "should do something when ok" do
    given_thing_with(:status => 'ok') do |thing|
      thing.do_fancy_stuff(1, true, :move => 'left', :obstacles => nil)
      ... 
    end
  end

  it "should do something else when not so good" do
    given_thing_with(:status => 'not so good') do |thing|
      thing.do_fancy_stuff(1, true, :move => 'left', :obstacles => nil)
      ... 
    end
  end
end

Answer 1

There are 2 issues with the code from book.

1. Setting up the initializer to yield itself

When the Thing object is created, it needs an initializer and need yield itself.

class Thing
  def initialize
    yield self
  end
end

However, this alone will still causes an error, at least on my system, which is Ruby 1.9.3. Specifically, the error is ‘block given to yield (SyntaxError)’. This doesn’t make much sense, since that is what we want it to do. Regarless, that is the error I get.

2. Fixing the ‘block given to yield’ error

This is not as obvious and has something to do with either Ruby or the ‘yield’ statement, but creating a block using ‘do…end’ as was written in the book and is shown below causes the error.

yield Thing.new do |thing| 
  thing.set_status(options[:status])
end

Fixing this error is simlpy a matter of creating the block using braces, ‘{…}’, as is shown below.

yield Thing.new { |thing| 
  thing.set_status(options[:status])
}

This is not good form for multiline Ruby code, but it works.

Extra. How the series of yields works to set the parameters of the ‘Thing’ object

The problem is already fixed, but this explains how it works.

• the “caller block” calls ‘given_thing_with’ method with a parameter
• that method yields back to the “caller block” a new “Thing” and a block (I’ll call it the “yield block”)
• to execute the “yield block”, the Thing class needs the initialization and ‘yield self’, otherwise the ‘set_status’ method will never be run because the block will be ignored
• the new “Thing” is already in the “caller block” and has it’s status set and now the relevant method is executed