http_session 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create ruby-1.9.2-p180@http_session

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# No dependencies required to use this gem
+
+# Dependencies to develop this gem
+group :development do
+  gem "rake", "= 0.8.7"
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.2"
+  gem "rcov", ">= 0", :platforms => :ruby_18
+  gem 'simplecov', '>= 0.4.0', :require => false, :platforms => :ruby_19
+  gem "rdoc", ">= 0", :platforms => :ruby_19
+end

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rdoc (3.6.1)
+    shoulda (2.11.3)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.2)
+  rake (= 0.8.7)
+  rcov
+  rdoc
+  shoulda
+  simplecov (>= 0.4.0)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by David Burry
+
+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.rdoc

@@ -0,0 +1,72 @@
+
+= HttpSession
+
+A useful yet still extremely light-weight web client built on top of Ruby <tt>Net::HTTP</tt>.  Keeps certain information internally in a session for each host/port used.  Great for simple web page scraping or web service API usage.
+
+== Dependencies
+
+* just Ruby 1.8.6 - 1.9.2
+* no third party gem dependencies!
+
+== Features
+
+* Extremely light-weight at just 100-200 lines of code
+* Supports GET and POST requests, including POST parameter data
+* Supports SSL connections in a natural way, and performs certificate verification using the same CA bundle as Mozilla
+* Automatically uses KeepAlives if the server supports them
+* Automatically remembers Cookies for each session (though currently ignores host/path/expires/secure options)
+* Automatically follows Redirects, up to a certain limit
+* Automatically retries again if certain possibly transient errors happen, up to a limit.  Useful, for example, when the KeepAlive limit is reached and the server hangs up on you, it just retries and keeps going without missing a beat.
+* Supports additional headers for whatever simple additional HTTP features you may need.
+
+== Usage
+
+Normal example usage, parses url string to determine its behavior:
+
+  response_object = HttpSession.get_request_url(url_string)
+  response_object = HttpSession.get_request_url(url_string, headers_hash)
+  response_object = HttpSession.post_request_url(url_string, post_params_hash)
+  response_object = HttpSession.post_request_url(url_string, post_params_hash, headers_hash)
+
+Lower level examples, if your url is already broken down into pieces:
+
+  session_object  = HttpSession.use(host_string, use_ssl_boolean, port_integer)
+  response_object = session_object.request(uri_string, headers_hash, get_or_post_symbol, post_params_hash)
+  
+  session_object  = HttpSession.use(host_string)  # defaults are: false, 80 (or 443 if use_ssl is true)
+  response_object = session_object.request        # defaults are: '/', {}, :get, {}
+
+All the above return:
+* a <tt>Net::HTTPResponse</tt> object in all its glory
+
+Or raise any of the following:
+* <tt>Timeout::Error</tt>, <tt>Errno::*</tt> (<tt>SystemCallError</tt> subclass), <tt>OpenSSL::SSL::SSLError</tt>, or <tt>EOFError</tt> - for various connection-related issues
+* <tt>Net::HTTP*Error/Exception</tt> (<tt>Net::ProtocolError</tt> subclass) - for HTTP response errors
+
+Notes:
+* You do not need to check the response object for HTTP errors like <tt>404 "Not Found"</tt> or others, they are raised automatically, and can be caught when needed.  In my opinion this is better than how <tt>Net::HTTP</tt> behaves.
+* A common pattern is to feed the <tt>response_object.body</tt> string into Nokogiri[http://nokogiri.org/] for further processing.
+
+== Contributing
+
+If you think you found a bug or want a feature, get involved at http://github.com/dburry/http_session/issues  If you'd then like to contribute a patch, use Github's wonderful fork and pull request features.  Keep in mind that one of the main goals of this library is to remain light-weight, so changes done in this spirit are most likely to be included.
+
+To set up a full development environment:
+* <tt>git clone</tt> the repository,
+* have RVM[https://rvm.beginrescueend.com/] and Bundler[http://gembundler.com/] installed,
+* then cd into your repo (follow any RVM prompts if this is your first time using that),
+* and run <tt>bundle install</tt> to pull in all the rest of the development dependencies.
+* After that point, <tt>rake -T</tt> should be fairly self-explanatory.
+* Check out the <tt>rake -T rubies</tt> tasks for some neat multi-ruby-version setup and testing.
+
+Note: If <tt>rake -T</tt> doesn't show much or gives you warnings about missing libraries, then perhaps you did not install RVM, or run <tt>bundle install</tt> correctly, or you do not have the right Ruby version or gemset installed/selected with RVM.  You can either correct this the normal way, or (if you have RVM) run the <tt>rake rubies:setup</tt> task, which makes sure several different versions of Ruby are intalled and sets up a nicely configured gemset in each for you.  You can then use RVM to switch between them for manually testing or running anything you want in any version (although the <tt>.rvmrc</tt> chooses Ruby 1.9.2 for you currently).
+
+== Alternatives
+
+Light-weight libraries are great resource savers when you only need limited features.  But they're not for every situation.  Here are some other great alternatives:
+
+* Mechanize[http://mechanize.rubyforge.org/] - Much more fully-featured web page scraping library.
+
+== License
+
+This library is distributed under the MIT license. Please see the LICENSE file.

data/Rakefile

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+# like printing `rvm current` only it actually works in `rvm version,version,version rake some:task`
+puts "\n*** Using #{File.basename(ENV['GEM_HOME'])}" if ENV.has_key?('GEM_HOME')
+
+# for some odd reason, requiring bundler causes rake and jeweler to do recursive requires on ruby 1.9.2...
+# therefore the following is all commented out for now...
+# bundler is still used in development, just use it on the command line to make a clean rvm gemset (or use rubies:* tasks)
+# instead of this enforcing the gems at rake run time
+
+# require 'rubygems'
+# require 'bundler'
+# begin
+#   Bundler.require(:default, :development)
+# rescue Bundler::BundlerError => e
+#   $stderr.puts e.message
+#   $stderr.puts "Run `bundle install` to install missing gems"
+#   exit e.status_code
+# end
+require 'rake'
+
+
+begin
+  require 'jeweler'
+rescue LoadError
+  puts 'WARNING: missing jeweler library, some tasks are not available'
+else
+  Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+    gem.name = "http_session"
+    gem.homepage = "http://github.com/dburry/http_session"
+    gem.license = "MIT"
+    gem.summary = %Q{A useful yet still extremely light-weight web client built on top of Ruby Net::HTTP}
+    gem.email = "dburry@falcon"
+    gem.authors = ["David Burry"]
+    # dependencies defined in Gemfile
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+end
+
+begin
+  require 'rake/testtask'
+rescue LoadError
+  puts 'WARNING: missing test library, some tasks are not available'
+else
+  task :default => :test
+  Rake::TestTask.new(:test) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/**/test_*.rb'
+  end
+end
+
+if RUBY_VERSION =~ /^1\.8\./
+  begin
+    require 'rcov/rcovtask'
+  rescue LoadError
+    puts 'WARNING: missing rcov library, some tasks are not available'
+  else
+    Rcov::RcovTask.new do |test|
+      test.libs << 'test'
+      test.pattern = 'test/**/test_*.rb'
+    end
+  end
+end
+if RUBY_VERSION =~ /^1\.9\./
+  begin
+    require 'simplecov'
+  rescue LoadError
+    puts 'WARNING: missing simplecov library, some tasks are not available'
+  else
+    desc 'Analyze code coverage with tests'
+    task :coverage => 'coverage:clobber' do
+      ENV['USE_SIMPLECOV'] = :true.to_s
+      Rake::Task['test'].invoke
+      # see top of test helper for the rest of this task, which is triggered with the environment var....
+    end
+    namespace :coverage do
+      desc 'Remove output directory generated by simplecov'
+      task :clobber do
+        FileUtils.rm_rf(File.expand_path('../coverage', __FILE__))
+      end
+    end
+  end
+end
+
+if RUBY_VERSION =~ /^1\.9/
+  begin
+    require 'rdoc/task'
+  rescue LoadError
+    puts 'WARNING: missing rdoc library, some tasks are not available'
+  else
+    RDoc::Task.new do |rdoc|
+      version = File.exist?('VERSION') ? File.read('VERSION') : ""
+      rdoc.rdoc_dir = 'rdoc'
+      rdoc.title = "http_session #{version}"
+      rdoc.rdoc_files.include('README*')
+      rdoc.rdoc_files.include('lib/**/*.rb')
+    end
+  end
+end
+
+if `which rvm`.empty?
+  puts 'WARNING: missing rvm executable, some tasks are not available'
+else
+  task :rubies => 'rubies:list'
+  namespace :rubies do
+    @@ruby_versions = [
+      # edit this list to test on more rubies...
+      # though beware that some development dependencies might be troublesome on some versions...
+      'ruby-1.9.2-p180',
+      'ruby-1.9.1-p378',
+      'ruby-1.8.7-p330',
+      'ruby-1.8.6-p399'
+    ]
+    def installed_ruby_versions
+      current_rubies = `rvm list`
+      ruby_version_gemsets_string = @@ruby_versions.select { |r| current_rubies =~ /\b#{r}\b/ }
+    end
+    def missing_ruby_versions
+      current_rubies = `rvm list`
+      ruby_version_gemsets_string = @@ruby_versions.select { |r| current_rubies !~ /\b#{r}\b/ }
+    end
+    desc "List all the versions of Ruby these tasks use"
+    task :list do
+      puts 'The following Ruby versions are used in testing:'
+      @@ruby_versions.each { |r| puts r }
+    end
+    desc "Setup multiple versions of Ruby for testing, and populate an RVM gemset for each"
+    task :setup do
+      missing = missing_ruby_versions
+      system "rvm install #{missing.join(',')}" unless missing.empty?
+      ruby_version_gemsets_string = @@ruby_versions.collect { |r| r + '@http_session' }.join(',')
+      system "rvm --create #{ruby_version_gemsets_string} gem install bundler"
+      system "rvm #{ruby_version_gemsets_string} exec bundle install"
+    end
+    desc "Remove RVM gemsets (leave the Ruby versions installed though)"
+    task :cleanup do
+      installed_ruby_versions.each { |r| system "rvm --force #{r} gemset delete http_session" }
+    end
+    desc "Run tests on multiple versions of Ruby, using RVM"
+    task :test do
+      installed = installed_ruby_versions
+      puts "WARNING: some rubies are missing from RVM, run `rake rubies:setup` to install them" if installed != @@ruby_versions
+      ruby_version_gemsets_string = installed.collect { |r| r + '@http_session' }.join(',')
+      system "rvm #{ruby_version_gemsets_string} exec rake test"
+    end
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/http_session.gemspec

@@ -0,0 +1,75 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{http_session}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{David Burry}]
+  s.date = %q{2011-06-25}
+  s.email = %q{dburry@falcon}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rvmrc",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "http_session.gemspec",
+    "lib/http_session.rb",
+    "share/ca/cacert.pem",
+    "test/helper.rb",
+    "test/ssl/README.rdoc",
+    "test/ssl/ca.crt",
+    "test/ssl/ca.key",
+    "test/ssl/server.crt",
+    "test/ssl/server.csr",
+    "test/ssl/server.key",
+    "test/test_http_session.rb"
+  ]
+  s.homepage = %q{http://github.com/dburry/http_session}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{A useful yet still extremely light-weight web client built on top of Ruby Net::HTTP}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0.4.0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+    else
+      s.add_dependency(%q<rake>, ["= 0.8.7"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0.4.0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rake>, ["= 0.8.7"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0.4.0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+  end
+end
+

data/lib/http_session.rb

@@ -0,0 +1,206 @@
+
+require 'net/http'
+require 'net/https'
+
+class HttpSession
+  
+  # it really sux that plain ruby doesn't have cattr_accessor so we have to do 30 lines of repeating ourselves!
+  def self.open_timeout=(v)
+    @@open_timeout = v
+  end
+  def self.read_timeout=(v)
+    @@read_timeout = v
+  end
+  def self.redirect_limit=(v)
+    @@redirect_limit = v
+  end
+  def self.retry_limit=(v)
+    @@retry_limit = v
+  end
+  def self.ssl_timeout=(v)
+    @@ssl_timeout = v
+  end
+  def self.ssl_verify_mode=(v)
+    @@ssl_verify_mode = v
+  end
+  def self.ssl_ca_file=(v)
+    @@ssl_ca_file = v
+  end
+  def self.ssl_verify_depth=(v)
+    @@ssl_verify_depth = v
+  end
+  
+  # timeout for opening tcp/ip connection, in seconds
+  self.open_timeout      =  4
+  # timeout for reading bytes from tcp/ip connection, in seconds
+  self.read_timeout      =  8
+  # number of redirects to follow before throwing an error
+  self.redirect_limit    = 10
+  # number of times to retry, on connection errors
+  self.retry_limit       =  1
+  # ssl timeout
+  self.ssl_timeout       =  2
+  # kind of ssl certificate verification (should be OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER)
+  self.ssl_verify_mode   = OpenSSL::SSL::VERIFY_PEER
+  # when ssl certificate verification is used, where is the certificate authority file
+  # you can get one from curl here: http://curl.haxx.se/ca/cacert.pem
+  self.ssl_ca_file       = ::File.expand_path('../../share/ca/cacert.pem',  __FILE__)
+  # ssl verify depth
+  self.ssl_verify_depth  =  5
+  
+  
+  # 
+  # Request handling
+  # 
+  
+  # shortcut for parsing a full url and performing simple GET requests
+  # returns Net::HTTPResponse, or raises Timeout::Error, SystemCallError, OpenSSL::SSL::SSLError, EOFError, Net::ProtocolError
+  def self.get_request_url(url, headers={})
+    parsed = URI.parse(url)
+    use(parsed.host, parsed.scheme == 'https', parsed.port).request(parsed.path + (parsed.query.nil? ? '' : "?#{parsed.query}"), headers)
+  end
+  
+  # shortcut for parsing a full url and performing simple POST requests
+  # returns Net::HTTPResponse, or raises Timeout::Error, SystemCallError, OpenSSL::SSL::SSLError, EOFError, Net::ProtocolError
+  def self.post_request_url(url, params, headers={})
+    parsed = URI.parse(url)
+    use(parsed.host, parsed.scheme == 'https', parsed.port).request(parsed.path + (parsed.query.nil? ? '' : "?#{parsed.query}"), headers, :post, params)
+  end
+  
+  # internally handle GET and POST requests (recursively for redirects and retries)
+  # returns Net::HTTPResponse, or raises Timeout::Error, SystemCallError, OpenSSL::SSL::SSLError, EOFError, Net::ProtocolError
+  def request(uri='/', headers={}, type=:get, post_params={}, redirect_limit=@@redirect_limit, retry_limit=@@retry_limit)
+    req = case type
+      when :get
+        Net::HTTP::Get.new(uri)
+      when :post
+        Net::HTTP::Post.new(uri)
+      else
+        raise ArgumentError, "bad type: #{type}"
+    end
+    headers.each { |k, v| req[k] = v } unless headers.empty?
+    req['Cookie'] = cookie_string if cookies?
+    req.set_form_data(post_params) if type == :post
+    
+    begin
+      handle.start unless handle.started? # may raise Timeout::Error or OpenSSL::SSL::SSLError
+      response = handle.request(req) # may raise Errno::* (subclasses of SystemCallError) or EOFError
+    rescue Timeout::Error, SystemCallError, EOFError
+      handle.finish if handle.started?
+      raise if retry_limit == 0
+      request(uri, headers, type, post_params, redirect_limit, retry_limit - 1)
+      
+    else
+      add_cookies response
+      if response.kind_of?(Net::HTTPRedirection)
+        raise Net::HTTPError.new('Redirection limit exceeded', response)  if redirect_limit == 0
+        loc = URI.parse(response['location'])
+        if loc.scheme && loc.host && loc.port
+          self.class.use(loc.host, loc.scheme == 'https', loc.port).request(loc.path + (loc.query.nil? ? '' : "?#{loc.query}"), headers, :get, {}, redirect_limit - 1)
+        else
+          # only really bad web servers would ever send this... since it's not technically a valid value!
+          request(loc.path + (loc.query.nil? ? '' : "?#{loc.query}"), headers, :get, {}, redirect_limit - 1)
+        end
+      else
+        response.error! unless response.kind_of?(Net::HTTPOK) # raises Net::HTTP*Error/Exception (subclasses of Net::ProtocolError)
+        raise Net::HTTPError.new('Document has no body', response) if response.body.nil? || response.body == ''
+        response
+      end
+    end
+  end
+  
+  
+  # 
+  # Session initialization and basic handling
+  # 
+  
+  # place to store references to all currently-known session instances, for singleton method usage
+  @@sessions = {}
+  
+  # storage for open session handle, for instance method usage
+  attr_accessor :handle
+  
+  # don't use new() directly, use singleton get() or use() instead
+  def initialize(host, use_ssl, port)
+    self.handle = Net::HTTP.new(host, port)
+    self.handle.open_timeout    = @@open_timeout     # seems to have no effect?
+    self.handle.read_timeout    = @@read_timeout     # seems to have an effect on establishing tcp connection??
+    self.handle.close_on_empty_response = true     # seems to have no effect?
+    if use_ssl
+      self.handle.use_ssl       = true
+      # respond_to? check is a ruby-1.9.1-p378 (+/-?) bug workaround
+      self.handle.ssl_timeout   = @@ssl_timeout if OpenSSL::SSL::SSLContext.new.respond_to?(:ssl_timeout=)
+      self.handle.verify_mode   = @@ssl_verify_mode
+      self.handle.ca_file       = @@ssl_ca_file
+      self.handle.verify_depth  = @@ssl_verify_depth
+    end
+    self.cookies = {}
+  end
+  
+  # just our own internal session key... (it looks like: "scheme://host:port")
+  def self.key(host, use_ssl, port)
+    "#{use_ssl ? 'https' : 'http'}://#{host}:#{port_or_default(port, use_ssl)}"
+  end
+  
+  # check if a session exists yet ot not
+  def self.exists?(host, use_ssl=false, port=nil)
+    @@sessions.has_key?(key(host, use_ssl, port))
+  end
+  
+  # get the session for the given host and port, nil if there isn't one yet
+  def self.get(host, use_ssl=false, port=nil)
+    @@sessions[key(host, use_ssl, port)]
+  end
+  
+  # get the session for the given host and port, creating a new one if it doesn't exist
+  def self.use(host, use_ssl=false, port=nil)
+    key = key(host, use_ssl, port)
+    @@sessions.has_key?(key) ? @@sessions[key] : (@@sessions[key] = new(host, use_ssl, port_or_default(port, use_ssl)))
+  end
+  
+  # done with this session, close and reset it
+  # but it still exists in the session storage in a dormant/empty state, so next request would easily reopen it
+  def close
+    handle.finish if handle.started?
+    self.cookies = {}
+  end
+  
+  # delete session from session storage (you should probably call close on it too, and set all references to nil so it gets garbage collected)
+  def delete
+    key = self.class.key(handle.address, handle.use_ssl?, handle.port)
+    @@sessions.delete(key) if @@sessions.has_key?(key)
+  end
+  
+  # return the given port, or defaults for ssl setting if it's nil
+  def self.port_or_default(port, use_ssl)
+    port.nil? ? (use_ssl ? Net::HTTP.https_default_port : Net::HTTP.http_default_port) : port
+  end
+  
+  
+  # 
+  # Cookie handling
+  # 
+  
+  # storage for cookies, for instance method usage
+  attr_accessor :cookies
+  
+  # check if a session has any cookies or not
+  def cookies?
+    cookies.length > 0
+  end
+  
+  # return all current cookies in a comma-delimited name=value string format
+  def cookie_string
+    cookies.collect { |name, val| "#{name}=#{val}" }.join(', ')
+  end
+  
+  # store the cookies from the given response into the session (ignores all host/path/expires/secure/etc cookie options!)
+  def add_cookies(response)
+    return unless response.key?('set-cookie')
+    response.get_fields('set-cookie').each do |cookie|
+      (key, val) = cookie.split('; ')[0].split('=', 2)
+      cookies[key] = val
+    end
+  end
+  
+end