putio 0.0.1.pre

data/development/ruby/1.8/gems/fakeweb-1.3.0/CHANGELOG

@@ -0,0 +1,215 @@
+fakeweb (1.3.0)
+
+* improve response header registration so you can pass an array to set a header
+  more than once [Myron Marston]
+
+* fix an exception when the response's :body option was set to nil [Chris Zingel]
+
+* fix that stubbed requests weren't mutating the Net::HTTP request object to set
+  the body and content-length, like real requests do [Chris Kampmeier]
+
+* add FakeWeb.last_request [Chris Kampmeier]
+
+* assigning a String or Regexp to FakeWeb.allow_net_connect= sets a whitelist
+  for outbound requests [Dan Dofter, Tim Carey-Smith, Ben Woosley]
+
+
+fakeweb (1.2.8)
+
+* support Pathname objects where a filename is expected [Chris Kampmeier]
+
+* fix compatibility with Ruby 1.9.2 [Chris Kampmeier]
+
+* simplify storage of FakeWeb::VERSION [Josh Peek, Woody Peterson, Ben Woosley]
+
+
+fakeweb (1.2.7)
+
+* revert to sorting query params before matching requests against regexps,
+  instead of the 1.2.6 behavior that tried every possible order combination;
+  that was factorial-time, which made matching hang for requests with long query
+  strings [Jason Wadsworth, David Dollar, Blaine Cook]
+
+* print a warning when FakeWeb is loaded before RightHttpConnection or after
+  Samuel, other libs that patch Net::HTTP [Chris Kampmeier, Ben Brinckerhoff]
+
+
+fakeweb (1.2.6)
+
+* fix that query params in a regex would have to be sorted for it to ever match
+  a request URI [Chris Kampmeier, Ben Hall]
+
+* improve regex handling so registration with an explicit port (like
+  /example.com:80/) matches a request that uses an implied port
+  (like "http://example.com/") [Chris Kampmeier, Dan Dofter]
+
+* refactor URI registry to reduce duplication; now about twice as fast at
+  handling requests [Chris Kampmeier]
+
+* Add FakeWeb::VERSION so you can programmatically determine what version of
+  FakeWeb is loaded without using RubyGems [Chris Kampmeier, Chris Wanstrath]
+
+
+fakeweb (1.2.5)
+
+* fix handling of userinfo strings that contain percent-encoded unsafe
+  characters [Chris Kampmeier, Ken Mayer]
+
+* fix that exact matches against strings/URIs with the :any method had a lower
+  precedence than regex matches using a real HTTP method (exact matches now
+  always take precedence) [Chris Kampmeier]
+
+* change request handling to raise an exception when more than one registered
+  regex matches a request URI [Chris Kampmeier]
+
+
+fakeweb (1.2.4)
+
+* add experimental support for matching URIs via regular expressions
+  [Jacqui Maher, Tiago Albineli Motta, Peter Wagene]
+
+* fix an exception when registering with the :response option and a string that
+  is the same as the name of a directory in the current path [Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri with a :string or :file option is
+  now deprecated. Both options have been replaced with a unified :body option,
+  since they supply the response body (as opposed to :response, which supplies
+  the full response including headers) [Chris Kampmeier]
+
+* add support for specifying HTTP headers as options to FakeWeb.register_uri
+  when using the :string or :file response types, since those methods only
+  specify a response body [David Michael, Chris Kampmeier]
+
+* DEPRECATION: Calling FakeWeb.register_uri and FakeWeb.registered_uri? without
+  an HTTP method as the first argument is now deprecated. To match against any
+  HTTP method (the pre-1.2.0 behavior), use :any [Chris Kampmeier]
+
+
+fakeweb (1.2.3)
+
+* fix the #http_version of :file and :string responses, which was returning the
+  request URI instead of something sensible like "1.0" [Chris Kampmeier]
+
+* add method aliases in the Net::HTTP patch to eliminate warnings when running
+  with -w [Joshua Clingenpeel]
+
+* fix that removing the redefinition of OpenURI::HTTPError in 1.2.0 caused
+  :exception responses to raise when OpenURI isn't available [Chris Kampmeier]
+
+* fix registering an :exception response with classes that require arguments for
+  instantiation, like Interrupt's subclasses [Chris Kampmeier]
+
+
+fakeweb (1.2.2)
+
+* fix that HTTP Digest and OAuth requests could raise URI::InvalidURIErrors
+  [Bill Kocik, Chris Kampmeier]
+
+
+fakeweb (1.2.1)
+
+* fix that query parameters are handled correctly when registering with a URI
+  object [Anselmo Alves, Chris Kampmeier]
+
+* fix an exception when registering with the :response option and a string
+  containing "\0" [Jonathan Baudanza, Chris Kampmeier]
+
+* fix that trailing slashes were considered significant for requests to the root
+  of a domain [Chris Kampmeier]
+
+* add support for HTTP basic authentication via userinfo strings in URIs
+  [Michael Bleigh]
+
+
+fakeweb (1.2.0)
+
+* add lib/fakeweb.rb so you can require "fakeweb" as well [Chris Kampmeier]
+
+* fix compatibility with Ruby 1.9.1 [Chris Kampmeier]
+
+* fix that newlines in file-based responses could be doubled in the response
+  object's body [Mark Menard, Chris Kampmeier]
+
+* fix unnecessary munging of the transfer-encoding header, which improves
+  compatibility with mechanize [Mark Menard]
+
+* fix a test and the RCov dependency to be compatible with JRuby [Mark Menard]
+
+* remove an unnecessary redefinition of OpenURI::HTTPError [Josh Nichols]
+
+* rearrange implementation code into separate files, one per class [Josh Nichols]
+
+* fix a bug where FakeWeb.response_for would raise if the request wasn't
+  registered [Chris Kampmeier]
+
+* add HTTP method support, so FakeWeb takes both the URI and method into
+  account for registration, requests, and responses. Backwards-compatible with
+  the old method signatures, which didn't have a method param. [Chris Kampmeier]
+
+* start work on Ruby 1.9 compatibility [Chris Kampmeier]
+
+* add FakeWeb.allow_net_connect= to enable/disable the pass-through to
+  Net::HTTP for unregistered URIs [Mislav Marohnić, Chris Kampmeier]
+
+* remove setup.rb, since most people use RubyGems [Mislav Marohnić]
+
+* fix that 'http://example.com/?' (empty query) matches a registered
+  'http://example.com/', and vice-versa [Mislav Marohnić]
+
+* improve the test suite to not rely on an internet connection [Chris Kampmeier]
+
+* use `rake test` instead of `rake tests` [Josh Nichols]
+
+* fix an incompatibility with Ruby 1.8.6 p36 where you'd get "Errno::EINTR:
+  Interrupted system call" exceptions in Socket#sysread for any non-faked
+  request [Chris Kampmeier]
+
+* response rotation: you can now optionally call FakeWeb.register_uri with an
+  array of options hashes; these are used, in order, to respond to
+  repeated requests (to repeat a response more than once before rotating, use
+  the :times option). Once you run out of responses, further requests always
+  receive the last response. [Michael Shapiro]
+
+* add support for Net::HTTP's undocumented full-URI request style (fixes
+  URI::InvalidURIErrors that you might see in older libraries) [Chris Kampmeier]
+
+* sort query params before storing internally, so that
+  http://example.com/?a=1&b=2 and http://example.com/?b=2&a=1 are considered the
+  same URL (although this is technically incorrect, it's much more
+  convenient--most web apps work that way, and Net::HTTP's use of a hash to pass
+  query params means that the order in which FakeWeb stores them can be
+  unpredictable) [Chris Kampmeier]
+
+* add support for ports in URLs, so that http://example.com/ and
+  http://example.com:3000/ are not the same [Chris Kampmeier]
+
+* fix for non-faked SSL requests failing with "Unable to create local socket"
+  [Chris Kampmeier]
+
+* update Rakefile to fix warning about deprecated code [Chris Kampmeier]
+
+
+fakeweb (1.1.2)
+
+* add required dependencies to GemSpec to ensure that tests pass in firebrigade
+  (http://firebrigade.seattlerb.org/) [Blaine Cook]
+
+
+fakeweb (1.1.1)
+
+* fix for non-existence of :string method on File as presented by open-uri
+  [Blaine Cook]
+
+* fix for curl example test - google redirects to ccTLDs for those outside US
+  [Blaine Cook]
+
+
+fakeweb (1.1.0)
+
+* update code to correspond to ruby 1.8.4 (breaks compatibility with ruby 1.8.2)
+  [Blaine Cook]
+
+
+fakeweb (1.0.0)
+
+  * initial import [Blaine Cook]

data/development/ruby/1.8/gems/fakeweb-1.3.0/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2006-2010 Blaine Cook, Chris Kampmeier, and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/development/ruby/1.8/gems/fakeweb-1.3.0/README.rdoc

@@ -0,0 +1,189 @@
+= FakeWeb
+
+FakeWeb is a helper for faking web requests in Ruby. It works at a global
+level, without modifying code or writing extensive stubs.
+
+
+== Installation
+
+  gem install fakeweb
+
+Note: the gem was previously available as +FakeWeb+ (capital letters), but now
+all versions are simply registered as +fakeweb+. If you have any old +FakeWeb+
+gems lying around, remove them: <tt>gem uninstall FakeWeb</tt>
+
+
+== Help and discussion
+
+RDocs for the current release are available at http://fakeweb.rubyforge.org.
+
+There's a mailing list for questions and discussion at
+http://groups.google.com/group/fakeweb-users.
+
+The main source repository is http://github.com/chrisk/fakeweb.
+
+== Examples
+
+Start by requiring FakeWeb:
+
+  require 'fakeweb'
+
+=== Registering basic string responses
+
+  FakeWeb.register_uri(:get, "http://example.com/test1", :body => "Hello World!")
+
+  Net::HTTP.get(URI.parse("http://example.com/test1"))
+  => "Hello World!"
+
+  Net::HTTP.get(URI.parse("http://example.com/test2"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+You can also call <tt>register_uri</tt> with a regular expression, to match
+more than one URI.
+
+  FakeWeb.register_uri(:get, %r|http://example\.com/|, :body => "Hello World!")
+
+  Net::HTTP.get(URI.parse("http://example.com/test3"))
+  => "Hello World!"
+
+=== Replaying a recorded response
+
+  page = `curl -is http://www.google.com/`
+  FakeWeb.register_uri(:get, "http://www.google.com/", :response => page)
+
+  Net::HTTP.get(URI.parse("http://www.google.com/"))
+  # => Full response, including headers
+
+=== Adding a custom status to the response
+
+  FakeWeb.register_uri(:get, "http://example.com/", :body => "Nothing to be found 'round here",
+                                                    :status => ["404", "Not Found"])
+
+  Net::HTTP.start("example.com") do |req|
+    response = req.get("/")
+    response.code     # => "404"
+    response.message  # => "Not Found"
+    response.body     # => "Nothing to be found 'round here"
+  end
+
+=== Responding to any HTTP method
+
+  FakeWeb.register_uri(:any, "http://example.com", :body => "response for any HTTP method")
+
+If you use the <tt>:any</tt> symbol, the URI you specify will be completely
+stubbed out (regardless of the HTTP method of the request). This can be useful
+for RPC-style services, where the HTTP method isn't significant. (Older
+versions of FakeWeb always behaved like this, and didn't accept the first
++method+ argument above; this syntax is now deprecated.)
+
+=== Rotating responses
+
+You can optionally call <tt>FakeWeb.register_uri</tt> with an array of options
+hashes; these are used, in order, to respond to repeated requests. Once you run
+out of responses, further requests always receive the last response. (You can
+also send a response more than once before rotating, by specifying a
+<tt>:times</tt> option for that response.)
+
+  FakeWeb.register_uri(:delete, "http://example.com/posts/1",
+                       [{:body => "Post 1 deleted.", :status => ["200", "OK"]},
+                        {:body => "Post not found",  :status => ["404", "Not Found"]}])
+
+  Net::HTTP.start("example.com") do |req|
+    req.delete("/posts/1").body  # => "Post 1 deleted"
+    req.delete("/posts/1").body  # => "Post not found"
+    req.delete("/posts/1").body  # => "Post not found"
+  end
+
+=== Using HTTP basic authentication
+
+You can fake requests that use basic authentication by adding +userinfo+ strings
+to your URIs:
+
+  FakeWeb.register_uri(:get, "http://example.com/secret", :body => "Unauthorized", :status => ["401", "Unauthorized"])
+  FakeWeb.register_uri(:get, "http://user:pass@example.com/secret", :body => "Authorized")
+
+  Net::HTTP.start("example.com") do |http|
+    req = Net::HTTP::Get.new("/secret")
+    http.request(req)  # => "Unauthorized"
+    req.basic_auth("user", "pass")
+    http.request(req)  # => "Authorized"
+  end
+
+=== Clearing registered URIs
+
+The FakeWeb registry is a singleton that lasts for the duration of your program,
+maintaining every fake response you register. If needed, you can clean out the
+registry and remove all registered URIs:
+
+  FakeWeb.clean_registry
+
+=== Blocking all real requests
+
+When you're using FakeWeb to replace _all_ of your requests, it's useful to
+catch when requests are made for unregistered URIs (unlike the default
+behavior, which is to pass those requests through to Net::HTTP as usual).
+
+  FakeWeb.allow_net_connect = false
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => raises FakeWeb::NetConnectNotAllowedError
+
+  FakeWeb.allow_net_connect = true
+  Net::HTTP.get(URI.parse("http://example.com/"))
+  => FakeWeb is bypassed and the response from a real request is returned
+
+It's recommended that you set <tt>FakeWeb.allow_net_connect = false</tt> in the
+setup for your tests.
+
+==== Allowing requests to a specific server
+
+If you want to prevent your tests from hitting the internet while allowing
+access to a specific server for integration testing, you can assign a URI or
++Regexp+ to be used as a whitelist for outbound requests:
+
+  FakeWeb.allow_net_connect = %r[^https?://localhost]
+  Net::HTTP.get(URI.parse("http://localhost/path"))  # => allowed
+  Net::HTTP.get(URI.parse("http://example.com/"))    # => raises FakeWeb::NetConnectNotAllowedError
+
+=== Specifying HTTP response headers
+
+When you register a response using the <tt>:body</tt> option, you're only
+setting the body of the response. If you want to add headers to these responses,
+simply add the header as an option to +register_uri+:
+
+  FakeWeb.register_uri(:get, "http://example.com/hello.txt", :body => "Hello", :content_type => "text/plain")
+
+This sets the "Content-Type" header in the response.
+
+=== Checking the last request
+
+It's often useful to retrieve the last request made by your code, so you can
+write tests for its content. FakeWeb keeps track of the last request, whether it
+was stubbed or not:
+
+  Net::HTTP.get(URI.parse("http://example.com"))
+  FakeWeb.last_request  # => Net::HTTP::Get request object
+
+== More info
+
+FakeWeb lets you decouple your test environment from live services without
+modifying code or writing extensive stubs.
+
+In addition to the conceptual advantage of having idempotent request
+behaviour, FakeWeb makes tests run faster than if they were made to remote (or
+even local) web servers. It also makes it possible to run tests without a
+network connection or in situations where the server is behind a firewall or
+has host-based access controls.
+
+FakeWeb works with anything based on Net::HTTP--both higher-level wrappers,
+like OpenURI, as well as a ton of libraries for popular web services.
+
+
+== Known Issues
+
+* Request bodies are ignored, including PUT and POST parameters. If you need
+  different responses for different request bodies, you need to request
+  different URLs, and register different responses for each. (Query strings are
+  fully supported, though.) We're currently considering how the API should
+  change to add support for request bodies in 1.3.0. Your input would be really
+  helpful: see http://groups.google.com/group/fakeweb-users/browse_thread/thread/44d190a6b12e4273
+  for a discussion of some different options. Thanks!

data/development/ruby/1.8/gems/fakeweb-1.3.0/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'rake'
+
+version = '1.3.0'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fakeweb"
+    gem.rubyforge_project = "fakeweb"
+    gem.version = version
+    gem.summary = "A tool for faking responses to HTTP requests"
+    gem.description = "FakeWeb is a helper for faking web requests in Ruby. It works at a global level, without modifying code or writing extensive stubs."
+    gem.email = ["chris@kampers.net", "romeda@gmail.com"]
+    gem.authors = ["Chris Kampmeier", "Blaine Cook"]
+    gem.homepage = "http://github.com/chrisk/fakeweb"
+    gem.add_development_dependency "mocha", ">= 0.9.5"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb", "test/vendor")
+  test.libs << "test"
+  test.verbose = false
+  test.warning = true
+end
+
+task :default => [:check_dependencies, :test]
+
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList["test/**/*.rb"].exclude("test/test_helper.rb", "test/vendor")
+    t.libs << "test"
+    t.rcov_opts << "--sort coverage"
+    t.rcov_opts << "--exclude gems"
+    t.warning = true
+  end
+rescue LoadError
+  print "rcov support disabled "
+  if RUBY_PLATFORM =~ /java/
+    puts "(running under JRuby)"
+  else
+    puts "(install RCov to enable the `rcov` task)"
+  end
+end
+
+
+begin
+  require 'sdoc'
+  require 'rdoc/task'
+  Rake::RDocTask.new do |rdoc|
+    rdoc.main = "README.rdoc"
+    rdoc.rdoc_files.include("README.rdoc", "CHANGELOG", "LICENSE.txt", "lib/*.rb")
+    rdoc.title = "FakeWeb #{version} API Documentation"
+    rdoc.rdoc_dir = "doc"
+    rdoc.template = "direct"
+    rdoc.options << "--line-numbers" << "--show-hash" << "--charset=utf-8"
+  end
+rescue LoadError
+  puts "SDoc (or a dependency) not available. Install it with: gem install sdoc"
+end

data/development/ruby/1.8/gems/fakeweb-1.3.0/fakeweb.gemspec

@@ -0,0 +1,126 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fakeweb}
+  s.version = "1.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Kampmeier", "Blaine Cook"]
+  s.date = %q{2010-08-22}
+  s.description = %q{FakeWeb is a helper for faking web requests in Ruby. It works at a global level, without modifying code or writing extensive stubs.}
+  s.email = ["chris@kampers.net", "romeda@gmail.com"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE.txt",
+     "README.rdoc",
+     "Rakefile",
+     "fakeweb.gemspec",
+     "lib/fake_web.rb",
+     "lib/fake_web/ext/net_http.rb",
+     "lib/fake_web/registry.rb",
+     "lib/fake_web/responder.rb",
+     "lib/fake_web/response.rb",
+     "lib/fake_web/stub_socket.rb",
+     "lib/fake_web/utility.rb",
+     "lib/fakeweb.rb",
+     "test/fixtures/google_response_from_curl",
+     "test/fixtures/google_response_with_transfer_encoding",
+     "test/fixtures/google_response_without_transfer_encoding",
+     "test/fixtures/test_example.txt",
+     "test/fixtures/test_txt_file",
+     "test/test_allow_net_connect.rb",
+     "test/test_deprecations.rb",
+     "test/test_fake_authentication.rb",
+     "test/test_fake_web.rb",
+     "test/test_fake_web_open_uri.rb",
+     "test/test_helper.rb",
+     "test/test_last_request.rb",
+     "test/test_missing_open_uri.rb",
+     "test/test_missing_pathname.rb",
+     "test/test_other_net_http_libraries.rb",
+     "test/test_precedence.rb",
+     "test/test_query_string.rb",
+     "test/test_regexes.rb",
+     "test/test_response_headers.rb",
+     "test/test_trailing_slashes.rb",
+     "test/test_utility.rb",
+     "test/vendor/right_http_connection-1.2.4/History.txt",
+     "test/vendor/right_http_connection-1.2.4/Manifest.txt",
+     "test/vendor/right_http_connection-1.2.4/README.txt",
+     "test/vendor/right_http_connection-1.2.4/Rakefile",
+     "test/vendor/right_http_connection-1.2.4/lib/net_fix.rb",
+     "test/vendor/right_http_connection-1.2.4/lib/right_http_connection.rb",
+     "test/vendor/right_http_connection-1.2.4/setup.rb",
+     "test/vendor/samuel-0.2.1/.document",
+     "test/vendor/samuel-0.2.1/.gitignore",
+     "test/vendor/samuel-0.2.1/LICENSE",
+     "test/vendor/samuel-0.2.1/README.rdoc",
+     "test/vendor/samuel-0.2.1/Rakefile",
+     "test/vendor/samuel-0.2.1/VERSION",
+     "test/vendor/samuel-0.2.1/lib/samuel.rb",
+     "test/vendor/samuel-0.2.1/lib/samuel/net_http.rb",
+     "test/vendor/samuel-0.2.1/lib/samuel/request.rb",
+     "test/vendor/samuel-0.2.1/samuel.gemspec",
+     "test/vendor/samuel-0.2.1/test/request_test.rb",
+     "test/vendor/samuel-0.2.1/test/samuel_test.rb",
+     "test/vendor/samuel-0.2.1/test/test_helper.rb",
+     "test/vendor/samuel-0.2.1/test/thread_test.rb"
+  ]
+  s.homepage = %q{http://github.com/chrisk/fakeweb}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{fakeweb}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A tool for faking responses to HTTP requests}
+  s.test_files = [
+    "test/test_allow_net_connect.rb",
+     "test/test_deprecations.rb",
+     "test/test_fake_authentication.rb",
+     "test/test_fake_web.rb",
+     "test/test_fake_web_open_uri.rb",
+     "test/test_helper.rb",
+     "test/test_last_request.rb",
+     "test/test_missing_open_uri.rb",
+     "test/test_missing_pathname.rb",
+     "test/test_other_net_http_libraries.rb",
+     "test/test_precedence.rb",
+     "test/test_query_string.rb",
+     "test/test_regexes.rb",
+     "test/test_response_headers.rb",
+     "test/test_trailing_slashes.rb",
+     "test/test_utility.rb",
+     "test/vendor/right_http_connection-1.2.4/lib/net_fix.rb",
+     "test/vendor/right_http_connection-1.2.4/lib/right_http_connection.rb",
+     "test/vendor/right_http_connection-1.2.4/setup.rb",
+     "test/vendor/samuel-0.2.1/lib/samuel/net_http.rb",
+     "test/vendor/samuel-0.2.1/lib/samuel/request.rb",
+     "test/vendor/samuel-0.2.1/lib/samuel.rb",
+     "test/vendor/samuel-0.2.1/test/request_test.rb",
+     "test/vendor/samuel-0.2.1/test/samuel_test.rb",
+     "test/vendor/samuel-0.2.1/test/test_helper.rb",
+     "test/vendor/samuel-0.2.1/test/thread_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<mocha>, [">= 0.9.5"])
+    else
+      s.add_dependency(%q<mocha>, [">= 0.9.5"])
+    end
+  else
+    s.add_dependency(%q<mocha>, [">= 0.9.5"])
+  end
+end
+

data/development/ruby/1.8/gems/fakeweb-1.3.0/lib/fake_web/ext/net_http.rb

@@ -0,0 +1,72 @@
+require 'net/http'
+require 'net/https'
+require 'stringio'
+
+module Net  #:nodoc: all
+
+  class BufferedIO
+    def initialize_with_fakeweb(io, debug_output = nil)
+      @read_timeout = 60
+      @rbuf = ''
+      @debug_output = debug_output
+
+      @io = case io
+      when Socket, OpenSSL::SSL::SSLSocket, IO
+        io
+      when String
+        if !io.include?("\0") && File.exists?(io) && !File.directory?(io)
+          File.open(io, "r")
+        else
+          StringIO.new(io)
+        end
+      end
+      raise "Unable to create local socket" unless @io
+    end
+    alias_method :initialize_without_fakeweb, :initialize
+    alias_method :initialize, :initialize_with_fakeweb
+  end
+
+  class HTTP
+    class << self
+      def socket_type_with_fakeweb
+        FakeWeb::StubSocket
+      end
+      alias_method :socket_type_without_fakeweb, :socket_type
+      alias_method :socket_type, :socket_type_with_fakeweb
+    end
+
+    def request_with_fakeweb(request, body = nil, &block)
+      FakeWeb.last_request = request
+
+      uri = FakeWeb::Utility.request_uri_as_string(self, request)
+      method = request.method.downcase.to_sym
+
+      if FakeWeb.registered_uri?(method, uri)
+        @socket = Net::HTTP.socket_type.new
+        FakeWeb::Utility.produce_side_effects_of_net_http_request(request, body)
+        FakeWeb.response_for(method, uri, &block)
+      elsif FakeWeb.allow_net_connect?(uri)
+        connect_without_fakeweb
+        request_without_fakeweb(request, body, &block)
+      else
+        uri = FakeWeb::Utility.strip_default_port_from_uri(uri)
+        raise FakeWeb::NetConnectNotAllowedError,
+              "Real HTTP connections are disabled. Unregistered request: #{request.method} #{uri}"
+      end
+    end
+    alias_method :request_without_fakeweb, :request
+    alias_method :request, :request_with_fakeweb
+
+
+    def connect_with_fakeweb
+      unless @@alredy_checked_for_net_http_replacement_libs ||= false
+        FakeWeb::Utility.puts_warning_for_net_http_replacement_libs_if_needed
+        @@alredy_checked_for_net_http_replacement_libs = true
+      end
+      nil
+    end
+    alias_method :connect_without_fakeweb, :connect
+    alias_method :connect, :connect_with_fakeweb
+  end
+
+end