cs-httpi 0.9.5.1

data/.autotest

@@ -0,0 +1,5 @@
+Autotest.add_hook(:initialize) do |at|
+  at.clear_mappings
+  at.add_mapping(%r%^spec/httpi/.*_spec.rb$%) { |filename, _| filename }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| ["spec/#{m[1]}_spec.rb"] }
+end

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.yardoc
+doc
+coverage
+tmp
+*~
+*.gem
+.bundle
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,8 @@
+script: "rake ci"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - rbx
+  - jruby
+  - ruby-head

data/CHANGELOG.md

@@ -0,0 +1,66 @@
+## 0.9.5 (2011-06-30)
+
+* Improvement: Moved support for NTLM authentication into a separate gem.
+  Since NTLM support caused quite some problems for people who didn't even
+  need it, I decided to move it into httpi-ntlm until it's stable.
+
+## 0.9.4 (2011-05-15)
+
+* Fix: issues [34](https://github.com/rubiii/httpi/issues/34) and
+  [29](https://github.com/rubiii/httpi/issues/29) - replaced the dependency
+  on `ntlm-http` with a dependency on `pyu-ntlm-http` which comes with quite
+  a few bugfixes.
+
+* Fix: Setting the default adapter did not always load the adapter's client library.
+
+* Improvement: Added a shortcut method to set the default adapter to use.
+
+      HTTPI.adapter = :net_http
+
+## 0.9.3 (2011-04-28)
+
+* Fix: [issue 31](https://github.com/rubiii/httpi/issues/31) missing headers when using httpclient.
+
+* Fix: [issue 30](https://github.com/rubiii/httpi/issues/30) fix for using SSL with Net::HTTP.
+
+## 0.9.2 (2011-04-05)
+
+* Fix: issues [161](https://github.com/rubiii/savon/issues/161) and [165](https://github.com/rubiii/savon/issues/165)
+  reported at [rubiii/savon](https://github.com/rubiii/savon).
+
+## 0.9.1 (2011-04-04)
+
+* Fix: [issue 25](https://github.com/rubiii/httpi/issues/22) problem with HTTPI using the Net::HTTP adapter [hakanensari].
+
+## 0.9.0 (2011-03-08)
+
+* Feature: improved the adapter loading process ([d4a091](https://github.com/rubiii/httpi/commit/d4a091)) [rubiii].
+
+  Instead of using HTTPClient as the default and falling back to NetHTTP, the loading process now does the following:
+
+  1. Check if either HTTPClient, Curb or NetHTTP are already defined.
+     If any one of those is defined, use it.
+
+  2. Try to require HTTPClient, Curb and NetHTTP at last.
+     If any one of those can be required, use it.
+
+  Of course you can still manually specify the adapter to use.
+
+* Fix: [issue 22](https://github.com/rubiii/httpi/issues/22) argument error on logging adapter warning [rubiii].
+
+* Fix: [issue 23](https://github.com/rubiii/httpi/issues/23) the HTTPI.log method now works as expected [rubiii].
+
+## 0.8.0 (2011-03-07)
+
+* Feature: added support for NTLM authentication ([96ceb1](https://github.com/rubiii/httpi/commit/96ceb1)) [MattHall].
+
+  You should now be able to use NTLM authentication by specifying your credentials via `HTTPI::Auth::Config#ntlm`:
+
+      request = HTTPI::Request.new
+      request.auth.ntlm "username", "password"
+
+* Improvement: changed the default log level to :warn ([d01591](https://github.com/rubiii/httpi/commit/d01591))
+  and log at appropriate levels ([21ee1b](https://github.com/rubiii/httpi/commit/21ee1b)) [ichverstehe].
+
+* Fix: [issue 18](https://github.com/rubiii/httpi/issues/18) don't mask exceptions in decoded_gzip_body
+  ([f3811b](https://github.com/rubiii/httpi/commit/f3811b)) [fj].

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+gemspec
+
+gem "jruby-openssl", :platforms => :jruby
+
+# http clients
+gem "httpclient", "~> 2.1.7"
+gem "curb", "~> 0.7.8", :platforms => :ruby
+gem "mock-server", :git => "https://github.com/djanowski/mock-server.git"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Daniel Harrington
+
+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/README.md

@@ -0,0 +1,229 @@
+CS-HTTPI
+=====
+
+CS_HTTPI provides a common interface for Ruby HTTP libraries. This gem is a fork of httpi gem (https://github.com/rubiii/httpi)
+
+[Bugs](http://github.com/concretesolutions/cs-httpi/issues) | [RDoc](http://rubydoc.info/gems/cs-httpi/frames)
+
+Installation
+------------
+
+cs-httpi is available through [Rubygems](http://rubygems.org/gems/cs-httpi) and can be installed via:
+
+```
+$ gem install cs-httpi
+```
+
+
+Getting started
+---------------
+
+In order to provide a common interface, HTTPI provides the `HTTPI::Request` object for you to
+configure your request. Here's a very simple GET request.
+
+``` ruby
+request = HTTPI::Request.new("http://example.com")
+HTTPI.get request
+```
+
+To execute a POST request, you may want to specify a payload.
+
+``` ruby
+request = HTTPI::Request.new
+request.url = "ht 78tp://post.example.com"
+request.body = "some data"
+
+HTTPI.post request
+```
+
+
+HTTPI
+-----
+
+The `HTTPI` module uses one of the available adapters to execute HTTP requests.
+
+#### GET
+
+``` ruby
+HTTPI.get(request, adapter = nil)
+HTTPI.get(url, adapter = nil)
+```
+
+#### POST
+
+``` ruby
+HTTPI.post(request, adapter = nil)
+HTTPI.post(url, body, adapter = nil)
+```
+
+#### HEAD
+
+``` ruby
+HTTPI.head(request, adapter = nil)
+HTTPI.head(url, adapter = nil)
+```
+
+#### PUT
+
+``` ruby
+HTTPI.put(request, adapter = nil)
+HTTPI.put(url, body, adapter = nil)
+```
+
+#### DELETE
+
+``` ruby
+HTTPI.delete(request, adapter = nil)
+HTTPI.delete(url, adapter = nil)
+```
+
+#### Notice
+
+* You can specify the adapter to use per request
+* And request methods always return an `HTTPI::Response`
+
+#### More control
+
+If you need more control over the request, you can access the HTTP client instance
+represented by your adapter in a block:
+
+``` ruby
+HTTPI.post request do |http|
+  http.use_ssl = true  # Curb example
+end
+```
+
+
+HTTPI::Adapter
+--------------
+
+HTTPI uses adapters to support multiple HTTP libraries.
+It currently contains adapters for:
+
+* [httpclient](http://rubygems.org/gems/httpclient) ~> 2.1.5
+* [curb](http://rubygems.org/gems/curb) ~> 0.7.8
+* [net/http](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc)
+
+You can manually specify the adapter to use via:
+
+``` ruby
+HTTPI.adapter = :curb  # or one of [:httpclient, :net_http]
+```
+
+If you don't specify which adapter to use, HTTPI try to load HTTPClient, then Curb and finally NetHTTP.
+
+#### Notice
+
+HTTPI does not force you to install any of these libraries. If you'd like to use on of the more advanced
+libraries (HTTPClient or Curb), you have to make sure they're in your LOAD_PATH. HTTPI will then load the
+library when executing HTTP requests.
+
+
+HTTPI::Request
+--------------
+
+#### URL
+
+``` ruby
+request.url = "http://example.com"
+request.url # => #<URI::HTTP:0x101c1ab18 URL:http://example.com>
+```
+
+#### Proxy
+
+``` ruby
+request.proxy = "http://example.com"
+request.proxy # => #<URI::HTTP:0x101c1ab18 URL:http://example.com>
+```
+
+#### HeadersHTTPI
+
+
+``` ruby
+request.headers["Accept-Charset"] = "utf-8"
+request.headers = { "Accept-Charset" => "utf-8" }
+request.headers # => { "Accept-Charset" => "utf-8" }
+```
+
+#### Body
+
+``` ruby
+request.body = "some data"
+request.body # => "some data"
+```
+
+#### Open timeout
+
+``` ruby
+request.open_timeout = 30 # sec
+```
+
+#### Read timeout
+
+``` ruby
+request.read_timeout = 30 # sec
+```
+
+
+HTTPI::Auth
+-----------
+
+`HTTPI::Auth` supports HTTP basic and digest authentication.
+
+``` ruby
+request.auth.basic("username", "password")   # HTTP basic auth credentials
+request.auth.digest("username", "password")  # HTTP digest auth credentials
+```
+
+For experimental NTLM authentication, please use the [httpi-ntlm](rubygems.org/gems/httpi-ntml)
+gem and provide feedback.
+
+``` ruby
+request.auth.ntlm("username", "password")    # NTLM auth credentials
+```
+
+HTTPI::Auth::SSL
+----------------
+
+`HTTPI::Auth::SSL` manages SSL client authentication.
+
+``` ruby
+request.auth.ssl.cert_key_file     = "client_key.pem"   # the private key file to use
+request.auth.ssl.cert_key_password = "C3rtP@ssw0rd"     # the key file's password
+request.auth.ssl.cert_file         = "client_cert.pem"  # the certificate file to use
+request.auth.ssl.ca_cert_file      = "ca_cert.pem"      # the ca certificate file to use
+request.auth.ssl.verify_mode       = :none              # or one of [:peer, :fail_if_no_peer_cert, :client_once]
+```
+
+
+HTTPI::Response
+---------------
+
+Every request returns an `HTTPI::Response`. It contains the response code, headers and body.
+
+``` ruby
+response = HTTPI.get request
+
+response.code     # => 200
+response.headers  # => { "Content-Encoding" => "gzip" }
+response.body     # => "<!DOCTYPE HTML PUBLIC ...>"
+```
+
+The `response.body` handles gzipped and [DIME](http://en.wikipedia.org/wiki/Direct_Internet_Message_Encapsulation) encoded responses.
+
+#### TODO
+
+* Return the original `HTTPI::Request` for debugging purposes
+* Return the time it took to execute the request
+
+
+Logging
+-------
+
+HTTPI by default logs each HTTP request to STDOUT using a log level of :debug.
+
+``` ruby
+HTTPI.log       = false     # disable logging
+HTTPI.logger    = MyLogger  # change the logger
+HTTPI.log_level = :info     # change the log level
+```

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/cs-httpi/**/*_spec.rb"
+end
+
+desc "Run RSpec integration examples"
+RSpec::Core::RakeTask.new "spec_integration" do |t|
+  t.pattern = "spec/integration/*_spec.rb"
+end
+
+task :default => :spec
+
+desc "Run RSpec code and integration examples"
+task :ci => [:spec, :spec_integration]

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/cs-httpi.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib/", __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "cs-httpi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cs-httpi"
+  s.version     = HTTPI::VERSION
+  s.authors     = ["Celestino Gomes", "Renato Elias", "Lenon Marcel", "Madson Cardoso", "Luca Bastos", "Marcelo Linhares"]
+  s.email       = %w[tinorj@gmail.com renato.elias@gmail.com lenon.marcel@gmail.com madsonmac@gmail.com lucabastos@gmail.com marcelolinhares@gmail.com]
+  s.homepage    = "http://github.com/concretesolutions/#{s.name}"
+  s.summary     = "Interface for Ruby HTTP libraries"
+  s.description = "HTTPI provides a common interface for Ruby HTTP libraries. This gem is a fork of httpi gem (https://github.com/rubiii/httpi)"
+
+  s.rubyforge_project = s.name
+
+  s.add_dependency "rack"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "autotest"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "webmock"
+
+  s.files = `git ls-files`.split("\n")
+  s.require_path = "lib"
+end

data/lib/cs-httpi.rb

@@ -0,0 +1,198 @@
+require "logger"
+require "cs-httpi/version"
+require "cs-httpi/request"
+require "cs-httpi/adapter"
+
+# = HTTPI
+#
+# Executes HTTP requests using a predefined adapter.
+# All request methods accept an <tt>HTTPI::Request</tt> and an optional adapter.
+# They may also offer shortcut methods for executing basic requests.
+# Also they all return an <tt>HTTPI::Response</tt>.
+#
+# == GET
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.get request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.get "http://example.com", :curb
+#
+# == POST
+#
+#   request = HTTPI::Request.new
+#   request.url = "http://example.com"
+#   request.body = "<some>xml</some>"
+#
+#   HTTPI.post request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.post "http://example.com", "<some>xml</some>", :curb
+#
+# == HEAD
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.head request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.head "http://example.com", :curb
+#
+# == PUT
+#
+#   request = HTTPI::Request.new
+#   request.url = "http://example.com"
+#   request.body = "<some>xml</some>"
+#
+#   HTTPI.put request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.put "http://example.com", "<some>xml</some>", :curb
+#
+# == DELETE
+#
+#   request = HTTPI::Request.new :url => "http://example.com"
+#   HTTPI.delete request, :httpclient
+#
+# === Shortcuts
+#
+#   HTTPI.delete "http://example.com", :curb
+#
+# == More control
+#
+# If you need more control over your request, you can access the HTTP client
+# instance represented by your adapter in a block.
+#
+#   HTTPI.get request do |http|
+#     http.follow_redirect_count = 3  # HTTPClient example
+#   end
+module HTTPI
+
+  REQUEST_METHODS = [:get, :post, :head, :put, :delete]
+
+  DEFAULT_LOG_LEVEL = :warn
+
+  class << self
+
+    # Executes an HTTP GET request.
+    def get(request, adapter = nil)
+      request = Request.new :url => request if request.kind_of? String
+
+      with_adapter :get, request, adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.get request
+      end
+    end
+
+    # Executes an HTTP POST request.
+    def post(*args)
+      request, adapter = request_and_adapter_from(args)
+
+      with_adapter :post, request, adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.post request
+      end
+    end
+
+    # Executes an HTTP HEAD request.
+    def head(request, adapter = nil)
+      request = Request.new :url => request if request.kind_of? String
+
+      with_adapter :head, request, adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.head request
+      end
+    end
+
+    # Executes an HTTP PUT request.
+    def put(*args)
+      request, adapter = request_and_adapter_from(args)
+
+      with_adapter :put, request, adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.put request
+      end
+    end
+
+    # Executes an HTTP DELETE request.
+    def delete(request, adapter = nil)
+      request = Request.new :url => request if request.kind_of? String
+
+      with_adapter :delete, request, adapter do |adapter|
+        yield adapter.client if block_given?
+        adapter.delete request
+      end
+    end
+
+    # Executes an HTTP request for the given +method+.
+    def request(method, request, adapter = nil)
+      raise ArgumentError, "Invalid request method: #{method}" unless REQUEST_METHODS.include? method
+      send method, request, adapter
+    end
+
+    # Shortcut for setting the default adapter to use.
+    def adapter=(adapter)
+      Adapter.use = adapter
+    end
+
+    # Sets whether to log HTTP requests.
+    attr_writer :log
+
+    # Returns whether to log HTTP requests. Defaults to +true+.
+    def log?
+      @log != false
+    end
+
+    # Sets the logger to use.
+    attr_writer :logger
+
+    # Returns the logger. Defaults to an instance of +Logger+ writing to STDOUT.
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+
+    # Sets the log level.
+    attr_writer :log_level
+
+    # Returns the log level. Defaults to :debug.
+    def log_level
+      @log_level ||= DEFAULT_LOG_LEVEL
+    end
+
+    # Logs given +messages+.
+    def log(*messages)
+      level = Symbol === messages.first ? messages.shift : log_level
+      logger.send level, messages.join(" ") if log?
+    end
+
+    # Reset the default config.
+    def reset_config!
+      @log = nil
+      @logger = nil
+      @log_level = nil
+    end
+
+  private
+
+    # Checks whether +args+ contains of an <tt>HTTPI::Request</tt> or a URL
+    # and a request body plus an optional adapter and returns an Array with
+    # an <tt>HTTPI::Request</tt> and (if given) an adapter.
+    def request_and_adapter_from(args)
+      return args if args[0].kind_of? Request
+      [Request.new(:url => args[0], :body => args[1]), args[2]]
+    end
+
+    # Expects a request +method+, a +request+ and an +adapter+ (defaults to
+    # <tt>Adapter.use</tt>) and yields an instance of the adapter to a given block.
+    def with_adapter(method, request, adapter)
+      adapter, adapter_class = Adapter.load adapter
+
+      log :debug, "HTTPI executes HTTP #{method.to_s.upcase} using the #{adapter} adapter"
+      yield adapter_class.new(request)
+    end
+
+  end
+end