How is visibility of methods changed in Ruby?

public, protected, and private


class Foo
def a; end

# call 'a' with explicit 'self' as receiver
def b; self.a; end

# call 'a' with implicit 'self' as receiver
def c; a; end
end

def safe_send(receiver, method, message)
# can't use 'send' because it bypasses visibility rules
eval "receiver.#{method}"
rescue => e
puts "#{message}: #{e}"
else
puts "#{message}: succeeded"
end

visibility = ARGV.shift || "public"
Foo.send(visibility, :a)

foo = Foo.new
safe_send(foo, :a, "explicit receiver ")
safe_send(foo, :b, "explicit 'self' receiver")
safe_send(foo, :c, "implicit 'self' receiver")

Basically, the script just creates a class “Foo” with three methods: a, which we’ll invoke directly with an explicit, non-self receiver; b, which invokes a with self as receiver, and c, which invokes a with an implicit receiver of self. We’ll use the safe_send method to call each of those methods and log the result.

So, first: the public keyword. In Ruby, public means that the method may be invoked just about any way you please; in technical terms, the receiver of the message may be either explicit (“foo.bar”), self (“self.bar”) or implicit (“bar”).


$ ruby demo.rb public
explicit receiver : succeeded
explicit 'self' receiver: succeeded
implicit 'self' receiver: succeeded


The protected keyword puts a straitjacket around the method. Any method declared protected may only be called if the receiver is self, explicitly or implicitly. (Update: protected methods may actually be called any time the receiver is of the same class as ‘self’...and an explicit self as receiver is just a specific case of that. Modifying the script to demonstrate this condition is left as an exercise for the reader.)


Lastly, the private keyword is the tightest setting of all. A private method cannot be called with an explicit receiver at all, even if that receiver is “self”.