1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
# Bacon -- small RSpec clone.
module Bacon
Counter = Hash.new(0)
ErrorLog = ""
def self.result_string
"%d specifications (%d requirements), %d failures, %d errors" %
[Counter[:specifications], Counter[:requirements],
Counter[:failed], Counter[:error]]
end
class Error < RuntimeError
attr_accessor :count_as
def initialize(count_as, message)
@count_as = count_as
super message
end
end
class Context
def initialize(name, &block)
@before = []
@after = []
@name = name
puts name
instance_eval(&block)
puts
end
def before(&block); @before << block; end
def after(&block); @after << block; end
def it(description, &block)
Bacon::Counter[:requirements] += 1
run_specify description, block
end
def run_specify(description, spec)
print "- #{description}"
@before.each { |block| instance_eval(&block) }
instance_eval(&spec)
@after.each { |block| instance_eval(&block) }
rescue Object => e
if e.kind_of? Bacon::Error
puts " [#{e.count_as.to_s.upcase}]"
Bacon::Counter[e.count_as] += 1
else
puts " [ERROR: #{e.class}]"
Bacon::Counter[:errors] += 1
end
ErrorLog << "#{e.class}: #{e.message}\n"
e.backtrace.find_all { |line| line !~ /\/bacon.rb:\d+/ }.
each_with_index { |line, i|
ErrorLog << "\t#{line}#{i==0?": "+@name + " - "+description:""}\n"
}
ErrorLog << "\n"
else
puts
end
end
end
class Object
def true?; false; end
def false?; false; end
end
class TrueClass
def true?; true; end
end
class FalseClass
def false?; true; end
end
class Proc
def raise?(*exceptions)
call
rescue *(exceptions.empty? ? RuntimeError : exceptions)
true
rescue
false
else
false
end
end
class Object
def should(*args, &block)
Should.new(self).be(*args, &block)
end
def describe(name, &block)
Bacon::Counter[:specifications] += 1
Bacon::Context.new(name, &block)
end
end
class Should
# Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
# kind_of?, nil?, respond_to?, tainted?
instance_methods.each { |method|
undef_method method if method =~ /\?|^\W+$/
}
def initialize(object)
@object = object
@negated = false
end
def not
@negated = !@negated
self
end
def be(*args, &block)
case args.size
when 0
self
else
block = args.shift unless block_given?
satisfy(*args, &block)
end
end
alias a be
alias an be
def satisfy(*args, &block)
unless @negated ^ yield(@object, *args)
raise Bacon::Error.new(:failed, "")
end
Bacon::Counter[:passed] += 1
@object
end
def method_missing(name, *args, &block)
satisfy { |x|
name = "#{name}?" if name.to_s =~ /\w/
x.__send__(name, *args, &block)
}
end
end
|