[QUIZ] QAPrototype (#91)

[Ruby Quiz]

The three rules of Ruby Quiz:

1. Please do not post any solutions or spoiler discussion for this quiz until
48 hours have passed from the time on this message.

2. Support Ruby Quiz by submitting ideas as often as you can:

http://www.rubyquiz.com/

3. Enjoy!

Suggestion: A [QUIZ] in the subject of emails about the problem helps everyone
on Ruby Talk follow the discussion. Please reply to the original quiz message,
if you can.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

by Caleb Tennis

I remember playing with some old AI programs of which you could ask questions
and if it didn't know the answer, it would ask you what the answer is:

Hi, I'm an AI program. What's your question?

I'm afraid I don't know the answer to that. Please tell me what I should say.

Okay, I will remember that. Please ask a question.

Just fine, thanks.
Please ask another question.

This got me thinking about an interesting concept in Ruby.

Your Quiz: Write a Ruby module that can be mixed into a class. The module does
the following: upon receiving a method call that is unknown to the class, have
Ruby inform the user that it doesn't know that particular method call. Then,
have it ask the user for Ruby code as input to use for that method call the next
time it is called.

Example:

object.some_unknown_method

some_unknown_method is undefined
Please define what I should do (end with a newline):

Okay, I got it.
"The value of foo is 5"

[Editor's Note:

I envision this could actually be handy for prototyping classes IRb. Bonus
points if you can later print the source for all methods interactively defined.

--JEG2]

 

[darren kirby]

--nextPart6413066.WPbtAHqSN2
Content-Type: text/plain;
charset="iso-8859-6"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

Well, here is my solution. I kind of surprised myself at how short it is, b=
ut=20
then, there are many ways I could make this much better. The biggest proble=
m=20
is that it cannot deal with arguments to the methods. It uses a global to=20
keep track of the interactively coded methods, I just couldn't get it to wo=
rk=20
any other way. I guess this is because modules/mixins are not supposed to=20
have instance variables or keep track of their own state. The print_method=
=20
function will break if your method is a one-liner. I know I could do some=20
case-analysis to take care of this but I am a lazy, lazy man.

Here is a brief irb session demonstrating it, the code follows...
#########################################

load 'quiz91.rb'
class Test; include MethodMaker; end
test =3D Test.new
test.foobar()

No such method: foobar
Care to define foobar? (y/n) y
Enter method definition ([ctrl-d] when done):
first =3D "Ruby"
middle =3D "is teh"
last =3D "roXX0r"
puts "#{first} #{middle} #{last}"

test.foobar()

Ruby is teh roXX0r
=3D> nil

test.print_method("foobar")

def foobar
first =3D "Ruby"
middle =3D "is teh"
last =3D "roXX0r"
puts "#{first} #{middle} #{last}"
end
=3D> nil

test.another_one()

No such method: another_one
Care to define another_one? (y/n) y
Enter method definition ([ctrl-d] when done):
a =3D 4
b =3D 5
c =3D 67
return a + b + c

x =3D test.another_one() =3D> 76
x =3D> 76
test.print_method("another_one")

def another_one
a =3D 4
b =3D 5
c =3D 67
return a + b + c
end

...

#########################################

module MethodMaker
$imethods =3D Hash.new

def method_missing(method_name)
puts "No such method: #{method_name}"
# It might be a simple typo...
# so give a chance to bail out.
print "Care to define #{method_name}? (y/n) "
if $stdin.getc =3D=3D 121 # 'y'
prompt_method(method_name)
else
raise NoMethodError, "#{method_name}"
end
end

def prompt_method(name)=20
puts "Enter method definition ([ctrl-d] when done):"
meth =3D "def #{name}"
while $stdin.gets
meth +=3D $_
end
meth +=3D "end"
meth =3D meth.gsub("\n",";")
$imethods["#{name}"] =3D meth
eval meth
end

def print_method(name)
meth_Array =3D $imethods[name].split(";")
puts meth_Array[0]
meth_Array[1..meth_Array.size-2].each { |line| puts " #{line}" }
puts meth_Array[-1]
end
end

########################################

=2Dd
=2D-=20
darren kirby :: Part of the problem since 1976 :: http://badcomputer.org
"...the number of UNIX installations has grown to 10, with more expected..."
=2D Dennis Ritchie and Ken Thompson, June 1972

--nextPart6413066.WPbtAHqSN2
Content-Type: application/pgp-signature

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)

