webmock 1.11.0 → 1.12.0

data/.gitignore

@@ -26,3 +26,5 @@ pkg/*
 tmp/*
 *.rbc
 *.rbx
+.ruby-gemset
+.ruby-version

data/.travis.yml

@@ -10,9 +10,8 @@ rvm:
   - rbx-19mode
 matrix:
   allow_failures:
-    - rvm: 2.0.0
     - rvm: rbx-18mode
     - rvm: rbx-19mode
-    - rvm: jruby-19mode
+    - rvm: jruby-18mode
 
 script: "bundle exec rake && rake em_http_request_0_x_spec"

data/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+
+## 1.12.0
+
+* Not using Gem spec anymore to check loaded Curb version.
+
+* `WebMock.disable_net_connect!` now accepts array of regexps as allow param:
+
+  i.e. `WebMock.disable_net_connect!(:allow => [/google.com/, /yahoo.com/])`
+
+  Thanks to [Bastien Vaucher](https://github.com/bastien)
+
+* Fixed `on_header` Curb callback behaviour in Curb adapter
+
+  Thanks to [Joel Chippindale](https://github.com/mocoso)
+
+* Fixed aws-sdk compatibility with Ruby 2.0, by supporting `continue_timeout` accessor on Net::HTTP socket.
+
+   Thanks to [Lin Jen-Shin](https://github.com/godfat)
+
+* Fixed WebMock::Server to not give "log writing failed. can't be called from trap context" warning with Ruby 2.0
+
+   Thanks to [Murahashi Sanemat Kenichi](https://github.com/sanemat)
+
+* Added support for EM-HTTP-Request streaming data off disk feature.
+
+   Thanks to [Lin Jen-Shin](https://github.com/godfat)
+
+* Added compatibility with Minitest 5
+
+   Thanks to [Tim Kurvers](https://github.com/timkurvers)
+
+* Excon >= 0.22 compatibility.
+
+* README has nice sytnax hightlighting and fixed code styling!
+
+   Thanks to [Ilya Vassilevsky](https://github.com/vassilevsky)
+
+* Compatibility with Rails 4 `rack.session.options`
+
+   Thanks to [gotwalt](https://github.com/gotwalt)
+
 ## 1.11.0
 
 * Excon >= 0.17 support.
@@ -57,7 +98,7 @@
 
 * Fixed issues with registering http requests in multi-threaded environments
 
-  Thanks to [Travis Beauvais](https://github.com/tbeauvais)
+  Thanks to [Tom Beauvais](https://github.com/tbeauvais)
 
 * Bumped Crack version to >=0.3.2
 

data/Gemfile

@@ -14,8 +14,9 @@ end
 
 group :test do
   gem 'rack'
+  gem 'minitest_tu_shim'
 end
 
 platforms :jruby do
-  gem 'jruby-openssl', '~> 0.7.7'
+  gem 'jruby-openssl'
 end

data/README.md

@@ -29,11 +29,11 @@ Supported HTTP libraries
 Supported Ruby Interpreters
 ---------------------------
 
-* MRI 1.8.6
 * MRI 1.8.7
 * MRI 1.9.1
 * MRI 1.9.2
 * MRI 1.9.3
+* MRI 2.0.0
 * REE 1.8.7
 * JRuby
 * Rubinius
@@ -52,32 +52,42 @@ Supported Ruby Interpreters
 
 Add the following code to `test/test_helper.rb`
 
-    require 'webmock/test_unit'
+```ruby
+require 'webmock/test_unit'
+```
 
 ### RSpec
 
 Add the following code to `spec/spec_helper`:
 
-    require 'webmock/rspec'
+```ruby
+require 'webmock/rspec'
+```
 
 ### MiniTest
 
 Add the following code to `test/test_helper`:
 
-    require 'webmock/minitest'
+```ruby
+require 'webmock/minitest'
+```
 
 ### Cucumber
 
-Add the following code to `features/support/env.rb`
+Create a file `features/support/webmock.rb` with the following contents:
 
-    require 'webmock/cucumber'
+```ruby
+require 'webmock/cucumber'
+```
 
 ### Outside a test framework
 
 You can also use WebMock outside a test framework:
 
-    require 'webmock'
-    include WebMock::API
+```ruby
+require 'webmock'
+include WebMock::API
+```
 
 ## Examples
 
@@ -88,268 +98,342 @@ You can also use WebMock outside a test framework:
 
 ### Stubbed request based on uri only and with the default response
 
-     stub_request(:any, "www.example.com")
+```ruby
+stub_request(:any, "www.example.com")
 
-     Net::HTTP.get("www.example.com", "/")    # ===> Success
+Net::HTTP.get("www.example.com", "/")    # ===> Success
+```
 
 ### Stubbing requests based on method, uri, body and headers
 
-    stub_request(:post, "www.example.com").with(:body => "abc", :headers => { 'Content-Length' => 3 })
+```ruby
+stub_request(:post, "www.example.com").with(:body => "abc", :headers => { 'Content-Length' => 3 })
 
-    uri = URI.parse("http://www.example.com/")
-    req = Net::HTTP::Post.new(uri.path)
-    req['Content-Length'] = 3
-    res = Net::HTTP.start(uri.host, uri.port) {|http|
-      http.request(req, "abc")
-    }    # ===> Success
+uri = URI.parse("http://www.example.com/")
+req = Net::HTTP::Post.new(uri.path)
+req['Content-Length'] = 3
+
+res = Net::HTTP.start(uri.host, uri.port) do |http|
+  http.request(req, "abc")
+end    # ===> Success
+```
 
 ### Matching request body and headers against regular expressions
 
-    stub_request(:post, "www.example.com").
-      with(:body => /^.*world$/, :headers => {"Content-Type" => /image\/.+/}).to_return(:body => "abc")
+```ruby
+stub_request(:post, "www.example.com").
+  with(:body => /^.*world$/, :headers => {"Content-Type" => /image\/.+/}).to_return(:body => "abc")
+
+uri = URI.parse('http://www.example.com/')
+req = Net::HTTP::Post.new(uri.path)
+req['Content-Type'] = 'image/png'
 
-    uri = URI.parse('http://www.example.com/')
-    req = Net::HTTP::Post.new(uri.path)
-    req['Content-Type'] = 'image/png'
-    res = Net::HTTP.start(uri.host, uri.port) {|http|
-      http.request(req, 'hello world')
-    }    # ===> Success
+res = Net::HTTP.start(uri.host, uri.port) do |http|
+  http.request(req, 'hello world')
+end    # ===> Success
+```
 
 ### Matching request body against a hash. Body can be URL-Encoded, JSON or XML.
 
-    stub_http_request(:post, "www.example.com").
-        with(:body => {:data => {:a => '1', :b => 'five'}})
+```ruby
+stub_http_request(:post, "www.example.com").
+  with(:body => {:data => {:a => '1', :b => 'five'}})
 
-    RestClient.post('www.example.com', "data[a]=1&data[b]=five",
-      :content_type => 'application/x-www-form-urlencoded')    # ===> Success
+RestClient.post('www.example.com', "data[a]=1&data[b]=five",
+  :content_type => 'application/x-www-form-urlencoded')    # ===> Success
 
-    RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}',
-      :content_type => 'application/json')    # ===> Success
+RestClient.post('www.example.com', '{"data":{"a":"1","b":"five"}}',
+  :content_type => 'application/json')    # ===> Success
 
-    RestClient.post('www.example.com', '<data a="1" b="five" />',
-      :content_type => 'application/xml' )    # ===> Success
+RestClient.post('www.example.com', '<data a="1" b="five" />',
+  :content_type => 'application/xml')    # ===> Success
+```
 
 ### Matching request body against partial hash.
 
-    stub_http_request(:post, "www.example.com").
-            with(:body => hash_including({:data => {:a => '1', :b => 'five'}}))
+```ruby
+stub_http_request(:post, "www.example.com").
+  with(:body => hash_including({:data => {:a => '1', :b => 'five'}}))
 
-    RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
-    :content_type => 'application/x-www-form-urlencoded')    # ===> Success
+RestClient.post('www.example.com', "data[a]=1&data[b]=five&x=1",
+:content_type => 'application/x-www-form-urlencoded')    # ===> Success
+```
 
 ### Matching custom request headers
 
-    stub_request(:any, "www.example.com").with(:headers=>{ 'Header-Name' => 'Header-Value' })
+```ruby
+stub_request(:any, "www.example.com").with(:headers=>{ 'Header-Name' => 'Header-Value' })
+
+uri = URI.parse('http://www.example.com/')
+req = Net::HTTP::Post.new(uri.path)
+req['Header-Name'] = 'Header-Value'
 
-    uri = URI.parse('http://www.example.com/')
-    req = Net::HTTP::Post.new(uri.path)
-    req['Header-Name'] = 'Header-Value'
-    res = Net::HTTP.start(uri.host, uri.port) {|http|
-      http.request(req, 'abc')
-    }    # ===> Success
+res = Net::HTTP.start(uri.host, uri.port) do |http|
+  http.request(req, 'abc')
+end    # ===> Success
+```
 
 ### Matching multiple headers with the same name
 
-    stub_http_request(:get, 'www.example.com').with(:headers => {'Accept' => ['image/jpeg', 'image/png'] })
+```ruby
+stub_http_request(:get, 'www.example.com').with(:headers => {'Accept' => ['image/jpeg', 'image/png'] })
 
-    req = Net::HTTP::Get.new("/")
-    req['Accept'] = ['image/png']
-    req.add_field('Accept', 'image/jpeg')
-    Net::HTTP.start("www.example.com") {|http|  http.request(req) } # ===> Success
+req = Net::HTTP::Get.new("/")
+req['Accept'] = ['image/png']
+req.add_field('Accept', 'image/jpeg')
+Net::HTTP.start("www.example.com") {|http| http.request(req) }    # ===> Success
+```
 
 ### Matching requests against provided block
 
-    stub_request(:post, "www.example.com").with { |request| request.body == "abc" }
-    RestClient.post('www.example.com', 'abc')    # ===> Success
+```ruby
+stub_request(:post, "www.example.com").with { |request| request.body == "abc" }
+RestClient.post('www.example.com', 'abc')    # ===> Success
+```
 
 ### Request with basic authentication
 
-    stub_request(:get, "user:pass@www.example.com")
+```ruby
+stub_request(:get, "user:pass@www.example.com")
 
-    Net::HTTP.start('www.example.com') {|http|
-      req = Net::HTTP::Get.new('/')
-      req.basic_auth 'user', 'pass'
-      http.request(req)
-    }  # ===> Success
+Net::HTTP.start('www.example.com') {|http|
+  req = Net::HTTP::Get.new('/')
+  req.basic_auth 'user', 'pass'
+  http.request(req)
+}    # ===> Success
+```
 
 ### Matching uris using regular expressions
 
-     stub_request(:any, /.*example.*/)
+```ruby
+stub_request(:any, /.*example.*/)
 
-     Net::HTTP.get('www.example.com', '/') # ===> Success
+Net::HTTP.get('www.example.com', '/')    # ===> Success
+```
 
 ### Matching query params using hash
 
