/
subject.rb
171 lines (160 loc) · 5.78 KB
/
subject.rb
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
module RSpec
module Core
module Subject
module InstanceMethods
# Returns the subject defined by the example group. The subject block is
# only executed once per example, the result of which is cached and
# returned by any subsequent calls to +subject+.
#
# If a class is passed to +describe+ and no subject is explicitly
# declared in the example group, then +subject+ will return a new
# instance of that class.
#
# == Examples
#
# # explicit subject defined by the subject method
# describe Person do
# subject { Person.new(:birthdate => 19.years.ago) }
# it "should be eligible to vote" do
# subject.should be_eligible_to_vote
# end
# end
#
# # implicit subject => { Person.new }
# describe Person do
# it "should be eligible to vote" do
# subject.should be_eligible_to_vote
# end
# end
def subject
@original_subject ||= instance_eval(&self.class.subject)
end
begin
require 'rspec/expectations/extensions/kernel'
alias_method :__should_for_example_group__, :should
alias_method :__should_not_for_example_group__, :should_not
# When +should+ is called with no explicit receiver, the call is
# delegated to the object returned by +subject+. Combined with
# an implicit subject (see +subject+), this supports very concise
# expressions.
#
# == Examples
#
# describe Person do
# it { should be_eligible_to_vote }
# end
def should(matcher=nil, message=nil)
self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message)
end
# Just like +should+, +should_not+ delegates to the subject (implicit or
# explicit) of the example group.
#
# == Examples
#
# describe Person do
# it { should_not be_eligible_to_vote }
# end
def should_not(matcher=nil, message=nil)
self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message)
end
rescue LoadError
end
end
module ClassMethods
# Creates a nested example group named by the submitted +attribute+,
# and then generates an example using the submitted block.
#
# # This ...
# describe Array do
# its(:size) { should == 0 }
# end
#
# # ... generates the same runtime structure as this:
# describe Array do
# describe "size" do
# it "should == 0" do
# subject.size.should == 0
# end
# end
# end
#
# The attribute can be a +Symbol+ or a +String+. Given a +String+
# with dots, the result is as though you concatenated that +String+
# onto the subject in an expression.
#
# describe Person do
# subject do
# Person.new.tap do |person|
# person.phone_numbers << "555-1212"
# end
# end
#
# its("phone_numbers.first") { should == "555-1212" }
# end
#
# When the subject is a +Hash+, you can refer to the Hash keys by
# specifying a +Symbol+ or +String+ in an array.
#
# describe "a configuration Hash" do
# subject do
# { :max_users => 3,
# 'admin' => :all_permissions }
# end
#
# its([:max_users]) { should == 3 }
# its(['admin']) { should == :all_permissions }
#
# # You can still access to its regular methods this way:
# its(:keys) { should include(:max_users) }
# its(:count) { should == 2 }
# end
def its(attribute, &block)
describe(attribute) do
example do
self.class.class_eval do
define_method(:subject) do
if super().is_a?(Hash) && attribute.is_a?(Array)
OpenStruct.new(super()).send(attribute.first)
else
attribute.to_s.split('.').inject(super()) do |target, method|
target.send(method)
end
end
end
end
instance_eval(&block)
end
end
end
# Defines an explicit subject for an example group which can then be the
# implicit receiver (through delegation) of calls to +should+.
#
# == Examples
#
# describe CheckingAccount, "with $50" do
# subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
# it { should have_a_balance_of(50, :USD) }
# it { should_not be_overdrawn }
# end
#
# See +ExampleMethods#should+ for more information about this approach.
def subject(&block)
block ? @explicit_subject_block = block : explicit_subject || implicit_subject
end
attr_reader :explicit_subject_block # :nodoc:
private
def explicit_subject
group = self
while group.respond_to?(:explicit_subject_block)
return group.explicit_subject_block if group.explicit_subject_block
group = group.superclass
end
end
def implicit_subject
described = describes || description
Class === described ? proc { described.new } : proc { described }
end
end
end
end
end