NOTE:
I'm not a "computer scientist".
So, I would really appreciate a revision of the text bellow by a "well
grounded rubyist", a "confident ruby"ist, a "ruby best practice"ing
one or any senior rubyist that loves this language as much as I do.
Any feedback are really welcome!

Hi Arup, (take the text bellow at your own risk ;-) )

I would disagree with you :)

Classes in Ruby are objects also.

Think of them as objects that has special methods (#new, #alocate,
#initialize) and are capable of creating other objects each one of
them being instances of its own metaclass that inherits from this
Class object.
So a Class object is kind of a "formula" to summon objects and their
metaclasses.

class Foo
  def hello
    puts "Hello from #hello instance method defined on Foo being
called at #{self}"
  end

  def hi
    puts "Hi from #hi instance method defined on Foo being called at #{self}"
  end
end

foo = Foo.new

Sfoo = foo.singleton_class

class Sfoo
  def hello
    puts "Hello from #hello instance method defined on Sfoo being
called at #{self}"
    puts "Calling super..."
    super
  end
end

# foo.hello will call the Sfoo#hello and from them it explicitly call
super that will call a method with the same name on the superclass

foo.hello

# But, if foo is an instance of Sfoo and not of Foo, how can I call #hi on foo?

foo.hi # It works

# That's because there's no #hi method defined on Sfoo

Sfoo.instance_methods(false) #=> [:hello]
Foo.instance_methods(false) #=> [:hello, :hi]

# And Foo is the superclass of Sfoo and "inherits" methods from it.

Sfoo.superclass #=> Foo

# So, If I want to know what Class object created a given object I
would call #class on it.
# That was the "formula" used to do it, and it's also the superclass
of its metaclass.

foo.class #=> Foo

# If I want to know what (real) class the object is a direct instance
of, I would call #singleton_class on it
# This is to what the "klass" pointer is really pointing.
# That's why there's two methods with the word "class" on the name ;-)

foo.singleton_class #=> #<Class:#<Foo:0x00000001fb84b0>>

There's a short video here that clarifies it a little bit.
http://drtom.ch/posts/2011/12/11/Rubys_Object_Model_and_Eigenclasses/

And the book "Metaprogramming Ruby: Program Like the Ruby Pros" by
Paolo Perrotta treats this subject pretty deeply.

Now let's wait for some feedback just to be sure there's no
misinformation in my post.

Best regards,
Abinoam Jr.

On Wed, Feb 12, 2014 at 8:44 AM, Arup Rakshit <lists / ruby-forum.com> wrote:
> Abinoam Jr. wrote in post #1136161:
>
>>
>>> My question is, how can i call a class method on a class X with
>>> X.classMethod if the method is defined on a singleton class as an
>>> instance method of that class(i am not asking how can i do it. It is
>>> what happens.).
>>
>> The method lookup chain searches first for methods defined on its
>> metaclass.
>>
>>>  It confuses me even more, because i noticed(running some tests) that
>>> the singleton class of a class is not even hierarchically related to the
>>> class it comes from,
>>
>> We could say that a class is an instance of its metaclass.
>
> Technically No. :)
>
> class Foo
>   def bar
>     12
>   end
> end
>
> singleton_klass = Foo.singleton_class
> Foo.instance_of? singleton_klass # => false
>
> *The method lookup chain searches first for methods defined on its
> metaclass.* ? Although it is correct .
>
> class Foo
>   def bar
>     12
>   end
> end
>
> foo = Foo.new
>
> def foo.bar
>   11
> end
>
> foo.bar # => 11
>
> Then how is *Or... the metaclass is "inserted" between MyClass and its
> class (Class) in the method lookup chain.* true ?
>
> --
> Posted via http://www.ruby-forum.com/.