-     stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
+```ruby
+stub_http_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
 
-     RestClient.get("http://www.example.com/?a[]=b&a[]=c") # ===> Success
+RestClient.get("http://www.example.com/?a[]=b&a[]=c")    # ===> Success
+```
 
 ### Matching partial query params using hash
 
-    stub_http_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))
+```ruby
+stub_http_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))
 
-    RestClient.get("http://www.example.com/?a[]=b&a[]=c&x=1") # ===> Success
+RestClient.get("http://www.example.com/?a[]=b&a[]=c&x=1")    # ===> Success
+```
 
 ### Stubbing with custom response
 
-    stub_request(:any, "www.example.com").to_return(:body => "abc", :status => 200,  :headers => { 'Content-Length' => 3 } )
+```ruby
+stub_request(:any, "www.example.com").
+  to_return(:body => "abc", :status => 200, :headers => { 'Content-Length' => 3 })
 
-    Net::HTTP.get("www.example.com", '/')    # ===> "abc"
+Net::HTTP.get("www.example.com", '/')    # ===> "abc"
+```
 
 ### Response with body specified as IO object
 
-    File.open('/tmp/response_body.txt', 'w') { |f| f.puts 'abc' }
+```ruby
+File.open('/tmp/response_body.txt', 'w') { |f| f.puts 'abc' }
 
-    stub_request(:any, "www.example.com").to_return(:body => File.new('/tmp/response_body.txt'), :status => 200)
+stub_request(:any, "www.example.com").
+  to_return(:body => File.new('/tmp/response_body.txt'), :status => 200)
 
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+```
 
 ### Response with custom status message
 
