PBI - mashing up RGL and method_missing

[Rich Morin]

Ruby Graph Language (RGL) allows graphical structures
to be modeled as collections of objects. So, you can
ask a node to iterate through its neighbors, etc.

I've been toying with ways to extend this notion, using
(say) method_missing. Here's a hand-waving example,
where "you" are assumed to be a Ruby object:

Let's say that I want to find out how many of your
neighbors have cats. Although you don't know the
answer, you do know who your neighbors are. They,
in turn, know whether they have cats. So, I send
you the following message:

count_neighbors_with_cats

Having no method of this name, you hand it off to
method_missing for parsing and such. As a result,
each of your neighbors is sent a message such as:

have_cats?

After they respond, you tally and return the results.

Obviously, this could be done without method_missing.
For example, I could send you a Ruby script to eval.
Alternatively, I could send you a YAML (or whatever)
description. Each approach has its own flexibility,
overhead, dangers, etc.

Has anyone done anything like this? I'd love to see
pointers to related work, etc.

-r
--
http://www.cfcl.com/rdm Rich Morin
http://www.cfcl.com/rdm/resume (e-mail address removed)
http://www.cfcl.com/rdm/weblog +1 650-873-7841

Technical editing and writing, programming, and web development

 

[Phil Tomson]

Ruby Graph Language (RGL) allows graphical structures
to be modeled as collections of objects. So, you can
ask a node to iterate through its neighbors, etc.

I've been toying with ways to extend this notion, using
(say) method_missing. Here's a hand-waving example,
where "you" are assumed to be a Ruby object:

Let's say that I want to find out how many of your
neighbors have cats. Although you don't know the
answer, you do know who your neighbors are. They,
in turn, know whether they have cats. So, I send
you the following message:

count_neighbors_with_cats

Having no method of this name, you hand it off to
method_missing for parsing and such. As a result,
each of your neighbors is sent a message such as:

have_cats?

After they respond, you tally and return the results.

Obviously, this could be done without method_missing.
For example, I could send you a Ruby script to eval.
Alternatively, I could send you a YAML (or whatever)
description. Each approach has its own flexibility,
overhead, dangers, etc.

Has anyone done anything like this? I'd love to see
pointers to related work, etc.

I guess I'd be inclined to do it like:

count_neighborshave_cats?)

and not use method_missing for this. method_missing is really quite nice,
but if you over-use it it can be very difficult to debug.

Phil

 

[Rich Morin]

I guess I'd be inclined to do it like:

count_neighborshave_cats?)

and not use method_missing for this.
method_missing is really quite nice,
but if you over-use it, it can be very
difficult to debug.

Why do I believe this?

Anyway, it looks like you're suggesting that I
ask the node to run the count_neighbors method,
asking each of the neighbors to run :have_cats?

This is vaguely along the lines of one approach
I've been considering, where I would send only
method names, in some hierarchical arrangement,
to be executed by the appropriate objects.

If the methods don't have side effects, it could
be a bit like functional programming. Also, by
restricting the availability of methods, I might
be able to achieve a sort of "sandbox" effect.

Speaking of which, is there a (reasonable) way to
limit the methods that are available within, say,
an eval?

-r
--
http://www.cfcl.com/rdm Rich Morin
http://www.cfcl.com/rdm/resume (e-mail address removed)
http://www.cfcl.com/rdm/weblog +1 650-873-7841

Technical editing and writing, programming, and web development

 

[Phil Tomson]

Why do I believe this?

Yes, it definitely can be difficult to debug programs which make heavy use
of method_missing (even light use in some cases ;-)

Anyway, it looks like you're suggesting that I
ask the node to run the count_neighbors method,
asking each of the neighbors to run :have_cats?

right.

This is vaguely along the lines of one approach
I've been considering, where I would send only
method names, in some hierarchical arrangement,
to be executed by the appropriate objects.

If the methods don't have side effects, it could
be a bit like functional programming. Also, by
restricting the availability of methods, I might
be able to achieve a sort of "sandbox" effect.

Speaking of which, is there a (reasonable) way to
limit the methods that are available within, say,
an eval?

Maybe playing with $SAFE ?

You might also want to look into _why's Sandbox.

Phil