Don't pass block when calling super

Question

How can I set a block to nil for the super call?

class A
  def foo
    if block_given?
      result = yield 
      # do stuff with the yield result
    end
    # some more code
  end
end

class B < A
  def foo
    block_result = yield
    # process block results and store it
    # ...
    super
  end
end

B.new.foo { puts "block called" }
# => block called
# => block called

I don't want to yield the block twice. Is it somehow possible that block_given? in class A returns false?

Background is that I don't own the A class and I can't change it's foo method but I want to avoid calling my block twice. I also don't want to pass a dummy / empty block to super, because the behaviour of A's foo method changes when a block is given.

Answer 1

It's actually not that obvious. From the documentation we know that:

• calling super passes all arguments
• calling super() passes no arguments

What the documentation doesn't say is that this only applies to positional and keyword arguments. super() still passes a given block!

You have to explicitly unset the block by calling:

super(&nil)

How does this work?

You probably know that you can define a method with an explicit block argument:

def foo(&block)
  # ...
end

and that you can pass it as a block to another method: (that other method might be super)

def foo(&block)
  super(&block)
end

Now, if you pass a block when calling the method, the corresponding block variable will be an instance of Proc:

def foo(&block)
  p block_given: block_given?, block: block
end

foo {}
#=> {:block_given=>true, :block=>#<Proc:0x00007ff4990d0030>}

If you call it without passing block, the block variable will just be nil:

foo
#=> {:block_given=>false, :block=>nil}

So if no block is given, block is nil and

super(&block)

becomes:

super(&nil)