-    stub_request(:any, "www.example.com").to_return(:status => [500, "Internal Server Error"])
+```ruby
+stub_request(:any, "www.example.com").to_return(:status => [500, "Internal Server Error"])
 
-    req = Net::HTTP::Get.new("/")
-    Net::HTTP.start("www.example.com") { |http| http.request(req) }.message # ===> "Internal Server Error"
+req = Net::HTTP::Get.new("/")
+Net::HTTP.start("www.example.com") {|http| http.request(req)}.message    # ===> "Internal Server Error"
+```
 
 ### Replaying raw responses recorded with `curl -is`
 
     `curl -is www.example.com > /tmp/example_curl_-is_output.txt`
-    raw_response_file = File.new("/tmp/example_curl_-is_output.txt")
+```ruby
+raw_response_file = File.new("/tmp/example_curl_-is_output.txt")
+```
 
    from file
 
-    stub_request(:get, "www.example.com").to_return(raw_response_file)
+```ruby
+stub_request(:get, "www.example.com").to_return(raw_response_file)
+```
 
    or string
 
-    stub_request(:get, "www.example.com").to_return(raw_response_file.read)
+```ruby
+stub_request(:get, "www.example.com").to_return(raw_response_file.read)
+```
 
 ### Responses dynamically evaluated from block
 