iD8DBQBE6FavwPD5Cr/3CJgRAkW/AJ9uaPau/U/4fWBwe3d06kEc75ldZwCgohkh
Tot1mYMk6/pvq2K2+QkeYi0=
=yUz5
-----END PGP SIGNATURE-----

--nextPart6413066.WPbtAHqSN2--

 

[Sander Land]

Here is my solution, it focuses on being able to use the methods you
input to patch the original file.
For inputting methods, you need to give the entire method declaration
(or any code that adds it, like attr_*).
The script automatically detects when you're done, except when you
have a syntax error (then you need to force input with "END").

An irb session:
91test.rb is a file with

require 'inputmethod.rb'
class Test
include InputMethod
end

irb -r91test.rb

irb(main):001:0> t = Test.new
irb(main):002:0> t.foo
Give the method definition for Test#foo
END to force input end, display error and return nil

def foo
bar
end

Give the method definition for Test#bar
END to force input end, display error and return nil

attr_accessor :bar

=> nil
irb(main):003:0> t.bar=42 ; t.foo
=> 42
irb(main):004:0> puts Test.patches
def foo
bar
end

attr_accessor :bar
irb(main):005:0> Test.remove_patch :foo
irb(main):006:0> t.test
Give the method definition for Test#test
END to force input end, display error and return nil

def test(x=42)

if x < 20
"smaller"
else
"greater or equal"
end
end

=> "greater or equal"
irb(main):007:0> Test.patch!
Adding methods bar,test to Test

91test.rb is now:
class Test
attr_accessor :bar

def test(x=42)

if x < 20
"smaller"
else
"greater or equal"
end
end

include InputMethod
end

Even the indent is added to fit the class definition.

Pastie: http://pastie.caboo.se/9396
Code:

require 'facets'
require 'facets/core/kernel/singleton'

class Module
public :class_variable_set, :class_variable_get # public in 1.9 (?)
end

module InputMethod
def self.included(klass)
klass.class_variable_set@@inputmethods, methods=Hash.new{|h,k| h[k]=[]})
include_point = caller.first
klass.singleton.senddefine_method,atch!) {
return if methods.empty?
_, file, line = /(.*)\\d+)/.match(include_point).to_a
puts "Adding methods #{methods.keys.join(',')} to #{klass}"
contents = File.readlines(file)

ix = line.to_i-1
indent = contents[ix][/^\s*/]
code = methods.values.join("\n").split("\n").map{|l| indent + l
}.join("\n") # add indent
contents[ix] = code + "\n\n" + contents[ix] # insert methods
before include statement
File.open(file,'w') {|f| f << contents.join }
methods.clear
}
klass.singleton.senddefine_method,atches) {
methods.values.join("\n") }
klass.singleton.senddefine_method,:remove_patch) {|m|
methods.delete m
remove_method m
}
end

def method_missing(method,*args)
print "Give the method definition for
#{self.class}\##{method}\nEND to force input end, display error and
return nil\n> ";
method_body = line = gets
begin
self.class.class_eval(method_body)
rescue SyntaxError
return puts("Syntax error: #{$!.message[/[^\:]+\Z/].lstrip}") if
line.chomp == 'END'
print '> '
method_body << line=gets
retry
end
self.class.class_variable_get@@inputmethods)[method] = method_body
send(method,*args)
end
end

 

[Matt Todd]

@Darren:

Actually, you can declare an attr in the module and it will work as an
instance variable in the class it's mixed in. For example:

module QAPrototype
attr :_methods_added
end

That's what I did.

Also, print does work with one liners, but you need to flush out the
buffer each time you print the one line with
<code>$stdout.flush</code>. (Thanks to to cool folks in #ruby-lang for
that info.)

I'm still working on my solution (I've had quite a busy weekend) but
I'm having some trouble figuring out how to remove the methods I've
added... It's odd: method_missing is called for things like
#class_eval and #remove_method. O_O So, I might be doing something
wrong just adding the methods in #instance_eval.

I'll work on it some more and post it later today.

M.T.

 

[Tim Hollingsworth]

My solution intercepts the missing method, generates the method
signature (including named arguments) and spits it back at the user.
The user fills in the body and ends with an 'end'.

The method is built as a string and simply eval'd against the
instance, producing a singleton method. The method string is also
stored in an array for later printing.

It uses the class of the given parameters as names for the method
arguments. This works up to the point where you have multiple
arguments of the same type.

