This is a kata. The point of a kata is not to create "implementations that would be used in the real world."

Nice :)

Thinking about it, I'm pretty sure you are right. It would only unfluence the result before the summation (0 included or not).

It seems to me that leaving the zero in does not affect the summation. Does that hold?

It would be nice to specify what do with empty keys or values. That is, should the string

foo=&bar=baz

return {"foo": "", "bar": "baz"} or just {"bar": "baz"}? I implemented the former behavior, but I have seen other solutions that do the latter. I think it would be good to have a test case that demands the one or the other.

While this solution works for free-standing functions as tested in this Kata, it would fall apart when applied to object methods. Consider this test case:

function Rectangle(width, height) {
  this.width = width;
  this.height = height;
}

Rectangle.prototype.area = function() {
  return this.width * this.height;
}

Rectangle.prototype.area = Rectangle.prototype.area.wrap(function(original) {
  return original();
});

var rect = new Rectangle(2, 4);
Test.assertEquals(rect.area(), 8);

This would fail with expected NaN to equal 8 as the solution binds this to the value it had at the time of the call to wrap, rather than to rect at the time of the call of the wrapper.

I have almost the same answer, but with an explicit return 1 if exponent == 0. The || 1 trick is pretty clever, I would never have thought of that!

has_key? is generally considered deprecated and key? is preferred. See this comment of Ruby's creator Matz.