-    stub_request(:any, 'www.example.net').
-      to_return { |request| {:body => request.body} }
+```ruby
+stub_request(:any, 'www.example.net').
+  to_return { |request| {:body => request.body} }
 
-    RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+```
 
 ### Responses dynamically evaluated from lambda
 
-    stub_request(:any, 'www.example.net').
-      to_return(lambda { |request| {:body => request.body} })
+```ruby
+stub_request(:any, 'www.example.net').
+  to_return(lambda { |request| {:body => request.body} })
 
-    RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+```
 
 ### Dynamically evaluated raw responses recorded with `curl -is`
 
     `curl -is www.example.com > /tmp/www.example.com.txt`
-    stub_request(:get, "www.example.com").to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt" }))
+```ruby
+stub_request(:get, "www.example.com").
+  to_return(lambda { |request| File.new("/tmp/#{request.uri.host.to_s}.txt" }))
+```
 
 ### Responses with dynamically evaluated parts
 
-    stub_request(:any, 'www.example.net').
-      to_return(:body => lambda { |request| request.body })
+```ruby
+stub_request(:any, 'www.example.net').
+  to_return(:body => lambda { |request| request.body })
 
-    RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+RestClient.post('www.example.net', 'abc')    # ===> "abc\n"
+```
 
 ### Rack responses
 
-    class MyRackApp
-      def self.call(env)
-        [200, {}, ["Hello"]]
-      end
-    end
+```ruby
+class MyRackApp
+  def self.call(env)
+    [200, {}, ["Hello"]]
+  end
+end
 
-    stub_request(:get, "www.example.com").to_rack(MyRackApp)
+stub_request(:get, "www.example.com").to_rack(MyRackApp)
 
-    RestClient.post('www.example.com')    # ===> "Hello"
+RestClient.post('www.example.com')    # ===> "Hello"
+```
 
 ### Raising errors
 
 #### Exception declared by class
 
-    stub_request(:any, 'www.example.net').to_raise(StandardError)
+```ruby
+stub_request(:any, 'www.example.net').to_raise(StandardError)
 
-    RestClient.post('www.example.net', 'abc')    # ===> StandardError
+RestClient.post('www.example.net', 'abc')    # ===> StandardError
+```
 
 #### or by exception instance
 
-    stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
+```ruby
+stub_request(:any, 'www.example.net').to_raise(StandardError.new("some error"))
+```
 
 #### or by string
 
-    stub_request(:any, 'www.example.net').to_raise("some error")
+```ruby
+stub_request(:any, 'www.example.net').to_raise("some error")
+```
 
 ### Raising timeout errors
 
-    stub_request(:any, 'www.example.net').to_timeout
+```ruby
+stub_request(:any, 'www.example.net').to_timeout
 
-    RestClient.post('www.example.net', 'abc')    # ===> RestClient::RequestTimeout
+RestClient.post('www.example.net', 'abc')    # ===> RestClient::RequestTimeout
+```
 
 ### Multiple responses for repeated requests
 
