Comments on: Metaprogramming in Ruby: It’s All About the Self

By: incognitus

incognitus — Sun, 20 Dec 2009 20:36:20 +0000

s/Homo Sapien/Homo Sapiens/g; http://en.wikipedia.org/wiki/Homo_Sapiens

By: Gabe da Silveira

Gabe da Silveira — Tue, 15 Dec 2009 22:29:24 +0000

@les The reason is simple. The syntax ‘bareword = :foo’ is ALWAYS local assignment. It could conceivably do something fancy like lookup to see if a ‘bareword=’ method exists, but that would be potentially even more confusing given potential method_missing? implementations. As it is you just need to remember the one simple rule to use self for setters (and occasionally to avoid keyword conflicts).

By: Les Nightingill

Les Nightingill — Tue, 17 Nov 2009 14:54:31 +0000

Thanks, Yehuda
OK, that explains what is happening, but why? This same behaviour is not seen if I replace the setter methods with getter methods throughout.
In the case that Ruby is simply assigning to a local variable, wouldn’t you have expected it to send the method to the (implicit) self receiver?

By: wycats

wycats — Tue, 17 Nov 2009 06:26:46 +0000

@les what’s happening there is that original_some_method=(attributes) is actually setting the local variable original_some_method.

Take a look at the ripper output:

> pp Ripper::SexpBuilder.new(“original_some_method=(attributes)”).parse
[:program,
[:stmts_add,
[:stmts_new],
[:assign,
[:var_field, [:@ident, "original_some_method", [1, 0]]],
[:paren,
[:stmts_add,
[:stmts_new],
[:var_ref, [:@ident, "attributes", [1, 22]]]]]]]]

You can see that there’s an “assign” to a :var_field (local variable).

> pp Ripper::SexpBuilder.new(“self.original_some_method=(attributes)”).parse
[:program,
[:stmts_add,
[:stmts_new],
[:assign,
[:field,
[:var_ref, [:@kw, "self", [1, 0]]],
:”.”,
[:@ident, "original_some_method", [1, 5]]],
[:paren,
[:stmts_add,
[:stmts_new],
[:var_ref, [:@ident, "attributes", [1, 27]]]]]]]]

Here, there’s an “assign” to self.original_some_method.

By: Les Nightingill

Les Nightingill — Tue, 17 Nov 2009 05:56:08 +0000

Nice write-up, thanks, Yehuda.
I thought I understood it pretty well until I ran across the following. Why do you think the two calls to #original_some_method, one with and one without the explicit “self” receiver, behave differently?

class Someclass

def some_method=(attributes)
puts(“in the original method with #{attributes}”)
end

alias_method :original_some_method=, :some_method=

def some_method=(attributes)
puts(“in the new method with #{attributes}”)
original_some_method=(attributes) # the original_some_method isn’t called, fails silently
puts(“between calls to original_some_method”)
self.original_some_method=(attributes) # the original_some_method IS called, because of the explicit self receiver
end
end

p = Someclass.new
p.some_method=(“foo”)

# Result is:
# in the new method with foo
# between calls to original_some_method
# in the original method with foo

By: Jared Grippe

Jared Grippe — Tue, 17 Nov 2009 00:44:08 +0000

Thanks for the knowledge and the inspiration http://jaredgrippe.com/post/246559026/javascript-like-ruby

By: Shih-gian Lee

Shih-gian Lee — Mon, 16 Nov 2009 19:07:08 +0000

This is a nice write up and it is consistent with Dave Thomas’ screen casts on meta-programming. The additional information on instance_eval is interesting, though can be confusing sometime.

By: Rich Collins

Rich Collins — Mon, 16 Nov 2009 18:14:00 +0000

@wycats Right. That is why they are unnecessary and only confuse developers. I didn’t see this until I happened to discover Io. After learning Io I was using Ruby and had to (once again) consult Pickaxe so I could remember the details of Ruby’s complicated inheritance / lookup model. Staring at the page in the context of having recently learned a simpler way, it was easy to see that classes, metaclasses, modules, class variables instance variables (and even blocks) aren’t needed. All you really need are objects that inherit from each other, slots and messages.

By: glie

glie — Mon, 16 Nov 2009 16:47:24 +0000

Great article, thanks.

I initially got a handle on ruby’s metaclasses from Brian Marick’s partially completed book (chp 3):

http://www.visibleworkings.com/little-ruby/

A great resource

By: wycats

wycats — Mon, 16 Nov 2009 02:50:43 +0000

@yugui @banisterfiend I have updated my post to reflect that instance_eval has different behavior than the other constructs, breaking up the self into “method defined on” and “methods resolved on”. Thanks for the correction!