Module: RSpec::Mocks::Syntax Private

Defined in:
lib/rspec/mocks/syntax.rb

Overview

This module is part of a private API. You should avoid using this module if possible, as it may be removed or be changed in the future.

Provides methods for enabling and disabling the available syntaxes provided by rspec-mocks.

Class Method Summary collapse

Class Method Details

.default_should_syntax_host ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determines where the methods like should_receive, and stub are added.



181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/rspec/mocks/syntax.rb', line 181

def self.default_should_syntax_host
  # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
  # yet `BasicObject` still exists and patching onto ::Object breaks things
  # e.g. SimpleDelegator expectations won't work
  #
  # See: https://github.com/jruby/jruby/issues/814
  if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
    return ::BasicObject
  end

  # On 1.8.7, Object.ancestors.last == Kernel but
  # things blow up if we include `RSpec::Mocks::Methods`
  # into Kernel...not sure why.
  return Object unless defined?(::BasicObject)

  # MacRuby has BasicObject but it's not the root class.
  return Object unless Object.ancestors.last == ::BasicObject

  ::BasicObject
end

.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Disables the expect syntax (expect(dbl).to receive, allow(dbl).to receive, etc).



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/rspec/mocks/syntax.rb', line 150

def self.disable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
  return unless expect_enabled?(syntax_host)

  syntax_host.class_exec do
    undef receive
    undef receive_messages
    undef receive_message_chain
    undef allow
    undef expect_any_instance_of
    undef allow_any_instance_of
  end

  RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
    undef expect
  end
end

.disable_should(syntax_host = default_should_syntax_host) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Disables the should syntax (dbl.stub, dbl.should_receive, etc).



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rspec/mocks/syntax.rb', line 89

def self.disable_should(syntax_host=default_should_syntax_host)
  return unless should_enabled?(syntax_host)

  syntax_host.class_exec do
    undef should_receive
    undef should_not_receive
    undef stub
    undef unstub
    undef stub_chain
    undef as_null_object
    undef null_object?
    undef received_message?
  end

  Class.class_exec do
    undef any_instance
  end
end

.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Enables the expect syntax (expect(dbl).to receive, allow(dbl).to receive, etc).



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
 
# File 'lib/rspec/mocks/syntax.rb', line 110

def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
  return if expect_enabled?(syntax_host)

  syntax_host.class_exec do
    def receive(method_name, &block)
      Matchers::Receive.new(method_name, block)
    end

    def receive_messages(message_return_value_hash)
      matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
      matcher.warn_about_block if block_given?
      matcher
    end

    def receive_message_chain(*messages, &block)
      Matchers::ReceiveMessageChain.new(messages, &block)
    end

    def allow(target)
      AllowanceTarget.new(target)
    end

    def expect_any_instance_of(klass)
      AnyInstanceExpectationTarget.new(klass)
    end

    def allow_any_instance_of(klass)
      AnyInstanceAllowanceTarget.new(klass)
    end
  end

  RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
    def expect(target)
      ExpectationTarget.new(target)
    end
  end
end

.enable_should(syntax_host = default_should_syntax_host) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Enables the should syntax (dbl.stub, dbl.should_receive, etc).



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
 
# File 'lib/rspec/mocks/syntax.rb', line 26

def self.enable_should(syntax_host=default_should_syntax_host)
  @warn_about_should = false if syntax_host == default_should_syntax_host
  return if should_enabled?(syntax_host)

  syntax_host.class_exec do
    def should_receive(message, opts={}, &block)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      ::RSpec::Mocks.expect_message(self, message, opts, &block)
    end

    def should_not_receive(message, &block)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      ::RSpec::Mocks.expect_message(self, message, {}, &block).never
    end

    def stub(message_or_hash, opts={}, &block)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      if ::Hash === message_or_hash
        message_or_hash.each { |message, value| stub(message).and_return value }
      else
        ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
      end
    end

    def unstub(message)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to receive(...).and_call_original` or explicitly enable `:should`")
      ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
    end

    def stub_chain(*chain, &blk)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
    end

    def as_null_object
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      @_null_object = true
      ::RSpec::Mocks.space.proxy_for(self).as_null_object
    end

    def null_object?
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      defined?(@_null_object)
    end

    def received_message?(message, *args, &block)
      ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
      ::RSpec::Mocks.space.proxy_for(self).received_message?(message, *args, &block)
    end

    unless Class.respond_to? :any_instance
      Class.class_exec do
        def any_instance
          ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
          ::RSpec::Mocks.space.any_instance_proxy_for(self)
        end
      end
    end
  end
end

.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Indicates whether or not the expect syntax is enabled.

Returns:

  • (Boolean) 


175
176
177
 
# File 'lib/rspec/mocks/syntax.rb', line 175

def self.expect_enabled?(syntax_host=::RSpec::Mocks::ExampleMethods)
  syntax_host.method_defined?(:allow)
end

.should_enabled?(syntax_host = default_should_syntax_host) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Indicates whether or not the should syntax is enabled.

Returns:

  • (Boolean) 


169
170
171
 
# File 'lib/rspec/mocks/syntax.rb', line 169

def self.should_enabled?(syntax_host=default_should_syntax_host)
  syntax_host.method_defined?(:should_receive)
end