-    stub_request(:get, "www.example.com").to_return({:body => "abc"}, {:body => "def"})
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
-    Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+```ruby
+stub_request(:get, "www.example.com").to_return({:body => "abc"}, {:body => "def"})
+Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
 
-    #after all responses are used the last response will be returned infinitely
+#after all responses are used the last response will be returned infinitely
 
-    Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+```
 
 ### Multiple responses using chained `to_return()`, `to_raise()` or `to_timeout` declarations
 
-    stub_request(:get, "www.example.com").
-        to_return({:body => "abc"}).then.  #then() is just a syntactic sugar
-        to_return({:body => "def"}).then.
-        to_raise(MyException)
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
-    Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
-    Net::HTTP.get('www.example.com', '/')    # ===> MyException raised
+```ruby
+stub_request(:get, "www.example.com").
+  to_return({:body => "abc"}).then.  #then() is just a syntactic sugar
+  to_return({:body => "def"}).then.
+  to_raise(MyException)
 
-### Specifying number of times given response should be returned
+Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+Net::HTTP.get('www.example.com', '/')    # ===> MyException raised
+```
 
-    stub_request(:get, "www.example.com").
-        to_return({:body => "abc"}).times(2).then.
-        to_return({:body => "def"})
+### Specifying number of times given response should be returned
 
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
-    Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+```ruby
+stub_request(:get, "www.example.com").
+  to_return({:body => "abc"}).times(2).then.
+  to_return({:body => "def"})
 
+Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "abc\n"
+Net::HTTP.get('www.example.com', '/')    # ===> "def\n"
+```
 
 ### Real requests to network can be allowed or disabled
 
-    WebMock.allow_net_connect!
+```ruby
+WebMock.allow_net_connect!
 
-    stub_request(:any, "www.example.com").to_return(:body => "abc")
+stub_request(:any, "www.example.com").to_return(:body => "abc")
 
-    Net::HTTP.get('www.example.com', '/')    # ===> "abc"
+Net::HTTP.get('www.example.com', '/')    # ===> "abc"
 
-    Net::HTTP.get('www.something.com', '/') # ===> /.+Something.+/
+Net::HTTP.get('www.something.com', '/')    # ===> /.+Something.+/
 
-    WebMock.disable_net_connect!
+WebMock.disable_net_connect!
 
-    Net::HTTP.get('www.something.com', '/')    # ===> Failure
+Net::HTTP.get('www.something.com', '/')    # ===> Failure
+```
 
 ### External requests can be disabled while allowing localhost
 
-    WebMock.disable_net_connect!(:allow_localhost => true)
+```ruby
+WebMock.disable_net_connect!(:allow_localhost => true)
 
-    Net::HTTP.get('www.something.com', '/')   # ===> Failure
+Net::HTTP.get('www.something.com', '/')    # ===> Failure
 
-    Net::HTTP.get('localhost:9887', '/')      # ===> Allowed. Perhaps to Selenium?
+Net::HTTP.get('localhost:9887', '/')    # ===> Allowed. Perhaps to Selenium?
+```
 
 ### External requests can be disabled while allowing any hostname or port or parts thereof
 
-    WebMock.disable_net_connect!(:allow => "www.example.org:8080")
+```ruby
+WebMock.disable_net_connect!(:allow => "www.example.org:8080")
+
+RestClient.get('www.something.com', '/')    # ===> Failure
 
-    RestClient.get('www.something.com', '/')   # ===> Failure
+RestClient.get('www.example.org', '/')    # ===> Failure.
 
-    RestClient.get('www.example.org', '/')     # ===> Failure.
+RestClient.get('www.example.org:8080', '/')    # ===> Allowed
 
-    RestClient.get('www.example.org:8080', '/')     # ===> Allowed
+WebMock.disable_net_connect!(:allow => /ample.org/)
 
-    WebMock.disable_net_connect!(:allow => /ample.org/)
+WebMock.disable_net_connect!(:allow => [/ample.org/, /googl/])
 
-    RestClient.get('www.example.org', '/')   # ===> Allowed
+RestClient.get('www.example.org', '/')    # ===> Allowed
+```
 
 ## Connecting on Net::HTTP.start
 
@@ -366,112 +450,136 @@ so when there is no request, `Net::HTTP.start` doesn't do anything.
 To workaround this issue, WebMock offers `:net_http_connect_on_start` option,
 which can be passed to `WebMock.allow_net_connect!` and `WebMock#disable_net_connect!` methods, i.e.
 