example:
irb(main):004:0> o.foobar("hello", 3)
def foobar(string, fixnum)
fixnum.times {puts string}
end
=> nil
irb(main):005:0> o.foobar("hello", 3)
hello
hello
hello
=> 3
irb(main):006:0> o.moobar("goodbye")
def moobar(string)
puts string.upcase
end
=> nil
irb(main):007:0> o.moobar("goodbye")
GOODBYE
=> nil
irb(main):008:0> o.qaprint
def foobar(string, fixnum)
fixnum.times {puts string}
end

def moobar(string)
puts string.upcase
end
=> nil
irb(main):009:0>

code:

module QAPrototype

def method_missing(meth, *args)
arg_list = args.map {|arg| arg.class.to_s.downcase}.join(", ")
meth_def = "def #{meth}(#{arg_list})\n"
puts meth_def
while (line = gets) != "end\n"
meth_def += " " + line
end
meth_def += "end\n"

eval meth_def

@qamethods ||= []
@qamethods << meth_def
nil
end

def qaprint
puts @qamethods.join("\n") if @qamethods
end
end

 

[Rick DeNatale]

I've been away from e-mail for a few days. I haven't looked at anyone
elses solution yet.

Here's my initial solution which didn't take long. I expect to refine
this with more function in the next few days.

I split out the function into a separate class
MethodPrompter::Interactor, so as not to polute the "class under
training" with extra methods while allowing for modular extension of
the function.

=== method_prompter.rb ===
module MethodPrompter

class Interactor

def initialize(target_object)
@target_object = target_object
end

def prompt_for_method(symbol, *args)
puts "#{symbol} is undefined"
puts "Please define what I should do (end with
a newline):"
@method_body = []
print ">> "
while line = gets
break if line == "\n"
puts "#{line.empty?} >>#{line}<<"
@method_body << line
print ">> "
end
end

def parms_from(*args)
""
end

def make_method(symbol, *args)
method_string = "def #{symbol.to_s}
#{parms_from(args)}\n" <<
@method_body.join("\n") <<
'end'
@target_object.class.module_eval(method_string,
'line',
-1)
end
end

def method_missing(symbol, *args)
interactor = Interactor.new(self)
interactor.prompt_for_method(symbol)
interactor.make_method(symbol, args)
end

end

 

[Brent Fitzgerald]

Not as nice as Tim Hollingsworth's use of the method signature, but
oh well.

-Brent

# Example Use

irb(main):001:0> include Friendly
=> Object
irb(main):002:0> foo = bar * z
It appears that bar is undefined.
Please define what I should do (end with a blankline):
12

It appears that z is undefined.
Please define what I should do (end with a blankline):
4

=> 48
irb(main):003:0> foo
=> 48
irb(main):004:0> bar
=> 12
irb(main):005:0> z
=> 4
irb(main):006:0> added_methods
=> [:z, :bar]
irb(main):007:0> puts added_method_definitions.join("\n\n")
def z
4
end

def bar
12
end
=> nil
irb(main):008:0>

# Solution

module Friendly

def method_missing name
@_new_methods ||= Hash.new
unless @_new_methods.has_key? name
prompt_for_definition name
end
eval @_new_methods[name]
end

def prompt_for_definition name
puts "It appears that #{name} is undefined."
puts "Please define what I should do (end with a blankline):"
@_new_methods[name] = ""
while $stdin.gets !~ /^\s*$/
@_new_methods[name] << $_
end
end

def added_methods
@_new_methods.keys
end

def added_method_definitions
@_new_methods.map {|k,v|
s = "def #{k}\n "
v.rstrip!
s << v.gsub("\n", "\n ")
s << "\nend"
}
end

end

 

[darren kirby]

--nextPart64258123.GJMuTItW9Z
Content-Type: text/plain;
charset="utf-8"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

quoth the Matt Todd:

@Darren:

Actually, you can declare an attr in the module and it will work as an
instance variable in the class it's mixed in. For example:

module QAPrototype
attr :_methods_added
end

That's what I did.

Thanks for the tip. I was reading the section on mixins in the pickaxe book=
,=20
and tried doing it with an instance variable, but the code examples led me =
to=20
believe that the attribute could only be set/read within the including clas=
s=20
itself. Coupled with the fact that I was getting "No method '[]' for=20
Nil:Nilclass" (which I gather now was unrelated) I settled on the global=20
solution...

Also, print does work with one liners, but you need to flush out the
buffer each time you print the one line with
<code>$stdout.flush</code>. (Thanks to to cool folks in #ruby-lang for
that info.)

What I mean here is that after I split the string which describes the metho=
d=20
to an array for pretty printing my subscripting only works if the method=20
definition is 2+ lines of code (the 'def foo' and 'end' lines are freebies)=
,=20
to make a total of 4+... =20

