fresh_simplehttp 0.1.7

data/AUTHORS

@@ -0,0 +1,4 @@
+* Tim Becker (tim@kuriositaet.de)
+* Minero Aoki (setup.rb)
+* Clint Pachl 
+* Dave Myron

data/CHANGELOG

@@ -0,0 +1,20 @@
+= Mon Sep 22 15:12:44 CEST 2008
+* 	General code cleanup
+*	Additional Docs
+*	Reluctantly changes tabs to (ruby default) spaces (YUCK!)
+= Mon Sep 22 13:25:22 CEST 2008
+*	bugfix: uri query parameter preserved on post req	
+
+= Sun Sep 21 18:29:20 CEST 2008
+* 	changes to redirect handling
+*	bugfix make_query
+
+= Wed Sep 26 16:25:55     2007
+	implemented +head+, +options+ and +trace+,
+	made filenames easier. 'simple_http' -> 'simplehttp'
+
+= Fri Feb  9 12:23:20 CET 2007
+*	easier access to response headers
+*	pass through headers during redirects
+*	more tests and documentation
+*	included `setup.rb`

data/LICENSE

@@ -0,0 +1,58 @@
+This package is copyrighted free software by Tim Becker <tim@kuriositaet.de>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see COPYING.txt file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/README

@@ -0,0 +1,96 @@
+= SimpleHttp - a simplified wrapper around Net::Http
+
+SimpleHttp aims to reduce the complexity of Net::Http while providing
+the most commonly used (by me) http functionality. 
+
+INSTALLATION
+
+* Using +gem+
+
+	gem install simplehttp
+
+* Using +setup.rb+
+
+	ruby setup.rb config
+	ruby setup.rb install
+
+* tarball and zip packages are available from
+  RubyForge[http://rubyforge.org/projects/simplehttp/]
+
+
+
+FEATURES / USAGE
+
+* Require the lib: 
+	
+	require 'simplehttp'
+
+* No fuss one line GET and POST requests:
+	
+	str = SimpleHttp.get "http://www.example.com"
+	str = SimpleHttp.get "www.example.com"
+
+* Can use URI or String url interchangibly
+
+	str = SimpleHttp.get URI.parse "http://www.example.com/"
+
+* Transparent Proxy Handling. Uses the 'http_proxy' environment
+  variable if set, also provides a +set_proxy+ method.
+
+	http = SimpleHttp.new "http://www.example.com"
+	http.set_proxy "http://proxy.example.com:8000"
+	http.post "query" => "example_query"
+
+* POST sends ruby Hashes as 'application/x-www-form/urlencoded' per
+  default, but can send any data.
+
+	http = SimpleHttp.new "http://www.example.com/image_upload"
+	http.post imageData, "img/png"
+
+* Automatically handles SSL
+	
+	str = SimpleHttp.get "https://secure.example.com"
+
+* Easy HTTP Basic Authentication
+	str = SimpleHttp.get URI.parse("http://usr:pwd@www.example.com") 
+	#or
+	http = SimpleHttp.new "http://www.example.com"
+	http.basic_authentication "user", "password"
+	http.post "query" => "example_query" 
+
+* Access headers of the request or response
+	http = SimpleHttp.new "www.example.com"
+	http.request_headers["X-Custom-Header"]="useful header"	
+	http.get
+	puts "server set cookie: #{http.response_headers['set-cookie']}"
+	
+* Automatically follows Http Redirects.
+	
+
+The +get+ and +post+ methods return a +String+ containing the
+body of the request if the request was successful (HTTP 200). In case of
+a redirect, the redirect is followed and the ultimate response is
+returned. Per Default, up to three redirects are followed, this
+behaviour can be modified by setting +follow_num_redirects+. 
+
+In case of any other type of response, an exception is raised.
+
+The default behaviour can be modified by registering handlers
+using the +register_response_handler+ method. E.g. if you'd like to
+retrieve the +Date+ header instead of the body for successful
+transactions:
+
+	http = SimpleHttp.new ...
+	http.register_response_handler(Net::HTTPSuccess) {|req,res,http|
+		res['date']
+	}
+
+Or you'd like to print the +Location+ and then raise an exception in
+case of a redirect:
+
+	
+	http = SimpleHttp.new ...
+	http.register_response_handler(Net::HTTPRedirect) {|req,res,http|
+		puts res['location']
+		raise "REDIRECT not allowed!"
+	}

data/Rakefile

@@ -0,0 +1,137 @@
+require "rake/rdoctask"
+require "rake/gempackagetask"
+require "rake/testtask"
+require "rake/clean"
+require "rubygems"
+
+require "lib/simple_http"
+
+# Specifies the default task to execute. This is often the "test" task
+# and we'll change things around as soon as we have some tests.
+
+task  :default => [:rdoc]
+
+# The directory to generate +rdoc+ in.
+RDOC_DIR="doc/html"
+
+# This global variable contains files that will be erased by the `clean` task.
+# The `clean` task itself is automatically generated by requiring `rake/clean`.
+
+CLEAN << RDOC_DIR 
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "fresh_simplehttp"
+    gemspec.summary = "simple_http: Simple Http client lib."
+    gemspec.description = "simple_http: Simple Http client lib. Use to do http requests without noise."
+    gemspec.email = "wilkerlucio@gmail.com"
+    gemspec.homepage = "http://github.com/wilkerlucio/simplehttp"
+    gemspec.authors = ["Wilker Lucio"]
+    
+    gemspec.files.exclude "pkg/**/*"
+    gemspec.files.exclude "test/**/*"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+# This is the task that generates the +rdoc+ documentation from the
+# source files. Instantiating Rake::RDocTask automatically generates a
+# task called `rdoc`.
+
+Rake::RDocTask.new do |rd|
+	# Options for documenation generation are specified inside of
+	# this block. For example the following line specifies that the
+	# content of the README file should be the main page of the
+	# documenation.
+	rd.main = "README" 
+	
+	# The following line specifies all the files to extract
+	# documenation from.
+	rd.rdoc_files.include(	"README", "AUTHORS", "LICENSE", "TODO",
+				"CHANGELOG", "bin/**/*", "lib/**/*.rb", 
+				"examples/**/*rb","test/**/*.rb", "doc/*.rdoc")
+	# This one specifies the output directory ...
+	rd.rdoc_dir 	= "doc/html"
+
+	# Or the HTML title of the generated documentation set.
+	rd.title 	= "simple_http: Simple Http client lib."
+
+	# These are options specifiying how source code inlined in the
+	# documentation should be formatted.
+	
+	rd.options 	= ["--line-numbers", "--inline-source"]
+
+	# Check:
+	# `rdoc --help` for more rdoc options
+	# the {rdoc documenation home}[http://www.ruby-doc.org/stdlib/libdoc/rdoc/rdoc/index.html]
+	# or the documentation for the +Rake::RDocTask+ task[http://rake.rubyforge.org/classes/Rake/RDocTask.html]
+end
+
+# The GemPackageTask facilitates getting all your files collected
+# together into gem archives. You can also use it to generate tarball
+# and zip archives.
+
+# First you'll need to assemble a gemspec
+
+PROJECT_NAME 	= "simplehttp"
+PKG_VERSION 	= SimpleHttp::VERSION 
+PKG_FILES 	= FileList['lib/**/*.rb', 'bin/**/*', 'examples/**/*', '[A-Z]*', 'test/**/*'].to_a
+
+spec = Gem::Specification.new do |s|
+	s.platform = Gem::Platform::RUBY
+	s.summary = "simple_http: Simple Http client lib."
+	s.name = PROJECT_NAME
+	s.version = PKG_VERSION
+	s.files = PKG_FILES
+	s.requirements << "none"
+	s.require_path = 'lib'
+	s.description = <<END_DESC
+Wrapper around net/http to provide quick and dirty http access.
+END_DESC
+end
+
+# Adding a new GemPackageTask adds a task named `package`, which generates
+# packages as gems, tarball and zip archives.
+Rake::GemPackageTask.new(spec) do |pkg|
+	pkg.need_zip = true
+	pkg.need_tar_gz = true
+end
+
+
+# This task is used to demonstrate how to upload files to Rubyforge.
+# Calling `upload_page` creates a current version of the +rdoc+
+# documentation and uploads it to the Rubyforge homepage of the project,
+# assuming it's hosted there and naming conventions haven't changed.
+#
+# This task uses `sh` to call the `scp` binary, which is plattform
+# dependant and may not be installed on your computer if you're using
+# Windows. I'm currently not aware of any pure ruby way to do scp
+# transfers.
+
+RubyForgeUser="a2800276"
+RubyForgeProject=PROJECT_NAME
+
+desc "Upload the web pages to the web."
+task :upload_pages => ["clean", :rdoc] do
+  if RubyForgeProject then
+    path = "/var/www/gforge-projects/#{RubyForgeProject}"
+    sh "scp -r doc/html/* #{RubyForgeUser}@rubyforge.org:#{path}"
+    sh "scp doc/images/*.png #{RubyForgeUser}@rubyforge.org:#{path}/images"
+  end
+end
+
+
+# This task will run the unit tests provided in files called
+# `test/test*.rb`. The task itself can be run with a call to `rake test`
+
+Rake::TestTask.new do |t| 
+	t.libs << "test" 
+	t.libs << "lib" 
+	t.test_files = FileList['test/*.rb'] 
+	t.verbose = true 
+end
+
+

data/TODO

@@ -0,0 +1,28 @@
+* Provide tests and documentation for +head+, +options+ and +trace+
+
+* There seems to be a bug in webrick that it doesn't recognize the
+  Content-Length header if using basic authentication. The POST test
+  cases lead to a:
+  ERROR HTTPRequest#fixup: WEBrick::HTTPStatus::LengthRequired occured.
+  even though the Content-Length header is set correctly in the http
+  packet...
+
+* I've not figured out how to set_up and teardown webbrick properly.
+  Since webbrick blocks after calling `start`, it needs to started in a
+  seperate thread. I didn't handle communication with it properly
+  though.  Test::Unit calls set_up and teardown before
+  and after executing each test... method, and not as I expected, before
+  and after each test file. This leads to a new TestServer being
+  instantiated which complains "bind-adress already in use", because the
+  other instance wasn't properly shut down. I tried to dix this by setting 
+  up the server in the constructor, but that has the same effect.
+  It seems like a new instance of TestCase is instantiated to run every
+  single test... method.
+
+* There also seems to be something screwy about how rake calls the
+  tests. Some ruby files seem to be included twice. This leads to
+  "already initialized constant" error in the output of the unit tests. 
+
+* The two previous bugs aren't really problematic, because they only
+  make the output of the tests ugly. They should be easy to fix... (But
+  they're not high on my list of priorities.)

data/VERSION

@@ -0,0 +1 @@
+0.1.7

data/fresh_simplehttp.gemspec

@@ -0,0 +1,55 @@
+# 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{fresh_simplehttp}
+  s.version = "0.1.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Wilker Lucio"]
+  s.date = %q{2010-04-22}
+  s.description = %q{simple_http: Simple Http client lib. Use to do http requests without noise.}
+  s.email = %q{wilkerlucio@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README",
+     "TODO"
+  ]
+  s.files = [
+    "AUTHORS",
+     "CHANGELOG",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "fresh_simplehttp.gemspec",
+     "lib/fresh_simplehttp.rb",
+     "lib/simple_http.rb",
+     "lib/simplehttp.rb",
+     "setup.rb",
+     "simplehttp.gemspec"
+  ]
+  s.homepage = %q{http://github.com/wilkerlucio/simplehttp}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{simple_http: Simple Http client lib.}
+  s.test_files = [
+    "test/http_test.rb",
+     "test/http_test_server.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/fresh_simplehttp.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+# kept for backwards compatibility
+#
+require 'simplehttp.rb'

data/lib/simple_http.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+# kept for backwards compatibility
+#
+require 'simplehttp.rb'

data/lib/simplehttp.rb

@@ -0,0 +1,482 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+require 'base64'
+
+
+# Wrapper around ruby's standard net/http classes. Currently, only GET
+# and POST https methods are supported. `SimpleHttp` provides class
+# methods `get` and `post` to handle basic functionality. In case more
+# complicated requests need to be made or default settings need to be
+# overriden, it's possible to instantiate `SimpleHttp` and use instance
+# methods `get` and `put`.
+#  
+#
+# Features:
+# 
+# * Handles Redirects automatically
+# * Proxy used transparently if http_proxy environment variable is
+#   set.
+# * SSL handled automatically
+# * fault tolerant uri, e.g. all of these would work:
+#   "www.example.com", "www.example.com/", "http://www.example.com"
+#
+# Some usage examples:
+#    # plain GET (using class methods)
+#    SimpleHttp.get "www.example.com"
+#
+#    # POST using the instance methods
+#    uri = URI.parse "https://www.example.com/index.html"
+#    sh = SimpleHttp uri
+#    sh.set_proxy "my.proxy", "8080"
+#    sh.post {"query" => "query_data"}
+#
+#    # POST using class methods.
+#    binaryData = getImage
+#    SimpleData.post binaryData, "image/png"
+#
+#    # GET requst with a custom request_header
+#    sh = SimpleHttp.new "http://www.example.com"
+#    sh.request_headers= {'X-Special-Http-Header'=>'my-value'}
+#    sh.get
+class SimpleHttp
+  
+  VERSION='0.1.5'
+  
+  # Host component of proxy uri
+  attr_accessor :proxy_host
+  # Port component of proxy uri
+  attr_accessor :proxy_port
+  # Proxy User
+  attr_accessor :proxy_user
+  # Proxy Password
+  attr_accessor :proxy_pwd
+  # The +URI+ object to connect to
+  attr_reader :uri
+  # +Hash+ of headers that will be sent in the request. 
+  attr_accessor :request_headers
+  # +Hash+ of headers that were set in the response.
+  attr_accessor :response_headers
+  # A +Hash+ of handlers for each class of HTTPResponse.
+  attr_accessor :response_handlers
+  # The number of redirects we should follow. Default 5.
+  # An exception gets raised after the fifth redirect.
+  attr_accessor :follow_num_redirects
+
+  RESPONSE_HANDLERS = {
+    Net::HTTPResponse => lambda { |request, response, http| 
+      http._update_response_headers(response)
+      raise "#{response.to_s} : #{response.code} : #{http.uri}"
+    },
+    Net::HTTPSuccess => lambda { |request, response, http|
+      http._update_response_headers(response)
+      #http.cookies += response.cookies
+      case request
+      when Net::HTTP::Head, Net::HTTP::Options
+        http.response_headers 
+      else
+        response.body
+      end
+    },
+    Net::HTTPRedirection =>  lambda { |request, response, http|
+      raise "too many redirects!" unless http.follow_num_redirects > 0  
+      # create a new SimpleHttp for the location
+      # refered to decreasing the remaining redirects
+      # by one.
+      
+      if (location = response['location']) !~ /^https?:\/\//
+        new_location = "#{http.uri.scheme}://#{http.uri.host}"
+        if location =~ /^\//
+          new_location += location
+        else
+          new_location += "/#{http.uri.path}/#{location}"
+        end
+        location = new_location  
+      end
+
+      sh = SimpleHttp.new location 
+      #STDERR.puts location  
+      sh.follow_num_redirects = http.follow_num_redirects-1
+
+      # copy the response handlers used in the current
+      # request in case they were non standard.
+      sh.response_handlers = http.response_handlers
+
+      # copy the request headers
+      sh.request_headers=http.request_headers
+      sh.response_headers=http.response_headers
+      #sh.cookies+=http.cookies
+
+      # copy host and port
+      sh.uri.host = http.uri.host
+      sh.uri.port = http.uri.port
+
+      # HTTP doesn't permit redirects for methods other than
+      # GET or HEAD. The exception is 303 redirects, which
+      # should automatically follow the redirect URI using a
+      # GET method regardless of the initial method. For
+      # other classes of redirection, the client is required
+      # to prompt the user before redirection occurs. Because
+      # that's not a feasible action for this library, all
+      # 3xx redirect URIs are followed using a GET method. 
+      #
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
+
+      case request
+      when   Net::HTTP::Get, 
+            Net::HTTP::Head,
+            Net::HTTP::Options
+        sh.get
+      when Net::HTTP::Post
+        sh.request_headers['content-length']=nil
+        sh.get
+       else 
+         raise "Not a valid HTTP method for redirection: #{request.class}"
+      end
+
+    }
+
+  }
+
+  # SimpleHttp can either be used directly through the +get+ and
+  # +post+ class methods or be instantiated, in case you need to
+  # to add custom behaviour to the requests.
+  #
+  # @param may be a URI or a String.
+  #
+  # Example:
+  #   http = SimpleHttp.new(URI.parse("http://www.example.com"))
+  #   http = SimpleHttp.new "www.example.com"
+  #   http = SimpleHttp.new "http://usr:pwd@www.example.com:1234"
+  def initialize uri
+    set_proxy ENV['http_proxy'] if ENV['http_proxy']
+            
+    if uri.class == String
+      unless uri =~ /^https?:\/\//
+        uri = "http://#{uri}"
+      end
+      uri = URI.parse uri
+    end
+    @uri = uri
+
+    if !@uri.path || "" == @uri.path.strip
+      @uri.path="/"
+    end
+
+    @request_headers={}
+    @response_headers={}
+    @cookies=[]
+    @response_handlers=RESPONSE_HANDLERS.clone
+    @follow_num_redirects=5
+
+    if @uri.user
+      basic_authentication @uri.user, @uri.password
+    end
+
+  end
+
+  # 
+  # Provides facilities to perform http basic authentication. You
+  # don't need to provide +usr+ and +pwd+ if they are already included
+  # in the uri, i.e. http://user:password@www.example.com/
+  #
+  # Usage:
+  #    sh = SimpleHttp.new "www.example.com/password_protected_resource"
+  #    sh.basic_authentication "user_name", "secret_password"
+  #    sh.get  
+  #
+  
+  def basic_authentication usr, pwd
+    @basic_auth = [usr, pwd]
+  end
+  
+  #
+  # This method can be used to register response handlers for specific
+  # http responses in case you need to override the default behaviour.
+  # Defaults are: 
+  #
+  # <b>HTTPSuccess (200-206)</b> :: return the body of the response 
+  # <b>HTTPRedirection (300-307)</b> :: follow the redirection until success
+  # *Others* :: raise an exception 
+  #
+  # ===Parameters:
+  #
+  # +clazz+ is the subclass of <code>Net::HTTPResponse</code> (or +HTTPResponse+ in case you
+  # want to define "default" behaviour) that you are registering the
+  # handler for. E.g. to register a handler for a HTTP 303 response, +clazz+ 
+  # needs to be +HTTPSeeOther+.
+  #
+  # +block+ is the handler itself. When a response of the appropriate class
+  # is received by the library, +block+ is called with three parameters: the 
+  # 'raw' <code>Net::HTTPRequest</code>, the actual +HTTPResponse+ object that was received
+  # and a reference to the instance of +SimpleHttp+ that is executing the
+  # call.
+  #
+  # ===Example: 
+  #
+  #   # to override the default action of following a HTTP
+  #   # redirect, you could register the folllowing handler:
+  #
+  #   sh = SimpleHttp "www.example.com" 
+  #   sh.register_response_handler Net::HTTPRedirection {|request, response, shttp| 
+  #     response['location'] 
+  #   }
+  #
+  
+  def register_response_handler clazz, &block
+    # completely unnecessary sanity check to make sure parameter
+    # `clazz` is in fact a HTTPResponse ...
+    unless clazz.ancestors.include? Net::HTTPResponse
+      raise "Trying to register a response handler for non-response class: #{clazz}"   
+    end
+    @response_handlers[clazz]=block 
+  
+  end
+
+  #
+  #  Set the proxy to use for the http request.
+  # 
+  # Note: you don't need to set the proxy in case the
+  # +http_proxy+ environment variable is set.
+  #
+  # To override  previous proxy settings and connect directly, 
+  # call +set_proxy+ +nil+.
+  #
+  # ===Usage:
+  #
+  #    http = SimpleHttp.new "www.example.com"
+  #    
+  #    http.set_proxy "http://proxy:8000"
+  #  or:
+  #    http.set_proxy(URI.parse("http://proxy:8000"))
+  #  or:
+  #    http.set_proxy 'proxy', '8000', 'my_user', 'secret'
+  #  or:
+  #    http.set_proxy nil # to override previous proxy
+  #    settings and make the request directly.
+  #
+      
+  
+  def set_proxy proxy, port=nil, user=nil, pwd=nil
+    
+    
+    if !proxy  
+      @proxy_host=@proxy_port=@proxy_user=@proxy_pwd=nil 
+      return
+    end
+
+    if String === proxy 
+      if !port && !user && !pwd
+        proxy = URI.parse(proxy)
+      else 
+        @proxy_host= host
+        @proxy_port= port
+        @proxy_user= user
+        @proxy_pwd = pwd
+      end
+    end
+    
+    if URI::HTTP === proxy 
+      @proxy_host= proxy.host
+      @proxy_port= proxy.port
+      @proxy_user= proxy.user
+      @proxy_pwd = proxy.password
+    end
+  end
+
+  # ===Internal 
+  # Takes a HTTPResponse (or subclass) and determines how to
+  # handle the response. Default behaviour is:
+  #
+  #   HTTPSuccess : return the body of the response
+  #   HTTPRedirection : follow the redirect until success.
+  #   default : raise the HTTPResponse.
+  #
+  # the default behaviour can be overidden by registering a
+  # response handler using the `register_response_handler` method.
+  #
+  
+  def _handle_response http_request, http_response
+    raise "Not a Net::HTTPResponse" unless http_response.is_a? Net::HTTPResponse
+    
+    c = http_response.class
+    # Go up the inheritance chain to find the most specific handler
+    # for the class of response we received.
+    while c!=Object
+      # the response_handlers hash contains a handler
+      # for the specific response class.
+      if @response_handlers[c]
+        return @response_handlers[c].call(http_request, http_response, self)
+      end
+      c=c.superclass
+    end  
+
+    # if we reached this place, no handler was registered
+    # for this response. default is to return the response.
+    
+    return http_response
+  end
+
+  # ===Internal
+  # 
+  # ===Parameter
+  # +request+ the <code>Net::HTTPRequest</code> to process.
+  def _do_http request
+    http = Net::HTTP.new(@uri.host, @uri.port, 
+                         @proxy_host, @proxy_port, @proxy_user, @proxy_pwd)
+    http.use_ssl = @uri.scheme == 'https'
+    request.basic_auth(@basic_auth[0], @basic_auth[1]) if @basic_auth
+    
+    # add custom request headers.
+    @request_headers.each {|key,value|
+      request[key]=value;
+    }
+    
+    response = http.request(request)
+    _handle_response(request, response);
+  end
+
+  # ===Internal
+  def _make_query query
+    return query unless query && query.class == Hash
+    query.inject([]) do |s, (key, value)|
+      s << CGI::escape(key) + "=" + CGI::escape(value)
+    end.join('&')
+  end
+  
+  # Make a simple GET request to the provided URI.
+  #
+  # ===Parameter
+  # 
+  # +uri+   :: the uri to connect to, may be a +URI+ or a +String+
+  # +query+ :: the query part of the +get+, may be a +String+ or +Hash+
+  #
+  # ===Usage:
+  #
+  #   puts(SimpleHttp.get("www.example.com"))
+  #   puts(SimpleHttp.get("www.example.com", "param"=>"value")
+  def self.get uri, query=nil
+    http = SimpleHttp.new uri
+    http.get query  
+  end
+
+  # Make a simple +HEAD+ request
+  #
+  # ===Parameter
+  # see +get+
+  def self.head uri, query=nil
+    http = SimpleHttp.new uri
+    http.head query
+  end
+
+  # Make a simple +OPTIONS+ request
+  def self.options uri
+    http = SimpleHttp.new uri
+    http.options 
+  end
+
+  # Make a simple +TRACE+ request
+  def self.trace uri
+    http = SimpleHttp.new uri
+    http.trace
+  end
+
+  # Make a POST request to the provided URI.
+  #
+  # ===Example:
+  #   puts(SimpleHttp.post("www.example.com", "query"=>"my_query"))
+  #
+  # Alternatively, to post arbitrary data, all you need to do is
+  # set the appriate +content_type+:
+  #
+  #   SimpleHttp.post("http://www.example.com/", binary_data, "img/png")
+   
+  def self.post uri, query=nil, content_type='application/x-www-form-urlencoded'
+    http = SimpleHttp.new uri
+    http.post query, content_type
+  end
+  
+  # Call the +get+ method as an instance method if you need to
+  # modify the default behaviour of the library, or set special
+  # headers:
+  #
+  #   http = SimpleHttp.new "www.example.com"
+  #   http.request_headers["X-Special"]="whatever"
+  #   str = http.get 
+  def get query = nil
+    req = Net::HTTP::Get.new( _handle_path(query) )
+    # puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
+    _do_http req
+  end
+  
+  #
+  # Call the +head+ method as an instance method.
+  # see +head+
+  def head query = nil
+    req = Net::HTTP::Head.new( _handle_path(query) )
+    # puts Net::HTTP::Proxy(@proxy_host, @proxy_port, @proxy_user, @proxy_pwd).get(@uri)
+    _do_http req
+  end
+  
+  # Call http +options+ method. Returns the response
+  # see +options+
+  def options
+    # we don't support sending a payload in options' body.
+    req = Net::HTTP::Options.new(@uri.path)
+    _do_http req
+  end
+
+  # Call http +trace+ method. Returns the response
+  # see +trace+
+  def trace
+    # payload? 
+    req = Net::HTTP::Trace.new(@uri.path)
+    _do_http req
+  end
+
+  #
+  #  Post the query data to the url. 
+  #
+  #  The body of the request remains empty if query=nil.
+  #
+  #  In case +query+ is a +Hash+, it's assumed that we are
+  #  sending a form.
+  #
+  #  In case +query+ is a +String+, it's also assumed that a
+  #  form is being sent, UNLESS the +content_type+ parameter
+  #  is set.
+  #
+  def post query=nil, content_type='application/x-www-form-urlencoded'
+    req = Net::HTTP::Post.new( _handle_path() )
+    req.body= _make_query query if query
+    req.content_type=content_type if query
+    req.content_length=query ? req.body.length : 0
+
+    _do_http req
+  end
+
+  def _handle_path query=nil
+    if (query = _make_query query)
+      @uri.query = @uri.query ? @uri.query+"&"+query : query
+    end
+    path = @uri.query ? "#{uri.path}?#{@uri.query}" : @uri.path
+  end
+
+  # ===Internal
+  # Used in the response handler to set the value of the
+  # response header fields.
+  def _update_response_headers http_response
+      http_response.each_header {|key, value|
+        self.response_headers[key]=value  
+      }
+  end
+  
+end
+
+
+