Strange OOP explanation at the beggining of the book...

[Skyblaze]

I have finished the book already but re-lokking at it i noticed that when the author explains at the beginning of the book the concepts of OOP he says that in OOP objects can interact with each other for example when an object (called the sender) sends a message (calls a method on) to another object. I don't really grasp this concept and it semms to me very strange as there isn't such a thing in OOP or rubu or rails i think. When we invoke methos we use the notation: "object.instance_method" directly in irb or in a ruby source file. Where and how we see an object that call another object's method?

[stereofrog]

Message receiver is an object whose method we're calling and message sender is an object whose method performs the call.

class Bob
	def send_message_to(other)
		other.say_hello
	end
end
 
class Alice
	def say_hello
		puts "hello"
	end
end
 
 
 
bob = Bob.new
alice = Alice.new
 
bob.send_message_to(alice)

Here bob is a sender and alice is a receiver of the message "say_hello".
Hope this helps.

[Skyblaze]

Message receiver is an object whose method we're calling and message sender is an object whose method performs the call.

class Bob
	def send_message_to(other)
		other.say_hello
	end
end
 
class Alice
	def say_hello
		puts "hello"
	end
end
 
 
 
bob = Bob.new
alice = Alice.new
 
bob.send_message_to(alice)

Here bob is a sender and alice is a receiver of the message "say_hello".
Hope this helps.

The example is ok but i think that design is less used in rails. In the book it explains it and then it never reuses it as a pratical example in the rails book application. Everytime we call a method on a object we do it directly.

[stereofrog]

Ok, I feel my example was a bit confusing... let's try another one (from rails scaffolding code):

class AdminController < ApplicationController
  def show
    @post = Post.find(params[:id])
  end
end

in "show": AdminController is a sender, Post is a receiver and "find" is a message.

[Skyblaze]

Ok, I feel my example was a bit confusing... let's try another one (from rails scaffolding code):

class AdminController < ApplicationController
  def show
    @post = Post.find(params[:id])
  end
end

in "show": AdminController is a sender, Post is a receiver and "find" is a message.

Can you explain in deatl that? Aren't both of they classes instead of objects?
You mean that when a page request is made by the browser rails instantiate the class AdminController and then call on that instance its instance method "show" as: "admin_controller_object.show"?

[stereofrog]

In pure OOP languages like ruby the boundary between classes and objects is rather blurred. 'Class' is just a special kind of 'object'.

When dispatching the request, rails instantiates a new object of class 'AdminController' and sends the message 'show' to it (= calls the method 'show' declared in the class 'AdminController'). This object (of class 'AdminController') sends the message 'find' to the class 'Post'. That message is sent directly to the class, not to any instance of it.

[Fenrir2]

This:

other.say_hello

is the same thing as this:

other.send(:say_hello)

So when you do some_object.some_method() you are sending the some_method message to some_object.

class Example
  def test
    3 + 4 # 3.+(4) == 3.send(:+, 4)
  end
end
 
e  = Example.new  # Example.send(:new)
 
# the e object sends the + message to the 3 object:
e.test # e.send(:test)

[Skyblaze]

This:

other.say_hello

is the same thing as this:

other.send(:say_hello)

So when you do some_object.some_method() you are sending the some_method message to some_object.

class Example
  def test
    3 + 4 # 3.+(4) == 3.send(:+, 4)
  end
end
 
e  = Example.new  # Example.send(:new)
 
# the e object sends the + message to the 3 object:
e.test # e.send(:test)

So in your last example first i send directly the message "test" to the "e" object variable, and then this object send the message "+" to the 3 object inside the instance method is it right the concept?
So in the end when we simply have "Object.object_method" WE are sending directly the message to the object in the source code or in irb right?

[Fenrir2]

Well, yes, but we are objects too ;-)

Array.new

Here you send the "new" message to Array. Array is a class object (i.e. the class of Array is Class). The new method isn't a keyword like in other languages. This new method first allocates memory for the object is creates, and then it calls the_new_object.initialize().

[Skyblaze]

so at the end there are many (even though a little bit hard to grasp at first) cases in which an object is the responsible to the call of another object's method and the rest is when WE are calling (send a message) directly an object's method right?

[Fenrir2]

Yes.

[Skyblaze]

one last doubt. "self" refer to the current class or object? For example in the class method definition "self.some_class_method_name" "self" refers to the current class but in a call to a method inside an action in a controller for example where we omit the receiver we are calling that method on the implicit self object right?

[Fenrir2]

Yes. Self always is the object before the dot:

object.method()

Object is self inside method().

So in YourController.class_method() => YourController is the self.

YourController.new().instance_method() => YourController is self in new(), and the return-value of new is self in instance_method().

[Skyblaze]

Yes. Self always is the object before the dot:

object.method()

Object is self inside method().

So in YourController.class_method() => YourController is the self.

YourController.new().instance_method() => YourController is self in new(), and the return-value of new is self in instance_method().

I forgot the fact that classes are also objects (of class Class)
Perfectly clear thanks