An artificial limitation I know, I will fix it when I add consideration for=
=20
method args. After reading a couple other solutions it seems much easier to=
=20
add this than I had imagined.

As for #ruby-lang, I have to agree. Someone in there saved my bacon too...
Coming from more of a Python background, my first instinct to tackle this=20
problem was to overload/redefine the "NoMethodError" exception to get it to=
=20
run my code. This, of course, didn't get me far, and I was directed=20
to "method_missing".

I guess I should just read the built in/standard lib docs strait through so=
I=20
will get a sense of what all methods are available... =20

=2Dd
=2D-=20
darren kirby :: Part of the problem since 1976 :: http://badcomputer.org
"...the number of UNIX installations has grown to 10, with more expected..."
=2D Dennis Ritchie and Ken Thompson, June 1972

--nextPart64258123.GJMuTItW9Z
Content-Type: application/pgp-signature

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)

iD8DBQBE6NtvwPD5Cr/3CJgRAn5VAJwNNsO+E18aYsWnJAhN8wwdWIhf4wCdFEyJ
LyCnhUlEa7FmUITx1vpPum8=
=nr3s
-----END PGP SIGNATURE-----

--nextPart64258123.GJMuTItW9Z--

 

[darren kirby]

--nextPart2997014.aKLpvyIufQ
Content-Type: text/plain;
charset="iso-8859-6"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

Here's solution 2...

It now handles args, though somewhat poorly. If you know what you are doing=
=20
you can get around this but it will win no points for user-friendlyness. Al=
so=20
got rid of the globals, I had to put @imethods within 'method_missing'=20
itself, whether or not I used :attr_accessor

I was wrong about not printing one-liners, as I have found [1..array.size-2=
]=20
will return the middle item of a three item array, so it works just fine.=20
Ruby is smart(er than me)...

Here is irb session showing usage:
############################

load 'quiz91.rb'
class Test; include MethodMaker; end
test =3D Test.new

test.print_addressnumber, :street)

No such method: print_address
Care to define print_address? (y/n) y
Enter method definition ([ctrl-d] when done):
puts "#{number} #{street}"
=3D> nil
irb> test.print_address("Four", "Pennsylvania Plaza")
=46our Pennsylvania Plaza
=3D> nil

test.print_address(350, "Fifth Avenue")

350 Fifth Avenue
=3D> nil

test.print_name("Joe", "Ruby")

No such method: print_name=20
Care to define print_name? (y/n) n
# bail out, or else 'Joe' and 'Ruby' will be the arg names=20
NoMethodError: print_name
from ./quiz91.rb:14:in `method_missing'
from (irb):10

test.print_namefirst,:last)

No such method: print_name
Care to define print_name? (y/n) y
Enter method definition ([ctrl-d] when done):
puts "#{first} #{last}"
=3D> nil

test.print_name("Joe","Ruby")

Joe Ruby
=2E..

Code:

module MethodMaker

def method_missing(method_name, *args)
@imethods =3D {}
puts "No such method: #{method_name}"
# It might be a simple typo...
# so give a chance to bail out.
print "Care to define #{method_name}? (y/n) "
if $stdin.gets.chomp =3D=3D "y" # 'y'
prompt_method(method_name, args)
else
raise NoMethodError, "#{method_name}"
end
end

def prompt_method(name, args=3Dnil)=20
puts "Enter method definition ([ctrl-d] when done):"
meth =3D "def #{name}(#{args ? args.join(", ") : ""})"
while $stdin.gets
meth +=3D $_
end
meth +=3D "end"
meth =3D meth.gsub("\n",";")
@imethods["#{name}"] =3D meth
eval meth
end

def print_method(name)
meth_Array =3D @imethods[name].split(";")
puts meth_Array[0]
meth_Array[1..meth_Array.size-2].each { |line| puts " #{line}" }
puts meth_Array[-1]
end
end
#################################
=2Dd
=2D-=20
darren kirby :: Part of the problem since 1976 :: http://badcomputer.org
"...the number of UNIX installations has grown to 10, with more expected..."
=2D Dennis Ritchie and Ken Thompson, June 1972

--nextPart2997014.aKLpvyIufQ
Content-Type: application/pgp-signature

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.5 (GNU/Linux)

iD8DBQBE6TPWwPD5Cr/3CJgRAlMxAKCAkGDrZxZY0RSq+aRrczMwiZJG+gCgvoaM
+elIYk5Nuutv8zqHG9bUFio=
=Tfkz
-----END PGP SIGNATURE-----

--nextPart2997014.aKLpvyIufQ--