-    WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+```ruby
+WebMock.allow_net_connect!(:net_http_connect_on_start => true)
+```
 
 This forces WebMock Net::HTTP adapter to always connect on `Net::HTTP.start`.
 
 ## Setting Expectations
 
 ### Setting expectations in Test::Unit
-    require 'webmock/test_unit'
 
-    stub_request(:any, "www.example.com")
+```ruby
+require 'webmock/test_unit'
 
-    uri = URI.parse('http://www.example.com/')
-    req = Net::HTTP::Post.new(uri.path)
-    req['Content-Length'] = 3
-    res = Net::HTTP.start(uri.host, uri.port) {|http|
-      http.request(req, 'abc')
-    }
+stub_request(:any, "www.example.com")
 
-    assert_requested :post, "http://www.example.com",
-      :headers => {'Content-Length' => 3}, :body => "abc", :times => 1    # ===> Success
+uri = URI.parse('http://www.example.com/')
+req = Net::HTTP::Post.new(uri.path)
+req['Content-Length'] = 3
 
-    assert_not_requested :get, "http://www.something.com"    # ===> Success
+res = Net::HTTP.start(uri.host, uri.port) do |http|
+  http.request(req, 'abc')
+end
 
-    assert_requested(:post, "http://www.example.com", :times => 1) { |req| req.body == "abc" }
+assert_requested :post, "http://www.example.com",
+  :headers => {'Content-Length' => 3}, :body => "abc", :times => 1    # ===> Success
+
+assert_not_requested :get, "http://www.something.com"    # ===> Success
+
+assert_requested(:post, "http://www.example.com", :times => 1) { |req| req.body == "abc" }
+```
 
 ### Expecting real (not stubbed) requests
 
-    WebMock.allow_net_connect!
+```ruby
+WebMock.allow_net_connect!
 
-    Net::HTTP.get('www.example.com', '/')    # ===> Success
+Net::HTTP.get('www.example.com', '/')    # ===> Success
 
-    assert_requested :get, "http://www.example.com"    # ===> Success
+assert_requested :get, "http://www.example.com"    # ===> Success
+```
 
 ### Setting expectations in Test::Unit on the stub
 
