Question

Ruby is pretty consistent about classes and objects. However, when it comes to top-level method declaration, that rule somehow breaks down. For example,

$ puts self # => main
$ puts self.class # => Object

However, the methods declared in the context of this main object are somehow available as private methods of class Object.

Is there any logical explanation for this? I understand that this is very convenient as these methods appear as “stand-alone functions”, but taking it just as “it just is so” breaks the otherwise consistent rules, as normally you have to define a method in the context of a class for it to be a method of that class. However, the main object is not class Object, nor is it a class at all.

Re-framing my question:
In what scope does the method gets declared inside ruby’s REPL? {class Object/ object main or module Kernel}

Regarding private nature of methods declared in REPL, plz see the following example:

def my_method # "a method declared in REPL"
  puts "method called"
end

# calling my_method in REPL aka top-level scope
my_method # => "method called"
[].my_method # => private method `my_method' called for []:Array (NoMethodError)
Array.my_method # => private method `my_method' called for Array:Class (NoMethodError)

Q: If my_method is defined as a private method under class Object, then why is self set to main instead of class Object. If someone says that its not under private scope, then why am I getting above mentioned error?

Answer 1

Although I’m not sure I fully understand the question, I’ll try to answer:

When you’re working inside irb you’re really working in a context like this:

class Object
  # you're here
end

So, if you declare a method inside the REPL you’re actually declaring it inside main‘s class:

ruby-1.9.3-rc1 :001 > def foo; end
 => nil 
ruby-1.9.3-rc1 :002 > self.class.public_methods.include?(:foo)
 => true 

I’m not sure where you get the idea that the methods defined there are private to the class (but again, I might be misunderstanding the question).

The class you’re inside in irb includes the Kernel module so that’s why you have access to its functions (which, since you’re inside the class, appear as stand-alone functions even though they’re regular methods):

ruby-1.9.3-rc1 :003 > self.class.included_modules
 => [Kernel] 

This would make it consistent with the typical Ruby behavior and indeed, main is just self inside the Object class.

If you call self you’ll receive main because that’s the way it’s instructed to do it through inspect. We can remove the #to_s method from self and see the real value:

ruby-1.9.3-p0 :001 > self
 => main 
ruby-1.9.3-p0 :002 > class << self; remove_method :to_s; end
 => #<Class:#<Object:0x007fc08387af00>> 
ruby-1.9.3-p0 :003 > self
 => #<Object:0x007fc08387af00 @prompt={:PROMPT_I=>"ruby-1.9.3-p0 :%03n > ", :PROMPT_S=>"ruby-1.9.3-p0 :%03n%l> ", :PROMPT_C=>"ruby-1.9.3-p0 :%03n > ", :PROMPT_N=>"ruby-1.9.3-p0 :%03n?> ", :RETURN=>" => %s \n", :AUTO_INDENT=>true}> 

Edit: Before moving forward I think you should clarify which Ruby version are you using, see the sample below for 1.9.3:

ruby-1.9.3-p0 :001 > def my_method
ruby-1.9.3-p0 :002?>     puts "method called"
ruby-1.9.3-p0 :003?> end
 => nil 
ruby-1.9.3-p0 :004 > 
ruby-1.9.3-p0 :005 >   [].my_method
method called
 => nil 
ruby-1.9.3-p0 :006 > Array.my_method 
method called