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
|
module RSpec
module Expectations
# @api private
# Provides methods for enabling and disabling the available
# syntaxes provided by rspec-expectations.
module Syntax
extend self
# @method should
# Passes if `matcher` returns true. Available on every `Object`.
# @example
# actual.should eq expected
# actual.should match /expression/
# @param [Matcher]
# matcher
# @param [String] message optional message to display when the expectation fails
# @return [Boolean] true if the expectation succeeds (else raises)
# @see RSpec::Matchers
# @method should_not
# Passes if `matcher` returns false. Available on every `Object`.
# @example
# actual.should_not eq expected
# @param [Matcher]
# matcher
# @param [String] message optional message to display when the expectation fails
# @return [Boolean] false if the negative expectation succeeds (else raises)
# @see RSpec::Matchers
# @method expect
# Supports `expect(actual).to matcher` syntax by wrapping `actual` in an
# `ExpectationTarget`.
# @example
# expect(actual).to eq(expected)
# expect(actual).not_to eq(expected)
# @return [ExpectationTarget]
# @see ExpectationTarget#to
# @see ExpectationTarget#not_to
# @api private
# Determines where we add `should` and `should_not`.
def default_should_host
@default_should_host ||= ::Object.ancestors.last
end
# @api private
# Enables the `should` syntax.
def enable_should(syntax_host = default_should_host)
return if should_enabled?(syntax_host)
syntax_host.module_eval do
def should(matcher=nil, message=nil, &block)
::RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
end
def should_not(matcher=nil, message=nil, &block)
::RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
end
end
::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if expect_enabled?
end
# @api private
# Disables the `should` syntax.
def disable_should(syntax_host = default_should_host)
return unless should_enabled?(syntax_host)
syntax_host.module_eval do
undef should
undef should_not
end
::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
end
# @api private
# Enables the `expect` syntax.
def enable_expect(syntax_host = ::RSpec::Matchers)
return if expect_enabled?(syntax_host)
syntax_host.module_eval do
def expect(*target, &target_block)
target << target_block if block_given?
raise ArgumentError.new("You must pass an argument or a block to #expect but not both.") unless target.size == 1
::RSpec::Expectations::ExpectationTarget.new(target.first)
end
end
::RSpec::Expectations::ExpectationTarget.enable_deprecated_should if should_enabled?
end
# @api private
# Disables the `expect` syntax.
def disable_expect(syntax_host = ::RSpec::Matchers)
return unless expect_enabled?(syntax_host)
syntax_host.module_eval do
undef expect
end
::RSpec::Expectations::ExpectationTarget.disable_deprecated_should
end
# @api private
# Indicates whether or not the `should` syntax is enabled.
def should_enabled?(syntax_host = default_should_host)
syntax_host.method_defined?(:should)
end
# @api private
# Indicates whether or not the `expect` syntax is enabled.
def expect_enabled?(syntax_host = ::RSpec::Matchers)
syntax_host.method_defined?(:expect)
end
# @api private
# Generates a positive expectation expression.
def positive_expression(target_expression, matcher_expression)
expression_generator.positive_expression(target_expression, matcher_expression)
end
# @api private
# Generates a negative expectation expression.
def negative_expression(target_expression, matcher_expression)
expression_generator.negative_expression(target_expression, matcher_expression)
end
# @api private
# Selects which expression generator to use based on the configured syntax.
def expression_generator
if expect_enabled?
ExpectExpressionGenerator
else
ShouldExpressionGenerator
end
end
# @api private
# Generates expectation expressions for the `should` syntax.
module ShouldExpressionGenerator
def self.positive_expression(target_expression, matcher_expression)
"#{target_expression}.should #{matcher_expression}"
end
def self.negative_expression(target_expression, matcher_expression)
"#{target_expression}.should_not #{matcher_expression}"
end
end
# @api private
# Generates expectation expressions for the `expect` syntax.
module ExpectExpressionGenerator
def self.positive_expression(target_expression, matcher_expression)
"expect(#{target_expression}).to #{matcher_expression}"
end
def self.negative_expression(target_expression, matcher_expression)
"expect(#{target_expression}).not_to #{matcher_expression}"
end
end
end
end
end
|