-    stub_get = stub_request(:get, "www.example.com")
-    stub_post = stub_request(:post, "www.example.com")
+```ruby
+stub_get = stub_request(:get, "www.example.com")
+stub_post = stub_request(:post, "www.example.com")
 
-    Net::HTTP.get('www.example.com', '/')
+Net::HTTP.get('www.example.com', '/')
 
-    assert_requested(stub_get)
-    assert_not_requested(stub_post)
+assert_requested(stub_get)
+assert_not_requested(stub_post)
+```
 
 
 ### Setting expectations in RSpec on `WebMock` module
  This style is borrowed from [fakeweb-matcher](http://github.com/freelancing-god/fakeweb-matcher)
 
-    require 'webmock/rspec'
+```ruby
+require 'webmock/rspec'
 
-    WebMock.should have_requested(:get, "www.example.com").with(:body => "abc", :headers => {'Content-Length' => 3}).twice
+WebMock.should have_requested(:get, "www.example.com").
+  with(:body => "abc", :headers => {'Content-Length' => 3}).twice
 
-    WebMock.should_not have_requested(:get, "www.something.com")
+WebMock.should_not have_requested(:get, "www.something.com")
 
-    WebMock.should have_requested(:post, "www.example.com").with { |req| req.body == "abc" }
+WebMock.should have_requested(:post, "www.example.com").with { |req| req.body == "abc" }
 
-    WebMock.should have_requested(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
+WebMock.should have_requested(:get, "www.example.com").with(:query => {"a" => ["b", "c"]})
 
-    WebMock.should have_requested(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]}))
+WebMock.should have_requested(:get, "www.example.com").
+  with(:query => hash_including({"a" => ["b", "c"]}))
 
-    WebMock.should have_requested(:get, "www.example.com").
-      with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'})
+WebMock.should have_requested(:get, "www.example.com").
+  with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'})
+```
 
 ### Setting expectations in RSpec with `a_request`
 
-    a_request(:post, "www.example.com").with(:body => "abc", :headers => {'Content-Length' => 3}).should have_been_made.once
+```ruby
+a_request(:post, "www.example.com").
+  with(:body => "abc", :headers => {'Content-Length' => 3}).should have_been_made.once
 
-    a_request(:post, "www.something.com").should have_been_made.times(3)
+a_request(:post, "www.something.com").should have_been_made.times(3)
 
-    a_request(:any, "www.example.com").should_not have_been_made
+a_request(:any, "www.example.com").should_not have_been_made
 
-    a_request(:post, "www.example.com").with { |req| req.body == "abc" }.should have_been_made
+a_request(:post, "www.example.com").with { |req| req.body == "abc" }.should have_been_made
 
-    a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
+a_request(:get, "www.example.com").with(:query => {"a" => ["b", "c"]}).should have_been_made
 
-    a_request(:get, "www.example.com").with(:query => hash_including({"a" => ["b", "c"]})).should have_been_made
+a_request(:get, "www.example.com").
+  with(:query => hash_including({"a" => ["b", "c"]})).should have_been_made
 
-    a_request(:post, "www.example.com").
-      with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'}).should have_been_made
+a_request(:post, "www.example.com").
+  with(:body => {"a" => ["b", "c"]}, :headers => {'Content-Type' => 'application/json'}).
+  should have_been_made
+```
 
 ### Setting expectations in RSpec on the stub
 
-    stub = stub_request(:get, "www.example.com")
-    # ... make requests ...
-    stub.should have_been_requested
+```ruby
+stub = stub_request(:get, "www.example.com")
+# ... make requests ...
+stub.should have_been_requested
+```
 
 ## Clearing stubs and request history
 
 If you want to reset all current stubs and history of requests use `WebMock.reset!`
 
-    stub_request(:any, "www.example.com")
+```ruby
+stub_request(:any, "www.example.com")
 
-    Net::HTTP.get('www.example.com', '/')    # ===> Success
+Net::HTTP.get('www.example.com', '/')    # ===> Success
 
-    WebMock.reset!
+WebMock.reset!
 
-    Net::HTTP.get('www.example.com', '/')    # ===> Failure
+Net::HTTP.get('www.example.com', '/')    # ===> Failure
 
-    assert_not_requested :get, "www.example.com"    # ===> Success
+assert_not_requested :get, "www.example.com"    # ===> Success
+```
 
 ## Disabling and enabling WebMock or only some http client adapters
 
-    WebMock.disable!                         #disable WebMock (all adapters)
-    WebMock.disable!(:except => [:net_http]) #disable WebMock for all libs except Net::HTTP
-    WebMock.enable!                          #enable WebMock (all adapters)
-    WebMock.enable!(:except => [:patron])    #enable WebMock for all libs except Patron
-
+```ruby
+WebMock.disable!                         #disable WebMock (all adapters)
+WebMock.disable!(:except => [:net_http]) #disable WebMock for all libs except Net::HTTP
+WebMock.enable!                          #enable WebMock (all adapters)
+WebMock.enable!(:except => [:patron])    #enable WebMock for all libs except Patron
+```
 
 ## Matching requests
 
@@ -487,10 +595,12 @@ An executed request matches stubbed request if it passes following criteria:
 
 Always the last declared stub matching the request will be applied i.e:
 
-    stub_request(:get, "www.example.com").to_return(:body => "abc")
-    stub_request(:get, "www.example.com").to_return(:body => "def")
+```ruby
+stub_request(:get, "www.example.com").to_return(:body => "abc")
+stub_request(:get, "www.example.com").to_return(:body => "def")
 
-    Net::HTTP.get('www.example.com', '/')   # ====> "def"
+Net::HTTP.get('www.example.com', '/')    # ====> "def"
+```
 
 ## Matching URIs
 
@@ -498,51 +608,55 @@ WebMock will match all different representations of the same URI.
 
 I.e all the following representations of the URI are equal:
 
-    "www.example.com"
-    "www.example.com/"
-    "www.example.com:80"
-    "www.example.com:80/"
-    "http://www.example.com"
-    "http://www.example.com/"
-    "http://www.example.com:80"
-    "http://www.example.com:80/"
+```ruby
+"www.example.com"
+"www.example.com/"
+"www.example.com:80"
+"www.example.com:80/"
+"http://www.example.com"
+"http://www.example.com/"
+"http://www.example.com:80"
+"http://www.example.com:80/"
+```
 
 The following URIs with basic authentication are also equal for WebMock
 
-    "a b:pass@www.example.com"
-    "a b:pass@www.example.com/"
-    "a b:pass@www.example.com:80"
-    "a b:pass@www.example.com:80/"
-    "http://a b:pass@www.example.com"
-    "http://a b:pass@www.example.com/"
-    "http://a b:pass@www.example.com:80"
-    "http://a b:pass@www.example.com:80/"
-    "a%20b:pass@www.example.com"
-    "a%20b:pass@www.example.com/"
-    "a%20b:pass@www.example.com:80"
-    "a%20b:pass@www.example.com:80/"
-    "http://a%20b:pass@www.example.com"
-    "http://a%20b:pass@www.example.com/"
-    "http://a%20b:pass@www.example.com:80"
-    "http://a%20b:pass@www.example.com:80/"
+```ruby
+"a b:pass@www.example.com"
+"a b:pass@www.example.com/"
+"a b:pass@www.example.com:80"
+"a b:pass@www.example.com:80/"
+"http://a b:pass@www.example.com"
+"http://a b:pass@www.example.com/"
+"http://a b:pass@www.example.com:80"
+"http://a b:pass@www.example.com:80/"
+"a%20b:pass@www.example.com"
+"a%20b:pass@www.example.com/"
+"a%20b:pass@www.example.com:80"
+"a%20b:pass@www.example.com:80/"
+"http://a%20b:pass@www.example.com"
+"http://a%20b:pass@www.example.com/"
+"http://a%20b:pass@www.example.com:80"
+"http://a%20b:pass@www.example.com:80/"
+```
 
 or these
 
-    "www.example.com/my path/?a=my param&b=c"
-    "www.example.com/my%20path/?a=my%20param&b=c"
-    "www.example.com:80/my path/?a=my param&b=c"
-    "www.example.com:80/my%20path/?a=my%20param&b=c"
-    "http://www.example.com/my path/?a=my param&b=c"
-    "http://www.example.com/my%20path/?a=my%20param&b=c"
-    "http://www.example.com:80/my path/?a=my param&b=c"
-    "http://www.example.com:80/my%20path/?a=my%20param&b=c"
-
+```ruby
+"www.example.com/my path/?a=my param&b=c"
+"www.example.com/my%20path/?a=my%20param&b=c"
+"www.example.com:80/my path/?a=my param&b=c"
+"www.example.com:80/my%20path/?a=my%20param&b=c"
+"http://www.example.com/my path/?a=my param&b=c"
+"http://www.example.com/my%20path/?a=my%20param&b=c"
+"http://www.example.com:80/my path/?a=my param&b=c"
+"http://www.example.com:80/my%20path/?a=my%20param&b=c"
+```
 
 If you provide Regexp to match URI, WebMock will try to match it against every valid form of the same url.
 
 I.e `/.*my param.*/` will match `www.example.com/my%20path` because it is equivalent of `www.example.com/my path`
 
-
 ## Matching headers
 
 WebMock will match request headers against stubbed request headers in the following situations:
@@ -571,15 +685,19 @@ To record your application's real HTTP interactions and replay them later in tes
 
 ####WebMock can invoke callbacks stubbed or real requests:
 
-    WebMock.after_request do |request_signature, response|
-      puts "Request #{request_signature} was made and #{response} was returned"
-    end
+```ruby
+WebMock.after_request do |request_signature, response|
+  puts "Request #{request_signature} was made and #{response} was returned"
+end
+```
 
 #### invoke callbacks for real requests only and except requests made with Patron
 
-    WebMock.after_request(:except => [:patron], :real_requests_only => true)  do |request_signature, response|
-      puts "Request #{request_signature} was made and #{response} was returned"
-    end
+```ruby
+WebMock.after_request(:except => [:patron], :real_requests_only => true) do |req_signature, response|
+  puts "Request #{req_signature} was made and #{response} was returned"
+end
+```
 
 ## Bugs and Issues
 
@@ -718,10 +836,17 @@ People who submitted patches and new features or suggested improvements. Many th
 * Pavel Forkert
 * Jordi Massaguer Pla
 * Jake Benilov
-* Travis Beauvais
+* Tom Beauvais
 * Mokevnin Kirill
 * Alex Grant
 * Lucas Dohmen
+* Bastien Vaucher
+* Joost Baaij
+* Joel Chippindale
+* Murahashi Sanemat Kenichi
+* Tim Kurvers
+* Ilya Vassilevsky
+* gotwalt
 
 For a full list of contributors you can visit the
 [contributors](https://github.com/bblimke/webmock/contributors) page.