Update: I posted an updated version of this code sample on my projects page. The new version allows for custom contract definitions and looks a *lot* cleanerWhen I was an undergrad, I spent a summer working on
PLT Scheme. My project was to add software-enforced contracts to the
HtDP learning languages.
Using the awesome power of Scheme's hygienic macros, I was able to let students specify their own contracts in their code, and signal runtime errors when they were violated.
Anyway, on to what this post is really about: I've been teaching myself Ruby for about a week now. It has some pretty cool meta-programming features that let you write things that give you similar functionality as a macro in Scheme or Lisp would. Moreover, Ruby (like Scheme) is dynamically typed-- in other words, if I tried to pass a string into a function that expects a number, nothing will go wrong until I try to do something to it that only numbers can do. A software contracts system for Ruby would help programmers catch these bugs early. So I was thinking about this, and I wondered: "How hard would it be to build a similar system for Ruby?"
The answer: not too hard at all. There are a few systems out there that do this already, such as
the ruby-contract library, and a
proof-of-concept by Andrew Hunt
(of "Pragmatic Programmer" fame). Keeping with the hacker spirit, I decided to build a VERY simplified contract library as a to explore meta-programming in Ruby.
Here's my approach: I'll define a module Contracts, that when mixed into your class, would let you call a function 'contract' that takes two arguments: the name of the function the contract applies to and the type of its argument. Ideally, it would work this way:
# our testcase
require "contracts"
class TestContracts
extend Contracts
contract :hello, :number
def hello(x)
x.times { puts "hello!" }
end
end
t = Test_contracts.new
t.hello(2)
t.hello("asfsad")
# output:
# ruby test-contracts.rb
#hello!
#hello!
#test-contracts.rb:18: contract violation: argument of
#function 'hello' must be a(n) number (Contracts::ContractError)
Cool. Let's see if we can make it happen (it turns out I couldnt, exactly). Let's start with this contract function: It will rename the function given as its first argument to something else, and then define a new function that checks the contract and then calls the original function. For example, the above code would result in something like this being added to the TestContracts class:
# our goal
...
def hello(x)
if (x.kind_of?(Integer)) then
return __hello(x)
end
raise StandardError, "contract violation"
end
def __hello(x)
x.times { puts "hello!" }
end
...
The renaming aspect is simple: Ruby provides the "alias_method" function in the Module class that does this. Introducing the new bindings into the calling class can be accomplished by using the "class_eval" method from Module. All that is left is translating ":number" into the test for the if statement and generating the "hello" function's name, which is simple enough to do. Lets look at the resulting code:
#implementation 1
module Contracts
def contract(methodname, inputtype)
renamed = rename(methodname)
tester = parse_type(inputtype)
class_eval <<-endofeval
alias_method #{renamed.inspect}, #{methodname.inspect}
def #{methodname}(arg)
if #{tester}.call(arg) then
return #{renamed}(arg)
end
raise ContractError, "contract violation: argument of function '#{methodname}' must be a(n) #{inputtype}", caller
end
endofeval
end
class ContractError < StandardError
end
def parse_type(s)
case s
when :number then "proc {|x| x.kind_of?(Integer)}"
end
end
def rename(s)
("__" + s.id2name).intern
end
end
And everything works as planned: When contract is called, we compute the new name for the "hello" function and the test we need to call on the argument. Then using class_eval, we put all of the pieces togther, and produce code very similar to the "goal" code above.
A slight problem: If we run the test case exactly as above, we get the following error message:
./contracts.rb:6:in `class_eval': (eval):1:in `alias_method':
undefined method `hello' for class `Test_contracts' (NameError)
from (eval):1:in `class_eval'
from ./contracts.rb:6:in `class_eval'
from ./contracts.rb:6:in `contract'
from test-contracts.rb:6
??!?! But hello is right there! Actually, its not-- when the "contract" method is called, the definition of hello hasnt been executed yet... If we move the call to "contract" after the definition of "hello," the code works as we would like, and we are all happy. This probably isnt a big deal, but we would like to keep the contract call as close to the definition as possible, which is right BEFORE the definition, as in the test case.
Thankfully Ruby provides lots of hooks that let you do what you want when certain events are triggered. One of these hooks, "method_added" is run when a method defined in the class. So our new approach: when contract is called, we will store its arguments in a hash. When a method is added to the class, we check in this hash if it has a contract attached to it. If so, we call the old contract function. Here is my final implementation, which executes the test case as we wanted:
#final implementation
module Contracts
def contract(methodname, inputtype)
if not @definedcontracts
@definedcontracts = {}
end
@definedcontracts[methodname] = inputtype
end
def method_added(method)
input = @definedcontracts[method]
if input
@definedcontracts[method] = nil
contract_doit(method, input)
end
end
def contract_doit(methodname, inputtype)
renamed = rename(methodname)
tester = parse_type(inputtype)
class_eval <<-endofeval
alias_method #{renamed.inspect}, #{methodname.inspect}
def #{methodname}(arg)
if #{tester}.call(arg) then
return #{renamed}(arg)
end
raise ContractError, "contract violation: argument of function '#{methodname}' must be a(n) #{inputtype}", caller
end
endofeval
end
# ..... the rest is unchanged
end
Conclusion: We built a really simple contract checking library in Ruby to explore its cool meta-programming features. Ive been really impressed by Ruby so far-- its great to see these powerful meta-programming features in more mainstream languages.
