Hello all,
I'm pretty new to ruby, but have some background in Java, and very little
C(++) and suchlike.
I'm currently - as a "learning-by-doing"-project - creating a simple
text-based interface for running (more or less) arbitrary programs.
I decided on a simple tree-based structure for the menu itself, however I'm
a bit stuck on the hook between my interface, and the program running behind
it.
In order to not couple my interface too tightly to my program running behind
it, I'd really like for my interface to not know what it's actually
interfacing with.
Basically, I just figured I could take a leaf from the
Functional-programming style and give my TextInterface a method to call when
I told it to:
def call_action
if(@action_method)
send(@action_method)
end
end
which works fine, as long as my method is defined "in the wild":
def foo
puts "foo called"
end
interface.set_action(:foo)
interface.call_action => foo called
but, how do I handle it if the method is an instance method on some object?
program = Program.new
interface.set_action(:program.foo)?
No variant of this works for me.
I realise I may be fundamentally wrong in my approach, so any tips would be
welcome. 
Regards,
Søren Andersen
You should pass the target object to the interface as well, and then
do "my_obj.send(an_instance_method_foo)"
···
On Oct 24, 6:31 pm, "Søren Andersen" <soren.ander...@gmail.com> wrote:
interface.set_action(:foo)
interface.call_action => foo called
but, how do I handle it if the method is an instance method on some object?
program = Program.new
interface.set_action(:program.foo)?
No variant of this works for me.
Søren Andersen wrote:
Hello all,
I told it to:
def call_action
if(@action_method)
send(@action_method)
end
end
which works fine, as long as my method is defined "in the wild":
def foo
puts "foo called"
end
interface.set_action(:foo)
interface.call_action => foo called
I'd suggest using blocks instead of the above construct. Your code
transformed:
def on_action(&block)
@action = block
end
def action
@action.call if @action
end
obj = Object.new
def obj.foo; puts "foo on #{self.inspect} called"; end
interface.on_action { obj.foo }
interface.action
# alternatively:
interface.on_action(&obj.method(:foo))
interface.action
Blocks are far more flexible than passing a method name or instance.
Regards
Stefan
···
--
Posted via http://www.ruby-forum.com/\.
Doh, ofc.
I should have figured that out myself.
Thank you!
Regards,
Søren
···
On 10/24/07, Vasyl Smirnov <vasyl.smirnov@gmail.com> wrote:
On Oct 24, 6:31 pm, "Søren Andersen" <soren.ander...@gmail.com> wrote:
> interface.set_action(:foo)
> interface.call_action => foo called
>
> but, how do I handle it if the method is an instance method on some
object?
> program = Program.new
> interface.set_action(:program.foo)?
> No variant of this works for me.
You should pass the target object to the interface as well, and then
do "my_obj.send(an_instance_method_foo)"
Thanks! I'll try this approach as well!
Regards,
Søren
···
On 10/24/07, Stefan Rusterholz <apeiros@gmx.net> wrote:
Søren Andersen wrote:
> Hello all,
>
> I told it to:
> def call_action
> if(@action_method)
> send(@action_method)
> end
> end
>
> which works fine, as long as my method is defined "in the wild":
>
> def foo
> puts "foo called"
> end
>
> interface.set_action(:foo)
> interface.call_action => foo called
I'd suggest using blocks instead of the above construct. Your code
transformed:
def on_action(&block)
@action = block
end
def action
@action.call if @action
end
obj = Object.new
def obj.foo; puts "foo on #{self.inspect} called"; end
interface.on_action { obj.foo }
interface.action
# alternatively:
interface.on_action(&obj.method(:foo))
interface.action
Blocks are far more flexible than passing a method name or instance.
Regards
Stefan